Search

A fundamental challenge in synthetic biology is to create molecular circuits that can program complex cellular functions. Because proteins can bind, cleave, and chemically modify one another, and interface directly and rapidly with endogenous pathways, they could extend the capabilities of synthetic circuits beyond what is possible with gene regulation alone. However, the very diversity which makes proteins so powerful also complicates efforts to harness them as well-controlled synthetic circuit components. Recent work has begun to address this challenge, focusing on principles such as orthogonality and composability that permit construction of diverse circuit-level functions from a limited set of engineered protein components. These approaches are now enabling the engineering of circuits that can sense, transmit, and process information, dynamically control cellular behaviors, and enable new therapeutic strategies, establishing a powerful paradigm for programming biology.

The human immune system is studied at different scales (molecular, cellular, tissue, organism, population) with varied granularity and spatiotemporal dimensions. Innate and adaptive immune responses to viral infections are researched in vitro, in vivo, and in silico using mathematical and computational methods. The construction of computational models is an iterative and interactive process which combines existing knowledge and hypotheses (knowledge-driven approach) with empirical datasets (data-driven approach). The resulting models should ideally provide reusability, composability, and interoperability to support system simulation. The main premises of this paper are (1) computational models can be used not only for representation of existing knowledge, but also as experimental tools to demonstrate, exemplify, create, and serve as test-beds for the analysis of empirical data;and (2) computational models should be evaluated in terms of their usability (defined as a measure of how well a specified group of users can achieve predefined goals effectively, efficiently, and satisfactorily in a specified context of use). The usability measure is specified by the context information: user characteristics, their goals, and additional constraints (e.g., data availability, temporal limitations). This paper focuses on the modelling process performed by multidisciplinary teams and the usability of models for the exploration of immune response to viral infections. (c) 2021 The Authors. Published by Elsevier B.V. This is an open access article under the CC BY-NC-ND license (https://creativecommons.org/licenses/by-nc-nd/4.0) Peer-review under responsibility of the scientific committee of the Complex Adaptive Systems Conference, June 2021.

Digital twin has the potential to be an important concept for achieving smart manufacturing. However, there remains a lot of confusion about the concept and how it can be implemented in real manufacturing systems, especially among small-to-medium-sized enterprises. This paper synthesizes the different perspectives that have been reported on the digital twin to identify the key characteristics that must be understood when developing a digital twin for a specific use case. Example applications are provided and the need for a standardized framework, such as the one under development as ISO 23247 (Digital Twin Manufacturing Framework), is motivated. This framework can enable context-dependent implementations and promote composability and reusability of digital twin components.

The microservice architecture (MSA) differs fundamentally from the monolithic, layered architecture. The use of microservices provides a high degree of autonomy, composability, scalability, and fault-tolerance. MSA is regarded by many as a promising architecture for smart-city applications; however, a number of issues remain, including (1) the management of complex call relationships among microservices; (2) ensuring the quality of the overall software system even as new microservices are added and existing ones are modified, and (3) locating existing microservices that satisfy new requirements. In this paper, we propose a novel approach to the development of microservice-based systems, referred to as GSMART (Graph-based and Scenario-driven Microservice Analysis, Retrieval and Testing). GSMART enables the automatic generation of a “Service Dependency Graph (SDG)” by which to visualize and analyze dependency relationships between microservices as well as between services and scenarios. It also enables the automatic retrieval of test cases required for system changes to reduce the time and costs associated with regression testing. A microservice retrieval method using VSM and word2vec accelerates the development of new microservices tailored specifically to the needs of users based on user-provided scenarios. Experiment results demonstrate the feasibility, effectiveness, and efficiency of all of the main features of GSMART.

Agent-based modeling and simulation has been proved useful in a variety of different complex adaptive systems comprised of autonomous, interacting components. To resolve the shortcoming of current agent-based modeling frameworks with respect to decomposition and modularity, this paper presents a formal hierarchical modeling and simulation framework with three–level architecture to reduce ambiguity as well as improve clarity in the model definition. The bottom level is Component Model (CM), which implements some domain-specific support functionality, such as curve motion in the physical domain, intelligent decision-making in the cognitive domain, etc. The middle level is Agent Model (AM), which describes an agent which can react to the current situation by executing a sequence of CMs. The top level is System Model (SM), which defines that a CAS model consists of several AMs and also the interactions between these AMs. In the hierarchical architecture, one SM can be built up from lower-level models, which were linked in a loosely coupled fashion via an event-driven interface. We then analyze the reusability and composability of lower-level models of this hierarchical framework in a formalized way. To demonstrate the effectiveness of the proposed solution, we develop a graphical composite modelling tool named GraphSim, and the case study concerning two social dynamics system scenarios is also presented.

With the advent of the Internet of Things (IoT), Cloud-based Cyber-Physical Systems (C2PS) are becoming more prevalent in manufacturing systems. Verifying the security of C2PS is a challenging task due to the inclusion of newer entities such as mobile phones and IoT devices. Therefore, scalable methods for verifying security properties of manufacturing systems are paramount. This paper presents an approach to guarantee security of C2PS using concepts from Communicating Sequential Processes (CSP) to describe the security properties of cloud constructs. We prove that composability is an essential property for enhancing the security of the C2PS. Furthermore, it also provides good scalability to the system. We propose formalisms required for modelling security properties in the Industrial IoT-based manufacturing system. Using this formalism and Hoares’ logic we provide conditions for composing systems. Finally, we provide strong authentication conditions among entity pairs in C2PS based manufacturing systems. We demonstrate the message exchanges, methodology, and different steps required for verifying C2PS.

One of the benefits of decentralized finance (DeFi) – an alternative financial system built on blockchain – is composability, which means the system’s building blocks (tokens) can freely interact with one another to form new services. One example is stablecoin, a token with fixed exchange rate, which is backed by token collaterals. While stablecoins can be used to facilitate payments and exchanges, in DeFi they can be used to earn returns (“yield farming”), potentially multiplicatively. We use transaction-level blockchain data to analyze a stablecoin’s flows between protocols and provide suggestive evidence of DeFi yield-chasing behavior. We shed light on what DeFi total value locked might really measure and highlight the complexity in DeFi analysis and market surveillance.

Over-The-Air Software Updates (OTASU) are gaining popularity on the safety-critical domain. The motivation behind this trend is twofold. On the one hand, the ability of adding new functionality and services to the system without a complete redesign makes product makers more competitive and improves user experience. On the other hand, the increasing connectivity of emerging embedded devices makes OTASU a crucial cyber-security demand to keep the system up-to-date with latest security patches. However, the application of OTASU in the safety-critical domain is not straightforward, as they are not contemplated by current functional safety standards. The UP2DATE European H2020 project, seeks to provide solutions to cope with the challenging requirements of safety and security standards with respect to software updates. This paper gives an overview of UP2DATE, its foundations and the initial description of its safe and secure architecture that builds around composability and modularity on heterogeneous high-performance platforms.

Object composability simplifies reasoning of multi-object concurrent executions.Linearizable objects are composable, but have a high performance price.We define a new type of objects, OSC, that are performant and can be composed.OSC captures the typical non-linearizable behavior of real-world services.This paper formally proves OSC composability correctness. We define ordered sequential consistency (OSC), a generic criterion for concurrent objects. We show that OSC encompasses a range of criteria, from sequential consistency to linearizability, and captures the typical behavior of real-world coordination services, such as ZooKeeper. A straightforward composition of OSC objects is not necessarily OSC, e.g., a composition of sequentially consistent objects is not sequentially consistent. We define a global property we call leading ordered operations, and prove that it enables correct OSC composition.

The article of record as published may be found at https://doi.org/10.1016/j.procs.2017.09.005 Unmanned aerial vehicle (UAV) swarm design and mission application is a burgeoning area of research. The applications of swarm technology to unmanned systems are in the infancy of realization, although clear benefits from the enhanced capabilities can be easily envisioned for commercial and government missions including persistent search, long-term monitoring, sensor data collection, object retrieval, and offensive attack missions. Designing a UAV swarm architecture without considering the mission doctrine is imprudent, as is developing a mission doctrine without understanding the unique capabilities of swarm technology. This paper provides a literature review of current UAV swarm design architectures, most of which employ bottom-up methods with little consideration for an intended operational mission. The proposed top-down framework and modeling approach is focused on developing a modular UAV swarm playbook-type architecture by decomposing a subset of US Navy missions, and developing tactics that can be applied to those missions and support future missions. The framework proposed herein is derived from a consolidation of heuristics from the model-based systems engineering, robotics, human systems integration, biology, and computer science disciplines. The goal of this framework is to provide a standard methodology for designing and operating swarm unmanned systems that will meet the performance requirements for military missions. In this paper, an integrated framework for designing a UAV swarm system with swarm mission doctrine as a primary design factor is presented.

Modeling languages are defined with a meta-model, which are specified using the meta-modeling tools that produce the editors for specifying models in accordance with the meta-models. In this paper, we aim to understand the top-used meta-modeling tools and practitioners’ expectations and challenges with respect to different requirements. So, we designed and conducted a survey, which was responded by 103 practitioners. The questionnaire considers the notation, semantics, editor services, model-transformation, validation, testing, and composability requirements. Some of the results are as follows: the top-used meta-modeling tools are Sirius and GEMS, Metaedit+, Xtext, and Microsoft DSL tools respectively. The top-preferred language visualizations are diagrammatic or textual. Practitioners prefer the editors with free-editing mode and are not familiar with projectional editing that promotes hybrid modeling. Translational semantics definition (i.e., model-to-model and model-to-text) is more popular than the interpretative semantics definition. Importing/exporting models and meta-models is highly important for facilitating the communication and collaboration. Modeling and meta-modeling with re-use and their versioning are among the top-desired features. Practitioners are willing to integrate any validation tools (e.g., model checkers) to define the languages’ semantical and structural validation rules and prove the model correctness. Lastly, defining the language semantics by composition and testing the semantics definitions are crucial for many practitioners. The survey also reveals many important challenges in each type of requirements. The survey results will be useful for meta-modelers in analyzing the meta-modeling tools and tool vendors in learning practitioners’ expectations.

This paper presents an approach for constructing an adaptive mesh refinement (AMR) scheme, targeting next-generation computing hardware. The key to the design is the particular combination of aspects of cell-based AMR and patch-based AMR. We examine the feasibility of this new method with respect to correctness, preservation of circular symmetry, ease of programming and performance impacts on runtime and memory usage. This method exploration is done in CLAMR, a cell-based AMR mini-app that already runs on GPUs and other next-generation hardware platforms. The composability of the application is improved by decoupling the physics code and mesh code. Each level of the mesh is made independent through the use of phantom cells. The net result is a clear pathway to getting the full application on the GPU while also minimizing development requirements to convert a regular grid application to AMR.

This study optimizes service composition on the basis of task requirements to solve the problem of multitask corresponding multi-service selection. First, the basic path structure and the implementation steps of cloud manufacturing (CMfg) service composition are analyzed, and service composition is divided into four patterns. Second, the quality of service (QoS) index system of service composition is proposed by combining the six goals of time, composability, quality, usability, reliability, and cost; the calculation expressions of QoS under different composition structures are listed; and the mathematical model of CMfg service composition is established. Then, the weight of each index value in QoS evaluation is determined using an improved fuzzy comprehensive evaluation method. Finally, the optimal selection scheme of service composition is proposed by using gray relational analysis method(GM), and the validity of the optimal selection scheme is verified by an example of mold manufacturing.

Imprecise manipulation of source code (semi-parsing) is useful for tasks such as robust parsing, error recovery, lexical analysis, and rapid development of parsers for data extraction. An island grammar precisely defines only a subset of a language syntax (islands), while the rest of the syntax (water) is defined imprecisely.Usually water is defined as the negation of islands. Albeit simple, such a definition of water is naive and impedes composition of islands. When developing an island grammar, sooner or later a language engineer has to create water tailored to each individual island. Such an approach is fragile, because water can change with any change of a grammar. It is time-consuming, because water is defined manually by an engineer and not automatically. Finally, an island surrounded by water cannot be reused because water has to be defined for every grammar individually.In this paper we propose a new technique of island parsing - bounded seas. Bounded seas are composable, robust, reusable and easy to use because island-specific water is created automatically. Our work focuses on applications of island parsing to data extraction from source code. We have integrated bounded seas into a parser combinator framework as a demonstration of their composability and reusability. HighlightsTraditional island grammars are difficult to define and are not flexible enough.Bounded seas - a new technique of island parsing - are composable, robust, reusable and easy to define.Bounded seas are specified using our extension of parsing expression grammars.Parsers utilizing bounded seas require less effort to define and provide both good precision and performance in the two performed case studies.

Triple-modular-redundant applications are widely used for fault-tolerant safety-critical computation. They have strict timing requirements for correct operation. We present an architecture which provides composability and mixed-criticality to support integration and to ease certification of such safety-critical applications. In this architecture, an additional layer is required for the sharing/partitioning of resources. This potentially jeopardizes the synchronization necessary for the triple-modular-redundant applications.We investigate the effects of different (unsynchronized) scheduling methods for the resource-sharing layer in this architecture and conclude that an out-of-the-box solution, which guarantees the technical separation between applications with fast reaction time requirements is only feasible when executing at most one instance of a triple-modular-redundant application per CPU-core for single and multi-core CPUs. Only when accepting changes in the applications or the applications' synchronization mechanisms, are more flexible solutions with good performance and resource utilization available.

In this second part, we evaluate the performances of our control framework by applying it to a casestudy that contains a minimum set of elements allowing to show its applicability and potentials. Weshow how the computation of the PQt profiles, belief functions, and virtual costs can be synthesized forgeneric resources (i.e., dispatchable and stochastic generation systems, storage units, loads). The metricsof interest are: quality-of-service of the network represented by voltages magnitudes and lines currentmagnitudes in comparison with their operational boundaries; state-of-charge of electric and thermalstorage devices; proportion of curtailed renewables; and propensity of microgrid collapse in the case ofrenewables overproduction. We compare our method to two classic ones relying on droop control: thefirst one with only primary control on both frequency and voltage and the second one with an additionalsecondary frequency control operated by the slack device. We find that our method is able to indirectlycontrol the reserve of the storage systems connected to the microgrid, thus maximizing the autonomy inthe islanded operation and, at the same time, reducing renewables curtailment. Moreover, the proposedcontrol framework keeps the system in feasible operation conditions, better explores the various degreesof freedom of the whole system and connected devices, and prevents its collapse in case of extremeoperation of stochastic resources. All of these properties are obtained with a simple and generic controlframework that supports aggregation and composability.

Research in narrative science across academia and industry continually uncovers new insights that have relevance to understanding how narratives affect behavior change in regions around the world. These insights are valuable to military decision-makers and analysts who seek to understand how adversaries create and use narratives to alter population behaviors. Unfortunately, the transfer of findings from research institutions to operational settings is often slow, indirect, and fraught with challenges [1]. Research results are most frequently expressed in scientific papers that tend to circulate among researchers, but not with tactical communities. We are developing a technique that facilitates the creation of models that represent the relationships among key research findings by leveraging concepts from user-centered modeling [2] and informed by prior work in model composability [3]. This technique supports the creation of models by researchers as well as operational users. We have uncovered several key insights in our development of this modeling technique. First, qualitative abstract-level summaries of research results are often useful on their own, as they provide descriptive information that can explain key variables and their interactions. Second, the use of well-defined qualitative terms enables a form of composability for summary models, which has the potential to enrich the larger body of research by connecting related findings. Third, the explicit capture of context within the summary models provides a means for recognizing or specifying the conditions under which a research finding may be applicable (e.g., with respect to culture, geographic location, mission objective, or intended audience). Fourth, enriching summary models with the ability to support higher model fidelity (i.e., deeper levels of detail about relationships in the model) allows for the representation of conflicting evidence and conflicting summary models, as well as connection to quantitative data and data-driven models. These summary models, represented as heterogeneous networks, can be used by different types of tactical tools to satisfy a variety of goals, such as analyzing an adversary's narratives, decomposing a specific adversary message, and assessing the physiological response to a narrative. Finally, results from applying research in operational environments can be fed back to the model context and could potentially provide researchers with data on the real-world implementation of concepts from the academic community.

We present a first evaluation of a Programming Model for real-time streaming applications on high performance embedded multi- and many-core systems. Realistic streaming applications are highly dependent on the execution context (usually of physical world), past learned strategies, and often real-time constraints. The proposed Programming Model encompasses both real- time requirements, determinism of execution and context dependency. It is an extension of the well-known Cyclo-Static Dataflow (CSDF), for its desirable properties (determinism and composability), with two new important data-flow filters: Select-duplicate, and Transaction which retain the main properties of CSDF graphs and also provide useful features to implement real-time computational embedded applications. We evaluate the relevance of our programming model thanks to several real-life case-studies and demonstrate that our approach overcomes a range of limitations that use to be associated with CSDF models.

HighlightsWe investigated the scalability of AOP for composing GoF design patterns.We study the benefits and drawbacks of AOP for composing GoF design patterns.Category of the pattern is a dominant factor impacting the pattern composability.Programming abstractions of AOP languages also impact the patterns composability. Design patterns often need to be blended (or composed) when they are instantiated in a software system. The composition of design patterns consists of assigning multiple pattern elements into overlapping sets of classes in a software system. Whenever the modularity of each design pattern is not preserved in the source code, their implementation becomes tangled with each other and with the classes' core responsibilities. As a consequence, the change or removal of each design pattern will be costly or prohibitive as the software system evolves. In fact, composing design patterns is much harder than instantiating them in an isolated manner. Previous studies have found design pattern implementations are naturally crosscutting in object-oriented systems, thereby making it difficult to modularly compose them. Therefore, aspect-oriented programming (AOP) has been pointed out as a natural alternative for modularizing and blending design patterns. However, there is little empirical knowledge on how AOP models influence the composability of widely used design patterns. This paper investigates the influence of using AOP models for composing the Gang-of-Four design patterns. Our study categorizes different forms of pattern composition and studies the benefits and drawbacks of AOP in these contexts. We performed assessments of several pair-wise compositions taken from 3 medium-sized systems implemented in Java and two AOP models, namely, AspectJ and Compose*. We also considered complex situations where more than two patterns involved in each composition, and the patterns were interacting with other aspects implementing other crosscutting concerns of the system. In general, we observed two dominant factors impacting the pattern composability with AOP: (i) the category of the pattern composition, and (ii) the AspectJ idioms used to implement the design patterns taking part in the composition.

We present the concept of runnable virtual node (RVN) as a means to achieve predictable integration and reuse of executable real-time components in embedded systems. A runnable virtual node is a coarse-grained software component that provides functional and temporal isolation with respect to its environment. Its interaction with the environment is bounded both by a functional and a temporal interface, and the validity of its internal temporal behaviour is preserved when integrated with other components or when reused in a new environment. Our realization of RVN exploits the latest techniques for hierarchical scheduling to achieve temporal isolation, and the principles from component-based software-engineering to achieve functional isolation. It uses a two-level deployment process, i.e. deploying functional entities to RVNs and then deploying RVNs to physical nodes, and thus also gives development benefits with respect to composability, system integration, testing, and validation. In addition, we have implemented a server-based inter-RVN communication strategy to not only support the predictable integration and reuse properties of RVNs by keeping the communication code in a separate server, but also increasing the maintainability and flexibility to change the communication code without affecting the timing properties of RVNs. We have applied our approach to a case study, implemented in the ProCom component technology executing on top of a FreeRTOS-based hierarchical scheduling framework and present the results as a proof-of-concept.

The two standard models used for communication in concurrent programs, shared memory and message passing, have been the focus of much debate for a long time. Still, we believe the main issue at stake should not be the choice between these models, but rather how to ensure that communication is structured, i.e., it occurs only in syntactically restricted code regions. In this survey, we explore concurrency control models and evaluate how their characteristics contribute positively or negatively to the support for structured communication. We focus the evaluation on three properties: reasonability, which is the main property we are interested in and determines how easily programmers can reason about a concurrent program's execution; performance, which determines whether there are any distinct features which can prevent or facilitate efficient implementations; and composability, which determines whether a model offers constructs that can be used as building blocks for coarser-grained, or higher-level, concurrency abstractions.

The European ARTEMIS ACROSS project aims to overcome the limitations of existing Multi-Processor Systems-on-a-Chip (MPSoC) architectures with respect to safety-critical applications. MPSoCs have a tremendous potential in the domain of embedded systems considering their enormous computational capacity and energy efficiency. However, the currently existing MPSoC architectures have significant limitations with respect to safety-critical applications. These limitations include difficulties in the certification process due to the high complexity of MPSoCs, the lacking temporal determinism and problems related to error propagation between subsystems. These limitations become even more severe, when subsystems of different criticality levels have to be integrated on the same computational platform. Examples of such mixed-criticality integration are found in the avionics and automotive industry with their desire to integrate safety-critical, mission critical and non-critical subsystems on the same platform in order to minimize size, weight, power and cost. The main objective of ACROSS is to develop a new generation of multi-core processors designed specially for safety-critical embedded systems; the ACROSS MPSoC. In this paper we will show how the ACROSS MPSoC overcomes the limitations of existing MPSoC architectures in order to make the multi-core technology available to the safety-critical domain. The proposed approach enables efficient certification, complexity management, mixed-criticality integration and the development of temporally deterministic hard real-time systems. The major technological innovations of ACROSS are an increased level of design abstraction, message-based interfaces for core-to-core communication and reliable fault and error containment established by a novel time-triggered network-on-chip. The achieved results comprise, a novel architecture for MPSoCs, a prototype implemenation on FPGA technology as a proof-of-concept, a comprehensive set of middle-ware services and multiple demonstrators that show the benefits of the ACROSS Architecture in real world industrial applications.

Viewpoint modeling is an effective approach for analyzing and designing complex systems. Splitting various elements and corresponding constraints into different perspectives of interests, enables separation of concerns such as domains of expertise, levels of abstraction, and stages in lifecycle. Specifically, in Systems Engineering different viewpoints could include functional requirements, physical architecture, safety, geometry, timing, scenarios, etc. Despite partial interdependences, the models are usually developed independently by different parties, using different tools and languages. However, the essence of Systems Engineering requires repetitive integration of many viewpoints in order to find feasible designs and to make good architectural decisions, e.g., in each mapping between consecutive levels of abstraction and in each design space exploration. This integration into one consistent model becomes a significant challenge from both modeling and information management perspectives. In this paper we suggest (1) a unique modular algebraic viewpoint representation robust to design evolution and suitable for generation of the integrated optimization/analysis models, and (2) an underlying ontology-based approach for consistent integration of local viewpoint concepts into the unified design space model. We show an example of an optimization model with different combinations of partially interdependent Analysis Viewpoints. Using the proposed modeling and information management approaches the underlying viewpoint's equations can be applied without modification, making the approach pluggable.

As the rapid development of web services, how to publish, discover and compose them in open and dynamic network environment has become one of the most important challenges for web-based technology. We abstract web service components as coalgebraic monads, which has an advantage of supporting the studying of state systems such as concurrent or uncertain systems. With the help of monad techniques, we present a novel formal model for web services in a black-box observation way. Through monads' properties such as abstraction, reflection and composability, this model can help us formally describe and support further study on service components during web service publishing. After publishing, we in this paper also propose a composition method based on program slicing technology. Our monad-based methods proposed in this paper relatively improve service reuse and enable the integration and composition of web services because of the integration of combinable and reusable monads techniques.

This paper reports on the development of a language construct designed to solve certain problems in composability at the level of object-oriented programming languages. Features were chosen to investigate how much compositional functionality could be added to core Java with as small a change as possible and in an additive manner. A fairly elegant and effective syntax on core Java resulted in reducing the clutter of the ''mechanics'' of composition. This construct features eliminating runtime cast and null exceptions within the construct, and the option of parametric covariant override. It does so while avoiding undesirable restrictions or new frameworks. Recently, new techniques intended to improve the composability of software components in the Java ecosystem have been vigorously pursued. Proposals take on the objectives of composition in largescale systems and enterprise applications but often implement on conventional object-oriented languages which face the same kinds of problems from the ground up. Benefitting from those experiences, the present work seeks to provide core Java-level solutions to problems that are analogous to those at the higher-levels. The supervenience construct described in this paper is based on a well-established formulation for composing a relationship over classes with some common behavioral elements, their behavioral intersection. The narrow concern of this construct is the sound composition of components across class families while eliminating certain barriers to runtime type-safety in core Java. The supervenience construct has been applied to certain classic problems and key case studies in composability and extensibility which represent fundamental issues that emerge at every level. The implementation requires no installed runtime frameworks and no changes to the JVM or type system of core Java. It is designed to deploy stand-alone or later integrate with the standard Java compiler and IDEs. The continuing research is now focusing on a more formal proof of its type-safety, applying the reference implementation to mid-scale and distributed applications.

Ubiquitous and urban computing share the goal of enabling users to access networked services and resources anytime, anywhere. The intermesh of planned and situational activities is a distinguishable characteristic of urban computing environments. This produces a diversity of service requirements that need to be tackled by opportunistically suggesting appropriate services to users or social groups, without having a previous definition of applications in templates or any other descriptions in advance. This paper leverages the approach of task-oriented computing to represent user goals in tasks. A task is composed of unit-tasks: user centric configurations of abstract service coordinations. The focus of this paper is on the provision of a mechanism to cover the spontaneous unit-task composition cycle, based on social, spatial, and temporal aspects. This is realized by identifying the essential semantic elements that describe unit-tasks, UrbComp environments, and social groups. We have extended a unit-task selection mechanism from our previous work. In addition, this paper contributes a set of composability metrics based on social, spatial, and temporal aspects. These metrics concern the measurement of semantic interoperability and potential conflicts between unit-tasks or unit-task composites. These metrics are used to join unit-tasks together in sequences. Experimental results for a real dataset of tasks were obtained. These results show a suitable time-overhead for the unit-task selection mechanism. In addition, a simulation of arrivals at a crowded space was utilized to measure the performance, throughput, and efficacy ratio of the composition mechanism.

In this paper a novel modelling methodology for industrial automation discrete event dynamical systems is presented and some preliminary results are drawn by means of a significative example. The proposed approach exploits behavioral rules expressed by means of regular languages generated by automata, and composed using automata parallel composition. In this framework, with a suitable rules definition, fault events will cause a changing in a limited set of rules (i.e automata), hence a sort of “fault modelling confinement” can be achieved. This approach leads to a sort of “multi-model” set of parallel automata representing a system in nominal and different faulty conditions, hence statecharts have been effectively used for representation. The resulting models are suitable for formal analysis and design based on well-established tools for discrete event dynamical systems. In addition, the “complexity explosion”, which is rather common for the models adopted in rigorous treatment of discrete event systems, can be effectively avoided exploiting composability properties and simple and “confined” fault modelling.

Logic meta-programming in Prolog is a powerful way to express program analysis and transformation. However, its use can be difficult and error-prone because it requires programmers to know the meta-level representation of the analysed language and to think and express their analyses in terms of this low-level representation. In addition, the backtracking-based evaluation strategy of Prolog may lead to subtle semantic problems when used to express transformations of a logic database. In this paper, we propose an alternative approach, GenTL, a generic transformation language that combines logic-based Conditional Transformations (CTs) and concrete syntax patterns. This combination addresses the above problems while still offering the full expressive power of logic meta-programming. Compared to approaches based on other formalisms, the design of GenTL offers advantages in terms of composability and easy transformation interference analysis.

We define reactive simulatability for general asynchronous systems. Roughly, simulatability means that a real system implements an ideal system (specification) in a way that preserves security in a general cryptographic sense. Reactive means that the system can interact with its users multiple times, e.g., in many concurrent protocol runs or a multi-round game. In terms of distributed systems, reactive simulatability is a type of refinement that preserves particularly strong properties, in particular confidentiality. A core feature of reactive simulatability is composability, i.e., the real system can be plugged in instead of the ideal system within arbitrary larger systems; this is shown in follow-up papers, and so is the preservation of many classes of individual security properties from the ideal to the real systems.A large part of this paper defines a suitable system model. It is based on probabilistic IO automata (PIOA) with two main new features: One is generic distributed scheduling. Important special cases are realistic adversarial scheduling, procedure-call-type scheduling among colocated system parts, and special schedulers such as for fairness, also in combinations. The other is the definition of the reactive runtime via a realization by Turing machines such that notions like polynomial-time are composable. The simple complexity of the transition functions of the automata is not composable.As specializations of this model we define security-specific concepts, in particular a separation between honest users and adversaries and several trust models.The benefit of IO automata as the main model, instead of only interactive Turing machines as usual in cryptographic multi-party computation, is that many cryptographic systems can be specified with an ideal system consisting of only one simple, deterministic IO automaton without any cryptographic objects, as many follow-up papers show. This enables the use of classic formal methods and automatic proof tools for proving larger distributed protocols and systems that use these cryptographic systems.

Behavioural specification based on hidden (sorted) algebra constitutes one of the most promising recently developed formal specification and verification paradigms for system development.Here we formally introduce novel concepts of behavioural object and equivalence between behavioural objects within the hidden algebra framework. We formally define several object composition operators on behavioural objects corresponding to the hierarchical object composition methodology introduced by CafeOBJ. We study their basic semantical properties and show that our most general form of behavioural object composition with synchronisation has final semantics and a composability property of behavioural equivalence supporting a high reusability of verifications. We also show the commutativity and the associativity of parallel compositions without synchronisation.

Component-based design has become a necessity for networked embedded systems where hardware platforms come in a great variety and evolve extremely rapidly. Operating system components and higher level middleware services call for modular software construction along clear interfaces. The way we describe these interfaces and process the captured information is of crucial importance for exploiting the benefits of component-based design. In this paper we present a model based approach to the development of embedded applications with a special emphasis on interface specification. The proposed formalism captures the temporal and type aspects of interfaces and supports the composition and verification of components. Along with the formal definition of the proposed interface language and component compatibility rules, we present a modeling environment targeting TinyOS, a representative embedded operating system. Two prototype tools are also described that check the composability of components based on their interface models and verify that the implementation of a component matches its formal model, respectively.

This paper proposes an agent-based composable simulation framework to address the challenges of integration, composability, distributed coordination, and interaction for the development of a virtual prototype of fluid power system. The approach proposed represents each virtual hydraulic component by a domain agent (DA). The agents are then gathered into a multi-agent system, which models the hydraulic system as a whole. The virtual prototyping evaluation depends on the communication and collaboration of multiple agents. A case study shows that agent-based composable simulation can predict the overall system performance. A prototype implementation of the proposed system is presented in this paper.

Time-triggered (TT) distributed real-time computing systems are moving into the mainstream for the implementation of safety-critical applications in the aerospace and automotive sectors. This paper introduces the basic principles of a time-triggered real-time computing system, and elaborates on the benefits that can be gained from the availability of a global time base in general, and in specifying the linking interfaces of components in particular. It describes the concept of a temporal firewall that forms a fully specified operational interface of a component. The most important contribution of the TT-paradigm is the capability to precisely specify operational interfaces in the temporal domain and thus establish a sound basis for the composability of a design and the reuse of components in distributed real-time systems.

Composability of entropy implies that entropy of the total system composed of independent subsystems is given by a function of entropies of the subsystems. It is shown that the zeroth law of thermodynamics naturally leads to Tsallis-type pseudoadditivity of the composable entropies. Then, macroscopic thermodynamics is discussed based on the simplest example of such entropies. It is found that, even if nonextensive entropy is initially employed, the resulting thermodynamic entropy is necessarily extensive at the macroscopic level, in accordance with Caratheodory's theorem. This result depends crucially on the assumptions that the subsystems are independent and the total energy is the sum of the energies of the subsystems.

This paper compares the principles of operation, the services, the dependability mechanisms and the system level properties of distributed real-time systems that are based on the Controller Area Network (CAN) protocol and the Time-Triggered protocol (TTP). The paper comes to the conclusion that CAN is well suited for soft real-time systems where flexibility is important, while TIP is most appropriate for the design of composable hard real-time systems with high dependability requirements.

Large distributed real-time systems can be built effectively by integrating a set of nearly autonomous components that communicate via stable control-free interfaces, called temporal firewalls. A temporal firewall provides an understandable abstraction of the subsystem behind the firewall, confines the impact of most changes to the encapsulated subsystem, and limits the potential of error propagation. This paper describes desirable properties of an ideal component, discusses the component interfaces and elaborates on the architecture support services that are needed to enable a component-based design of large distributed real-time systems.

Model-based expert systems are expected to contribute to overcoming the difficulties of conventional rule-based systems. This paper describes the modeling of mechanical systems and a method of qualitative reasoning based on causal specifications. The causal specifications represent a component's local causal properties, following the principles for reusability and composability. It contributes to providing intuitive causal ordering of complex behavior originated in the combination of components, including inter-component negative feedback. A model of a system is represented by combining a set of local component models and global knowledge derived from general properties of the physical entity. This allows for reusable knowledge which is easy to describe. Furthermore, the method has been successfully applied to a nuclear power plant. Reasoning results were unambiguous and matched those obtained by domain experts.

Implementations of abstract data types are defined via enrichments of a target type. We propose to use an extended typed λ-calculus for enrichments in order to meet the conceptual requirement that an implementation has to bring us closer to a (functional) program. Composability of implementations is investigated, the main result being that composition of correct implementations is correct if terminating programs are implemented by terminating programs. Moreover, we provide syntactical criteria to guarantee correctness of composition. The proof is based on strong normalization and Church-Rosser results of the extended λ-calculus which seem to be of interest in their own right.