Composition Of Software Components Research Articles

Synchronized Shared Memory and Black-box Procedural Abstraction: Toward a Formal Semantics of Blech

Traditional imperative synchronous programming languages heavily rely on a strict separation between data memory and communication signals. Signals can be shared between computational units but cannot be overwritten within a synchronous reaction cycle. Memory can be destructively updated but cannot be shared between concurrent threads. This incoherence makes traditional imperative synchronous languages cumbersome for the programmer. The recent definition of sequentially constructive synchronous languages offers an improvement. It removes the separation between data memory and communication signals and unifies both through the notion of clock synchronized shared memory . However, it still depends on global causality analyses, which precludes black-box procedural abstraction. This complicates reuse and composition of software components. This article shows how black-box procedural abstraction can be accommodated inside the sequentially constructive model of computation. We present the Sequentially Constructive Procedural Language ( SCoPL ) and its semantic theory of policy-constructive synchronous processes. SCoPL supports black-box procedural abstractions using policy interfaces to ensure that procedure calls are memory-safe and wait-free and their scheduling is determinate and causal. At the same time, a policy interface constrains the level of freedom for the implementation and subsequent refactoring of a procedure. As a result, policies enable separate compilation and composition of procedures. We present our extensions abstractly as a formal semantics for SCoPL and motivate it concretely in the context of the open-source, embedded, real-time language Blech .

Modular Over‐the‐air Software Updates for Safety‐critical Real‐time Systems

ABSTRACTAutomotive software is undergoing a rapid change toward artificial intelligence and towards more and more connectedness with other systems. For both, an incremental design paradigm is desired, where the car's software is frequently updated after production but still can guarantee the highest automotive safety standards. We present a design flow and tool framework enabling a DevOps paradigm for automotive software development. DevOps means that software is developed in a continuous loop of development, deployment, usage in the field, collection of runtime data and feedback to the developers for the next design iteration. The software developers get support in defining, developing, and verifying new software functions based on the data gathered in the field by the previous software generation. The software developers can define contracts describing the time and resource assumptions on the integration environment and guarantees for other dependent software components in the system. These contracts allow a composition of software components and proof obligations to be discharged at design time through virtual integration testing and runtime through continuous monitoring of assumptions and guarantees on the software component's interfaces. An update package, consisting of the software component and its contracts, is then automatically created, transferred over the air, and deployed in the car. Monitors derived from the contracts allow for supervising the system's behavior, detecting failures at runtime, and annotating the situation to be included in a data collection, fueling the next design iteration.

Exception Handling in SARL as a Responsibility Distribution

Exception handling has been successfully proposed in software engineering practice as a simple, but effective, technology to address abnormal situations possibly occurring at runtime. Such mechanisms support the robust composition of heterogeneous software components, promoting code modularity, decoupling, and separation of concerns. Multi-agent systems bring these features to an extreme, but often lack systematic mechanisms for treating exceptions as part of their design. In this paper, we show how exception handling mechanism can be introduced in SARL, leveraging the abstractions that characterize its programming model. We introduce a new kind of space, supporting the responsibility distribution among agents concerning the handling of exceptional situations.

Security aspects in modern service component-oriented application logic for social e-commerce systems

Modern practices in social commerce are a subset of e-Commerce focusing on security framework protocols such as secure transactional protocols, cryptographic schemes, and sanitization criteria. It is assumed that these practices will ensure stable social media-based e-Commerce applications. The main concern in utilizing these practices focus on software component composition, and integration flaws, which are often overlooked in their business application logic. These problems can render the effect of modern information security concepts null and void. The weakest link in social media-based e-Commerce applications is the component’s logic subversion on its server side, which is caused by developers overlooking the design process. This paper addresses a unique issue in aspects of information security in application logic vulnerability called subversion attack, which can be classified as a design flaw. This kind of security flaw cannot be prevented by many traditional security mechanisms commonly used in modern e-Commerce systems. To address this issue, we propose the use of security assurance methodologies in service component-oriented applications to be utilized through threat modeling and a novel technique component fault detection model. This idea is further extended to the modeling component and its applications using a UML secure design approach. To validate the technique, the methods applied in this paper are verification and validation for security by design testing to avoid the business logic design flaw problem in rapidly built component-based social media e-Commerce applications.

CAM-D: A Description Method for Multi-Cloud Marketplace Application

Multi-cloud Marketplace facilitates to create adiverse ecosystem for cloud software and cloud resourceservices provided by many stakeholders. To leverage theadvantage of multi-cloud environment, cloud application couldbe a composition of software components which are able tobe distributed across various cloud providers. So the cloudapplication is therefore a complex system. Consequently, animportant key problem remained in research is to definemulti-cloud application in a particular form and to constructhis description. In this paper, we particularly focus ondeveloping a description method that can be taken to tacklethe lack of description for multi-cloud application by designingdescription templates for CAM which was developed in[1][2][3], called CAM-D. A completed application descriptioncan be synthesized from individual component descriptions.Our experimentation is expressed through the transformationof CAM-D template to TOSCA specification illustrated by casestudy. In addition, we also develop an flattening algorithm toassist in mapping to TOSCA.

Myths and mythconceptions: what does it mean to be a programming language, anyhow?

Modern software does not stand alone; it is embedded in complex physical and sociotechnical systems. It relies on computational support from interdependent subsystems as well as non-code resources such as data, communications, sensors, and interactions with humans. Both general-purpose programming languages and mainstream programming language research focus on symbolic notations with well-defined abstractions that are intended for use by professionals to write programs that solve precisely specified problems. There is a strong emphasis on correctness of the resulting programs, preferably by formal reasoning. However, these languages, despite their careful design and formal foundations, address only a modest portion of modern software and only a minority of software developers. Several persistent myths reinforce this focus. These myths express an idealized model of software and software development. They provide a lens for examining modern software and software development practice: highly trained professionals are outnumbered by vernacular developers. Writing new code is dominated by composition of ill-specified software and non-software components. General-purpose languages may be less appropriate for a task than domain-specific languages, and functional correctness is often a less appropriate goal than overall fitness for task. Support for programming to meet a specification is of little help to people who are programming in order to understand their problems. Reasoning about software is challenged by uncertainty and nondeterminism in the execution environment and by the increasingly dominant role of data, especially with the advent of systems that rely on machine learning. The lens of our persistent myths illuminates the dissonance between our idealized view of software development and common practice, which enables us to identify emerging opportunities and challenges for programming language research.

Matchmaking for Multi-Cloud Marketplace Application

Cloud computing has burst into the trend that a cloud application is developed and provided by a specific cloud provider in form of SaaS (Software as a Service). One limitation of this approach is the vendor lock-in problem, in which the consumers of a SaaS are tightly bound to the ecosystem from the cloud provider in both senses of software development environment and computation resource. Toward solving this problem, in this paper, we propose Composable Application Model (CAM) which formalizes a cloud software as a composition of software components, each of them can be independently developed and can be separately deployed on different cloud platform. We show that our prosed model could be useful for verifying correctness of software composition as well as for checking the correct deployment of a software composition on specified cloud platforms. As an illustration, we experimentally transform our proposed application model into TOSCA application template, a standardized specification for creating multi-cloud application.

CLS-SMT: Bringing Together Combinatory Logic Synthesis and Satisfiability Modulo Theories

We introduce an approach that aims to combine the usage of satisfiability modulo theories (SMT) solvers with the Combinatory Logic Synthesizer (CL)S framework. (CL)S is a tool for the automatic composition of software components from a user-specified repository. The framework yields a tree grammar that contains all composed terms that comply with a target type. Type specifications for (CL)S are based on combinatory logic with intersection types. Our approach translates the tree grammar into SMT functions, which allows the consideration of additional domain-specific constraints. We demonstrate the usefulness of our approach in several experiments.

User Support for the Combinator Logic Synthesizer Framework

Usability is crucial for the adoption of software development technologies. This is especially true in development stages, where build processes fail, because software is not yet complete or was incompletely modified. We present early work that aims to improve usability of the Combinatory Logic Synthesizer (CL)S framework, especially in these stages. (CL)S is a publicly available type-based development tool for the automatic composition of software components from a user-specified repository. It provides an implementation of a type inhabitation algorithm for Combinatory Logic with intersection types, which is fully integrated into the Scala programming language. Here, we specifically focus on building a web-based IDE to make potentially incomplete or erroneous input specifications for and decisions of the algorithm understandable for non-experts. A main aspect of this is providing graphical representations illustrating the step-wise search process of the algorithm. We also provide a detailed discussion of possible future work to further improve the understandability of these representations.

HTN Planning for the Composition of Stream Processing Applications

Goal-driven automated composition of software components is an important problem with applications in Web service composition and stream processing systems. The popular approach to address this problem is to build the composition automatically using AI planning. However, it is shown that some of these planning approaches may neither be feasible nor scalable for many large-scale flow-based applications. Recent advances have proven that the automated composition problem can take advantage of expert knowledge describing the many ways in which different reusable components can be composed. This knowledge can be represented using an extensible composition template or pattern. In prior work, a flow pattern language called Cascade and its corresponding specialized planner have shown the best performance in these domains. In this paper, we propose the use of Hierarchical Task Network (HTN) planning for the composition of stream processing applications. To this end, we propose an automated approach of creating an HTN-based problem from the Cascade representation of the flow patterns. The resulting technique not only allows us to use the HTN planning paradigm and its many advantages including added expressivity but also enables optimization and customization of composition with respect to preferences and constraints. Further, we propose and develop a lookahead heuristic and show that it significantly reduces the planning time. We have performed extensive experimentation with stream processing applications and evaluated applicability and performance of our approach.

Middleware strategies for clouds and grids in e‐Science

Middleware strategies for clouds and grids in e‐Science

An Integration Ontology for Components Composition

Software components composition can improve the efficiency of knowledge management by composing individual components together for complex distributed application. There are two main areas of research in knowledge representation for component composition: the syntactic based approach and the semantic-based approach. In this paper, the authors propose an integrated ontology-supported software component composition. The authors’ approach provides dual modes to perform component composition. Ontologies are employed to enrich semantics at both components description and composition. The authors demonstrate that their search engine SEC++ fulfills automated component composition, in particular, and knowledge management in general.

Semantic templates for case-based reasoning systems

AbstractIn this paper, we present an approach to solve the drawbacks of manual composition of software components. Our approach is applied within the jcolibriframework for building case-based reasoning (CBR) applications. We propose a system design process based on reusingtemplatesobtained from previously designed CBR systems. Templates store the control flow of the CBR applications and include semantic annotations conceptualizing its behavior and expertise. We use CBR ontology to formalize syntactical, semantical and pragmatical aspects of the reusable components of the framework. The ontology vocabulary facilitates an annotation process of the components and allows to reason about their composition, facilitating the semi-automatic configuration of complex systems from their composing pieces.

Version management and composition of software components in different phases of software development life cycle

The key factor of component-based software development is the composition of pre-fabricated components. Although research efforts have focused on this issue, yet the optimal performance of component-based systems has not been achieved. If the concept of version management is introduced along with composition technology then it will help in locating the component mismatch in the earlier stages of software development life cycle. This paper analyses the significance of version management and composition of software components in different phases like analysis phase, design phase and deployment phase of software development life cycle. A comparative analysis of different available component models like COM, .NET, Enterprise JavaBeans (EJB), CORBA, SOFA, UML 2.0 and Web Services with respect to these two issues is also discussed.

Computer aided software design via inference and constraint propagation

Engineered systems, including computer programs, are mainly composed of versions of known components. We describe systems that produce computer software by composition and specialization of generic software components. The work of the human designer is reduced because components can infer or defaul t many specifications, propagating them to connected components. Specialized programs can be constructed rapidly and easily using a graphical programming interface. We describe systems that can capture and understand data from the web, allowing a user to write programs easily to analyze the data. Web pages that perform calculations or data lookup can be treated as remote procedure calls, allowing calculations, proprietary data and real-time data to be used. Examples are presented to illustrate construction of programs for analysis of web data. These capabilities provide connectivity between web data, codified knowledge, and generic programs, providing a pathway to fulfillment of the promise of integration of the vast amount of information on the web.

Models and Architecture for Autonomic Network Management

This paper presents a model-based framework to support the automated and adaptive deployment of communication services for QoS. The application domain targets cooperative group activities applied to military emergency operation management systems. Various models are introduced to represent the different levels of cooperation (applicative / middleware / transport). The adaptation decision process relies on structural model transformations while its enforcement is based on the dynamic composition of micro-protocols and software components. Automated deployment is performed both at the transport (i.e. UDP-TCP level) and middleware level. The architecture to support automated network management based on these models is introduced and its performance is evaluated through the use of a Java prototype.

Component-based architecture: the Fractal initiative

Component-based software engineering (CBSE) [32] and software architecture [30] have become mature and very active fields of study. Both can be traced back to an early vision of systematically produced software [24] and are primarily concerned with the construction of software systems by composition or assembly of software components, with well-defined interfaces and explicit dependencies. Nowadays, it is generally recognized that component-based software engineering and software architecture approaches are crucial to the development, deployment, management, and maintenance of large, dependable software systems [6]. Several component models and associated architecture description languages (i.e., notations for defining components and component assemblages) have been defined in the past 15 years. In large part, this diversity stems from differences in application domains targeted by the different models, as well as differences in choices for component interconnection and composition capabilities (much as there exists today a wealth of models and languages for concurrency). In the face of this diversity, the Fractal component model [10]—a programming language-independent component model for the construction of highly configurable software systems introduced by France Telecom and INRIA in 2001—was designed from the outset to allow arbitrary forms of component interconnection and component composition and to allow other component models to be derived as Fractal personalities. To achieve this, the Fractal model combines ideas from three main sources: (1) CBSE and software architecture, (2) reflective systems [18], and (3) configurable and adaptable distributed systems, (notably, the OpenORB [7] system and its associated OpenCOM component model [12]). From CBSE and software architecture, Fractal inherits basic concepts for the modular construction of software systems: software components, interfaces, and explicit connections (called bindings) between them. Notably, these concepts allow for the (recursive) construction and management of hierarchical component architectures possibly with sharing (a subcomponent can be part of several parent components) this last feature being an originality of Fractal. From reflective systems, Fractal inherits the idea that components can exhibit meta-level behavior reifying, through appropriate interfaces (called controller interfaces), their internal structure, and behavior. From configurable Ann. Telecommun. (2009) 64:1–4 DOI 10.1007/s12243-009-0086-1

Designing socio-technical systems: from stakeholder goals to social networks

Software systems are becoming an integral part of everyday life influencing organizational and social activities. This aggravates the need for a socio-technical perspective for requirements engineering, which allows for modelling and analyzing the composition and interaction of hardware and software components with human and organizational actors. In this setting, alternative requirements models have to be evaluated and selected finding a right trade-off between the technical and social dimensions. To address this problem, we propose a tool-supported process of requirements analysis for socio-technical systems, which adopts planning techniques for exploring the space of requirements alternatives and a number of social criteria for their evaluation. We illustrate the proposed approach with the help of a case study, conducted within the context of an EU project.

New Model and Algorithm for Hardware/Software Partitioning

This paper focuses on the algorithmic aspects for the hardware/software (HW/SW) partitioning which searches a reasonable composition of hardware and software components which not only satisfies the constraint of hardware area but also optimizes the execution time. The computational model is extended so that all possible types of communications can be taken into account for the HW/SW partitioning. Also, a new dynamic programming algorithm is proposed on the basis of the computational model, in which source data, rather than speedup in previous work, of basic scheduling blocks are directly utilized to calculate the optimal solution. The proposed algorithm runs in O(n ċ A) for n code fragments and the available hardware area A. Simulation results show that the proposed algorithm solves the HW/SW partitioning without increase in running time, compared with the algorithm cited in the literature.

COMDEVALCO framework - the modeling language for procedural paradigm

This work is part of a series referring to COMDEVALCO - a framework for Software Component Definition, Validation, and Composition. Its constituents are: a modeling language, a component repository and a set of tools. This is the first paper describing the object-oriented modeling language, which contains finegrained constructions, aimed to give a precise description of software components. The current status of the language reflects the procedural paradigm constructs.