Software configuration of the first chapter
Chapter 1: Software built views and quality objectives 1.1 software to build a multi-dimensional view of the
1.1 software to build a multi-dimensional view of the
outline
multi-dimensional views of the software - in stages: to build and run the view - by dynamics: time and cycle view - by level: Code and the component view - elements of each view, the relationship between structure and model software: convert between views - ∅⇒ code - Code ⇒ components - build time ⇒ running time - time period ⇒ summary
1.1 software to build a multidimensional view of this lecture It targets
; § three orthogonal dimensions to be understood that the software components of the system; § understand what model to describe the shape and the state of the software system; § software configured as a conversion between the different views
software build
view a multidimensional software
1.1 software to build a multidimensional view of
what is software?
AlanTuring first proposed the word "software." - open source and proprietary software - system software and application software - Desktop / Network / mobile / embedded software - for business / personal software
Alan Turing (1912-1954)
part of a multi-dimensional view of the software system 1.1 software to build
Software = program (Code)? Algorithms + Data Structures = software? = + Software program document data + = software modules (components) + data / control flow
Donald E. Knuth (1938-) Turing Award 1974
Edager the Dijkstra (1930-2002) 1972 Turing Award
NiklausWirth (1934-) FIG. spirit Awards 1984
part of a multi-dimensional view of the 1.1 software to build software systems: another step
software = - program (UI, algorithms, utility, API, test cases, etc.) - data (files, databases, etc.) - Document (SRS, SDD, user manuals, etc.) +++++++++++ ++++++ user who will use it? - Why is it useful to business goals? - What kind of social environment should follow the rules? - How to implement technological environment? - Hardware / Web Runtime is when?
1.1 software to build a multidimensional view of the multi-dimensional views of the software
timing cycle Code Level Code Level component assembly stage
when building
the source code, AST, Interface-ClassAttributeMethod (ClassDiagram )
packet, the source files, static link libraries, the test case (FIG assembly)
Code the Churn (code changes)
configuration items, version
run
the code snapshot, Memorydump
package, libraries, dynamic linking, configuration, database, middleware, networks, hardware (deployment diagram)
perform the procedure call graph tracking the event log, the message diagram (sequence diagram)
parallel and multi-thread / process distributed process
software building
(1) build time view
when building software to build a multi-dimensional view of the 1.1 software system view
build time: idea needs ⇒ ⇒ ⇒ design codes ⇒ attachable / executable package - code level view: how ---- source code by the source code organized logically the basic block (such as functions, classes, methods, interfaces, etc.) , and the dependencies between them - component level view: architecture ---- how the source code physically organized into files, directories, packages, library and the dependencies between them ---------- ---- ---------------------------------------------- ---- view at that time: the way the source code and assembly within a certain time - period view: how they evolved / change over time
(1) Construction, time, and code-level view
how the source code through the logical organization of basic blocks (such as functions, classes, methods, interfaces, etc.), and the dependencies between them. form interconnected three kinds: - word-oriented source code - syntax-oriented programming structure: For example, the abstract syntax tree (AST) - semantics-oriented programming structure: For example, FIG class
1.1 software to build a multidimensional view of
source: software development is the most important asset
-based vocabulary of semi-structured source code
1.1 software to build a multidimensional view of grammar-oriented programming structure
abstract syntax tree (AST) the semi-structured source code represents a structured tree.
And (a ≠ b) {if ( a> b) a = a - b; otherwise, b = b - a; return;}
https://en.wikipedia.org/wiki/Abstract_syntax_tree
1.1 software to build a multidimensional view Semantic the program structure
e.g., using the class diagram (UML) to describe interfaces, classes, attributes, methods and relationships between them. based graphical or formal definition. typically modeled at the design stage, and converted into source code. This is the result of object-oriented analysis and design, and user requirements.
1.1 software to build a multidimensional view of semantics-oriented program structure
1.1 software to build a multidimensional view (2) Construction of time, period, and code-level view
view for describing "Change" and time. loss of code: add from one version to another, modify, or delete a file line.
1.1 software code for the loss of the multi-dimensional view of the structure of the code is defined as loss from one version to add the file to another file, modified or deleted.
1.1 software to build a multidimensional view (3) construct, and component level view of the time
§ physically organized in source code to a file, according to a further directory organization; § encapsulating file to the package, the package in the components and subsystems logically. reusable modules take the form of libraries. Static link
1.1 software to build a multi-dimensional view of the
library
library stored in its own disk file, collect a set of codes function, can be reused in various programs. - Developers do not always build a single executable file, but custom-developed software and pre-built libraries join into a single program. When building, library functions can be viewed as extensions to the standard language, use the same function that the developers write. System.out.println ( "Hello World"); source libraries: - Set FromOS pre-installed library for file and network I / O, GUI, mathematics, database assessment and other operations; - from language SDK; - from third-party sources, such as downloading from the Internet. - Developers can also publish their own libraries.
1.1 software to build a multi-dimensional view
link library
when edit, build and install the program, you must provide a list of libraries to be searched. If the source code is referenced in a function, but the developer did not explicitly write it, it will search the library list to find the desired function. After find this function, the corresponding target file will be copied into the executable program. integrate the library into an executable program in two different ways: - The static link - Dynamic Link
Statically linked
In statically linked, the library is a collection of individual object files. In the build process, when the link tool to determine the need for a function, it will extract the corresponding object files from the library and copied into the executable program. - the same as any target document library object file looks developers have created. static linking occurs when the building - in the build process, the library with its own software developers to link together. - eventually loaded into an executable program on the target machine. - After creating the final executable program, the program is separate from its library is not possible.
1.1 UML in software to build a multi-dimensional view of the assembly drawing
1.1 software to build a multi-dimensional view (4) Construction of time, period, and component-level view of
all files software system / package / how the component / library change over time? § software configuration item (SCI) Version
1.0 1.1 1.2 1.3
File 3File 2File 1Version Labels
final version
Beta. 1
1.0 1.1 1.2 1.3
1.0 1.1 1.2
1.0 1.1 1.2 1.3 1.4
1.1 software to build a version control system (VCS) multidimensional view
1.1 software builds evolution FIG. (SCI or software) multidimensional view
1.1 software to build a multidimensional view of
the version
software version control process is the only state is allocated a unique version name or number unique to the computer software version. - the version number in the given category (primary, secondary) of these numbers are usually assigned in ascending order, and corresponding to the development of new software. - at the granular level, version control is often used for different versions of the track increment electronic information, regardless of whether the information is computer software.
1.1 software to build a multi-dimensional view
Software evolution
software evolution is a term for software maintenance, it refers to the process of initial development software, and then update the software again and again for various reasons. - More than 90% of the cost of a typical system appears in the maintenance phase, and any successful software will inevitably be maintained.
Frederick Kebu Brooks (1931-) Turing Award 1999
software building
(2) view the runtime
view running 1.1 software to build a multi-dimensional view of the software system at the time
runtime: what it was like to run in the target machine when that goal What all the machine needs to be loaded into memory in a disk file is? - code-level view: the source code ---- executable memory state what kind of program units (objects, functions, etc.) how to interact with each other? - Component-level view: architecture ---- how to deploy the package to the physical environment (operating systems, networks, hardware, etc.) and how they interact? -------------------------------------------------- -------------- Moment view: programs behave in a particular time - period view: how they change over time
advanced concepts 1.1 software to build a multi-dimensional view of the run-time software
executable program : a machine-readable sequence of instructions executed by the CPU and associated data values. - This is a fully compiled program that can be loaded into the computer's memory and executed. Library: A collection of object code used can be reused by different procedures. - Most operating systems include a standard set of libraries that developers can reuse, rather than requiring each program offers its own library. - libraries can not be loaded and executed directly on the target machine; it must first be linked to an executable program. Advanced Concepts when running software
configuration and data files: These are not executable files; they provide the program can be loaded from the disk of useful data and configuration information. distributed program: this type of software program executable by the plurality of composition, these procedures can, or simply run multiple processes on the same machine communicate with each other through a network. - This is in contrast with the more conventional single monolithic software having program image.
1.1 software program to build the executable multidimensional view: native code
program is first loaded into memory, and several mechanisms for executing software exist, depending on how much has been compiled and a program before loading the program how many OS support needs . native machine code: - fully converted is converted into executable programs native CPU code. - CPU only "jump" to the beginning of the program, all execution is simply use the CPU hardware execution. - When it is executed, the program can choose to call the operating system to access files and other system resources. - This is the fastest method of executing code, as the program full access to the CPU functions.
1.1 Construction multidimensional view software executable: complete explanation
explain the complete program: The system will load the entire source code is run into memory and interprets (e.g. BASIC, UNIX shell, etc.)
1.1 software to build a multidimensional view of an executable program : bytecode interpretation
interpreted byte code: - byte code similar to native code, but the CPU does not understand them. - that they are first converted to native machine code, or they are interpreted during program execution. - the environment is required to load the byte code interpreter or compiler further in the next program. Java Virtual Machine (the JVM)
1.1 software build executable program multidimensional view: interpreted byte code
Perl or Python: they are interpreted rather than compiled, but using byte code at runtime. perform simple Perl or Python scripts automatically triggers generated byte code.
1.1 software to build a multi-dimensional view of the
dynamic link
dynamic linking method does not copy files to the target executable image; rather, it pointed out that the successful implementation of the required library. program starts, the library is loaded into memory as a separate entity and then connected to the main routine. dynamic library is constructed by connecting the target file disk file. Then the library collection to the distribution package and installed on the target computer. The only way it can be loaded into the machine's memory.
Multidimensional view 1.1 software to build
dynamic link
advantages: - You can upgrade to a newer version of the library (add features or fix bugs), without having to re-create the executable program. - Many operating systems can optimize memory usage by simply loading a copy of the library into memory, then share it with other programs require the same library.
1.1 software and configuration data files configured multidimensional views
any size programs use an external data source, such as a file on disk. Your program calls the operating system to request the read data into memory. - bitmap graphic image displayed on the screen - is stored as a digital sound waveform - Customize program behavior profile - a set of documents includes online help text - the database contains the name and address of the
1.1 software to build a multi-dimensional view of the
distribution programming
For example, the software system may use a client / server model, a single server program running on a single computer, run the program on a large number of clients in many other computers. In this case, the build system can create two publishing package, because different people will install the server program instead of the client program. Alternatively, you can use the same release package to install two separate programs.
1.1 software to build a multi-dimensional view
Snapshot Figure: Focus on variable-level execution state of the target computer's memory. fine-grained state.
(Memory dump
memory dump: the files on the hard disk that contains a copy of the contents of the memory process, when the process is aborted produce some internal error or signal. - The debugger can load the dump file and displays information about the state of the running program it contains. - information includes a register, and all other programs call stack data (counter, variable switches, signs, etc.) content. - It depends on the latest status of the program and the programmer appears to record what data items at the time of the failure is being processed in memory.
1.1 software to build a multidimensional view of
a memory dump
1.1 software to build a multidimensional view of (6) runs, and code-level view of the cycle
sequence in FIG UML: interaction between program units (objects)
1.1 software to build a multidimensional view of
execution trace
tracking involves the use of specialized logging to record information about the program execution. This information is usually used by a programmer debugging purposes, in addition, depending on the type of tracking and detailed information contained in the log, frequently asked questions by experienced system administrators or technical support, and software monitoring tools and diagnostic software.
1.1 software to build a multi-dimensional view (7) runs, time and component-level view of the
deployment diagram UML the
1.1 software to build a multi-dimensional view (8) runs, cycle and component-level view
event log provides diagnostic system administrators audit and useful information. - different types of events will be recorded and detailed information that will be displayed in the event message into account in the development cycle. for each type of event is assigned a unique "codes", to format and print a human-readable information. - which is conducive to localization, and system administrators to more easily obtain information about the problem.
1.1 software to build a multidimensional view of execution trace and event logging
Event logging software tracks mainly by the system administrator consumption mainly by the developer consumption record "high-level" information (such as installation failed) record "low-level" information (such as thrownexception) can not be too "noisy" (contains many duplicate events) or for There is no information to help its target audience) might be noisy based Astandard output format is often desirable, and sometimes need to limit the output format of the event log messages are often little Localization Localization is rarely a problem to add a new type of events, and new event messages do not require agility to add a new trace messages must be agile
software building
2 software builds: transitions between views
1.1 software to build software to build a multi-dimensional view: view conversion btw
construction time
is running
short of
time
period
code
parts
of code loss of
CI and release
the code snapshots of
the physical architecture of
the call graph
threads and processes
programming
designed to
build the install deployment
reconstructed
version control
the evolution of
the deployment of
the review, static analysis
debugging test
analysis, dumping
record
1.1 software to build software to build a multi-dimensional view of the conversion class
∅⇒ Code - Programming / Coding (Chapter 3 ADT / OOP) - review, static analysis / inspection (Chapter 4 intelligibility) ⇒ assembly Code § - Design (Chapter 3 ADT / OOP; Chapter 5 Reusable sex; Chapter 6 serviceability) - build: compile statically linked, package, installation, cleaning (Chapter 2 build process) build time ⇒ running time - installation / deployment (3 year course) - debugging, unit / integration testing (Chapter 7, robustness) ⇒ time period - reconstruction (Chapter 9 reconstruction) - version control (Chapter 2 SCM) - loading, dynamic linking, interpretation, execution (dump, analyze, document) (first Chapter 8 performance)
software building
summary
1.1 software to build a multidimensional view of this lecture summary
software system described in three dimensions: - in stages: build and runtime view - dynamic press: cycle time and views - by level: component code and element view each view, the relationship between the model and software configured : switching between views - ∅⇒ code - the code assembly ⇒ - ⇒ runtime build time - time period ⇒
software Construction
end