The graph modeling of applied systems (AS) from ready resources (modules) are presented. The graph is represented by an adjacency and reach ability matrix. A new program structures are modeling by mathematical operations (unions, connections, etc.). The assemble of programs structures (complex, system, packets, AS, OS, IS, etc.) from modules in LP, as resources are integrating by such operations (link, make, weaver, config, etc.) and controlled on the quality every recourses and the making systems from them.
Definition 2. Two program structure S1 = (Т1, χ1) and S2 = (Т2, χ2) are identical if Т1 = Т2, χ1 = χ2 and the structures S1 and S2 are isomorphic, then Т1 is isomorphic to Т2 and χ1 = χ2. The concept of isomorphism of program structures and their models is used in the specification of the abstraction level at which operations on these structures are defined. For isomorphic graph objects, operations will be interpreted in the same way without orientation to a specific composition of program elements, provided that such operations are defined over pairs (G, χ). The software module is described in the LP and has an interface section in which external and internal parameters are set for data exchange between related modules through Call/RMI operations, etc.
The interface defines the connection of heterogeneous software modules according to the data and the way they are
displayed by programming systems with the LP. Its main functions are: data transfer between program elements (modules),
data conversion to the equivalent form and transition from the environment and platform of the called module to the caller
and back. Functions of conversion of different, non-equivalent data types is carried out with the help of a previously
developed library of 64 primitive functions for heterogeneous types of data of LP in the APROP system [
In practice, the assembly method of software modules is performed by operations (link, make, assembling, config,
weaver) special programs OS libraries (OS ES, IBM, MS.Net, etc.), a builder of complex applications in OS RV for SM
computers, complication modules for ERM "Elbrus" are used. In these operations and interface functions data type
conversion library [
Definition 3. A program aggregate is a pair S = (T, χ), where E – a model of the program modular structure of the aggregate; χ - a characteristic function defined on the set of vertices X of the graph of the modular structure G. The value of the χ function is defined as follows: χ(x) = 1 if the module corresponding to the vertex х X, - included in the unit; χ(x) = 0 if the module corresponding to the vertex х X, - not included in the software unit, but it is accessed from other modules previously included.
Definition 4. The model of the program structure of the program unit is an object described by the triple T = (G, Y, F), where G = (X, E) - a directed graph, which is a graph of a modular structure;
Y is a set of modules included in the program aggregate; F is a correspondence function that puts an element of the set y at each vertex X of the graph.
Function F maps X to Y, F : X → Y (1)
In General, an element from Y can correspond to several vertices from the set X (which is typical for the dynamic
structure of the aggregate) [
The graph of software aggregates has the following properties: 1) graph G has one or more connectivity elements, each of which represents an acyclic graph, i.e. does not contain oriented cycles;
2) in each graph G is allocated a single vertex, which is called the root and is characterized by the fact that there are no arcs included in it and the corresponding module of the software unit is performed first;
3) cycles are allowed only for the case when some vertex has a recursive reference to itself. Typically, this feature is implemented by the compiler with the corresponding LP and this type of communication is not considered by the intermodule interface. Therefore, such arcs are not included in the graph. The exception to the consideration of other types of cycles is due to the fact that some modules will have to remember the history of their calls in order to return control correctly, which contradicts the properties of the modules; 4) An empty graph G0 corresponds to an empty program structure.
Next, the graph G will be used to illustrate mathematical operations on modular structures. On Fig.2. four types of subgraphs are shown for Fig.1. For the graph (Fig.1) set of subgraphs (from left to right) to create four programs: 1) from the vertex x1 given three related vertices x1, x3 and x4; 2) for x3 given two vertices x5 and x6; 3) for x5 given two vertices x7 and x8; 4) to the program x5 added vertex x6, not associated with it.
x 2
The graph of the module (m) is represented as: Gm = (Хт, Eт). It contains a single vertex х Хт for which χ(xj)=1. This vertex is the root. An arc of the form (хj, хе, k) means calling the module to the corresponding vertex хj , i.e. to the module with the vertex xl. The dark circle on the graph corresponds to the vertex for which χ(x) = 1; light – χ(x)=0.
Program graph Gp = (Хр, Ep) which is performed С (Sp) = 1; R (Sp) = 1. An example of a graph of such a program modular structure is shown in Fig. 1.
The graph of the complex G = (Xc, Ec) consists of n connectivity components (n > 1), each of which is a graph and c p p p includes: G c = G1 G2 , … , Gn , where Xc = X1p X2p , … , Xnp и Ec = E1p E2p , … , Enp.
These definitions of the graph of the program module, program and complex are used for the process of assembling the
modules. These concepts may differ from similar ones, which are considered in other contexts of the work.
1.3 Matrix representation of graphs from program elements of module types
To determine the main operations on software structures, we use the mathematical apparatus of the matrix representation of
graphs in the form of an adjacency and reachability matrix. That is, the graph is represented by the matrix M= m (i, j) of
adjacency and is proved by the reachability matrix [
In addition to the adjacency matrix (calls), the characteristic vector Vi = χ (xi) for i-elements is used. For a modular structure graph (Fig. 1) characteristic vector and adjacency matrix have the form:
11 00 00 V = 1 M = 0 0 (2) 1 0 0 1 0 2 1 0 1 0 1 0 M 1s 000 100 100 100 ; V 5s 111 , M5s 000 100 002, (3) 0 0 0 0
For the program graph (Fig. 1) the characteristic vector and the matrix of calls coincide with V and M, respectively, and determine the form (2), in which all elements of V are equal to one. In the case of the complex, the characteristic vector and the call matrix have the following form: 0 0
M np
Here V ip and M ip (i = 1, n ) denote the characteristic vector and the adjacency matrix for the graph of the i-th program included in the graph of the complex. In the future, the matrix representation is used when performing mathematical operations on software structures.
Let G = (X, E) - a graph of a program of modular structure; хi, xj - vertices belonging to X. If there is an oriented chain from хi to xj in the graph G, then the vertex xj is reachable from the vertex хi. The following statement is true: if the vertex xj is reachable from xl – из хj ,хl – from xj , then хl is reachable from хl. The proof of this fact is obvious.
Consider a binary relation on the set X that determines the reach ability of one vertex of a graph to another. We introduce the notation хi →хj - reach ability of the vertex xj from xi. The relation is transitive. Denote by D(хi)) the set of vertices of graph G reachable from xi.. Then the equality
xi хi D xi (5) of determines the transitive closure of хi in relation to the achievability of tops. We prove the following theorems.
Theorem 1. For the selected element of connectivity of the graph of the program structure, any vertex is reachable from the root corresponding to the given vertex of the graph, i.e. the equality (х1 – root vertex).
x1 х1 D x1 X .
Evidence. Suppose the vertex хi (хi Х) is unattainable from x1. Then хi x1 and the set X' = X \ x1 - not empty. Since the selected component of the graph is connected, there is a vertex хj x1 and a chain Н(хi, xj), leading from хi to xj. Based on the acyclicity of the graph G, in X'' there should be a simple chain Н(хi,, xj), where the vertex хl does not include arcs (this chain can be empty if X' consists only of xi). Consider the chain Н(xl, xj) = Н (xl, xi) U Н (xi, xj). This means that the module xi is reachable from vertices х1 and хi and both vertices contain no incoming arcs. This contradicts the definition of a graph of a modular structure with a single root vertex. The theorem is proved.
The results of this theorem are important to substantiate the requirement of the absence of oriented cycles in the x11 x 5 rgeraacphhaboiflitthye. pCroongsraidmerstthruecgturarpehwsihthowrenspinecFtigto. 3th.e notion of x 2 x 4 1
From this figure it is clear that the graph contains a 1 1 directed cycle and modules corresponding to vertices х4, х5, x 3 x 6 х6 will never be executed.
Thus, the results of theorem1 reinforce the requirement that there are no oriented cycles in the graph of the program.
We analyze the matrix representation of the reach ability relation for the graph of the program structure Fig.1 with the reach ability matrix A, which has the form (7).
Coefficient aij = 1 if the module corresponding to the index l is reachable from the module corresponding to the index i the following results are based on the theorem from graph theory. 0 0 А= 0 0 0 0 (4) (6)
Theorem 2. The coefficient mij of the l-th degree of the adjacency matrix Мl determines the number of different routes
containing l arcs and connecting vertex xi to the vertex of the xj –oriented graph. The proof of this theorem is given in [
Corollary 1.1. Matrix M = n М i , where M is the adjacency matrix of a directed graph with n vertices coincides up l1 to the numerical values of the coefficients with the reachability matrix A.
Evidence. In a directed graph containing n vertices, the maximum path length without repeating arcs cannot exceed n. Therefore, the sequence of degrees of the adjacency matrix Mi, where i = 1,2, ..., n determines the number of all possible paths in the graph with the number of arcs ≤ p. Let the coefficient mij of the matrix M be different from zero. This means that there is a degree of matrix М i in which the corresponding coefficient mij is also nonzero. Therefore, there is a path from vertex xi to xj, i.e. vertex xj is reachable from xi. This consequence determines the connection of the matrix of calls of the graph of the modular structure M, coinciding with the reachability matrix A, and determines the algorithm for constructing the latter.
Corollary 1.2. Let there be a coefficient mii > 0 for some i in the sequence of degrees of the adjacency matrix Mi. Then there is a cycle in the original graph.
Evidence. Let mii > 0 for some l. Therefore xl reachable from xi, i.e. there is a cycle. According to the theorem, this cycle has l arcs (generally repeated).
Corollary 1.3. Let the n-th degree of the adjacency matrix of the Мп of the acyclic graph coincide with the zero matrix (all coefficients are zero).
Evidence. If the graph is acyclic, then the simplest path cannot have more than п – 1 arcs.
If Мп has a coefficient other than zero, then there must be a path consisting of n arcs. And this way can only be oriented cycle. Therefore, all coefficients of Мп for an acyclic graph are zero. This consequence provides a necessary and sufficient condition for the absence of cycles in the graph of a modular structure.
For acyclic graphs, the reachability ratio is equivalent to a partially strict order. The transitivity of the reachability ratio was considered above. Anti-symmetry follows from the absence of oriented cycles: if the vertex xj is reachable from xj, then the opposite is not true.
We introduce the notation xi>xj if vertex xj is reachable from vertex xi.
Let G = (X, E) be an acyclic graph corresponding to some program structure.
Consider the decreasing chain of elements of a partially ordered set X: xi1 >xi2 >…> xin . …, where " > ” denotes the reachability ratio.
Since X is finite, the chain breaks. The vertex xin has no outgoing arcs, i.e. the element xin is minimal (it corresponds to a module that does not contain access to other modules). The maximum element in the set X is the root vertex.
Mathematical operations (U, , /, +, - ) on graphs are performed at the level of abstractions of elements of program structures that lead to changes in graph elements and characteristic functions of systems: S = (G, χ). Let S1 = (G1, χ1) and S2 = (G2, χ2) be two graphs of program structures G1 = (Х1 , E1 ) and G2 = (X2, E2) respectively.
We introduce the following notations: D (х) – the set of vertices reachable from the vertex x; D*(x) – the set of vertices from which vertex x is reachable.
The same symbols are used for the same vertices included in the graphs G1 and G2. The main operations on the program structures are discussed below
Merge (join) operation S =S1 U (9) is intended to form a graph of the structure of the complex and is formally defined as follows S1 and S2 – any program structures that satisfy the definitions of claim 1:
G = G1 G2, where the symbol denotes a direct sum provided:
Х = Х1 Х2, E1 E2 , χ (х) = χ1(х), if χ X1, χ (х) = χ2(x), if χ Х2.
The same vertices included in G1 and G2 are represented by different objects in the operations of combining program structures. The characteristic vector and adjacency matrix of the program structure S are defined as follows: V1,2 = V1 , M1,2 = V2 where V1,2 and M1,2 are characteristic vectors and adjacency matrices of modular structures S1 and S2 respectively. This operation is associative, but not commutative – the order of the operands determines the order of the components of the complex. (10) (11)
It should be noted that if the operands S1 and S2 satisfy the conditions for defining program structures, the result S will also satisfy the same requirements. The join operation increases the number of connected graph elements. In addition, the column structures may themselves have multiple items of connectedness. For the rest of the operation counts of the operands and result are the only element of connection.
The connection operation. We denote by xi and xj the root vertices of graphs G1 and G2 of program structures S1 and S2, respectively. This operation
S = S1 + S2 (12) which is execute if these structures meet the following conditions: - set X' = X2 X2 not empty; - vertex xj X' and χ (хj) = 0; - D* (х) D (x) = 0 for every х Х', where D* (х) X1 и D (х) X2;
- G = G1 U G2, X = X 1 U X2 , E = E1 U E2, (13) The characteristic function χ is satisfied under the condition:
χ(х) = χ1(х), if х Х1 \ X'; Х(х) = mах (χ1(х), χ2 (x))> if х X',
χ(х) = χ2(х), if х Х2 \ X' .
First condition means that there are common vertices in graphs G1 and G2. According to the second condition, the root vertex G2 belongs to the common part and for S1 the object corresponding to xj is not included in the program structure yet.
The third condition prohibits the existence of cycles in the result graph. Indeed, if there is хп D*(x) D(x) , then хп> х and x > хn, and x > хn, then this means the existence of a cycle.
If S1 and S2 satisfy the above conditions, the connection operation is partial.
Let us determine whether the result of the connection operation belongs to the class of program structures. Since X'' is not empty, the graph G has one connected component. The root vertex of the graph G is xi. The graph G itself has no oriented cycles, i.e. is acyclic.
Thus, S belongs to the class of program structures under consideration.
This connection operation is not commutative and is generally not associative. To show that this operation is not associative, consider the result S = (S1 + S2) + S3, where the root vertices of graphs G2 and G3 are part of the vertices of graph G1 and Х2 Х3 ≠ 0.
Then the result of the S2 + S3 join operation is undefined.
The operation of projection. Let S1 = (G1, χ1) be a program structure and хiХ1. The operation of projection of this structure to the top of the graph S1 is denoted as S = Рrxi(S1) and is defined as
G(X, Г), Х = x i , E = {(xi, xj, K)| xi, xj X}, (14) and for the characteristic function is χ(х) = χ1(х), if х Х. The projection operation defines the program structure S1 in the structure S. let's check the belonging of the structure S to the class of the considered program structures. If the graph of the structure S1 is connected acyclically, then the same properties will be possessed by the graph G. There is a single root vertex xi in the graph G. Thus, the program structure S belongs to the class under consideration.
The difference operation for program structures is defined as follows. Let S1 = (G1, χ1) be a program structure and xi Х1. The difference operation is performed on this structure and its projection to the vertex xi of the corresponding graph (хi is not the cortical vertex of the graph G1). Formally, the difference operation of the program structure has the form:
S = S1 - Prxi (S1 and defined as follows
E = {(xi , xj , K) | xi , xj X } , where the set X' consists of such elements for which
G = {X, E), X = (X1 \ xi ) X'
X' = {x'j | (xl X1 \ xi ) & (x'j xi ) & (xl , x'j ,K)E (15) (16) (17) χ(х) = χ1(х), если х Х1 \ xi ;
χ(х) = 0), если х X' .
The set X includes vertices that are not included in the set xi , and those vertices xi that include arcs from vertex X1 \ xi (sets X'). The characteristic function for elements х' X' is zero. The difference operation is the inverse of the join operation, i.e. the equality is performed:
S - Pr (S) + Pr (S) = S. (18)
xi xi
Let us check that S, defined in (15), belongs to the class of program structures. If the graph is G, connected and acyclic, then the graph G1 will have the same properties. The root vertex G is the same as the root vertex G1. Thus, S satisfies the conditions for determining the program structure given in paragraph 1.
Let S* be the set of program structures given by the direct product G* X χ*, where G* and χ* are the set of graphs and the set of characteristic functions. Denote by Ω = {U, , /, +, -} - set of mathematical operations on program structures and P, C and R - predicates of:
Ω = {U, , /, +, - , P, C, R (19)
Thus, an algebraic system = (S, Ω ) over a set of program structures and operations on them (union, connection, differences and projections) is defined.
Among the variety of program structures there are three main ones – a simple, complex structure with a call of modules from the external environment and a dynamic structure. The main purpose of various structures is the most optimal use of the main memory during the execution of the unit.
Simple structure. An aggregate with a simple structure is created in the process of building modules based on the operations of link calls. The amount of main memory occupied by an aggregate with a simple structure is constant and n equal to the sum of the volumes of individual modules: Vs = vi , where vi is the amount of memory occupied by the i-th i1 module. The corresponding graph of a modular structure is always connected.
Complex structure. Assembly of complex structures with dynamic invocation of modules in the shared memory is created in the Assembly process of the modules. In such an aggregate, the connections between the modules are not so rigid and their sequence is determined by the modules included in the chain. The modules are loaded into the main memory at the time of processing. When finished, the memory is freed and used to load another module. The graph of a complex program structure is also connected (Fig.4) and is reflected in the matrix (2). l0,n+p=v01+ … +vrp,n+p = v0 v1 +…+ v2 p vn p = v0 +v1 +…+vrp+ vn p = v1+ … + vrp.
2 2 2 2 This length l0, n+p will be equal to the sum of the memory modules for path х1,..., хrр.
Thus, applying Floyd's algorithm to the graph in Fig. 2, we solve the problem of calculating the amount of memory for the maximum chain.
3). We replace the adjacency matrix with the path matrix. For each mij>0, the corresponding location will be vij. The values тij = Ø are replaced by – ∞. The program implementing Floyd's algorithm has the following form (it is assumed that the path matrix is described as a two-dimensional matrix (п n): this length l0, n+p will be equal to the sum of the memory modules for path х1, хrр. For k = 1 to n do
For I = 1 to n do
For j = 1 to n do
if M[I, j ] < M [ i l k] + M[k, j] then M [I, j]: = M [ i , k] + M[k, j].
As a result of this algorithm, a matrix of maximum paths will be constructed. The maximum of l0, п+p will determine the minimum amount оf l0, п+p memory for the memory-overlapping aggregate.
The most complex structure for the values V0min ≤ V0 ≤ V0max can be constructed by following the algorithms proposed in [
Dynamic structure. The mechanism of dynamic links between modules is different from the call mechanism. Dynamic objects are loaded into the main memory when they are accessed. By analogy, we call the volume loaded with a single treatment of a dynamic element, has its own program structure, for which the adjacency matrix is composed. If the same modules are found in different dynamic structures, they are different objects.
The original graph is used for illustration (Fig.1). Let the module corresponding to the vertex х1, be dynamically called from the module corresponding to the vertex х3. The resulting modified graph is shown in Fig. 6. A dashed arrow indicates a dynamic call. The module corresponding to the vertex x6, occurs twice.
We construct an adjacency matrix for this aggregate. Each dynamic element will have its own CAL.L. To distinguish a dynamic call, the corresponding matrix elements will contain negative numbers whose absolute values specify the number of dynamic calls between the data of the module pair. The adjacency matrix will look like:
amount of RAM on the number of dynamic segments (Fig.5 and Fig. 6).
With one component in the software unit of a simple structure we have V1d = V .
s
If each dynamic component consists of one module, then the modified Floyd algorithm finds the maximum path and Vdn =V0min.
Curve 1 defines a relationship in which different segments do not have the same modules. Curve 2 describes the dependence for the case when different segments have the same modules. For them, the required memory increases due to the duplication of such modules. However, dependence 2 is typical for the case when there are no identical modules in dynamic structures and they are written in high-level LP. These modules are handled by utility tools – memory management, I /o, emergency handling, etc.
Let the graph G be represented by the set of modules Х= {х1, х2... хт}, as described in PL, and located at the vertices of the graph. The modules are assembled into a software unit. In this case, each pair of modules хi, хj (i, j – languages from the set of LP are connected by the relation of call on the basis of which the module of communication х'ij is formed. In General, for simple program structures, the aggregate contains link communication (call) operators and forward and reverse transformations of data types passed from the calling module (in i-language) to the calling module (in j-language) and back [23].
LP allows you to describe the information part - passport modules with a description of the transmitted data [
The operator modules link (make, config, assembling, etc. since 1994) takes the form:
Link <aggregate type> <aggregate name> (<main module name>, <additional list of module names>) <execution mode>,
when constructing specific program structures, the vertices of the graph – modules can be marked with special symbols ρ, denoting: * – the beginning of the dynamic fragment with the vertex marked by this symbol; + - the module in the graph G is marked as the main program of the complex; / - means enabling debugging and so on.
Using these designations, the graph G will take the form shown in figure 8 and has a representation: E = { ( х 5 , х 7 , 1 ) , ( х 5 , x 8 , 1 ) , ( x 5 , х 8 , 2 ) } .
The aggregate is given a unique name corresponding to the generated root module. For the graph E = {(х4, х6, 1)} a fragment of operators providing a dynamic call will be formed in the communication module x'46. For a pair of modules specified in Fig.8 vertices x4, x6, the structure of the corresponding part of the unit, including the communication module, is shown in Fig. 9. Similarly links of modules and other types of calls are implemented.
Thus, for a pair of modules xi, xj, a module of connection xij of the form:
х'ij = S0 * (S1 S1T) * (S2 S2T) * S01, where S0 is a fragment of the aggregate that defines the environment of xj module functioning;
S1 – a fragment of the aggregate, including a sequence of calls to functions from the set {P, C, S}, each of which performs the necessary conversion of the actual parameters when referring to the xj -module;
S2 – a system with a fragment of operators for the inverse transformation of data types transmitted from xj to хi after its execution;
S01 – a piece of software structures with operators epilogue for the vertex xi, for the restoration of the environment. Для описанных структур программ зададим операции link для сборки отдельных программ на рис.8: Link Prog P1 (x1, x2); Link Prog P2 (x1, x3) (x3, x6); Link Comp P3 ((x1, x3) (x3, x5/ х'58)+ (x5, x7 (20) Link Prog P4 (x1, x4), (x4, x6); Link Comp (P1 U P2 U P3 U P4).
The programs of the complex (aggregate, packets) are given unique names (P1, P2, P3, P4) corresponding to the root names of modules in the chains of the graph.
Thus, the process of constructing the program structure on the graph includes: 1. Enter the module description in the LP (L') and perform syntax checking. 2. Select the required modules and interfaces from the repositories and place them in the graph. 3. Translation of the unit modules in the LP. 4. Generation of communication modules for each interconnected pair of graph modules.
5. Assembly of the elements of the graph in the finished structure, linking modules in the operating system (IBM, MS,
Oberon, Unix и др.) [
6. Test the system on data sets and assess the reliability of the unit.
After the modules are built, the name of the software Assembly is entered into the boot library. If you create a fragment that is later included in another aggregate, its name must match the name of the main module. In connection with the transition to the Internet environment to work with various software and system services in the configuration assembly of such tools provides security, data protection and quality assessment of ready-made modules, service resources and web systems in Internet.
The key characteristics of quality attributes is reliability and completeness as properties of the AS to eliminate failures with hidden defects with this criterion and a quality model, which relates the measures and metrics of the internal, external and operational type. From the standpoint of completeness of the product is the main indicator of quality are defects and failures.
The model of defects based on multiple quality factors, analysis of causal relationships between them, combining
qualitative and quantitative assessments of their impact on the density of defects [
R ( t | T ) exp( ( m (T t ) m (T ))) ,
Where t - the operating time of PS without a failure when testing in a period of time T; m (T) is a function of reliability growth, as the average number of defects.
The reliability of the software largely depends on the number remaining and corrected errors in the development process. During operation, errors are also detected and eliminated. If the bug fixes are not made new, or at least new bugs introduced is less than clear, in the course of operation reliability increases.
To assess the quality systems used the standard quality model: Mgua = {Q, A, M, W}, where Q = {q1, q2, …, qi } i = 1,..., 6, – various quality characteristics (Quality – Q);
A = { a1, a2,…, aj} j = 1,..., J, – the set of attributes (Attributes – A), each of which captures a separate property of the qi quality characteristics;
M = {m1, m2,..., mk} k =1,..., K, – the set of metrics (Metrics M) each element of the attribute aj for the measurement of this attribute.
W = {w1, w2,...,wn}, n = 1,..., N are weight coefficients (Weights W) for metrics of the set M.
The quality standard identifies six basic quality characteristics: q1: functionality; q2: reliability; q3: use; q4: efficiency; q5: maintainable; q6: portability.
The quality q1 – q6 are assessed by the general formula:
6 q 1 a 1 j m 1 j w 1 j
j 1
On the basis of obtained quantitative characteristics of the final grade is calculated by summing the values of individual indicators and their comparison with the benchmark systems.
Configuration of ready-made software recourses in the system
Under the configuration of the system is understood the structure of some of its version, including software elements,
combined with each other by link operations with parameters that specify the options for the functioning of the system [
Configuration Management is to monitor the modification of configuration parameters and components of the system, as well as to conduct system monitoring, accounting and auditing of the system, maintaining the integrity and its performance. According to the standard, the configuration includes the following tasks: 1. Configuration identification. 2. Configuration Control. 3. Configuration Status Accounting. 4. Configuration audit. 5. Trace configuration changes during system maintenance and operation; 6. Verification of the configuration components and testing of the system.
A configuration build uses a system model and a set of out-of-the-box components that accumulate in the
operating environment repositories or libraries, and selects their operating environment Configurator (for example,
in http://7dragons.ru/ru). The Configuration assembles the components according to their interfaces [
The Configuration builds components and reuses for the AS using config operations to obtain the output PP file. The product must be tested on a set of tests with the least number of errors. After that, the resulting PP is evaluated for quality taking into account the incoming resources in the AS. For maintenance of PP the certificate of quality according to standards has to be issued.
Coordinated and parallel programming provides a division of the computational process into several subtasks (processes)
for TRAN’s computers and supercomputers, the results of which are sent via communication channels. Languages for
parallel programming - PVM, LAM. CHMP and MPI (Message Passing Interface) interface descriptions and OpenMP. The
POSIX standard provides messaging between programs in LP of C, C+ and Fortran [
Programming on classes, on a prototype in OOP and Object-component methods - OCM
OCM are the mathematical design of systems by Graph from ready-made resources (objects, components, services, etc.)
to OM (Object Model). It is the formal method which transform the elements OM to a component model or a service
model [
Component paradigm. The basis of this paradigm - OCM graph in which vertexes graph are the components of the CRP
(reuses), interfaces and arcs specify the subject classification and the relationship between the vertices. Components are
described by the formalisms of the triangle of Frege [
Service-component paradigm. System and service-components - web resources implement intellectual knowledge of
specialists about applied fields in the Internet environment. Each implements some function and communicates with the
technological interface to interact with other services through protocols and provide Assembly and solution of applications
of different nature [
Methods of production of factories (Product Line/Product Family) programs and Appfab and certificate them of the
quality are discussed [
Application of the ontology language OWL (www.semantic_web.com), resource language (RDF) and intelligent agents of ISO 15926 standard for networking. Ontology of Life Cycle and Computational geometry is a part of computer graphics and algebra. Used in the practice of computing and control machines, numerical control etc. is also used in robotics (motion planning and pattern recognition tasks), geographic information systems [27].
The Agile methodology is focused on the close collaboration of a team of developers and users. It is based on a waterfall model lifecycle incremental and rapid response to changing demands on PP. Variants of Agile: eXtreme Programming (XP), SCRUM, DSDM…
Within the Internet (Things, Smart IoT) technologies are developing in the direction of creating smart computers, cities, robots and devices for use in medicine, genetics, physics, etc. The information objects (IO) that specifies the digital projection of real or abstract objects that use Semantic Web Ontology interoperability interfaces. IO through Web services began more than 10 years ago. Interaction semantics IO is based on RDF and OWL language of ISO 15926 Internet 3.0. The next step of the development of the Internet is Web 4.0, which allows network participants to communicate, using intelligent agents. A new stage in the development of enterprise solutions-cloud (PaaS, SaaS) who spliced with Internet space and used to create Adaptive applications. Cloud services interact through the Web page by using agents [28]. Internet stuff (Internet of Things, Smart IoT) indicates the Smart support competing APPS using distributed micro services such as Hyper cat (mobile communications); industrial Internet (Industrial), covering the new automation concepts-smart energy, transportation, appliances, industry», and another.
Today computer nanotechnology is actually already working with the smallest elements, "atoms" similar to the thickness of the thread (transistors, chips, crystals, etc.). For example, a video card from 3.5 million particles on single crystal, multitouch maps for retinal embedded in the eyeglasses, etc.[28].
In the future, ready-made software elements will be developed in the direction of nanotechnology by "reducing" to look
even smaller particles with predetermined functionality. Automation of communication, synthesis of such particles will give
a new small element, which will be used like a chip in a small device for use in medicine, genetics, physics, etc.[28-33].
In this article proposed the theoretical apparatus of graphs to create modular program structures. The graph theory allows us
to establish the shortest path of program elements (modules) and prove the correctness of binding graph modules using
adjacency matrices, reach ability and mathematical operations (association, connection, difference, etc.) in complex
program structures (complex, system, packets, etc.). Author are formulated the theoretical aspects of the application of
graph theory in [
The graph theory, programming paradigms and ontology of mathematical modeling of applied problems for vital areas of
society (medicine, biology, physics, mathematics, economics, etc.) will become the main tools of smart machines of the
21st century [