Automating the software development process has long been a central topic in software engineering. The advent of modern AI methods and tools, especially the recent rapid advancement of generative AI has brought renewed research interest in automation capability. A main limitation of the current AI-based approaches is that they are only able to generate code fragments and not the complete software module. Our recent works have proposed a novel software generation solution for a popular type of web frontend application, named single page application (SPA). Our works use annotation-based domain-specific languages (aDSLs) to express the SPA design specification and code generators to generate complete SPA software modules automatically. However, our works currently lack the ability to express the SPA specifications in higher-level languages, necessary to leverage the AI methods and tools. In this paper, we aim to make a first novel step in bridging this gap by using a knowledge graph to express the SPA specification, bringing it closer to the domain expert languages. We construct and implement the knowledge graph model in a Java software framework, named JDA. After that, we develop an algorithm named SPKGen to generate aDSL-based SPA specification from the knowledge graph model. Subsequently, we evaluate the effectiveness of the knowledge graph model against real-world SPA case studies. We assess the knowledge graph model’s ability to accurately represent the SPA configurations. Further, we evaluate the effectiveness of our method in generating the SPA components and configurations from the knowledge graph. The results of these evaluations demonstrate the viability of using knowledge graph for capturing and realizing SPA.

The integration of Artificial Intelligence (AI) into Advanced Driver Assistance Systems (ADAS) is transforming vehicle safety and autonomy, improving real-time decision making for safe and efficient driving. Several previous works have surveyed the use of AI in ADAS and the service-based view of the system. However, no works have surveyed the combined subject of AI-powered, service-based ADAS (AiSDAS). We aim to bridge this gap by systematically surveying AiSDAS. Within the scope of this work, we present a preliminary systematic literature review of the subject. Through the lens of microservice architecture, we explore how AI-driven services enable scalable and flexible ADAS implementations by leveraging advanced AI techniques, such as machine learning and deep learning. Our survey discovers both functional and non-functional requirements of AiSDAS, the frequently cited technical sub-features of each type of requirement, and several research directions that would benefit researchers interested in the subject.

Context: Domain-driven design is commonly used with microservices architecture to develop complex microservices-based software systems. Layered, tree-based microservices architectures have recently been discussed as a solution to tame the complexity of these systems. However, there exists a knowledge gap in terms of the exact nature of this architecture style and how it is constructed. Objective: In this paper, we propose a domain-driven multitree microservices architecture (TMSA) to bridge this gap. Method: We precisely define the TMSA metamodel in UML/OCL. A service is composed of a nested service tree, whose internal nodes are domain-driven modules. Service structure reuse is enabled by unidirectional edges that connect nodes in distinct service trees. The multitree structure provides a scaffolding on which to precisely define service resiliency and TMSA model evolution. We use OCL and the UML communication diagram to model the resiliency patterns and the architectural model evolution. Results: Our UML/OCL-based metamodel of TMSA provides a foundation on which to define three essential service resiliency patterns and two operators for architectural model evolution. To ease software construction, we further define an annotation-based DSL, named TASL, to specify the TMSA model and a semi-automatic procedure that takes a TASL specification as input and constructs software as the output. We demonstrate TMSA with an implementation in a Java software framework and a real-world software example. We also evaluate the performance, resiliency and modifiability of TMSA. The results show that TMSA possesses the expected levels of quality for these attributes. Conclusion: Our work provides not only a framework to identify and formally define multitree-based MSAs but a state-of-the-art realisation of this framework in high-level object-oriented programming languages.

Single Page Application (SPA) is a most popular approach for developing responsive frontend web applications. We proposed in recent works a generative module-based method for SPA. This method is based on domain driven design and consists in a generic and foundational metamodel for SPA. It is applicable to four popular frontend frameworks (Angular, React, React Native and Vuejs). However, creating real-world, complex SPAs requires design patterns at higher levels of abstraction. In this paper, we extend our previous works with a method to modularly generate SPAs from cross-framework frontend design paterns. We define an enhanced metamodel in UML/OCL and use an annotation-based DSL as an intermediate representational language to realise this model. We use this language to construct multi-platform code generators for the frontend frameworks in high-level object oriented programming platforms. We implement our method in a Java software framework and demonstrate its effectiveness with a set of commonly-used cross-framework frontend patterns.

JSON has not only become a de factor language for data exchange between distributed systems but commonly been used as the intermediate configuration format in those systems. On the other hand, annotations have extensively been used as the intermediate metadata sublanguage of object-oriented programming languages in various generative software development (GSD) scenarios. However, existing works have not formally addressed the mapping between JSON and annotations and how such mapping is used in GSD. In this paper, we bridge this gap by matching JSON and annotations and formalising the resulted mapping in terms of a set of primitive transformation operators between the two languages. We use UML/OCL to construct syntax models of the two languages and match these models to identify mapping rules. We also semi-formalise design specifications of the operators. We demonstrate the effectiveness of JSONA using two GSD case studies: (1) SPA generation and (2) design pattern application.

Developing very large scale distributed software systems is challenging from both functional and data management perspectives. Methods based on Microservices Architecture (MSA) have gained popularity for addressing the functional challenges. On the other hand, cloud-aware, very large scale NoSQL data management systems have also proved their effectiveness in tackling data management’s scalability challenges. Recent work have studied the combined approach for specific methods and systems. However, there has been no work that propose a complete method or study the underlying design principles. In this paper, we present the result of our initial research on this subject. We choose Cassandra as a case study as it is a popular system that supports cloud-aware, very-large-scale NoSQL data management. We propose the CaMSAndra software development method that combines the MSA and Cassandra methods. We define a UML metamodel for CaMSAndra and uses it as the basis for discussing the design principles. We analyse the relationship between bounded context and application workflow and, based on this, define a hierarchical service design that builds a service hierarchy by transforming an application workflow. We also discuss a data-driven cluster design in connection to the microservices. We demonstrate CaMSAndra with a well-known software domain called Hotel Reservation. We contend that our method is promising for developing very large microservice-based, NoSQL-based systems in general.

Domain-driven design (DDD) aims to iteratively develop software around a realistic domain model. Recent research in DDD has been focusing on using annotation-based domain-specific languages (aDSLs) to build the domain model. However, within current approaches behavioral aspects, that are often represented using UML Activity and State machine diagrams, are not explicitly captured in the domain model. The focus of this paper is to introduce a new approach for incorporating behavioral aspects into domain models within the Domain-Driven Design (DDD) approach. The proposed approach involves using a new activity graph language ( AGL ) as an aDSL for representing behavioral aspects within a unified domain model. This integration of AGL and the previously developed aDSL ( DCSL to represent domain models) aims to achieve three important features of DDD: feasibility, productivity, and understandability. Our approach involves building a unified class model in DCSL within a domain-driven architecture, which uses the annotation attachment feature of the host programming language (such as Java) to attach AGL activity graphs directly to the activity class of the unified class model, resulting in a unified domain model. In this work, we define the abstract and concrete syntax of AGL . To demonstrate our method, we use a Java framework called jDomainApp and evaluate AGL through a case study to show that it is expressive and practical for real-world software. This paper presents two contributions. Firstly, it proposes a mechanism to include behavioral aspects in a unified domain model by introducing a new aDSL called AGL to represent domain behaviors. Secondly, it presents a unified modeling method for domain-driven software development. Our method significantly extends the state-of-the-art in DDD in two important fronts: constructing a unified domain model for both structural and behavioral aspects of domain models and bridging the gaps between model and code.

Domain-driven design is commonly used with microservices architecture to develop scalable microservices-based software systems. Layered, tree-based architectures have recently been discussed as a solution to tame the system complexity. However, there exists a knowledge gap in terms of the exact nature of this architecture style and how it is constructed. In this paper, we draw from two well-known system design principles to propose a nested, multitree microservices architecture (TMSA). We define the TMSA metamodel in UML/OCL. A service consists in a nested service tree. Service reuse is enabled by edges that connect nodes in distinct service trees. The multitree structure provides a scaffolding on which to precisely define service resiliency and TMSA model evolution. We use OCL and UML communication diagram to model three essential resiliency patterns in TMSA. Further, we define TMSA model evolution in terms of two microservice reconfiguration operations. These operations enable a model to adapt to the changing requirements. To ease software construction, we define an annotation-based DSL, named TASL, to specify the TMSA model of a software and a semi-automatic procedure for constructing the software. We demonstrate our method with an implementation in a Java software framework and a software case study.

Domain-driven design (DDD) has widely been used to develop RESTful software in a range of programming language platforms. The use of code generators in these technologies helps significantly increase productivity and achieve large scale software reuse. However, there have been no work that address incremental construction of RESTful full stack software (RFS) at both the module and software levels. In this paper, we propose a generative module-based method for RFS to bridge this gap. We characterise an essential RFS and realise this in a module-based DDD software architecture, named MOSA $$ ^{R} $$ . Our method takes as input a software configuration and the required software assets and automatically generates a module-based RFS software. We present algorithms for the frontend and backend generation functions. The backend software consist of web service modules. The frontend software consists of modules that are designed with single-page views. Each view can be nested to reflect the containment tree of the module. We demonstrate by implementing the generators for two popular platforms (React and Spring Boot). The evaluation shows that the generators are able to support large software.

Single Page Application (SPA) is a most common approach for developing modern web applications. A chief benefit of SPA is reduced round-trip to the server and more responsive user experience. Although several well-known SPA frameworks have been developed and applied in practice, SPA developers are still facing two main challenges: (i) design an SPA that would work accross the frameworks and (ii) realise this design in an intermediate high-level language that would effectively be transformed into a target framework of choice. In this paper, we propose a multi-platform, hierarchical domain-driven design method to tackle these challenges. Our method uses the domain model as the core to build the SPA. We formulate a set of essential technical SPA requirement patterns and, based on these, define a precise SPA metamodel in UML/OCL. We use an annotation-based DSL as an intermediate representational language for the SPA metamodel and from this propose an SPA generator that generates SPAs for four popular SPA frameworks (Angular, React (Native) and Vuejs). The evaluation results show that our method is very promising for building multi-platform SPAs.

Automatic grading of object‐oriented programming (OOP) assignments is an important problem from practical, theoretical, and educational viewpoints. Apart from computing a specific grade, an effective grading method needs to provide systematic feedback comments to both the design and code elements. Existing works have proposed grading methods that make various assumptions about the design. However, none of these methods have considered using a design language for the program model. A challenge here is to use a language that eases learning and application in program design. In this paper, we propose a novel grading method, named OOPGRADER, which automatically grades OOP assignments constructed based on an essentially detailed program model. This model is defined in an embedded design language, which directly uses the annotation feature of OOP language to express the essential design rules. We explain how programming assignments can be designed with this language and propose a program checker and a grader for both student and teacher to use in working on the assignments and in grading them. We implement these components in a tool and develop an Eclipse plugin for this tool. We evaluate our method using a combination of qualitative and quantitative techniques. The main result is that our method helps students effectively learn to program through detailed feedback comments based on a program model. The tool is adaptable, has a good performance, and helps enhance the productivity of both students and teachers through IDE integration.

Architectural decay imposes real costs in terms of developer effort, system correctness, and performance. Over time, those problems are likely to be revealed as explicit implementation issues (defects, feature changes, etc.). Recent empirical studies have demonstrated that there is a significant correlation between architectural "smells" -- manifestations of architectural decay -- and implementation issues. In this paper, we take a step further in exploring this phenomenon. We analyze the available development data from 10 open-source software systems and show that information regarding current architectural decay in these systems can be used to build models that accurately predict future issue-proneness and change-proneness of the systems' implementations. As a less intuitive result, we also show that, in cases where historical data for a system is unavailable, such data from other, unrelated systems can provide reasonably accurate issue- and change-proneness prediction capabilities.

Software engineering (SE) courses are facing increased challenges from emerging online learning platforms. Teaching project-based SE (PBSE), however, remains complex because SE development itself is complex, broad and requires constant practice to master. In this work, we propose to apply SE to teach online PBSE courses. We present the instructional design model of PBSE course, which revolves around an iterative software development model that uses a software framework to help students practise software development. We discuss our experience in applying the course model to a recent PBSE course. The course was delivered in a hybrid mode in order to adapt to the frequent Covid-19 lockdowns in Hanoi, Vietnam. The course uses an integrated LMS consisting of the Google and GitHub classroom platforms. The former helps manage the student class and teaching materials, the latter helps students learn to collaboratively work on and manage a software project online. © 2021 CEUR-WS. All rights reserved.

This paper identifies a model of software evolution that is prevalent in large, long-lived academic research tool suites (3L-ARTS). This model results in an "archipelago" of related but haphazardly organized architectural "islands", and inherently induces technical debt. We illustrate the archipelago model with examples from two 3L-ARTS archipelagos identified in literature.

This paper presents the design, implementation, and usage details of ARCADE, an extensible workbench for supporting the recovery of software systems' architectures, and for evaluating architectural change and decay. ARCADE has been developed and maintained over the past decade, and has been deployed in a number of research labs as well as within three large companies. ARCADE's implementation is available at https://bitbucket.org/joshuaga/arcade and the video depicting its use at https://tinyurl.com/arcade-tool-demo.

Object-oriented domain-driven design (DDD) has been advocated to be the most common form of DDD, thanks to the popularity of object-oriented development methodologies and languages. Although the DDD method prescribes a set of design patterns for the domain model, it provides no languages or tools that realise these patterns. There have been several software frameworks developed to address this gap. However, these frameworks have not tackled two important software construction issues: generative, module-based software construction and development environment integration. In this paper, we propose a framework, named JDomAINAPP, and an Eclipse IDE plugin to address these issues. In particular, we extend our recent works on DDD to propose a software configuration language that expresses the software configuration, needed to automatically generate software from a set of modules. The modules are automatically generated using a module configuration language that we defined in a previous work. We demonstrate the framework and plug-in using a real-world software example. Further, we evaluate the performance of software construction to show that it is scalable to handle large software.

Object-oriented domain-driven design (DDD) aims to iteratively develop software around a realistic model of the application domain, which both thoroughly captures the domain requirements and is technically feasible for implementation. The main focus of recent work in DDD has been on using a form of annotation-based domain specific language (aDSL), internal to an object-oriented programming language, to build the domain model. However, these work do not consider software modules as first-class objects and thus lack a method for their development. In this paper, we tackle software module development with the DDD method by adopting a generative approach that uses aDSL. To achieve this, we first extend a previous work on module-based software architecture with three enhancements that make it amenable to generative development. We then treat module configurations as first-class objects and define an aDSL, named MCCL , to express module configuration classes. To improve productivity, we define function MCCGen to automatically generate each configuration class from the module’s domain class. We define our method as a refinement of an aDSL-based software development method from a previous work. We apply meta-modelling with UML/OCL to define MCCL and implement MCCL in a Java software framework. We evaluate the applicability of our method using a case study and formally define an evaluation framework for module generativity. We also analyse the correctness and performance of function MCCGen . MCCL is an aDSL for module configurations. Our evaluation shows MCCL is applicable to complex problem domains. Further, the MCCs and software modules can be generated with a high and quantifiable degree of automation. Our method bridges an important gap in DDD with a software module development method that uses a novel aDSL with a module-based software architecture and a generative technique for module configuration.