ABSTRACT Enterprise Information System (EIS) streamlines business processes and enhances productivity by integrating various functions. However, conventional development methods are labor‐intensive, time‐consuming, and error‐prone, often necessitating a design model from requirements for implementation. Existing solutions focus on auto‐generating code from Object‐Oriented (OO) design models, but specifying the design model from a validated requirements model requires more effort due to information gaps between requirements and design. This paper introduces RM2EIS, an approach that automatically generates EIS from contract‐based requirements models, which include use case diagrams, conceptual class diagrams, and use case definitions specified by system sequence diagrams and contracts. System operation contracts are formally specified using pre‐ and post‐conditions written in OCL. We conducted nine case studies to evaluate RM2EIS. The results indicate that the time of the generation including modeling and validation by RM2EIS is at least twice as fast as the design and implementation of developers. Moreover, the generated EIS outperforms the developer‐implemented systems in functionality and is close to the non‐functional aspects like performance.

AUTOSAR enhances the management of complex automotive electrical and electronic architectures by improving the reusability and interchangeability of software modules between OEMs and suppliers. However, existing AUTOSAR modeling tools need help with non-intuitive representation and complicated architectural relationship modeling processes. In this paper, we propose a visual architecture modeling language to represent based on model-driven development of the system architecture design of vehicles. Our approach addresses these issues by implementing multi-dimensional visualization capabilities, incorporating two-dimensional graphical representations and detailed one-dimensional tabular displays. Furthermore, we introduce a practical'AUTOSAR meeting in the middle modeling method, which allows for separate modeling at different levels. This approach effectively harnesses the expertise of detailed bottom-level designers and high-level architects, improving efficiency in automotive system design. A detailed case study and evaluation substantiate the effectiveness of our modeling language in describing the system architecture.

With the trend of intelligence, automobile archi-tecture has become more complex. It is necessary to predict and discover reliability-related issues to reduce the cost of correction in the later period. In AUTOSAR-based automotive architecture design, software and hardware interaction, mid-dleware platform behavior, physical environment, and system usage profile affect the system's reliability. It is necessary to comprehensively consider these factors to predict the system's reliability reasonably. However, existing methods often overlook the influence of some factors, especially oversimplifying the control flow of the middleware platform in the system. Resulting in difficulty in effectively modeling the behavior of the AUTOSAR middleware platform in error propagation and its impact on system failure behavior. To analyze the impact of middleware platforms on failure behavior, this paper analyzes the impact of the AutoSAR middleware platform on application software faults based on error propagation methods. Then, expand the AUTOSAR meta-model to model reliability parameters and automatically convert the architecture model into a formal model for reliability prediction. Finally, the effectiveness of considering unreliable platform behavior modeling was verified through a car headlight design case study.

Enterprise information systems(EIS) focus on dealing with the complex business logic of collecting, filtering, processing, and distributing data for improving productivity and service in our daily life. The successful development of enterprise information system is the labor-intensive activities in software engineering, it requires the sophisticated human efforts for requirements validation, system design, implementation and verification. Our previous work RM2PT can help to achieve a validated requirements model through automatically generating prototypes from requirements models to support incremental and rapid requirements validation. In this paper, we present a tool named RM2EIS to further alleviate the problem of system development by supporting automatically generate the back-end source code of enterprise information system from the validated requirements model, which are achieved by several round requirements validation in RM2PT. We demonstrate that RM2EIS can achieve higher quality code (+8.27%) with less time cost (-61.92%) than the manual development through 9 case studies. Overall, the results were satisfactory. The proposed approach can be further extended and applied for the EIS development in the software industry. The tool can be downloaded at https://rm2pt.com/advs/rm2eis and a demo video casting its features is available at https://www.youtube.com/watch?v=5Nde-JYezg4.

Summary Software complexity is the very essence of computer programming. As the complexity increases, the potential risks and defects of software systems will increase. This makes the software correctness analysis and the software quality improvement more difficult. In this paper, we present a quantitative metric to describe the complexity of a hierarchical software and a Complexity‐oriented Software Architecture Refactoring (CoSSR) approach to reduce the complexity. The main idea is to identify and then reassemble subcomponents into one hierarchical component, which achieves minimum complexity in terms of the solution algorithm. Moreover, our algorithm can be improved by introducing partition constraint, heuristic search strategy, and spectral clustering. We implement the proposed method as an automated refactoring tool and demonstrate our algorithm through a case study of battery management system (BMS). The results show that our approach is more efficient and effective to reduce the complexity of hierarchical software system.

A smart contract is a program running on a blockchain platform. Smart devices send data to smart contracts or change their own status based on smart contracts. Businesses want to use smart devices and smart contracts to streamline workflow because smart contracts reduce the need in trusted intermediators and cut down enforcement costs. However, developing smart contract applications is challenging due to different memory models, different interaction models, and a dearth of supporting tools and libraries. When developers are asked to reimplement conventional applications to smart contracts, it is thus ideal to automatically transform them, avoiding manual labor, as well as ensuring reliability and security. This paper contributes a set of rules to transform conventional applications in the Model-View-Controller (MVC) pattern into smart contracts running on Hyperledger Fabric, a blockchain platform preferred by businesses. Major transformations are performed in the model, while in the controller, model calls are replaced by smart contract calls. The source application and the target smart contract are all written in Java. Our rules add read-your-writes consistency that Hyperledger Fabric does not natively support. Runtime pre- and post-condition checking in the original application is supported in the transformed smart contract. We evaluated our rules on CoCoME and other MVC applications, and all code ran correctly and passed unit tests.

Current KeY verification tool for Java programs provides limited capability for verifying Java programs.In order to solve this problem, we provide a method for simplifying complex Java programs into a format that is compatible with the KeY.A set of simplification rules based on abstract syntax tree (AST) are proposed.These rules can keep the logic and semantics of the original Java programs mostly unchanged, while meeting the requirements of KeY verification tool.The paper concludes with a bank ATM example to demonstrate the feasibility of our work.

Web service classification is one of the common approaches to discover and reuse services. Machine learning methods are widely used for web service classification. However, due to the limited high-quality services in the public dataset, the state-of-the-art deep learning methods can not achieve high accuracy. In this paper, we propose a transfer learning approach Tr-ServeNet to reuse the knowledge of the App classification problem for web service classification. We pre-train a deep learning model for the App classification problem, in which the dataset contains high-quality data from Apple Store, and then transfer the embedded and extracted features to assist web service classification. To demonstrate the effectiveness of our approach, we compare the proposed method with other existing machine learning methods on the 50-category benchmark with 10, 000 real-world web services. The experimental results indicate that the proposed transfer learning method can reach the highest Top-1 accuracy in the benchmark of service classification.

Automatic service classification plays an important role in service discovery, selection, and composition. Recently, machine learning has been widely used in service classification. Though promising results are obtained, previous methods are merely evaluated on web services datasets with small-scale data and relatively balanced data, which limit their real-world applications. In this paper, we address the long-tailed web services classification problem with more categories and imbalanced data. Due to the long-tailed distribution of datasets, the existing machine learning and deep learning methods cannot work well. To deal with the long-tailed problem, we propose a normalized multi-head classifier learning strategy, which effectively reduces the classifier bias and benefit the generalization capacity of the extracted features. Extensive experiments are conducted on a large-scale long-tailed web services dataset, and the results show that our model outperforms the 11 compared service classification methods to a large margin.

Non-functional requirements specify those qualities that software products must have in order to meet the user’s business requirements. The elicitation of these non-functional requirements requires expertise, experience, and domain knowledge, which is challenging and time-consuming for requirements engineers and developers. It would be very beneficial if the nonfunctional requirements can be automatically extracted from the requirements documentation to reduce the human efforts, time, and avoid the mental fatigue. In this paper, we present a novel deep neural network model called NFRNet to automatically extract non-functional requirements from software requirements documentation.

Problem analysis has long been considered the key to requirements engineering, and the Problem Frames (PF) approach provides a structured method by deploying a common model for analyzing various types of problems. Problem decomposition is an important technique in structuring the software solution and also the key to reducing problem size and complexity. However, there has not been a suite of flexible and effective tools to describe details of problem domains in PF models. In this paper, we combine model-driven engineering and PF to provide a tool that can refine domain descriptions. In order to support modeling between domain stakeholders and software designers, we provide a technique and tool to allow the modeller to zoom in the details of a problem diagram, by adding UML State Machine Diagrams and SysML Block Definition Diagrams to domain descriptions.A demo video of this tool is available at https://youtu.be/BcQPlDYiOa8. More details of this tool and the appendix to this article are available at https://github.com/Wsfff-lf/ZOOM4PF/tree/main.

Automated service classification plays a crucial role in service discovery, selection, and composition. Machine learning has been widely used for service classification in recent years. However, the performance of conventional machine learning methods highly depends on the quality of manual feature engineering. In this paper, we present a novel deep neural network to automatically abstract low-level representation of both service name and service description to high-level merged features without feature engineering and the length limitation, and then predict service classification on 50 service categories. To demonstrate the effectiveness of our approach, we conduct a comprehensive experimental study by comparing 10 machine learning methods on 10,000 real-world web services. The result shows that the proposed deep neural network can achieve higher accuracy in classification and more robust than other machine learning methods.

Prototyping is an effective and efficient way of requirements validation to avoid introducing errors in the early stage of software development. However, manually developing a prototype of a software system requires additional efforts, which would increase the overall cost of software development. In this article, we present an approach with a developed tool RM2PT to automated prototype generation from formal requirements models for requirements validation. A requirements model consists of a use case diagram, a conceptual class diagram, use case definitions specified by system sequence diagrams, and the contracts of their system operations. A system operation contract is formally specified by a pair of pre and postconditions in object constraint language. We propose a method with a set of transformation rules to decompose a contract into executable parts and nonexecutable parts. An executable part can be automatically transformed into a sequence of primitive operations by applying their corresponding rules, and a nonexecutable part is not transformable with the rules. The tool RM2PT provides a mechanism for developers to develop a piece of program for each nonexecutable part manually, which can be plugged into the generated prototype source code automatically. We have conducted four case studies with over 50 use cases. The experimental result shows that the 93.65% system operations are executable, and only 6.35% are nonexecutable, which can be implemented by developers manually or invoking the third-party application programming interface (APIs). Overall, the result is satisfactory. Each 1 s generated prototype of four case studies requires approximate one day's manual implementation by a skilled programmer. The proposed approach with the developed computer-aided software engineering tool can be applied to the software industry for requirements engineering.

Automated service classification plays a crucial role in service discovery, selection, and composition. Machine learning has been used for service classification in recent years. However, the performance of conventional machine learning methods highly depends on the quality of manual feature engineering. In this paper, we present a deep neural network to automatically abstract low-level representation of service description to high-level features without feature engineering and then predict service classification on 50 service categories. To demonstrate the effectiveness of our approach, we conduct a comprehensive experimental study by comparing 10 machine learning methods on 10,000 real-world web services. The result shows that the proposed deep neural network can achieve higher accuracy than other machine learning methods.

Prototyping is an effective and efficient way of requirements validation to avoid introducing errors in the early stage of software development. Our previous work presents a tool RM2PT to automatically generate prototypes from requirements models. The stakeholders can easily check whether the requirements reflect their real needs by investigating the executions of use cases in the generated prototypes. However, the conflict and contradictory of the requirements are hard to be discovered. In this paper, we enhance RM2PT by introducing consistency checking and state observations in the generated prototypes. Requirements inconsistency can be automatically detected and further fixed through carefully analyzing the contracts of system operations and system state observations. We have conducted four case studies with over 50 use cases. The experimental result shows that 107 requirements inconsistency are founded in requirements validations. Overall, the result is satisfiable, and the enhanced RM2PT can be further applied to the software industry for requirements validation. The tool can be downloaded at http://rm2pt.mydreamy.net and a demo video casting its features is at https://youtu.be/Y7GNa57WGfA.

We present a formal OpenFlow-based network programming language (OF) including various flow rules, which can not only describe the behaviors of an individual switch, but also support to model a network of switches connected in the point-to-point topology. Besides, a topology-oriented operational semantics of the proposed language is explored to specify how the packet is processed and delivered in the OpenFlow-based networks. Based on the formal framework, we also propose an approach to detect potential security threats caused by the conflict of dynamic flow rules imposed by dynamic OpenFlow applications.