Evaluating the Impact of Possible Dependencies on Architecture-Level Maintainability

Scaling up software architecture analysis

Open-source software projects are characterized by their loose management property. Most of the activities of their developers are voluntary instead of mandatory. Compared to closed-source software projects, open-source projects are less dependent on external turbulence, but more on its own structure and operation mechanism. In this paper, we assume that the activities of open-source software projects are only dependent on time. We use time series analysis techniques to study the time dependence of open-source software activities. The activities of open-source Software projects are extracted from mailing lists, bug reports, and revision history. Three mailing list (Linux, FreeBSD, and Apache HTTP), two bug archives (Eclipse and Apache Software Foundation), and one revision history (Apache Software Foundation) are mined. Various time series analysis techniques are used. We find that some activities of some open-source projects are cyclic and seasonally dependent, some are cyclic but seasonally independent, and some are acyclic. We build regression models for cyclic activities and analyzed their model accuracy.

Analysis of the source code of video games is not an integrated part of the formal analysis. Rather, few scholars have investigated how an analysis of the source code can inform a hermeneutic reading of the game. In this paper I will present a reading of the source code of Passage (Rohrer, 2007), argue for why a traditional focus on authorial intention is unnecessary when investigating the symbolism and metaphors of a game, and illustrate how source code analysis can inform the formal analysis of the executed game. Finally, I shall discuss how the source code relates to the game as a ‘work’, and how it can be used for studies of symbolism and metaphors. Thus, I will conclude that it is indeed a valuable method for game studies, although further studies should expand on the textual relation between executed game and source code.

Regression testing can be systematically applied at the software architecture level in order to reduce the cost of retesting modified systems, and also to assess the regression testability of the evolved system. With the advent of model-based specification and analysis of software architectures, regression testing at the architectural level can be handled by analyzing how the architectural model evolves when moving from an initial to a subsequent version. This paper analyzes how model differencing, a recent research topic in the model-based community, can be employed for implementing model-based architecture-level regression testing.

Software architecture analysis plays an important role in software development lifecycle. However, from the view of separation of concerns, there is an absence of both structural description and behavioural analysis of software architecture. This paper proposes an aspect-oriented software architecture (AOSA) to reduce the complexity of software model and improve the reliability of software system. Aspect-oriented architecture description language based on XML is defined for structural description of software architecture, while aspect-oriented statechart and temporal logic are used for its behavioural analysis. A carousel case illustrates that the formal method is effective.

In the past decade, software architecture research has mainly focused on the concept formulation and the development of various architecture description languages. This field has now matured enough and thus requires more emphasis on techniques for developing and analyzing software architecture specifications. SAM is a general software architecture model for developing and analyzing software architectures. In this paper, we show how to integrate high-level Petri nets and first-order temporal logic as the foundation of SAM to establish a unified framework for specifying and analyzing all aspects of a software architecture. We provide a set of heuristics, which are supported by well-defined existing methods and techniques developed by other researchers as well as our own, for software architecture development and analysis. We demonstrate the application of this framework and the heuristics with an example.

Early system modelling is an essential tool to accelerate software development, architectural analysis and hardware verification in complex many-core system-on-chips (SoCs). Transaction level modelling (TLM) offers a higher level of abstraction than register transfer level (RTL) and can be used for early system modelling. Maintaining simulation speed with the right accuracy is a major challenge and this paper proposes SystemC-based architectural modelling techniques that extend TLM to deliver faster simulation models for many-core system. The proposed approach considers a micro-scheduler for large modules (in the sense of SystemC modules) to locally manage all events in the module. Exploiting this micro-scheduler along with function object and coroutine concepts, the authors propose a lightweight thread process that significantly reduces the context switching overhead among the different processes. Additionally the micro-scheduler allows some processes to be run ahead of simulation time. The proposed techniques are applied to the model of a very large networks-on-chip (NoC) formed by thousands of cores stressing the simulation capabilities of the host computer and operating system. The experimental results demonstrate that the model can run successfully and exhibits up to 93% improvement in simulation speed compared to traditional SystemC-based modelling.

Code analyzers such as Error Prone and FindBugs detect code patterns symptomatic of bugs, performance issues, or bad style. These tools express patterns as quick fixes that detect and rewrite unwanted code. However, it is difficult to come up with new quick fixes and decide which ones are useful and frequently appear in real code. We propose to rely on the collective wisdom of programmers and learn quick fixes from revision histories in software repositories. We present Revisar, a tool for discovering common Java edit patterns in code repositories. Given code repositories and their revision histories, Revisar (i) identifies code edits from revisions and (ii) clusters edits into sets that can be described using an edit pattern. The designers of code analyzers can then inspect the patterns and add the corresponding quick fixes to their tools. We ran Revisar on nine popular GitHub projects, and it discovered 89 useful edit patterns that appeared in 3 or more projects. Moreover, 64% of the discovered patterns did not appear in existing tools. We then conducted a survey with 164 programmers from 124 projects and found that programmers significantly preferred eight out of the nine of the discovered patterns. Finally, we submitted 16 pull requests applying our patterns to 9 projects and, at the time of the writing, programmers accepted 7 (63.6%) of them. The results of this work aid toolsmiths in discovering quick fixes and making informed decisions about which quick fixes to prioritize based on patterns programmers actually apply in practice.

In the Internet environment, software gradually moves from closed, static and controllable status towards open, dynamic and unpredictable state. How to propose suitable software theory for such adaptive software has become the challenging issue facing the computer science and technology. Applicable formal theoretical basis is one of signs that software technology achieves maturity, while support for protocol, analysis and verification of adaptive software architecture is inadequate in existing mobile and concurrent theories. Although the software architecture technology has now entered into the golden era of development, there are still many issues to be resolved, one of which is the need for effective mechanism to describe, analyze and verify software architecture. Bigraph puts emphasis on two factors of calculated position and connection on the basis of the existing theories, and a relatively complete and extensible theoretical framework is established. Nowadays, bigraph theory has now begun to be applied, and studies are gradually carried out on extension and shift of bigraph theory basis, description of concurrency theory, bigraph logic, modeling of pervasive computing system, and BPL programming language of bigraph. Hence, bigraph theory can provide a solid foundation for the formal methods of adaptive software architecture.

Architecture description languages deal with the description, analysis and reuse of software architectures. This paper describes DAOP-ADL, a component- and aspect-based language to specify the architecture of an application in terms of components, aspects and a set of plug-compatibility rules between them. With the aim of connecting the specification of the application architecture to the implementation, we describe our language using XML and XML Schemas. The DAOP-ADL language was designed to be interpreted by DAOP, our own dynamic component- and aspect-oriented platform. DAOP provides a composition mechanism that plugs aspects into components dynamically at runtime. The software architect will use the DAOP-ADL language at design time to describe the architecture of the application. Later this architectural information is loaded into the DAOP platform, which needs it to establish the dynamic connections between autonomous components and aspects. Therefore, the use of DAOP-ADL closes the gap between design and implementation of component- and aspect-based applications.

An architecture style defines a commonly occurring pattern of the structural organization of components and connectors such that the impact of the pattern on the different non functional attributes is known. It is possible to make a qualitative assessment of whether a specific style is conducive to the nonfunctional attribute of performance based on the knowledge and experience in the use of the style. It is necessary however, that such a qualitative judgment be substantiated by a quantitative estimate obtained using a systematic performance analysis approach, since architecture styles are likely to be used in domains where application performance will play a critical role in ensuring its widespread use. Recognizing this need, several research efforts have focused on the development of quantitative performance analysis approaches for general purpose software architectures as well as for architecture styles. A notable drawback of the existing approaches is that they do not consider failures of components and connectors and hence provide optimistic performance estimates. In this paper we present a performability analysis approach for a pipeline architecture style which accounts for unreliable components. The performance estimate provided by the proposed approach is more realistic than what can be provided by the prevalent approaches. We illustrate the potential of the approach with an industrial case study of a document analysis system.

Efficient deadlock analysis of component-based software architectures

Analysis and selection of software architecture for the implementation of control system of automated control base-plates shakers at their rising to a predetermined height, holding in vibration test and lowering to the supports are analyzed. It is shown that the software implements are a dynamic process, which depends on the quality of further vibration testing.

: Architecture Description Languages provide significant opportunity for the incorporation of formal methods and engineering models into the analysis of software and system architectures. A standard is being developed for embedded real-time safety critical systems which will support the use of various formal approaches to analyze the impact of the composition of systems from hardware and software and which will allow the generation of system glue code with the performance qualities predicted. The standard the Avionics Architecture Description Language (AADL), is based on the MetaH language developed under DARPA and US Army funding and on the model driven architectural based approach demonstrated with this technology over the last 12 years. The AADL standard will include a UML profile useful for avionics, space, automotive, robotics and other real-time concurrent processing domains including safety critical applications.

This paper introduces a new trade analysis software called the Space Mission Architecture and Risk Analysis Tool (SMART). This tool supports a high-level system trade study on a complex mission, such as a potential Mars Sample Return (MSR) mission, in an intuitive and quantitative manner. In a complex mission, a common approach to increase the probability of success is to have redundancy and prepare backups. Quantitatively evaluating the utility of adding redundancy to a system is important but not straightforward, particularly when the failure of parallel subsystems are correlated. SMART offers the unique capability of handling correlated redundancies and accurately evaluating the probability of mission success as well as its sensitivity to the reliability of mission components. It can also perform Monte-Carlo analysis to find the confidence interval of the success probability, total mission cost, and total mass. Additionally, SMART provides a GUI interface based on Matlab/Simulink that allows users to graphically define mission architecture as well as the logical relationship between mission components and outcomes. These analysis capabilities enable to answer questions such as: “for a given upper bound on total cost and mass, on which subsystem should we implement redundancy to maximize the chance of mission success?” Although the focus of SMART is high-level trade analysis, it also provides an interface to detailed models of mission components, allowing to perform an integrated analysis that covers from low-level details to high-level architecture. The analysis capabilities are enabled by our unique propositional logic-based approach. SMART translates the graphical mission model to a propositional logic representation through symbolic computation. We demonstrate SMART's analysis capabilities on a MSR model as well as a model of a fictional mission.