Machine learning has been implemented as a part of many software systems to support data-driven decisions and recommendations. The prominent machine learning technique is the artificial neural network, which lacks the explanation of how it produces the output. However, many application domains require algorithmic decision making to be transparent so explainability in these systems has been an important challenge. This paper proposes an automated framework that elicits the contributing rules describing how the neural network model makes decisions. The explainability of contributing rules can be measured and it is able to address issues in the training dataset. With the ontology representation of contributing rules, an individual decision can be automatically explained through ontology reasoning. We have developed a tool that supports applying our framework in practice. The evaluation has been conducted to assess the effectiveness of our framework using open datasets from different domains. The results prove that our framework performs well to explain the neural network models, as it can achieve the average accuracy of 81% to explain the subject models. Also, our framework takes significantly less time to process than the other technique.

The evolutionary architecture supports software systems to make small functional changes frequently and reliably. With fitness functions defined, we can ensure that the architectural goals are met as the system evolves. However, some functionality changes cause architectural changes, which impact a large part of the software system. Therefore, we aim at ensuring that changes in the architectural design do not impact the existing functionalities, while new functionalities are incorporated into the new design. This paper proposes an approach to automate architectural design refactoring that supports changes in functionalities. Our approach applies formal modeling and verification to refactor and verify the evolution process of software systems. The proposed algorithms help to automatically refactor the design by referencing the given architecture design. With our appproach, the evolution process can be planned and formally verified to guarantee that the system can evolve safely to support functionality changes. We evaluated our approach with four real-world systems. The results show the effectiveness of our refactoring approach to support new functional properties.

Software architectural designs are usually changed over time to support emerging technologies and to adhere to new principles. Architectural migration is an important activity that helps to transform the architectural styles applied during a system’s design with the result of modernising the system. If not performed correctly, this process could lead to potential system failures. This article presents an automated approach to refactoring architectural design and to planning the evolution process. With our solution, the architectural design can be refactored, ensuring that system functionality is preserved. Furthermore, the architectural migration process allows the system to be safely and incrementally transformed. We have evaluated our approach with five real-world software applications. The results prove the effectiveness of our approach and identify factors that impact the performance of architectural verification and migration planning. An interesting finding is that planning algorithms generate migration plans that differ in term of their relative efficiency.

Software architecture design usually needs to be migrated to new architectural styles when new technologies and principles are adopted to enhance the qualities of the software system. The architectural migration is an evolution process, which the system is gradually and incrementally changed while the functionalities are still preserved. Planning the migration towards a new design is an important and challenging task. This paper presents an automated planning approach for architectural migration by applying AI planning and model checking technique. Our approach can automatically generate migration plans that can be used to find evolution path towards the new architecture designs. We have demonstrated our approach with a real-world system and found that it works effectively.

The architecture smells are the poor design practices applied to the software architecture design. The smells in software architecture design can be cascaded to cause the issues in the system implementation and significantly affect the maintainability and reliability attribute of the software system. The prevention of architecture smells at the design phase can therefore improve the overall quality of the software system. This paper presents a framework that supports the detection of architecture smells based on the formalization of architecture design. Our modeling specification supports representing both structural and behavioral aspect of software architecture design; it allows the smells to be analyzed and detected with the provided tools. Our framework has been applied to seven architecture smells that violate different design principles. The evaluation has been conducted and the result shows that our detection approach gives accurate results and performs well on different size of models. With the proposed framework, other architecture smells can be defined and detected using the process and tools presented in this paper.

Software architecture design plays a vital role in software development, as it gives an overview of how the software system should be constructed and executed at runtime.The verification of software architecture design is hence important but it is an error-prone task that heavily relies on knowledge and experience of the software architect, especially for a large software system that its behaviour is complex.Automated verification can be a solution to this problem, however, the specification language must be expressive enough to describe the behaviour of different design entities.This paper presents an enhancement of an architecture description language supported by PAT.The enhancement aims to improve the expressiveness of the language, in order to support the automated behaviour verification of software architecture design.With this enhancement, different behaviour of specific component and connector can be thoroughly checked and traced.The implementation of this enhancement is presented to demonstrate how the standard model checking engine such as PAT can be extended to support an architecture description language.We evaluated our approach with a case study and the result is presented.

Designing software architecture is a knowledgeintensive task that typically involves textual and diagrammatic notation.Using these kinds of notation is often inconsistent, misleading, and ambiguous.Ontology representation is, therefore, a suitable approach, as it can semantically define architectural design model that can be automatically verified through reasoning.However, a large-scale software system is usually complex and applies more than one architectural styles with various behavioral patterns.Therefore, the scalability of automated verification for a complex software architecture design is a challenge.We propose an approach that helps to formally define complex architectural design model and automate different verifications such as consistency checking, architectural styles recognition, and behavioral sequence inference.Ontology Web Language (OWL) is used to semantically define basic architectural elements and architectural styles, while a set of rules defined in Semantic Web Rule Language (SWRL) helps to capture behavioral pattern according to style.We evaluated the scalability of our approach.The result shows that different levels of complexity in architectural design model has a minor impact on the verification performance. I.