The research initiative “self-improving system integration” (SISSY) was established with the goal to master the ever-changing demands of system organisation in the presence of autonomous subsystems, evolving architectures, and highly-dynamic open environments. It aims to move integration-related decisions from design-time to run-time, implying a further shift of expertise and responsibility from human engineers to autonomous systems . This introduces a qualitative shift from existing self-adaptive and self-organising systems, moving from self-adaptation based on predefined variation types, towards more open contexts involving novel autonomous subsystems, collaborative behaviours, and emerging goals. In this article, we revisit existing SISSY research efforts and establish a corresponding terminology focusing on how SISSY relates to the broad field of integration sciences. We then investigate SISSY-related research efforts and derive a taxonomy of SISSY technology. This is concluded by establishing a research road-map for developing operational self-improving self-integrating systems.

In this article, we make the case for the new class of Self-aware Cyber-physical Systems. By bringing together the two established fields of cyber-physical systems and self-aware computing, we aim at creating systems with strongly increased yet managed autonomy, which is a main requirement for many emerging and future applications and technologies. Self-aware cyber-physical systems are situated in a physical environment and constrained in their resources, and they understand their own state and environment and, based on that understanding, are able to make decisions autonomously at runtime in a self-explanatory way. In an attempt to lay out a research agenda, we bring up and elaborate on five key challenges for future self-aware cyber-physical systems: (i) How can we build resource-sensitive yet self-aware systems? (ii) How to acknowledge situatedness and subjectivity? (iii) What are effective infrastructures for implementing self-awareness processes? (iv) How can we verify self-aware cyber-physical systems and, in particular, which guarantees can we give? (v) What novel development processes will be required to engineer self-aware cyber-physical systems? We review each of these challenges in some detail and emphasize that addressing all of them requires the system to make a comprehensive assessment of the situation and a continual introspection of its own state to sensibly balance diverse requirements, constraints, short-term and long-term objectives. Throughout, we draw on three examples of cyber-physical systems that may benefit from self-awareness: a multi-processor system-on-chip, a Mars rover, and an implanted insulin pump. These three very different systems nevertheless have similar characteristics: limited resources, complex unforeseeable environmental dynamics, high expectations on their reliability, and substantial levels of risk associated with malfunctioning. Using these examples, we discuss the potential role of self-awareness in both highly complex and rather more simple systems, and as a main conclusion we highlight the need for research on above listed topics.

This paper is about designing and constructing real-time systems, using mechanisms that support self-organization. Objects make a popular and convenient paradigm for keeping persistent data encapsulated with the operations that act on it, but they tend to omit what is arguably the most important aspect of real-time systems, which is time. There are other mechanisms that do model time, but few of them make time the central part of the programming model. In this short position paper, we offer two alternative(but complementary) approaches to modeling time (and other resource dependencies) in real-time systems, which should lead to more effective designs, since the timing and other interactions can be modeled sooner, and in any case, provide models with a different emphasis. We also make suggestions about the expressive language that can be used for the suggested kinds of modeling, and the infrastructure that underlies the process, which provides the computational reflection that enables self-organization.

No system in the real world can compute an appropriate response in reaction to every situation it encounters, or even most situations it is likely to encounter. Biological systems address this issue with four strategies: (1) a repertoire of already computed responses tied to a situation recognition process, (2) organized in a response-time hierarchy that allows a quick response to occur immediately, and one or more slower and more deliberate responses to begin at the same time, with (3) decision processes that allow one of them to take over after a little while, or that (4) merge several of them in a combined and possibly novel response. In this paper, we describe an approach to building self-adaptive computing systems that incorporates these strategies, to cope with their intended use in hazardous, remote, unknown, or otherwise difficult environments, in which it is known a priori that the system cannot keep up with all important events, and that “as fast as possible” is not appropriate for some interactions. The key to implementing these strategies is an abstraction/refinement hierarchy of behavioral models and processes at multiple levels of granularity and precision. The key to coordinating these different models is the collection of integrative mappings among them, which are developed along with the models, and used for managing system behavior. We also describe the system development process that we use to build such systems, which differs from conventional methods by taking the basic artifacts of development, considered as partial models of aspects of the system in its environment, and retains them all in a model hierarchy, which eventually becomes the definition of the run time system. We show how to implement such systems, explain why we think they are good candidates for real-time operational environments, and illustrate the method with an example implementation.

One of the banes of modern software development is needing to make design decisions before enough information is available to do so with adequate justification. In this paper, we describe a novel system engineering technique that helps alleviate the problem by allowing many such decisions to be delayed until they can be made with sufficient supporting information. We expect this approach will substantially improve the effectiveness of software design in the most difficult cases of complex software systems embedded in dynamic and uncertain environments. We describe the steps in the process, and how the Problem Posing Interpretation extends the Scenario Based Engineering Process to provide this flexibility. We illustrate the development steps with an example of a testbed for studying distributed cooperative behavior.

In this paper we argue (1) that new kinds of models and modeling techniques are needed to address the difficult public policy problems we all currently face, and (2) that new mathematical methods are required to support the new kinds of models and modeling techniques that are needed. We believe that proposed policy solutions have often failed in the past because of modeling deficiencies, and that policy creation should take place at the level of models, not just shouting and hand-waving. The mathematics underlying those models should be appropriate to the problem at hand, not vice versa (this is a failing of much of the current modeling, and an explanation of why modeling has such a bad reputation in policy circles). We believe that that means we have to make up some new mathematics to address the problem, instead of making the problem and data fit the mathematics we already have. In this paper we describe our progress and prospects in the invention of new mathematical methods for appropriate modeling of policy problems.

We discuss the following measurable characteristics of intelligent behavior in computing systems: (1) speed and scope of adaptability to unforeseen situations, including recognition, assessment, proposals, selection, and execution; (2) rate of effective learning of observations, behavior patterns, facts, tools, methods, etc., which requires identification, encapsulation, and recall; (3) accurate modeling and prediction of the relevant external environment, which includes the ability to make more effective abstractions, (4) speed and clarity of problem identification and formulation; (5) effective association and evaluation of disparate information; (6) identification of more important assumptions and prerequisites; and (7) the use of symbolic language, including the range and use of analogies and metaphors (this is about identification of similarities), and the invention of symbolic language, which includes creating effective notations. We make no claim that these are all the important characteristics; discovering others is the point of our research program.

This paper describes lessons we have learned over the last ten years from our "wrapping" approach to large-scale system development. Our research program in integration for constructed complex systems has led to several results with system engineering applications: the wrapping expression notation wrex for communication among distributed entities, the problem posing interpretation that inserts knowledge-based polymorphism into any programming language, and a new systematization of design patterns. We show how we implement wrappings and describe example applications. A little bit of this theory goes a long way, since it was designed for extremely large systems, such as space systems, with their hundreds of organizations, thousands of components, and millions of lines of code.

Computational embodiment is the computer implementation of principles of autonomy that allows software systems to exist in and interact with complex environments. We restrict our attention here to symbolic environments MUDs , as an initial step towards understanding and constructing ''interaction spaces'' in which humans and computer programs can interact on an equal footing. Our approach to constructing autonomous software systems is based on theoretical work on the organization of structures underlying language and movement in biological systems and on the structure of constructed complex systems mediated or integrated by software. We have developed an approach to integration called ''wrapping,'' which is a computationally reflective dynamic integration infrastructure. We regard integration infrastructure as an essential part of operating robust, flexible systems that exhibit appropriate behavior in the face of failures and uncertainties. The wrapping approach supports autonomy by supporting at least primitive versions of most of the functions that are necessary, and by providing an infrastructure that makes changing those functions easy. We show how the wrapping approach supports autonomy by describing ongoing experiments with software agents in MUDs.

This paper discusses computational approaches to computing meaning, arguing that the following four steps are necessary intermediates between the appearance of words in natural language, in whatever medium, and the meaning we want to compute from natural language: pattern detection, information structure creation, knowledge extraction, and application to understanding. It presents computational models for each step as well, in the form of algorithms that detect repetitive or persistent patterns in otherwise unrestricted natural language text, construct information structures from those patterns, extract knowledge from those information structures, and apply the knowledge to problems of understanding situation descriptions obtained in natural language.

Virtual Worlds are computer-mediated environments, in which we can monitor the interactions among our tools, the human users of the tools, and the humans themselves. They thus provide a powerful new experimental platform for studying issues that were heretofore very difficult. In this paper, we describe an experiment to study two claims about language formation: (1) all communication requires shared semantics (and not shared syntax), and (2) shared semantics requires shared experience. The key technical contributor is a new data structure called a Conceptual Category, which allows us to deal with representational and other semiotic issues within the program.

The paper applies some recent developments in computing to the problem of building very large software systems. We (1) emphasize the system's infrastructure as a way to keep large numbers of disparate components coordinated, and (2) show that our earlier wrapping research provides an active integration framework for heterogeneous system integration. The basic expressive notion is the "posed problem", and the basic computational component is the "resource". They are connected by the "wrappings", which consist of processes and associated knowledge bases that convert a posed problem into coordinated collections of resources that can address the problem.

Information flow analysis algorithms for programs typically overestimate the amount of information flow that occurs in a program, since they must account for all paths through the computation graph, whether or not they are actually possible. This is the source of the information flow anomalies, which are simple situations not properly handled by syntactic information flow analysis. This paper introduces an abstract information content function for state machine models of programs, and applies it to the information firm analysis problem, in conjunction with a semantic analysis of functional behavior provided by a program verification system. Our method fits well within the framework of many existing program verification systems, requiring only a small amount of knowledge of set theory. Some of the more common information flow anomalies are shown to be handled correctly by the method.

A distributed system of cooperating minicomputers is simulated by AIMER (Automatic Integration of Multiple Element Radars) to model and analyze the behavior of a radar tracking system. Simulation is applied in the AIMER project in an attempt to model a network of minicomputers to discover a maximally flexible network architecture. Because building the tracking system out of real hardware would not result in a flexible enough testbed system, the proposed configuration is represented by a software emulation. The instruction sets of the individual processors are emulated in order to allow separation of the measurement facilities from the execution of the system. The emulation is supported by a Nano-data QM-1 micro and nano-programmable host. Extensive performance monitoring hooks have been built into the emulation system which allow small performance perturbations to become visible.