Interacting Software Components Research Articles

Life cycle support software components

Modern software development is based on a systems approach, in which a program or software complex is considered as a system of interacting software components. Models of software components are analogs of complex system subsystems. Therefore, a complex program is considered as a system of software components. The organization of the structure of software components affects the quality and result of the program. The organization of interaction between software components affects the efficiency of the program. An important factor in the system of software components is the life cycle, which determines the effectiveness and feasibility of using this program. Software differs from many complex systems and information systems in that it has the ability to increase its life cycle. Moreover, the need to increase the life cycle is characterized by two factors: external and internal. The internal factor arises due to the obsolescence of the program. In this case, it does not meet the new conditions, for example, a new operating system. The external factor arises from external influences in the form of interference or purposeful actions, such as computer viruses. The problem of creating the structure of software components of computing systems and information systems that ensure the duration of the life cycle in the presence of external influences is topical. The study of this problem contributes to the improvement of the technological base of computing systems and information systems that solve applied problems. The article presents a new life cycle model based on two models of growth and degradation. The article recommends a resource-based approach for life cycle assessment. As an analytical solution, it is proposed to use a logistic equation, which describes the mechanisms of the life cycle formation process quite well. The article discusses three types of resource in calculations: physical, technological and communicative. A general redundancy solution is proposed to create a network with the inclusion of a multigraph model.

Multi-objective Beam-ACO for Maximising Reliability and Minimising Communication Overhead in the Component Deployment Problem

Automated deployment of software components into hardware resources is a highly constrained optimisation problem. Hardware memory limits which components can be deployed into the particular hardware unit. Interacting software components have to be deployed either into the same hardware unit, or connected units. Safety concerns could restrict the deployment of two software components into the same unit. All these constraints hinder the search for high quality solutions that optimise quality attributes, such as reliability and communication overhead. When the optimisation problem is multi-objective, as it is the case when considering reliability and communication overhead, existing methods often fail to produce feasible results. Moreover, this problem can be modelled by bipartite graphs with complicating constraints, but known methods do not scale well under the additional restrictions. In this paper, we develop a novel multi-objective Beam search and ant colony optimisation (Beam-ACO) hybrid method, which uses problem specific bounds derived from communication, co-localisation and memory constraints, to guide the search towards feasibility. We conduct an experimental evaluation on a range of component deployment problem instances with varying levels of difficulty. We find that Beam-ACO guided by the co-localisation constraint is most effective in finding high quality feasible solutions.

Response-Time Analysis for Task Chains with Complex Precedence and Blocking Relations

For the development of complex software systems, we often resort to component-based approaches that separate the different concerns, enhance verifiability and reusability, and for which microkernel-based implementations are a good fit to enforce these concepts. Composing such a system of several interacting software components will, however, lead to complex precedence and blocking relations, which must be taken into account when performing latency analysis. When modelling these systems by classical task graphs, some of these effects are obfuscated and tend to render such an analysis either overly pessimistic or even optimistic. We therefore firstly present a novel task (meta-)model that is more expressive and accurate w.r.t. these (functional) precedence and mutual blocking relations. Secondly, we apply the busy-window approach and formulate a modular response-time analysis on task-chain level suitable but not restricted to static-priority scheduled systems. We show that the conjunction of both concepts allows the calculation of reasonably tight latency bounds for scenarios not adequately covered by related work.

A comparative study of many-objective evolutionary algorithms for the discovery of software architectures

During the design of complex systems, software architects have to deal with a tangle of abstract artefacts, measures and ideas to discover the most fitting underlying architecture. A common way to structure such complex systems is in terms of their interacting software components, whose composition and connections need to be properly adjusted. Along with the expected functionality, non-functional requirements are key at this stage to guide the many design alternatives to be evaluated by software architects. The appearance of Search Based Software Engineering (SBSE) brings an approach that supports the software engineer along the design process. Evolutionary algorithms can be applied to deal with the abstract and highly combinatorial optimisation problem of architecture discovery from a multiple objective perspective. The definition and resolution of many-objective optimisation problems is currently becoming an emerging challenge in SBSE, where the application of sophisticated techniques within the evolutionary computation field needs to be considered. In this paper, diverse non-functional requirements are selected to guide the evolutionary search, leading to the definition of several optimisation problems with up to 9 metrics concerning the architectural maintainability. An empirical study of the behaviour of 8 multi- and many-objective evolutionary algorithms is presented, where the quality and type of the returned solutions are analysed and discussed from the perspective of both the evolutionary performance and those aspects of interest to the expert. Results show how some many-objective evolutionary algorithms provide useful mechanisms to effectively explore design alternatives on highly dimensional objective spaces.

Enhancing ontology alignment through a memetic aggregation of similarity measures

Modern infrastructures for information and communication technologies are aimed at providing enhanced services by integrating the knowledge spread on the web through an ontological representation of information. However, ontology usefulness in managing different knowledge sources is limited by the so-called semantic heterogeneity problem arising when several interacting software components use different ontologies for representing the same information. In order to bridge this gap and, consequently, enable a full interoperability across the software components, it is necessary to bring the corresponding ontologies into a mutual agreement by identifying a set of semantic relationships among their entities. This result is achieved by means of a so-called ontology alignment process that, for each pair of entities belonging to the ontologies under alignment, computes their semantic closeness through an optimized aggregation of different similarity measures. Unfortunately, this similarity aggregation is a hard optimization process, above all, when no information is known about ontology features. The aim of this paper is to define an ontology alignment process based on a memetic algorithm able to efficiently aggregate similarity measures without using a priori knowledge about ontologies under alignment. As shown by a statistical multiple comparison procedure, our approach yields high performance in terms of alignment quality with respect to top-performers of well-known Ontology Alignment Evaluation Initiative campaigns.

Analytical modeling for what-if analysis in complex cloud computing applications

Modern cloud applications are complex distributed systems with tens or hundreds of interacting software components. An important management task in cloud computing platforms is to predict the impact of a certain workload or reconfiguration change on the performance of the application. Such predictions require the design of "what-if" models of the application that take as input hypothetical changes in the application's workload or environment and estimate its impact on performance. We present a workload-based what-if analysis system that uses commonly available monitoring information in large scale systems to enable the administrators to ask a variety of workload-based "what-if" queries about the system. We use a network of queues to analytically model the behavior of large distributed cloud applications. Our system automatically generates node-level queueing models and then uses model composition to build system-wide models. We employ a simple what-if query language and an intelligent query execution algorithm that employs on-the-fly model construction and a change propagation algorithm to efficiently answer queries on large scale systems. We have built a prototype and have used traces from two large production cloud bapplications from a financial institution as well as real-world synthetic applications to evaluate its what-if modeling framework. Our experimental evaluation validates the accuracy of our node-level resource usage, latency and workload models and then shows how our system enables what-if analysis in four different cloud applications.

Mutable Protection Domains: Adapting System Fault Isolation for Reliability and Efficiency

As software systems are becoming increasingly complex, the likelihood of faults and unexpected behaviors will naturally increase. Today, mobile devices to large-scale servers feature many millions of lines of code. Compile-time checks and offline verification methods are unlikely to capture all system states and control flow interactions of a running system. For this reason, many researchers have developed methods to contain faults at runtime by using software and hardware-based techniques to define protection domains. However, these approaches tend to impose isolation boundaries on software components that are static, and thus remain intact while the system is running. An unfortunate consequence of statically structured protection domains is that they may impose undue overhead on the communication between separate components. This paper proposes a new runtime technique that trades communication cost for fault isolation. We describe Mutable Protection Domains (MPDs) in the context of our Composite operating system. MPD dynamically adapts hardware isolation between interacting software components, depending on observed communication “hot-paths,” with the purpose of maximizing fault isolation where possible. In this sense, MPD naturally tends toward a system of maximal component isolation, while collapsing protection domains where costs are prohibitive. By increasing isolation for low-cost interacting components, MPD limits the scope of impact of future unexpected faults. We demonstrate the utility of MPD using a webserver, and identify different hot-paths for different workloads that dictate adaptations to system structure. Experiments show up to 40 percent improvement in throughput compared to a statically organized system, while maintaining high-fault isolation.

The Tekkotsu "Crew": Teaching Robot Programming at a Higher Level

The Tekkotsu "crew" is a collection of interacting software components designed to relieve a programmer of much of the burden of specifying low-level robot behaviors. Using this abstract approach to robot programming we can teach beginning roboticists to develop interesting robot applications with relatively little effort.

Merging covering arrays and compressing multiple sequence alignments

Covering arrays have been extensively studied, in part because of their applications in testing interacting software components. In this setting, fast and flexible methods are needed to construct covering arrays of close-to-minimum size. However testing scenarios often impose additional structure on the tests that can be selected. We extend a greedy method to construct test suites for complex systems that have a hierarchical structure in which components combine to form subsystems, which in turn form larger subsystems, until the entire system is formed. The algorithm for merging covering arrays that we propose is then shown to have further potential application in the compression of multiple sequence alignments of genomic data.

Software Design Patterns for Information Visualization

Despite a diversity of software architectures supporting information visualization, it is often difficult to identify, evaluate, and re-apply the design solutions implemented within such frameworks. One popular and effective approach for addressing such difficulties is to capture successful solutions in design patterns, abstract descriptions of interacting software components that can be customized to solve design problems within a particular context. Based upon a review of existing frameworks and our own experiences building visualization software, we present a series of design patterns for the domain of information visualization. We discuss the structure, context of use, and interrelations of patterns spanning data representation, graphics, and interaction. By representing design knowledge in a reusable form, these patterns can be used to facilitate software design, implementation, and evaluation, and improve developer education and communication.

Tool Support for Estimating the Memory Usage of Mobile Phone Software

We present and discuss a tool that can estimate the worst-case memory usage of interacting software components. The tool applies formal analysis based on Coloured Petri nets (CPN). For a given set of interaction scenarios, the tool calculates a state space of a CPN model and finds a path, which corresponds to a worst-case memory usage interleaving of the events in the scenarios. To hide the formal analysis from the users of the tool, IBM Rational Rose is used as front-end to specify scenarios as annotated UML sequence diagrams, and Microsoft Excel is used as back-end to present the analysis results.

Using Firewalls to Enforce Enterprise-wide Policies over Standard Client-Server Interactions

We propose and evaluate a novel framework for enforcing global coordination and control policies over message passing software components in enterprise computing environments. This framework combines the use of firewalls, both per-node software and dedicated firewalls, with an existing coordination and control system to enforce policies that, among other properties, are stateful and communal. The firewalls act as a set of distributed reference monitors that filter messages exchanged between the interacting software components. The coordination and control system coordinates the firewalls to enforce a specific set of policies, passing only messages allowed by these policies. Filtering decisions may be based on credentials presented to the coordination and control system as well as system state accumulated over time. This filtering approach decouples coordination and control from application implementation, allowing the coordination and control mechanism and application implementations to evolve independently of each other. We demonstrate the power of our framework by using it to specify and enforce an RBAC policy with delegation, revocation, and separation-of-duty over accesses to a cluster of NFS and SMB file servers without changing any client or server implementations. Measurements show that our framework imposes acceptable overheads when enforcing this policy.

Front-End-Electronics Communication software for multiple detectors in the ALICE experiment

In the ALICE experiment at CERN, the Detector Control System (DCS) employs several interacting software components to accomplish its task of ensuring the correct operation and monitoring of the experiment. This paper describes the Front-End-Electronics Communication ( FeeCommunication) software and its role within the DCS. The FeeCommunication software's central task is passing configuration and monitoring data between the top level DCS process control and the field devices of several detectors within ALICE. The lowest level of the FeeCommunication software runs on the DCS boards, specialized embedded systems which are in direct contact with the field devices and are physically located within the detector. The middle and upper layers run on standard PC hardware located in the counting room or other external locations. This paper focuses on the design and implementation of the FeeCommunication software and the steps that were taken to fulfill the imposed reliability and performance requirements, specifically those related to safe operation in environments exposed to radiation and magnetic fields.

Parametric design synthesis of distributed embedded systems

This paper presents a design synthesis method for distributed embedded systems. In such systems, computations can flow through long pipelines of interacting software components, hosted on a variety of resources, each of which is managed by a local scheduler. Our method automatically calibrates the local resource schedulers to achieve the system's global end-to-end performance requirements. A system is modeled as a set of distributed task chains (or pipelines), where each task represents an activity requiring nonzero load from some CPU or network resource. Task load requirements can vary stochastically due to second-order effects like cache memory behavior, DMA interference, pipeline stalls, bus arbitration delays, transient head-of-line blocking, etc. We aggregate these effects-along with a task's per-service load demand and model them via a single random variable, ranging over an arbitrary discrete probability distribution. Load models can be obtained via profiling tasks in isolation or simply by using an engineer's hypothesis about the system's projected behavior. The end-to-end performance requirements are posited in terms of throughput and delay constraints. Specifically, a pipeline's delay constraint is an upper bound on the total latency a computatation can accumulate, from input to output. The corresponding throughput constraint mandates the pipeline's minimum acceptable output rate-counting only outputs which meet their delay constraints. Since per-component loads can be generally distributed; and since resources host stages from multiple pipelines, meeting all of the system's end-to-end constraints is a nontrivial problem. Our approach involves solving two subproblems in tandem: 1) finding an optimal proportion of load to allocate to each task and channel and 2) deriving the best combination of service intervals over which all load proportions can be guaranteed. The design algorithms use analytic approximations to quickly estimate output rates and propagation delays for candidate solutions. When all parameters are synthesized, the estimated end-to-end performance metrics are rechecked by simulation. The per-component load reservations can then be increased, with the synthesis algorithms rerun to improve performance. At that point, the system can be configured according to the synthesized scheduling parameters-and then revalidated via on-line profiling. In this paper, we demonstrate our technique on an example system, and compare the estimated performance to its simulated on-line behavior.

Object-oriented and functional software design for distributed real-time systems

Real-time systems in applications like command, control, communications and intelligence require complex distributed systems with many interacting software components, heterogeneous processing systems and sharing resources. These systems should satisfy not only the functional requirements of application software, but also the specified timing constraints on the execution of the software, despite faults and failures. In addition, parallelism needs to be expressed in the design of such systems and exploited on the target distributed computing systems. In this paper, an approach to software design for distributed real-time computing systems, based on the PROOF computation model which integrates object-oriented and functional paradigms, is presented. To support adaptability of the software system to a predictably changing environment, our approach supports multi-versions of a method definition, synchronous communication within objects, asynchronous communication among objects, encapsulation of timing constraints in objects and expressing parallelism in object-level and method-level. Our design approach consists of the high-level object-oriented design and object design phases. Our design approach is illustrated with a hypothetical chemical plant simulation system.