The technology of Assembly of intellectual (Reuses) and information (data) resources which are developed and saved up in libraries and storages of the Internet, in applied web-systems of different function is offered. The intellectual tasks of subject areas of knowledge in the Semantic Web in mind service, software and system resources used in creating Web systems are presented. Methods of assembling resources (link, make, assemble, weaver, kconfig) are considered for modern environments. The problem of data exchange and generation to the formats of the global network environment according to ISO/IEC 11404 GDT is defined. The concept of a network resource collector is proposed as a generalization of ways to assemble resources with functional security, resource protection and quality assessment of Web-systems. Perspective paradigms of programming of different areas of knowledge are defined.
formed in the country [
- analysis, integration, aggregation of information (for example, documents, in the required structures for processing at different levels of management of organizations of the country, etc.) for the calculation of tasks, etc.
2.1
Modern means of knowledge representation in terms of descriptive logic include: FaCT (in LISP), FaCT++ (in C++), CEL, KAON-2 (JAVA), MSPASS (C) and Pellet (JAVA), etc. The necessary component of knowledge representation are applied webservices focused on collective problem solving in the subject areas of knowledge in modern environments (problem-solving environments, PSE) in the world community. KBS (Knowledge-based systems), CommonKADS, etc. are used in the process of creating knowledge models of subject areas. They provide the construction of knowledge libraries containing elements of problem solving, which can then be reused in other areas of knowledge. Based on the fact that the PL program is some formal or mathematical text, the system of text information and terminology management (System Quirk – SQ, http://www.computing.surrey.ac.uk/SystemSQ. This system is focused on the creation and maintenance of terms in the terminology database (TBD) and knowledge bases (BZ), as well as the organization of collections of texts on the computer using the tools Virtual Corpus, KonText, Ferret, Grid, etc. To maintain large amounts of data and ensure the functioning of systems in the global Internet, system, service and communication resources are used, including web Semantics tools-this information environment in the World Wide Web, which provides semantic resources, languages, tools and tools for developing ontologies of subject areas of knowledge, application systems and business processes using the accumulated knowledge in the environment http://semwebprogramming.org. In the web Semantics environment, automated processing of scientific tasks, big data in different formats, integration of data from collages (Mash-Ups), search and composition of web services, management of intelligent agents in mobile applications, etc. is carried out. One of the tools of knowledge intellectualization in Semantics about different subject areas of knowledge (mathematics, physics, biology, medicine, etc.) is ontology (www.semantic.web.ontology). Ontology is a conceptual model building tool for knowledge domains / domains. The conceptual model includes objects, object classes, data structures, relationships, and relationships (theorems, constraints) for a particular field of knowledge.
There is experience in developing the domain ontology SE-Life Cycle ISO / IEC
12207 -2007 in OWL (Web Ontology Language) in Protégé 2.3 environment with the
output result in XML. The approach to automation of Life Cycle (LC) management
was presented at the International conference "Science and Information-2015"
(www.conference.thesai.org) in London and at the XVII all-Russian scientific
conference-2015-2016 "Scientific service on the Internet" in Novorossiysk, KIAM by M. V.
Keldysh [
Intelligent and information resource Assembly technology is the process of assembling resources (modular elements in different subject areas – SA), data structures, procedures, classes, components and services. Resources are developed for different applied fields of knowledge (mathematics, medicine, biology, genetics, etc.). They are stored in libraries, Internet repositories, and system-wide environments (IBM, MS.Net, Unux, Intel, etc.). Repositories include libraries, repositories, databases (DB). Procedure libraries, knowledge Bases, Reusability Libraries and other. Functional elements of the reuses type are created by highly intelligent specialists in the field of computer science, mathematics, biology, etc. (for example, MatLab, Demral, etc.). Each ready-made reuse when placed in a shared library is checked for the correctness and quality of the implementation of the functions of the knowledge domain.
Intellectual resources (INR) are reuses, Components Ready Using (CRU) that
reflect the knowledge of professionals in different fields of knowledge. Any the
knowledge domain Pro function is described in the PL as a module (object,
component, service, etc.) and can interact through the link Assembly operator and
Call/RPC/RMI operations in the texts of PL programs, in the parameters of which
data are specified in IDL, API, ABI, WSDL, etc. CRU process data that belong to the
fundamental (FDT) and General data types (GDT) of the ISO/IEC 11404 standard,
and can also operate with large amounts of data (Big Data). INR interact with
modules, objects or service components of the Internet through the interface specified in
the languages IDL, API, ABI, WSDL, etc. [
Reuse is a ready-made intelligent software object, component, service that implements the algorithm of a function in some subject area of knowledge. It is specified in the standard WSDL language and can be reused if it meets the functional requirements of individual subject areas. CRU as Reuses has the code (implementation) with the interface (interface) and the scheme of deployment (deployment) for their performance. CRU, Reuses can have common variables that form classes or sets. External shared variables and class methods are specified in the class instance interface.
Information resources (IR) are data of different volumes, including Big Data,
presented in Databases, files, directories, tables, documents, etc. IR are processed by
service, system, client and server services of the Internet and placed in data
Warehouses, databases of small and large volumes with structured and unstructured data
[
The interface is described in WSDL and generally contains: - function (method) name and resource ID; - description (specification) of a function by means of PL; - parameters (input and output) for data transmission to other CRUS; - CRU description language (C, C++, Java, Python, Ruby, etc.); - optional attributes (date, status, version, access right, author, term of use, etc.).
The programming environment (Eclipse, Protege, etc.) allows you to automatically create resource descriptions based on JAVA classes.
The following main data types are defined: 1) strings (xsd: string); 2) integers (xsd: int, xsd:long, xsd:short, xsd:integer, xsd:decimal), floating point numbers (xsd:float, xsd:double); 3) logical type (xsd:boolean); 4) byte sequence (xsd:base64Binary, xsd:hexBinary); 5) date and time (xsd: time, xsd:date, xsd:g); 6) the object type (xsd:anySimpleType).
As variables can be used sets, sequences, including a fixed number of variables of simple types. A typical WSDL file has the following structure: <wsdl:definitions> <!-- Declaration of the types that are used in the service --> <wsdl:types> <element name="someMethod"> <complexType> <sequence> <element name="arg0" type="xsd:double"/> <element name="arg1" type="xsd:boolean"/> </sequence> </complexType> </element> <element name="someMethodResponse"> <complexType> </wsdl: types> …
This WSDL description specifies a MyService web service with a single string method someMethod (double arg0, boolean arg1). On its basis, you can generate two types of data that correspond to the input and output parameters of the method. These types are used in the someMethodRequest and someMethodResponse descriptionsinput and output messages for the someMethod operation. The operations are declared in the service interface description (WSDL:portType Declaration) and then the description of binding the service to the SOAP Protocol (Simple Object Access Protocol) through the WSDL:binding Declaration is given. This sets the call to <wsdlsoap:bodyuse= "literal" /> with the parameters specified in the class method. At the end of the WSDL file is a web service Declaration (<wsdl:service>) that contains location information <location parameter>.
Web services are based on open Internet standards, which are widely supported on Unix, Intel, Windows, IBM, Linux, etc. platforms and are specified by PHP, ASP, JSP script, JavaBeans, etc. The format of requests to Web services defines the SOAP Protocol, which is specified in XML and sent via HTPP to the Web server. IBM, Microsoft, and Universal Description, Discovery and Integration (UDDI) contribute to the creation of a common web services catalog. SOAP, XML, and UDDI also ensure that applications from Web services and service components function reliably.
The means of creating application systems in the Internet include service-oriented architecture SOA (Service Oriented Architecture) and service-component architecture SCA (Service-Component Architecture). SOA defines the functionality and Quality of services at the levels:
– transport (transport layer) for the exchange of external data at the communication layer (service communication layer);
– service and interface descriptions (service description layer) with security and protection (authorization, authentication);
– operations of publishing, searching and calling services through the services registry.
Consider the services of SOA and SCA. Operations on SOA services are as follows: 1) publishing the service through the service call and its interface; 2) search for a service using the SOAP Protocol; 3) UDDI communication with CORBA, DBMS, JNET, etc.; 4) request to the provider for published service interfaces.
The SCA service provides access to service components that are packaged into a service module in a WebSphere environment equivalent to a J2EE EAR file. SCA services are integrated through the JAVA interface and implemented as JAVA™classes.
In the SCA model, data objects are represented in JAVA common.sdo.A
DataObject that includes a method for defining data properties. WebSphere Integration
Developer platform Eclipse 3.0 allows you to compose (assemble) SCA services and
service interfaces. You use JMS, Enterprise JavaBeans, or off-the-shelf services to
call an external service. Access to the database of the system is carried out through
the link server. The web system is assembled from the service components described
in Python, JAVA, BPEL, OWL and interfaces using the SAP kconfig configuration
operation [
(http://www.ibm.com/developerworks/websphere/techjournal).
These services can be created in the Java Enterprise Edition environment [
SCA can create new service components for problem areas of knowledge, as well as data objects (Service Data Objects-SDO) and interfaces that provide data transfer to other CRUs.
You use JMS, Enterprise JavaBeans, or off-the-shelf services to call an external service. Access to the database from the system (enterprise / company) is carried out through the link apparatus. The Web system you create is assembled from the service components described in Python, Java, BPEL, OWL, and interfaces using the SAP kconfig configuration operation (Fig. 2).
When working with web services with data from the Big Data class, the following Internet tools are used: IBM WSDK+WebSphere; Apach Axis+Tomcat; Apach Axis+ Classfish; Microsoft.Net + IIS, etc.
The main system resources of the Internet include the client-server architecture of the
Internet [
The database server starts from the application server and performs database maintenance to ensure the integrity, safety of data when the client accesses the database information. To work with Big Data, you perform tasks of analyzing large amounts of data, as well as manipulating data with small and large loads.
The client corresponds to the Internet browser (Chrome, Firefox, MS Internet Explorer, Safari, Opera, etc.). It sends messages to the server through an interface like this: WebAppInterface = {Requestp}, where Requestp is the PTH request. Request processing is performed by server components such as: Internet Information Server, Apache, Tomcat, JBoss, WebSphere, WebLogic, Cloudscape. Apache Web server and JAVA provide INR processing in modern PL and have the form:
IR APACHE = {PERL, PHP, PYTHON, XML, SQL},
IRJAVA = {JAVA, JSP, JSTL, JSF, XML, SQL} in system components envirinment (Tomcat, JBoss, WebSphere, WebLogic и др.).
Server Internet have the tools: ASP, JavaScript, VB Script, ASP.NET, .NET, J#.NET, XML, SQL) and languages (C, C++, C#, Python, Ruby, Cobol, Prolog and ets.).
Data IR includes: data models, data storage and access operations, data processing, etc. They perform data access and interaction with entity resources in the EJB model. When working with large amounts of data, the ETL (Extract Transform Load) method transfers data from one application to another through the client-server architecture and extracts data from external sources, analyzes it and transforms it to meet the requirements of conceptual models and executes it on the Internet.
The technology is based on the method of assembling resources and communication
interface (assembler) of heterogeneous CRUs into an architecture with a one-to-one
conversion of input and output data types. An intermodule interface is a set of tools
for formal conversion of multilingual CRUs. The interface between CRUs includes a
set of formal means of data exchange between modular elements [
An Assembly technology is a method, means, tools, and process for assembling heterogeneous resources that consists of defining:
- schemes, graphs and models of the subject area of knowledge; - repository modules (CRU, Reuses, procedures, etc.);
- module algorithms with CALL / RPC /RMI module operations; – interface modules with the parameters of the transmitted data;
- storage operations and selection of modules, CRU from repositories; - verification, testing of modules, their interfaces, etc.; - functional reliability and quality of resources and systems from them.
In practice of programming systems of Assembly of modules by means of operations of Assembly were formed: link APROP (CORBA); make of compiler programs BSD, GNU, MSBuild; assemble, Kconfig of system, service and computing resources EuroGrid; config of service SOA, SCA of resources in Semantic Web; weaver BEA WebLogic Oracle, SAP Net. Consider these build systems.
Link Assembly in APROP connects modular resources in different YAP (Algol,
Fortran, Cobol, Prolog, Modula, etc.) through the interface in MDL, IDL (Interface
Definition Language) type stub, skeleton (CORBA). On the basis of link, data and
control links of modules are generated and non-equivalent data exchanged between
them is converted [
This scheme is a client program C, in which CALL A and CALL B are specified to call modules A and B and transmit data to them through the interface modules A’, B’ with the necessary conversion to the form of data A and B, which are performed on the server. The server accepts the message from the programs and starts of the modules A, b with demarshaling arguments. After executing modules A, B, the result is obtained, which the server packages into a message and sends it back to program C.
An example of communication modules P1, P2 in PL (Pascal, Delphi) through the interface Unit 1 is given in Table 1.
Assembly according to the scheme Fig.3 implemented on a variety of software and
hardware complexes MIC (PROMETHEUS, RUZA, YAUZA, etc.) of the USSR
1981–1990 [
In this system, modules are built in different link by type APROP using the object model (OM) and assembled through interface intermediaries - Stub-client and Skeleton-server, performing the same functions as data transfer and processing between objects written in the NPS class (Fig. 4), based on the library of primitive functions APROP with the addition of primitive functions for PL: C++. Ada-95, Basic, Prolog, Smaltalk et al.
The Assembly operator processes the transmitted data between modules using the CTS system (Common Type System, Fig. 5).
The objectives of the Assembly included: - display value types, reference and inline data types in computer data format;
- description of common Language Runtime (CLR) routines and processing of integer data, floating point, strings, bits;
- specifications of classes, interfaces, built-in data types, enumerations, etc., specified in the CLS (Common Language Specification);
- translation of data in PL to intermediate MSIL, which is converted to CPU code for execution on different architectures of network computers.
Implementation of this scheme on the platform MS.NET is given for PL in [
The operation parameters (op_dcl) in the interface assignment are: 1) data type (type_dcl); 2) the constant (const_dcl); 3) the name of the exception (except_dcl) that may occur during the execution of the object method; 4) parameter attributes (attr_dcl). The description of data types (TD) begins with the typedef keyword, followed by the base or constructed type and its identifier. As a constant, there can be some value of the given type or an expression composed of constants. TD and constants are described as fundamental data types: integer, bool, string, float, char and etc.
The description of op_dcl data transfer operations includes: 1) the name of the operation interface; 2) parameter list (zero or more); 3) types of arguments and results, otherwise-void; 4) control parameter or description of an exceptional situation, etc.
Attributes of transmitted parameters begin with service words: in – when sending a parameter from the client to the server; out - when sending parameters-results from the server to the client; inout – when passing parameters in both directions (from the client to the server and back).
The interface description for one object can be inherited by another object and then this description becomes basic. An example of this is given below: const long l=2 interface A { void f (in float s [l]); } interface B { const long l=3 ) interface C: B, A { }.
Interface C uses interface B and A. this means that interface C inherits the description of data types A and B, which are external to C. But the syntax and semantics remain unchanged. According to the given example-the operation of the function f in the interface C is inherited from A.
This method performs processing of the source code in PL (C++, Fortran, Go, Perl, PHP, Pyrhon, Java) with make, cmake on BSD systems, GNU Unix, and MS and Assembly interface in the API (Application Programming Interface) an executable file in native code (libraries of modules of Microsoft, Unix, etc.), as well as the integration of the integration of compiled modules with ABI (Application Binary Interface) to an intermediate language MSIL bytecode in the environment .NET (Fig.6).
The process of building resources in PL with an interface in API and ABI through make executes the GNU Build system Assembly script generator in MSBuild (.NET), Apache Ant (Java), Apache Maven translators with Java, C#, Scala; Scons(C, C++, Java, Fortran,Tex), etc.: - the instruction set of the processor to the register file, stack and memory; - the size and location of the base data that the computer processor works with; binary file formats, libraries and executables.
Program communication operations in API and ABI for C++ and Fortran (Fig.Seven): add executable (exec_name source1 source2 ...) - create executable file from source code files source1, source2, etc.;
- add library (lib_name source1 source2 ...) # create lib_name library from source code files source1, source2, etc.
- target include_directories (target PUBLIC dir1 dir2 ...) # include dir1, dir2, ... direc-tories in the header search list when building an executable from the library; - target_link_libraries(target lib1 lib2 ...) # link (include in Assembly) library elements lib1, lib2 for target.
Build in GRID (www.gloubos.org) provides interaction of resources through calls of RPC/RMI in programs on YAP by means of operations assembling, config, make and establish communication of resources among themselves at work with Cloud Computing and Big Data. A system GRID (Fig. 8) provides processing and management of software, service and other Web resources of the global network. The Assembly of heterogeneous network and system resources into Web systems, applications and packages that work with data of different volumes is carried out in the ETICS GRID system (Fig. 8). Resources are described in different modern PL. The basic entities of systems, services, and applications, as well as relationships, are described in the CIM (Common Information Model). ETICS uses a standardized description of the project for the main objects: Project, Subsystem, and Component. Project. A subsystem can contain only Components. They use the CIM data model to define relationships between different objects and to describe objects and relationships between them, and to pass the results of their execution to queries. Storing and maintaining data is based on a relational type model in MySQL.
The data model description is based on the following basic assumptions: 1) each component contains a description of the information (name, license, repository URL, etc.) and a global unique identifier-ID (GUID); 2) the configuration object contains version information, repository link, GUID, framework platform and system configuration link; 3) each component is checked (checkout) compiled element, test commands and GUIDs, as well as communication with the configuration; 4) when defining the configuration and platform, each object displays a GUID, its properties, runtime, and dependencies, which can be declared statically or dynamically. A static dependency is a relationship between two configurations, a dynamic dependency is a relationship between a configuration and a module.
ETICS by function is a modern software factory. It is based on a set of features, services, and package-building procedures that can be combined by plugins, provide job management, and provide access to the OS, CPU architecture, compilers in the YAP, and tools to define different packages and test them after resource Assembly and deployment. Many functional plug-ins provide contract verification, execution tests of different system elements, documentation generation, maintenance of readymade СPIs in the operational or static repository.
The main task of the ETICS system is to convert some system components for an alternative platform of heterogeneous computer environment by means of links from 16 -, 32-bit platforms to 64-bit Grid environment platform. Unicore (Uniform Interface to Computingresources) deals with software interface support issues (www.unicore.org). the WSRF (Web Service Recurse Framework) tool provides security And protection of data resources and systems. The Grid environment includes system components that provide simulation of physical experiments, Cloud computing and processing of large amounts of data:
- Globus Toolkit (GGF) for SOA and SCA; Condor (www.cs.wisc.edu/condor); WebFlow (http://www.npac.syr.edu/users/haupt/WebFlow/); Nimrod/G - (www.csse.monash.edu.au/~davida/nimrod/references.htm); - Gridbus Data Grid Service Broker;GRACE (Grіd Archіtecture for Computatіonal Economy);
- Grid- Port and Grid Port Toolkit) for management creation of Web-systems.
Build by type of software factories: IBM WebSphere, Microsoft Biz Talk, BEA
WebLogic Oracle 10g, SAP NetWeaver and IVK “Jupiter”. They contain CASE tools
for assembling (link) resources (services, components and data through the data
broker stub and skeleton of the CORBA system, overeating data using the Workflow
Protocol with safety and quality control (Table 2) [
In the software factories of these systems, the architecture is modified according to the required service resource codes of the SOA model in Visual Studio Industry Partners (VSIP). This uses the Guidance Automation eXtensions (GAX) and Guidance Automation Toolkit (GAT) models in Visual Studio. GAX is an execution environment in VSIP using recommendation packages. There are two service options: web service ASP.NET (ASMX) for Windows Communication Foundation (WCF) in the .NET Framework 3.0. Versions for the WCF web service are available from the developers of the GotDotN SOFTWARE factory. It includes enterprise processes and packages of documentation and recommendations for an application such as Global Bank. This is similar to the SCA model in IBM WebSphere.
Build (integrate) different programs on CASE tools: Make, Apache Ant, Apache Maven, Gradle, etc. Make is a cross-platform automation system for building systems from source code. It generates Assembly control files, such as a Makefile on Unix systems, for Assembly through the make operation (see 3.4.) Apache Ant-JAVAutility to automate the process of building a software product. Ant is a platformindependent analogue of the UNIX make utility, but using the JAVA language adapted for JAVA projects. The most important difference between Ant and Make is that Ant uses XML to describe the build process and its dependencies, while Make has its own Makefile format. XML file (or build.xml) builds executable programs.
Assembly in GFM is a way to assemble resources in an industry. K. Chernetsky created a generational multiassembly on Product Line / Product Family. (see Generative programming. Methods, tools, application, 2005.- 750s.). The GDM model introduces new concepts to represent the subject areas of knowledge: the problem space, the solution space, and the configuration base of the system family (SF). The task space displays the concepts of Software Systems / Family (SSP), members and their General characteristics in the MF (Feature Model), as well as functions and tasks that are described by the GPL (General-Purpose Language) or domain-oriented languages DSL, UML2. The solution space is the components, frameworks, templates, and CRUs of implementing the tasks of members FS of the SSF family.
The rules of description, generation of components and selection of СPIs for individual SSF tasks are included in the configuration database. In this case, the framework is equipped with variable model parameters, which can lead to excessive fragmentation and the appearance of "many small methods and classes". The framework provides dynamic linking of aspects and components in the process of implementing variability between different applications. Design patterns enable the creation of reusable solutions in different program systems (PS). ActiveX and JAVABeans component technologies, as well as new build mechanisms, are used to define aspects such as synchronization, remote interaction, data protection, etc.
The results of the description of the SSF model in these spaces are in the configuration knowledge base (BZ): connections and characteristics (functional or nonfunctional) specified in the corresponding MF model of family members and construction operations are combined into a common PS or SSF. Knowledge about system configuration in the form of abstractions of General and special purpose, CRU and Reuses c results of their testing, measurement and evaluation are displayed in BZ.
The transformation model is described in a DSL. The main mechanism of transition from the description of models to the initial result is the transformation of domain concept descriptions into an intermediate language of DSL-space of solutions, and then into a language of implementation of components taking into account the platform, where ready-made components and/or new tasks are located.
In the software factories of these systems, the architecture is modified according to the required service resource codes of the SOA model in Visual Studio Industry Partners (VSIP). This uses the Guidance Automation eXtensions (GAX) and Guidance Automation Toolkit (GAT) models in Visual Studio. GAX is an execution environment in VSIP using recommendation packages. There are two service options: web service ASP.NET (ASMX) for Windows Communication Foundation (WCF) in the .NET Framework 3.0. Versions for the WCF web service are available from the developers of the GotDotN SOFTWARE factory. It includes enterprise processes and packages of documentation and recommendations for an application such as Global Bank. This is similar to the SCA model in IBM WebSphere. Build (integrate) different programs on CASE tools: Make, Apache Ant, Apache Maven, Gradle, etc. Make is a cross-platform automation system for building systems from source code. It generates Assembly control files, such as a Makefile on Unix systems, for Assembly through the make operation (see 3.4.) Apache Ant-JAVA-utility to automate the process of building a software product. Ant is a platform-independent analogue of the UNIX make utility, but using the JAVA language adapted for JAVA projects. The most important difference between Ant and Make is that Ant uses XML to describe the build process and its dependencies, while Make has its own Makefile format. XML file (or build.xml) builds executable programs.
Under the configuration of the system is understood the structure of some of its
versions, including functions, combined with each other communication operations with
parameters that specify the modes of operation of the system [
Configuration Management is to monitor the modification of configuration parameters and components of the system, as well as to conduct systematic monitoring, accounting and auditing of changes, integrity and health of the system on the processes: 1. Configuration Identification; 2. Configuration Control; 3. Configuration Status Accounting; 4. Configuration Audit; 5. The tracing configuration, maintenance and operation of the system; 6. Verification of component services according to the model of the system or the web system.
The system model and MF (Model Feature) model are used in the configuration Assembly of the CRU. RUs are selected by their libraries, adapted and integrated into the system. The main role in these processes is performed by the Configurator, for example, Fig. 9 in (http://7dragons.ru/ru).
The Configurator manages the creation of a variant of the finished product and stores it in the repository. The model of the environment of the Configurator includes: граф graph structure of the system from resources; system options model; configuration model and CRU Assembly operations; аудит system configuration audit; verification of models and resources; quality assessment of KRU and systems.
The Configurator builds the web system using the config operation (http://7dragons.ru/ru) on the model of Msys, MMF and specified domain resources and their interfaces. The configured file is then evaluated for quality and security.
Linux OS variant configuration build OS Linux contains more than 10 000
variables and a large number of functional system components that provide processing of
various tasks for the functioning of any application systems running OS Linux is
presented in the diagram (Fig.10) and performed in the master's work [
At the top level is the user space, which houses user applications and the GNU C library (glibc) with system call interfaces to communicate with the kernel. The Linux OS kernel contains more than 11,000 program elements and is common to all processor architectures supported by Linux. The next level – architecture-dependent BSP (Board Support Package) kernel code defines a specific processor and platform architecture. Linux OS can be compiled for a huge number of different processors and platforms with different architectural constraints and needs. Linux OS can run on a processor with or without a memory management unit (MMU).
The main components of the Linux OS kernel include the following: - kernel function system call interface; - manage processes or threads using the application programming interface (API) via SCI to create a new process and scheduler algorithm whose running time is independent of the number of threads; - memory management with the participation of hardware that establishes the correspondence between virtual memory and physical memory; - definition of a virtual file system (VFS), which provides a General abstraction of the interface to file systems and serves for switching between SCI and kernel file systems; - the network stack has a multilevel structure of the protocols themselves.
Internet Protocol (IP) is the basic Protocol of the network layer and is located below the transport Protocol TCP (Transmission Control Protocol). Above TCP is the socket layer and is a standard API to the network subsystem and to hardware devices. From the OS kernel, the necessary components are selected and an MF model is created with the basic characteristics of the OS components and the Msys system model, including many functional MF, interface Mio and Md of working with the data of the Linux OS base kernel.
The types build different resources in Sections 3.1–3.9 (link, make, config, assembling, building, weaver, integration) for creating application, service, information and technical systems in the network to the Global Internet, is based on the theory of conversion of complex data types ISO/IEC 11404 GDT to a more simple FDT for calculations on the created systems. The General provisions of the data type conversion theory of this standard are discussed below.
Fig. 10. The structure of kernel ОS Linux.
Heterogeneous CRUs, service components work with data that includes multiple
values, operations on those values, and the interaction of performing operations on them.
Initially, the module Assembly method used the axiomatic FDT (Fundamental Data
Types) in the YAP class for the EU OS. This axiomatics was developed by
wellknown specialists E. Dijkstra, N. Wirth, V. Tursky, V. N. Agafonov and others in the
70s [
Fundamental data types (FDT) include: simple types (integer, real, boolean,
character, bite, etc.); complex (arrays, tables, files, records, sets, trees, etc.). These
parameters set the basic values of data in the programs in the PL, which is checked at
the compilation stage for type compliance. At runtime, they are implemented using
polymorphic type predicates. CRUs exchange data, the values of which must
correspond to each other. In case of nonconformity of TD (for example, integer is passed,
and it is required for execution of the called module real), equivalent transformations
of the exchanged data (integer <-> real) are carried out by means of primitive
functions of APROP interface library for FDT [
To the problems of conversion of TD are different in of modules or components: a) discrepancy of quantity (formal and actual) of parameters or their incorrect description;
b) inconsistency of types of transmitted parameters or their values for computer formats; с) absence of direct and inverse transformations of parameters, etc.; d) no transformation of complex to simple data types. The new GDT standard works in information and software systems with data such as containers, templates, patterns, protocols, pointers, sets, lists, sequences, non-structural, heterogeneous, etc.
This standard ISO/IEC 11404 GDT-1996 has passed many years of testing and released a new version in 2007. the standard ISO / IEC 11404 GDT-1996 includes aggregate, generative, extensible, etc. TD, which require their generation to the fundamental TD for subsequent use in the ready resources of the Global Internet to perform calculations. In this regard, it is necessary to develop new primitive conversion functions of non-equivalent TD for new YAP (C, C++, Python, Basic, Ruby, JAVA, etc.) and other types (Fig. 12).
Fig. 11. The data types in GDT standard.
To solve the problems of data transformation according to the GDT and FDT standard when linking (interacting) CRU and services specified in different modern NPS, an approach to the generation of GDT<=>FDT is proposed (Fig. 13), the Basis of this approach is the problem of converting common data types to simpler FDT.
To support resource Assembly, you must implement the following GDT<=>FDT data conversions: specifying external TD’S in WSDL, saving them in DB and in repositories; convert TD GDT to TD in new PL1,..., PL n ; implementation of TD GDT with special primitive functions and taking into account the format of framework platforms; equivalent mapping and generation of GDT<=>FDT data taking into account the platforms of modern computer and Internet cluster systems where resources will operate.
Semi-structured, unstructured and expandable TD appear in connection with the exploration of the bowels of the earth, space and ocean. Practical processing of these new data structures will be required in order to solve effectively applied tasks in different application areas, especially those working with Big Data
Approaches to processing unstructured Big Data a set of large-volume data, as
well as approaches, tools and methods of presenting unstructured huge amounts of
data to obtain data and effectively use them on numerous nodes of the Internet when
solving applied intelligence is and it systems using DBMS [
The main properties of Big Data include: horizontal scalability of processed big data and a large number of clusters and servers;
fault tolerance against the failure on processor clusters and nodes in the network. Thus, the Yahoo hadoop cluster tool has more than 42,000 computers, among which some of them may fail;
data localization and processing on servers where big data is practically stored to solve the relevant tasks; change the number of workers on the cluster using MySQL Cluster tools;
Big Data can be represented as tensors that control computation (e.g. multilinear subspace learning, Etc.).
System tools for processing Big Data include:
NoSQL is a database of non-relational and distributed data with open source and horizontal scalability, effectively support random read, write and versioning. MapReduce is a distributed computing model that is used in parallel computing with big data in computer clusters. Hadoop is a freely distributed set of utilities, libraries, and frameworks for developing and running distributed applications (including MapReduce programs) running on clusters of hundreds or thousands of nodes.
SMB-big data processing systems within Cloud computing. Big Data is analyzed by means of statistical and dynamic methods of analysis of artificial intelligence, neural networks, mathematical linguistics; A/B Testing, Crowdsourcing Data Fusion; Integration Genetic Algorithms Machine Learning; Natural Language Processing; Signal Processing Simulation and Visualization; Massively Parallel Processing; Search-Based Applications, Data Mining, Multilinear Subspace Learning, etc.
To build services there is a Jopera tool for Eclipse (http://www.jopera.ethz.ch/), containing a set of Eclipse-plugins for communication of various software resources and implementation of iterative composition of services (via routers SOAP and RESTful Web-service, Grid-services, Java snipes, etc.) and modeling of processes on the Internet. To search for services by their semantic descriptions, Feta Client and Feta Engine are used, where Feta Client is a GUI plugin of the Internet Taverna system to describe the service, and Feta Engine to specify the Webservice.
Internet to work with resources uses three-level Internet Architecture: client,
application server and Database server (DB) [
The database server starts from the application server and performs database maintenance to ensure the integrity, safety of data and client access to database information. When working with Big Data on the server, the tasks of managing and analyzing large data, as well as manipulating data with a large load are solved. The front-end client part of the application is responsible for the interface to the hardware and software part of the web application. Front-end servers handle Internet applications that take up sufficient memory space. Back-end server runs a server application in PL (C, C++, Python, Ruby, Java, Basic, etc.), organizes their calculation and processing of emergencies.
According to the ISO / IEC 12207 standard, the software LC standard regulates the
planning, quality management and cost estimation for the creation of the system. In
these processes, lifecycle analyses quality assurance; verification and validation
(V&V) resources and evaluating the degree of achievement of individual quality
indicators; test of the finished system; data collection about the failures, defects etc. and
failures; assessment of the reliability on the respective reliability models based on the
results of testing [
The ISO/IEC 9000 (1-4) Quality model defines six characteristics q1– q6 (q –
qualiEach qi characteristic is calculated according to special formulas and metrics of the
standard. Reliability is evaluated according to the errors, defects and failures in the
SOFTWARE obtained during the testing process and according to the corresponding
reliability models (evaluation, measurement, etc.). Data on all quality indicators
q1 — q6 are evaluated by the formula:
6
=1
=
∑
where aij-attributes of each quality indicator (i = 1..6); mi – metrics of each quality
attribute; wi – weight of each attribute of the system quality indicator. The obtained
values for the indicators of the quality model are included in the product quality
certificate. Options for assessing the quality of configured systems are given on the ITC
website [
The technology of assembling Web-systems from intellectual and service resources
was formed in the framework of RFBR project No. 16-01-00352 "Theory and
methods of development of variable software systems" [
The analysis of intellectual and information resources in the environment of Semantics of Web and open models of SOA and SCA for representation of these elements by means of system services, servers, clients and means of data processing of Big Data in Cloud Computing is given. Assembly operations (link, make, cmake, config, weaver) are considered on the example of existing systems (APROP, CORBA, BSD, GNU, MSBuild; EuroGrid; Semantic Web; BEA WebLogic Oracle, SAP Net, etc.). The theoretical apparatus of resource Assembly using fundamental and General data types and mechanisms of transformation of non-equivalent unstructured data (including Big Data) transmitted through the Assembly operations in the Internet environment based on the ISO/IEEE 11404 GDT standard is presented. The configuration Assembly of resources and processes of verification, testing and quality assessment using the ISO/IEC 9000 (1-4) Quality standard of the received product is described. The RFBR project 16-01-00209 (2019-2021) considers the client-server architecture of the Internet and the configuration Assembly of intellectualization and information ready-made resources with the provision of functional security, reliability and quality of Web systems for working with Big Data in the Cloud Computing environment. The graph theory, new 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.