A Software Architecture Framework for Home Service Robots

It is our great pleasure to welcome you to the 8th International ACM Sigsoft Conference on the Quality of Software Architectures -- QoSA'12. For almost a decade, QoSA aims at advancing the state of the art in the quality assessment and management for software architectures. Specific issues of interest are defining quality measures, evaluating and managing architecture quality, linking architecture to requirements and implementation, and preserving architecture quality throughout the lifetime of the system. Past themes for QoSA include Quality throughout the Software Lifecycle (2011), Research into Practice -- Reality and Gaps (2010), Architectures for Adaptive Software Systems (2009), and Models and Architecture (2008). The umbrella theme of QoSA 2012 is Evolving Architectures. The QoSA'12 call for papers attracted 52 abstracts leading to the final number of 44 submissions from Europe, North and South America, Australia, Asia, and Africa. The program committee accepted 11 long papers and 7 short papers that cover a variety of topics related to the quality of software architectures. In addition, the program includes two keynote speeches, first by Alberto Montresor (University of Trento, Italy) on Designing Extreme Distributed Systems: Challenges and Opportunities, and second by Johan Bendz (Convenor of the ISO/IEC-JTC1-SC7 Working Group on Architecture) on International Standards Supporting Quality in Software Architecture. QoSA is part of the federated event CompArch, this year together with "CBSE 2012: 15th International ACM SIGSOFT Symposium on Component Based Software Engineering," "ISARCS 2012: 3rd International ACM SIGSOFT Symposium on Architecting Critical Systems," "WCOP 2012: 17th International Doctoral Symposium on Components and Architecture," and "ROSS 2012: Workshop on Reusing Open-Source Components." We are grateful to the organizers of all these events for making CompArch a successful federated event on Component-based Software Engineering and Software Architecture.

Recently, more attention is paid to the researches and practices on how to use software architecture in software maintenance and evolution to reduce their complexity and cost. The key in such architecture-based maintenance and evolution is to recover software architecture from existing systems. Almost all studies on architecture recovery focus on analyzing the source code and other documents. Such recovered software architecture can hardly capture runtime states and behaviors of the system. At the same time, current work pays little attention on how to change the system directly via manipulating the recovered software architecture. This paper presents a novel approach to recovering software architecture from component based systems at runtime and changing the runtime systems via manipulating the recovered software architecture. Containing much more details than the designed software architecture, the recovered software architecture can accurately and thoroughly describe the actual states and behaviors of the runtime system. It can be described formally with the extension of traditional architecture description language, which enables the recovered software architecture to absorb the semantics embedded in the designed software architecture. The recovered software architecture can be represented as multiple views so as to help different users to control the complexity from different concerns. Based on the reflective ability of the component framework, the recovered software architecture is up-to-date at any time and changes made on it will immediately lead to the corresponding changes in the runtime system. The approach presented in this paper is demonstrated on PKUAS, a reflective J2EE (Java 2 Platform Enterprise Edition) application server, and the performance is also evaluated.

There is a plethora of models, techniques and tools that support model-and component-based software development of vehicular distributed embedded systems. However, a large majority of them have a limited or no support to model and specify end-to-end resource reservations on the software architectures of these systems. Resource reservations allow flexibility during the development and execution of such complex systems without jeopardizing their predictable behavior. As a result, several applications in the system that share the same hardware platform can be developed independently. In this paper we identify several requirements that any existing component model should fulfill in order to support the modeling of end-to-end resource reservations on the software architectures of such systems. As a proof of concept, we extend the Rubus Component Model (RCM) by fulfilling these requirements. RCM is used for the development of control functionality in vehicular embedded systems by several international companies. We also provide a technique to extract execution models from the software architectures of these systems with resource reservations. In order to show the usability of our technique, we model a vehicular distributed embedded system with the extended component model and extract the execution model from the software architecture augmented with end-to-end resource reservations.

The software architecture is typically defined as the fundamental organization of the system embodied in its components, their relationships to one another and to the system's environment. It also encompases principles governing the system's design and evolution. In order to manage the architecture of a large software system the architect needs a holistic model that supports continuous integration and verification for all system artifacts. In earlier papers we proposed a unified graph-based approach to the problem of managing knowledge about the architecture of a software system. In this paper we demonstrate that this approach facilitates convenient and efficient project measurement. First, we show how existing software metrics can be translated into our model in a way that is independent of the programming language. Second, we introduce new metrics that cross the programming language boundaries and are easily implementable using our approach. We conclude by demonstrating how the new model can be implemented using existing tools. In particular, graph databases are a convenient implementation of an architectural repository. Graph query languages and graph algorithms are an effective way to define metrics and specialized graph views.

Modern Control Center Systems - Architecture, Data Handling, Extended Communication

The growth of various software architectural frameworks and models provides a standard governing structure for different types of organizations. Selection of a suitable framework for a particular environment needs much more detailed information in various aspects and a reference guide of features should be provided. This paper brings out the history of software architecture with a new evolution tree. It also technically analyses well known frameworks used in industries and other governmental organizations and lists out the supportive tools for them. This paper presents the comparative chart that can be used as a reference guide to understand top level frameworks and to further research to enable and promote the utilization of these frameworks in various environments. The basic principles of 'software architecture' have been applied since the mid 1980's and it crossed various stages from algorithm's era by borrowing the concepts from others to get a shaped form. In 1928, An Algorithm was formulated to solve the problem by the finite sequence of instructions. Von Neumann developed 'Flow Chart' that has a visual representation of the instruction flow, to plan computer programs in 1947 by inheriting the idea from the flow process chart(1921) and multi flow chart(1944)which were used mostly in the area of electrical engineering. But, there is a gap to point out the flow of control. So, 'Control Flow Diagram' (CFD) was developed in the late 1950's to describe the control flow of a business process and program. This was not enough to view the complex systems. The high level view of the work and immediate access of particular points can't be represented using this diagram. So, to reveal the entire system by dividing into blocks, 'Block Diagram' was developed in late 1950's. A specific function for each block and the connection between blocks will be shown in a diagram. The introduction of abstraction concept became a booster in the field of software architecture. It made a revolution and tremendous growth to that area. By that way, data structures that have similar behaviour, data structures that have similar behaviour, certain data types and modules of one or more programming languages that have similar semantics are grouped in the late 1960's.This was happened by the introduction of Abstract data types. It again leads to 'Modular Programming' that introduces the concept of separate parts called modules in software in 1968. Separation of concerns with the logical boundaries between components is called as modules. In 1977, 'Three Schema Approach' that adopts layered architecture based on the modular programming was developed. It is used to build information systems using three different views in systems development. Here an application will be broken into tiers and developers have to modify a

This paper provides an introduction to the field of software engineering requires facility in architectural software design. The goal is to demonstrate the current state of the discipline and examine the ways in which architectural design can impact soft-ware design. Software architecture is used to describe a high level design methodology of large software systems. It provides the overall structure of a system in an abstract and structured fashion. A smart architectural demonstration holds the key to the effectiveness of a software architecture description and usage. This paper focuses on criterion to select appropriate architecture style for software system. It also gives overview of definition, goals and requirements of software architecture with various architecture styles, their benefits and applications. The authors have also described the requirements and goals of robotic software architecture. The proposal for layered robotic software architecture for a distributed system is also presented.

Feature modeling is a main stream technology in domain requirement analysis of software product line engineering. Establishing the traceability between feature model and software architecture plays the essential role in improving software quality. Based on Formal Concept Analysis technology, we proposed a method to verify traceability between feature model and software architecture. The method analyzed the constitution of the feature, defined feature model and software architecture function expression, constructed a concept lattice and presented several mapping criteria to analysis it. It is more applicable for higher complexity model, comparing to the other model traceability method. A case study is used to demonstrate the feasibility of the method.

Software architecture has become an important area of research and practice since the late 1980s (Shaw and Clements 2006). The term “software architecture” started gaining acceptance by the software engineering community in early 1990s but the foundations of this field were laid by the seminal work of Edsger Dijkstra, David Parnas, and others between 1960s and 1980s (Clements 2000). The increasing size and complexity of software systems and demand for high quality are some of the most important factors that have driven the increased interest in this sub-discipline of software engineering. It has generally been realized that a high-level design description can play an important role in successfully understanding and managing large and complex software systems (Clements et al. 2002; Lung and Kalaichelvan 2000). The high-level design decisions regarding the software architecture of a system are not only the hardest and most expensive to change but also play a fundamental role in setting the boundaries for the required quality attributes such as maintainability, reliability, usability, performance, and flexibility of a system (Bass et al. 2003; Clement and Northorp 1996). As a result of increasing realization of the important role of software architecture in large-scale software development and evolution projects, the software architecture community has developed several methods, techniques, and tools to support the software Empir Software Eng (2011) 16:539–543 DOI 10.1007/s10664-011-9168-6

The Internet of Things-based systems and software allow computations anywhere at any time by interconnecting individuals, networks, services, computers and artefacts that allow autonomous systems to form digitized communities. As the blueprint for software-intensive applications, and software architecture that precise the complexity of a network’s planning, development, and changing phases to effectively and efficiently build complex IoT-driven applications. In any case, there exists no comprehensive analysis in the state of the research on the adoption of MSA for IoT systems. This study effort is needed to explore architectural concepts and practices for designing and developing IoT software to excel state-of-the-art for IoTs along with suggestions and recommendations for IoT software to the adoption of MSA to fulfil the identified gaps. A systematic analysis was coordinated, covering up the literature on existing IoT solutions by studying 140 qualitatively selected articles performed between 2005 and Jan 2020. One hundred forty articles were comprised in this SLR. The findings of this study demonstrated different research topics including software architectural styles, patterns, and models to build IoT software. This research presents cloud-based computing environments, autonomous, software-defined networking, and responsive applications, and IoT-driven agent-based systems, (1) thirteen MSA architectural and design patterns for IoTs and classification of patterns, (2) classification of software architectures for IoTs into nine main categories and their sub-categories, (3) twenty-three most investigated IoT challenges, and (4) mapping of IoT challenges with software architectural solutions. The study revealed the innovative work on IoT software architecture and trends that help in the creation and dynamic adaptation of IoT software for reusability, automation and human decision-making. The outputs of this SLR are useful in revealing many recommendations to the software industry, software engineering community, and computer sciences community with over the past 15 years of research into the adoption of MSA. This study reflects a distilled awareness of architectural practices and principles to assist researchers and practitioners in promoting information sharing software architectural roles and responsibilities for the Internet of Things software.

Software architecture provides a high-level design that serves as the basis for system implementation and communication among stakeholders. However, changes in requirements and lack of conformance checks during development can cause the implemented architecture to deviate from the intended one. Such architecture degradation can cause rapid software aging and high maintenance costs. Conformance checking to detect inconsistencies between a model and its corresponding implementation is one of the strategies used to minimise architecture degradation. Existing conformance checking tools often require formal architecture specifications, which are not usually available outwith academic settings, or manual intervention in the process, which affects their viability. This paper describes an automated approach that uses mappings between architecture models in UML and corresponding implementations in Java to check conformance. These notations have been chosen for their adoption in industry. A customisable tool called Card, which implements this approach, is also introduced and evaluated.

To support robust plan execution of autonomous robots in dynamic environments, autonomous robot software should include adaptive and reactive capabilities to cope with the dynamics and uncertainties of the evolving states of real-world environments. However, conventional software architectures such as sense-model-plan-act and behaviour-based paradigms are inadequate for meeting the requirements. A lack of sensing during acting in the sense-model-plan-act paradigm makes the software slow to react to run-time contingencies, whereas the behaviour-based architectures typically fall short in planning of long-range steps and making optimized plan adaptations. This article proposes a hybrid software architecture that maintains both adaptivity and reactivity of robot behaviours in dynamic environments. To implement this architecture, we further present the multi-agent development framework known as AutoRobot, which views the robot software as a multi-agent system in which diverse agent roles collaborate to achieve software functionalities. To demonstrate the applicability and validity of our concrete framework and software architecture, we conduct an experiment to implement a typical case, for example, a robot that autonomously picks up and drops off dishes for remote guests, which requires the robot to plan and navigate in a highly dynamic environment and can adapt its behaviours to unexpected situations.

Introduced in the early stages of software development, the Charmy framework assists the software architect in making and evaluating architectural choices. Rarely, the software architecture of a system can be established once and forever. Most likely poorly defined and understood architectural constraints and requirements force the software architect to accept ambiguities and move forward to the construction of a suboptimal software architecture. Charmy aims to provide an easy and practical tool for supporting the iterative modeling and evaluation of software architectures. From an UML-based architectural design, an executable prototype is automatically created. Charmy simulation and model checking features help in understanding the functioning of the system and discovering potential inconsistencies of the design. When a satisfactory and stable software architecture is reached, Java code conforming to structural software architecture constraints is automatically generated through suitable transformations. The overall approach is tool supported.

Software architecture is a software system’s earliest set of design decisions that are critical for the quality of the system desired by the stakeholders. The architecture makes it easier to reason about and manage change during different phases of complex software life cycle. The modeling of software architecture for System of Systems (SoS) is a challenging task because of a system’s complexity arising from an integration of heterogeneous, distributed, managerially and operationally independent systems collaborating to achieve global missions. SoS is essentially dynamic and evolutionary by design requiring suitable architectural patterns to deal with runtime volatility. Service-oriented architecture offers several architectural features to these complex systems; these include, interoperability, loose coupling, abstraction and the provision of dynamic services based on standard interfaces and protocols. There is some research work available that provides critical analysis of current software architecture modeling approaches for SoS. However, none of them outlines the important characteristics of SoS or provides detailed analysis of current service-oriented architecture modeling approaches to model those characteristics. This article addresses this research gap and provides a taxonomy of software architecture modeling approaches, comparing and contrasting them using criteria critical for realization of SoS. Additionally, research gaps are identified, and future directions are outlined for building software architecture for SoS to model and reason about architecture quality in a more efficient way in service-oriented paradigm.

Managing evolution of complex software architecture is a continuous challenge in industry. Systems such as mobile handsets undergo a continuous increase in complexity, while the fast market evolution imposes quick integration of new features. Being able to easily manage software architecture evolution is the basis for shorter time-to-market and faster product release. The term “viewpoint” has become familiar with the publication of the IEEE standard 1471–2000 on recommended practices for architectural modelling. Based on the classical 4+1 view model, we have elaborated our own set of viewpoints in order to support our domain-specific architectural modelling needs. We hereby justify the introduction of the architectonic viewpoint, which models the evolutionary aspects of software architecture. The term, as well as the rationale behind it, is inspired from architecture as in buildings. We describe the viewpoint and the way it links to the others we use. Additionally, we briefly elaborate on the other viewpoints that we use for architectural modelling of mobile telephone software architecture. We provide basis for discussion and further research into the matter.