On Self-adaptation Model for Internetware

Metric-based Evaluation of Implemented Software Architectures

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.

With the growing complexity of complex software-intensive systems, some new features emerge such as logical complexity, boundary erosion and failure normalization, which bring new challenges for software dependability assurance. As a result, there is urgent necessity to analyze the failure mechanism of these systems in order to ensure the dependability of complex software-intensive systems. Research indicates that because of the emerging new features, the failure mechanism of complex software-intensive systems is related closely to the system's runtime states and behaviors. But direct analysis of failure mechanism on actual complex software-intensive systems is costly and nearly impossible because of their large scale. So failure mechanism analysis was normally performed on abstract models of real systems. However, current modelling methods are insufficient for describing the system's internal interaction, software/hardware interaction behavior, runtime behavior comprehensively. So it is necessary to propose a new modelling method to support the description of these new features. This paper proposes a method for constructing runtime models for complex software-intensive systems which takes into consideration internal interaction behavior, interaction behavior between software and hardware on system boundary as well as dynamic runtime behavior. The proposed method includes a static structure model to describe the static structure property of the system, a software/hardware interaction model to describe the interaction characteristics between hardware and software on system boundary and a dynamic runtime behavior model to describe the dynamic features of runtime behavior formally. An example is provided to demonstrate how to use the proposed method and its implication for failure mechanism analysis in complex software-intensive systems is discussed.

Chapter 1 - Relating System Quality and Software Architecture: Foundations and Approaches

The foundation for any software system is its architecture. Software architecture is a view of the system that includes the system’s major components, the behaviour of those components as visible to the rest of the system, and the ways in which the components interact and coordinate to achieve the overall system’s goal. Every efficient software system arises as a result of sound architectural basement. This requires the use of good architecture engineering practices and methods. This paper recognizes software architecture practice as a discipline pervading all phases of software development and also presents an enhanced model for software engineering process which provides an avenue for speedy, efficient and timely delivery of software products to their intended users. The integration of software architecture into the phases of software development process in a generic software life cycle is also contained in this research report. This is to enable software engineers and system analysts to use effective software architecture practices and to employ appropriate methodology during the software engineering process.

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.

Software architecture (SA) is the blueprint of the software system and considered as one of the most important artifacts in component based development. The design and analysis of SA can be very complex. Under the inspiration of Model-Driven Development, the design of SA has been no more constrained in one stage. It is a trend to construct multiple SA models in multiple stages during the software life cycle. Thus, the traceability between these SA models becomes a new challenge. The information between these SA models in deferent stages is usually not recorded well and easy to be lost lately, which makes the maintenance and evolution difficult and error-prone. In this paper, we present an approach to recording the information between SA models via a traceability model for reducing the loss of design decisions and helping developers understand the software system well.

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.

Two major study topics have emerged because of the challenges in software architecture and ML working together, as modern software systems produce a vast amount of data that is supported particularly by machine learning (ML), and artificial intelligence (AI) to produce useful insights. Software architecture for machine learning systems that primarily concerned with creating architectural methods for creating ML systems more effectively; ii) ML for Software architectures is concerned with creating ML methods for better-developing software systems. This study focuses on the ML-based software systems' architecture to highlight the many architectural methods currently in use. To more clearly identify a set of acceptable standards for designing ML-based software systems, we explore four crucial components of software architecture in this work that demand the focus of ML and software developers. These areas are based on an ML-based software system for addressing challenges in the COVID-19 detecting system.

For a software-intensive system, software quality measures how well the software is designed and how well the software conforms to that design, whereas architecture of a software system is typically defined as the fundamental organization of the system embodied in its components, their relationships to each other and the environment, and the principles governing the system's design and evolution. Obviously, as long as there were no software systems, governing their architecture was no problem at all; when there were only small systems, governing their architecture became a mild problem; and now we have gigantic software systems, and governing their architecture has become an equally gigantic problem (to paraphrase Edsger Dijkstra). In this paper we propose a unified approach to the problem of governing (or managing) the knowledge about architecture of software systems and demonstrate by example its impact on a certain software project. First we postulate that only the holistic approach that supports continuous integration and verification for all system architectural artifacts is one worth taking. Next we demonstrate by example how a concrete large software project being developed in an agile approach is being perceived using the model in question

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

Large-scale data processing forms the core of modern online services, such as social media and e-commerce, calling for an ever-increasing performance with predictable service quality. Even though emerging hardware platforms can deliver the required performance, actually harnessing it and guaranteeing a certain service quality is still a challenge for application and system software developers. We argue that the major hindrance for applications and system software alike lies in the design of today’s system software architecture. The thread abstraction, for example, hides hardware characteristics, such as the memory topology or accelerators from applications and application behavior from the system software, forcing the latter to base resource management on assumptions while preventing the former from leveraging the potential of modern hardware. We present the as a novel system software architecture with the requirements of modern data-intensive applications in mind. Instead of threads, the provides s as control flows, short, closed units of work that can easily be annotated with application-specific hints giving a glimpse into an application’s future behavior. These hints are used by the to provide automatic synchronization and prefetching, as well as efficient dynamic resource partitioning to ensure performance isolation and the observance of quality of service requirements.

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.

To keep our software products and cross-product software components maintainable, an approach to software architecture management with a long-term perspective is required. One-time modeling of the intended software architecture is not sufficient. Instead, it must be maintained throughout the whole life-cycle of the software system. Tool support is required to monitor the actual physical software architecture. Deviations must be resolved by modifying the software system or the software architecture description. All software architectures are required to follow a consistent architectural style, which is defined in a technology-neutral way and mapped to all technologies we use in development. In order to support this multi-technology landscape, the architectural style, and our use cases, we developed a tool suite, the BTC RevEngTools.

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.