Teaching Model-Driven Engineering in a Master's Program

Model-driven engineering (MDE) is an approach to software engineering that adopts models as the central artefact. Although the approach is promising in addressing major issues in software development, particularly in dealing with software complexity, and there are several success cases in the industry as well as growing interest in the research community, it seems that it has been hard to generalize its gains among software professionals. To address this issue, MDE must be taught at a higher-education level. This chapter presents a three-year experience in teaching MDE in a course of a master program in informatics engineering. The chapter provides details on how a project-based learning approach was adopted and evolved along three editions of the course. Results of a student survey are discussed and compared to those from another course. In addition, several other similar teaching experiences are analyzed.

Based on the Software Complexity Measurement of Complex Networks under Big Data Technology

With the development of the times, computer technology is booming, so the network is becoming more and more complex, software design is becoming more and more complex, because of the protection against a variety of internal or external risks. The internal risk is that the traffic carried by the system is too large to cause the system to crash or the system to crash caused by the code operation error, and the external threat is that hackers use computer technology to break into the system according to security vulnerabilities, so the purpose of this paper is based on big data technology, the software complexity of complex networks is measured and studied. With the consent of the school, we used the school’s internal network data, and after consulting the literature on the complex construction and analysis of complex networks and software, modeled and analyzed it using the improved particle group algorithm. The experimental results show that there is a certain correlation between complex network and software complexity. Because complex networks determine that software requires complex construction to withstand potential risks to keep the software running properly.

COMPARISON OF SOFTWARE COMPLEXITY OF SEARCH ALGORITHM USING CODE BASED COMPLEXITY METRICS

Measures of software complexity are essential part of software engineering. Complexity metrics can be used to forecast key information regarding the testability, reliability, and manageability of software systems from study of the source code. This paper presents the results of three distinct software complexity metrics that were applied to two searching algorithms (Linear and Binary search algorithm). The goal is to compare the complexity of linear and binary search algorithms implemented in (Python, Java, and C++ languages) and measure the sample algorithms using line of code, McCabe and Halstead metrics. The findings indicate that the program difficulty of Halstead metrics has minimal value for both linear and binary search when implemented in python. Analysis of Variance (ANOVA) was adopted to determine whether there is any statistically significant differences between the search algorithms when implemented in the three programming languages and it was revealed that the three (3) programming languages do not vary considerably for both linear and binary search techniques which implies that any of the (3) programming languages is suitable for coding linear and binary search algorithms.

Software Functional Complexity Using a New Set of Criteria

With the rapid technology advances, there is an emerging consensus that the size and complexity of software designs are increasing so rapidly that they proportionally affect the magnitude of administrative and development efforts. An important consideration is how to estimate software complexity. This subject continues to be a research topic in the literature. The software design process researched here uses the Unified Modeling Language (UML) diagrams and the database design for extracting pertinent information. The Entity Relationship (ER) model of Peter Chen (of MIT) is a conceptual method of describing the data in a relational structure. An Entity Relationship Diagram (ERD) and an Entity Relationship Schema (ERS) represents the ER model, containing the entities, attributes, primary and foreign keys, and the relationships between the entities. Extending this ERS modeling construct, this paper uses an additional enhanced schema, called the Object Relationship Schema (ORS), which, together with the existing ERS, creates an enhanced view of the requirements and the design of the database. In addition, functional dependency, security, computational complexity, use cases, component structure and interpretations are considered for estimating functional complexity of modern software systems which is very valuable in higher education for new workforce development.

Modeling Software Development Process Complexity

Modern software systems are growing increasingly complex, requiring increased complexity of software and software development process (SDP). Most software complexity measurement approaches focus on software features such as code size, code defects, number of control paths, etc. However, software complexity measurement should not only focus on code features but on features that cover several aspects of SDP in order to have a more complete approach to software complexity. To implement this approach, an extensive literature review for identifying factors that contribute to the complexity of SDP was performed and seventeen complexity factors were identified. As there were indications that the identified factors were not independent from each other but there were interrelations between them, statistical methods for identifying the underlined relations and refining them were applied, resulting to the final set of measures used in the proposed model. Finally, the proposed model has been tested in five software projects and the results were evaluated.