LLMs as Assistants in Software Architecture Design

Context. Software systems play a pervasive role in people's lives. Since ethics in software systems is hardly ever considered as a first-class entity, its support of, or hindrance to, values of users and society is usually neglected. Addressing ethics requires both to consider the context in which a software system is used, and the fact that ethical values (e.g., social, cultural and personal) are intrinsically ambiguous and subjective. Software architecture and architecture design decision making are the right levels of abstraction to both consider such a context, and support reasoning about such subjectivities. Goal. We aim to embed ethical aspects in software architecture design decision making. We have studied the state of the art in ethics for software engineering, to identify the ethical aspects influencing software architecture design. We will use the learned ethical aspects to (i) support architecture design decision making with respect to ethics through proposing methods, models, and techniques, and (ii) conduct empirical studies to evaluate them in industrial practice. Method. We will adopt a design science approach for our research which includes three phases: (i) problem understanding, (ii) solution design, and (iii) solution validation. Results. Based on our previous literature study, we build models (and techniques) embedding the ethical aspects to be used in architecture design decision making. Also, we will apply design science research to use and validate these models in a method assisting practitioners and architects to embed ethical aspects in software architecture design.

The application of AI technology in architectural software has brought various innovations and changes to the industry. By introducing convolutional neural networks and deep neural networks, architectural design software is expected to automatically identify and generate complex architectural images, optimize the design process, and provide intelligent design assistance. Through literature research, this paper aims to discuss the specific application of CNN and DNN in parametric design and the innovation brought by them, and analyzes the application of these technologies in architectural image recognition, generation, design optimization and other aspects. This paper aims to provide a comprehensive reference for researchers in related fields and promote the innovative application of AI technology in architectural design. The application of AI technology in architectural software has brought numerous innovations and changes to the industry. By introducing convolutional neural networks and deep neural networks, architectural design software is expected to automatically identify and generate complex architectural images, optimize the design process, and provide intelligent design assistance. Through literature research, this paper aims to discuss the specific application of CNN and DNN in parametric design and the innovation brought by them; it also analyzes the application of these technologies in architectural image recognition, generation, design optimization, and other aspects. This paper aims to provide a comprehensive reference for researchers in related fields and promote the innovative application of AI technology in architectural design.

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.

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.

This paper presents an initial model for evaluating and improving the availability of a software architecture design. The model is implemented as a reasoning framework in the ArchE architecture expert system developed jointly with the Software Engineering Institute. To ensure continuous availability many automotive electronic control units (ECUs) employ an external watchdog running on a separate CPU to monitor the software running on the ECU. If the ECU has a failure that causes interruption of its functionality, the watchdog can detect this and reset the ECU to restore correct operation. The availability model can automatically evaluate the effectiveness of a watchdog design in the software architecture and can propose improvements to achieve better availability before implementation decisions are made. The model enables a quantitative analysis of system availability that can better guide software architecture and dependability design decisions and potentially reduce implementation and testing effort.

Software architecture design - The missing step

We compare five industrial software architecture design methods and we extract from their commonalities a general software architecture design approach. Using this general approach, we compare across the five methods the artifacts and activities they use or recommend, and we pinpoint similarities and differences. Once we get beyond the great variance in terminology and description, we find that the 5 approaches have a lot in common and match more or less the ideal pattern we introduced.

An important issue for the specification and design of software architectures is how to combine the analysis capabilities of multiple architectural definition languages (ADLs) and their supporting toolsets. In this paper, we describe our experience of integrating three ADLs: Wright, Rapide, and Aesop. We discovered that it is possible to achieve interoperability in ADL tools for a non-trivial subset of the systems describable by these languages, even though the languages have different views about architectural structure and semantics. To carry out the integration we used the Acme architectural interchange language and its supporting tools.KeywordsSoftware ArchitectureArchitectural StructureSpeci CationConnector TypeArchitectural Description LanguageThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Since the architecture of a software system constrains the quality attributes, the decisions taken during architectural design have a large impact on the resulting system. An architectural design method is presented that employs iterative evaluation and transformation of the software architecture in order to satisfy the quality requirements. Architecture evaluation is performed by using scenarios, simulation, mathematical modelling and experience-based reasoning. The architecture can be transformed by imposing an architectural style, imposing an architectural pattern, using a design pattern, converting a quality requirement to functionality and by distributing quality requirements. The method has evolved through its application in several industrial projects.

This paper addresses the problem of supporting usability in the early stages of a product line architecture design. The product line used as an example is intended to support a variety of different products each with a radically different user interface. The development cycles for new products varies between three years and five years and usability is valued as an important quality attribute for each product in the line.Traditionally, usability is achieved in a product by designing according to specific usability guidelines, and then performing user tests. User interface design can be performed separately from software architecture design and prototyping, but user tests cannot be performed before detailed UI design and prototyping. If the user tests discover usability problems leading to required architectural changes, the company would not know about this until two years after the architecture design was complete. This problem was addressed by identifying a collection of 19 well known usability scenarios that require architectural support. In our example, the stakeholders for the product line prioritized three of these scenarios as key product-line scenarios for improving usability. For each of these three chosen product-line scenarios we developed an architectural responsibility pattern that provided support for the scenario. The responsibilities are expressed in terms of architectural requirements with implementation details and rationales. The responsibilities were embodied in a web based tool for the architects.The two architects for the product line developed a preliminary design and then reviewed their design against the responsibilities supporting the scenarios. The process of review took a day and the architects conservatively estimated that it saved them five weeks of effort later in the project.

Crosscutting behaviors and features of architectural units have always been a tricky issue in software architecture design. If not well treated, they may lead to a number of architectural breakdowns, such as increased maintenance overhead, reduced reuse capability, and architectural erosion over the lifetime of a system. Unfortunately, traditional software modeling approaches lack abstraction to support the modular representation of crosscutting concerns. This paper employs a special kind of architectural component called Aspectual Component to encapsulate crosscutting behaviors and features to improve modularization, and extends the semantic of conventional connectors to represent the crosscutting effect of aspectual components. Moreover,we present a general-purpose aspect-oriented architecture description language AC-ADL for formal specification of the software architecture of systems. The whole designing process of the approach is illustrated systematically through a case study of HealthWatcher system.

<p>The purpose of this study was to find out the challenges facing Machine Learning (ML) software development and create a design architecture and a workflow for successful deployment. Despite the promise in ML technology, more than 80% of ML software projects never make it to production. As a result, majority of companies around the world with investments in ML software are making significant losses. Current studies show that data scientists and software engineers are concerned by the challenges involved in these systems such as: limited qualified and experienced ML software experts, lack of collaboration between experts from the two domains, lack of published literature in ML software development using established platforms such as Django Rest Framework, as well as existence of cloud software tools that are difficult use. Several attempts have been made to address these issues such as: Coming up with new software models and architectures, frameworks and design patterns. However, with the lack of a clear breakthrough in overcoming the challenges, this study proposes to investigate further into the conundrum with the view of proposing an ML software design architecture and a development workflow. In the end, the study gives a conclusion on how the remedies provided helps to meet the objectives of study.</p>

An approach for semi-automated design of software architecture is proposed. The approach makes use of a search-based architecture synthesis technique exploiting genetic algorithms. An interactive process of software architecture design is proposed, where the automatic search-based generation of architectural fragments interleaves with the decisions of a human architect. To support such a process, tool mechanisms are proposed and implemented. The approach is studied using a sample system, whose architecture is designed following the interactive process model.

With the gradual development of enterprise information systems, the enterprises' knowledge is in the environment of heterogeneous sources. This paper analyzes the barriers to knowledge integration under such condition. It is pointed that software systems, as support of the knowledge integration, is the key enabler of knowledge integration, and that the software usability is the major issue of the system design. In addition, the relationship between the software usability (focused on knowledge aggregation, knowledge reuse and personalization) and the software architecture is discussed. Furthermore, recommendations for the software architecture design are provided to support effective knowledge integration.

Software architecture involves a series of decisions based on many factors in a wide range of software development. Architects face recurring issues in different software architecture design, and to reduce huge cost and risks, software architecture decisions can rely on a set of idiomatic patterns commonly named architectural styles or patterns. Architectural pattern determines the vocabulary of components and connectors that are used in instances of the pattern together with a set of constraints to combine the two. Little contemporary data exists to document actual practices used by software professionals when selecting and incorporating architectural patterns for their projects in industry. Therefore, a comprehensive survey of software professionals was conducted to attempt to discover these practices. This exploratory survey and its quantitative results offer opportunities for further interpretation and comparison. Data from this survey are presented in this paper and include characteristics of projects, practices, organizations, and practitioners related to the usage of architectural patterns. Some of the notable findings include that architectural patterns are widely used in software projects with the Model–View–Controller being the most common. Despite reported difficulties in incorporating architectural patterns, the majority of the software professionals revealed that patterns were the most essential for completing the projects. The most difficult pattern to implement and the most expensive to adopt was the peer-to-peer, while the easiest was the client–server.