Normalized Systems are a model-driven development technique focusing on evolvability and sustainability of resulting enterprise information systems. It applies well-defined principles to create a fine-grained modular structure while limiting combinatorial effects. The systems are generated (or, more precisely, expanded) from models of so-called NS Elements. NS has its own modelling language; however, interoperability with other knowledge representations is necessary. This work presents our solution for transforming knowledge kept in one of the most generic forms – RDF semantic triples – to NS Elements. The transformation enables mapping using RDFS/OWL ontologies describing both the input RDF. It utilizes SPARQL for executing the transformation to RDF based on the existing NS Element ontology. The presented transformation is demonstrated on an example case study, and its features and limitations are discussed together with potential future steps.

Normalized Systems (NS) theory describes how to design and develop evolvable systems. It is applied in practice to generate enterprise information systems using NS Expanders from models of NS Elements. As there are various well-established modelling languages, the possibility to (re-)use them to create NS applications is desired. This paper presents a mapping between the NS metamodel and the Ecore metamodel as a representant of essential structural modelling. The mapping is the basis of the transformation execution tool based on Eclipse Modeling Framework and NS Java libraries. Both the mapping and the tool are demonstrated in a concise case study but cover all essential Ecore constructs. During the work, several interesting similarities of the two metamodels were found and are described, e.g., its meta-circularity or ability to specify data types using references to Java classes. Still, there are significant differences between the metamodels that prevent some constructs from being mapped. The issues with information loss upon the transformation are mitigated by incorporating additional options that serve as key-value annotations. The results are ready to be used for any Ecore models to create an NS model that can be expanded into an NS application.

Evolvability is one of the most desirable non-functional requirements of software architectures. In the area of automation control, the permanent shift of the requirements and the prevention of side-effects are key points. In addition, adaptability and flexibility in manufacturing systems continue to gain importance. This paper proposes an approach to achieve evolvability in IEC 61131-3 based software modules, from a structural point of view, i.e., starting from an individual line of code. We based our design of an evolvable ISA88 Equipment Phase on the Normalized Systems theory recently introduced. It seems indeed possible to develop evolvable IEC 61131-3 based modules with the existing, commercially available development environments. However, our guidelines require a disciplined programming style in extending software, based on a limited set of anticipated changes.

SUMMARY In today's increasingly volatile environments, evolvability is quickly becoming the most desirable characteristic of information systems. Current information systems still struggle to provide these high levels of evolvability. Based on the concept of stability from systems theory, we require that information systems should be stable with respect to a set of anticipated changes in order to exhibit high evolvability. This requires that information systems should be free from so‐called combinatorial effects. Combinatorial effects occur when the impact of a change is dependent on the size of the information system. To eliminate these combinatorial effects, we propose four theorems that are constraints on the modular structure of software architectures. The theorems are prescriptive and ensure that stable information systems are built, thereby guaranteeing high evolvability. We further present five higher level modular structures called elements. These elements provide the core functionality of information systems and comply fully with the stringent constraints implied by the four theorems. The internal structure of these elements is described by design patterns which are eligible for automatic code generation. These design patterns offer a constructive proof that it is possible to build information systems in practice by applying this set of theorems. Copyright © 2011 John Wiley & Sons, Ltd.

Normalized systems theory has recently been proposed to engineer evolvable information systems. This theory includes a potential of improvement in control software for the automation of production systems. This paper aims at contributing towards evolvable and therefore easy-to-maintain control software. We introduce IEC 61131-3 code which complies with the theorems of normalized systems, forming a building block which complies with the model of an ISA88 control module, accessible via an OPC UA interface. Since OPC UA brings control software to a new level, it enables original intra-process projects to interoperate in an inter-process context. OPC UA offers new possibilities for system integration, but might also lead to a larger impact of evolvability problems.

Normalized systems theory has recently been established to engineer evolvable information systems. In order to build information systems according to this theory, a method to identify the normalized systems' primitives has to be constructed. Because business processes are currently receiving more attention as process-centric representations of an enterprise, this method should be able to translate business process models into the normalized systems primitives. In this paper, a preliminary mapping method based on proven software engineering principles, is discussed. The proposed method adheres to the normalized systems' viewpoint of business processes being normalized production lines. In this sense, business process production lines are identified as workflow elements operating on a single type of data element. These process lines are operated as state machines, triggering action elements on the specified data element. The mapping method is illustrated using an example of a realistic business process flow. Some initial conclusions on the method construction are presented.

Unlike other engineering areas, software engineering has yet to produce designs that enable automated production. This seems related to the fact that the fundamental laws for software engineering have yet to be found, leading to the belief that researchers should strive for a unified theory of software engineering. In this paper, the construction of a software engineering theory that could constitute an embryo to a unified theory is explored. The starting point of the theory is the major challenge of evolvability, and the related concept of systems theoretic stability. The basic assumptions of the theory, regarding evolvability and the related concept of modularity, are stated, and a number of definitions are presented. Based on a single postulate, five design rules or principles are deduced, proved, and explained. The results of the theory are discussed, including a brief overview of the implications on other software engineering issues like performance and testability, and a comparison with other software engineering theories, that could constitute an embryo to a unified theory.

The automation of all business processes and network management functions, and the Web-enabling of those information systems, is proceeding at a rapid pace. It seems inevitable that the monitoring and control of most industrial equipment and industrial controllers, shall become web- based as well. In general, this industrial equipment is controlled through binary protocols, and is not able to support modern Internet standards such as XML. In this contribution, a structured framework is presented to Web-enable the monitoring and control of various types of industrial equipment. It is both based on open software standards and component models, and on dedicated architectural design patterns. In order to describe the framework and its detailed design patterns, this contribution builds upon a recently proposed technique for the elaboration of architectural descriptions. The implementation of several management systems for various types of industrial equipment is described, and the results are discussed.

Automated production does not yet have an equivalent in the software development industry. Mathematical laws describing software development, and rules for structural composition of building blocks to create larger systems, do not exist exist at this point in time. Nevertheless, due to the fundamental need to improve the efficiency of software development, and to eliminate human errors, it is imperative to automate the software development process. In this paper, we explore some concepts that may contribute towards a more deterministic approach to software engineering. As the software industry is currently evolving to service oriented architectures, an attempt is made to define concepts like service interfaces, loose coupling, and stability of interfaces. In order to achieve a more structured and deterministic implementation of the components, the concept of pattern expansion is proposed: the extension of current code generation techniques to entire template solutions or design patterns. This technique is elaborated, and an implementation example is presented. The results of this pattern expansion prototype are discussed.

The ever-growing size and complexity of software systems creates a strong need for a major improvement in productivity in the software development process. However, automated production does not yet have an equivalent in the software development industry. Maintenance costs in particular, due to changes in requirements, remain extremely high in most software systems. Structured component models, component-based development processes, and initiatives for software factories are trying to tackle these issues. This paper states that there is a need to establish firm rules and laws that govern the process of software changes and evolvability. In order to contribute to the process of discovering these rules and laws, a case-driven approach is used. Based on a highly structured and large-scale codebase, an attempt is made to identify and quantify impacts and propagations of basic changes. Though the study is limited to a single codebase, the purpose is to contribute to an inductive reasoning process that may one day establish laws for software evolvability, similar to the mathematical foundation of systems theory.

A parallel, self-similar network is proposed for the analysis and identification of possibly complex objects. The system allows one to define objects, or even conceptions at more abstract hierarchical levels, as equivalence classes. Based on this hierarchical, parallel, and distributed definition, the system constructs its networks. The system considers the object as an assembly of subparts or stiff components. Each stiff component can be defined by its geometrical contour and by surface characteristics (smoothness, texture, color, . . .). The entire object is defined hierarchically by the spatial and structural interrelations among the components. The system is able to recognize and analyze complex objects. Examples on real images are presented. It is also shown that the analysis can lead to an identification of specific instances of a complex equivalence class, as specific components and features of a new instance can be compared with several known instances. The identification of human faces is discussed as a test case