Infrastructure for complex systems - CAD frameworks

Abstract- A major challenge in teaching software engineering to undergraduates is that most students have limited industry experience, so the problems addressed are unknown and hence unappreciated. Issues of scope prevent a realistic software engineering experience, and students often graduate with a simplistic view of software engineering’s challenges. Problems and Programmers (PnP) is a competitive, physical card game that simulates the software engineering process from requirements specification to product delivery. Deliverables are abstracted, allowing a focus on process issues and for lessons to be learned in a relatively short time. The rules are easy to understand and the game’s physical nature allows for face-to-face interaction between players. The game’s developers have described PnP in previous publications, but this paper reports the game’s use within a larger educational scheme. Students learn and play PnP, and then are required to create a software requirements specification based on the game. Finally, students reflect on the game’s strengths and weaknesses and their experiences in an individual essay. The paper discusses this approach, students ’ experiences and overall outcomes, and offers an independent, critical look at the game, its use, and potential improvements.

Using software for large-scale simulations has become an important research method in many disciplines. With increasingly complex simulations, simulation software becomes a valuable assest. Yet, the quality of many simulation codes is worrying. In this paper, we want to collect and structure the challenges for a systematic simulation software engineering as a reference and the basis for further research. We describe our own experiences with developing simulation software and collaborating with non-computer-scientists. We complement our experienced challenges with a brief literature review. We structured the challenges for simulation software engineering into six areas: motivation and recognition; education and training; developer turnover; software length of life; verification, validation and debugging; and efficiency vs. maintainability. Overcoming these challenges needs efforts from research agencies, scientific computing researchers as well as software engineering researchers.

It is increasingly recognised that successful Software Engineering not only depends on technical or process issues, but requires attention to human factors. Researchers include such aspects which has led to both new theories and refined methods. However, it is not clear if professionals in the software industry agree that human factors are critical and what the related challenges and possibilities are. The purpose of the present study is to address this discrepancy. Using a qualitative research method, we elicited information about how and why human factors affect Software Engineering projects, which challenges are of special interest and the context in which they arise. Thematic analysis of data from interviews with nine senior software professionals in multiple Swedish software companies of differing size identified four main challenging areas. As supported by existing research, customer relations and communications were highlighted as important, but so too is the need for more holistic and multi-dimensional solutions and the importance of human factors in software organisational change. In addition, quantitative results indicate that the professionals see the organisational and group aspects as more important than the individual aspect. Our results can help to focus future research on matters that software practitioners consider important.

Software engineers are expected to possess a variety of technical, social and personal competencies to be well prepared for real world working environments. At the German University in Cairo (GUC), we were able to guide large groups of students into becoming self managing and self learning communities whose members work together as a team to build large scale software. The students were able to experience many of the challenges in software engineering and develop a variety of related skills in a short period of time. This report describes our detailed experience in reaching such results using agile development practices in a simulated enterprise environment. With an aim to enable educators realise the same success, this report serves as a guide for educators who wish to replicate the process. The resulting successes and the concerns from this unique experience are discussed along with future recommendations.

The software cost estimation (SCE) problem is one of the major challenges in software engineering. Inaccurate cost and time estimation in a software project may lead to devastating damage to software companies. To deal with this issue, software researchers have made significant efforts during recent years to improve and modify the available SCE models, one widely-used model of which is the Constructive Cost Model (COCOMO). This research aims to optimize the coefficients of a standard COCOMO model for SCE by combining genetic algorithm (GA) and environmental adaptation (EA) methods. The results indicate that the EA algorithm can solve the divergence issue of the genetic algorithm and optimize the coefficients of the COCOMO model as well. Moreover, the accuracy of the SCE in the case of combining GA and EA algorithms is 8% higher than when these algorithms are separately adopted.

On behalf of the entire conference committee, it is our great pleasure to welcome you to Pune, India for the 12th Innovations in Software Engineering Conference (ISEC, formerly known as the India Software Engineering Conference). ISEC is the annual conference of iSOFT, the India chapter of ACM SIGSOFT (http://isoft.acm.org) under the umbrella of ACM India. ISEC brings together researchers, practitioners, and educators from India and around the world to present and discuss the most recent innovations, trends, visions, experiences, and challenges in software engineering.

The maintenance of legacy software systems presents a significant and escalating challenge in software engineering, characterized by high costs, technical debt, and resistance to modernization. This paper introduces an innovative AI-augmented framework for the autonomous refactoring of these systems. Our approach is uniquely centered on the identification of architectural anti-patterns, or ”code smells,” and the subsequent application of appropriate, well-established design patterns to resolve them. The core of our contribution is a hybrid AI model that synergizes Graph Neural Networks (GNNs) for structural code analysis and Transformer-based language models for semantic understanding and code generation. To facilitate collaborative model improvement without compromising proprietary codebases, we propose a novel federated learning framework. This framework is underpinned by a trust metric system that ensures integrity and accountability by weighting contributions from participating silos based on their performance, data distribution, and historical reliability. Furthermore, we address the critical trade-off between model performance and the need for human-understandable outputs by introducing a methodology to quantify and optimize the balance between refactoring efficacy and explainability. We present a comprehensive experimental design and a discussion of hypothetical results, demonstrating our framework’s potential to significantly reduce cyclomatic complexity and improve software maintainability metrics compared to traditional and baseline automated refactoring tools. Our work charts a course toward more intelligent, secure, and transparent software maintenance paradigms

It is a major challenge in software engineering to statically analyze in advance the expectable run-time behavior of applications. The most needed information is the expected execution time of a function to determine its computational cost. In this paper, we present a sophisticated approach that solves this problem by utilizing Machine Learning (ML) techniques based on regression modeling to automatically derive precise predictions for this information. This enables to focus optimization efforts on the parts that are relevant for the resulting performance and to predict execution times of functions on different processing elements of a heterogeneous architecture. Among others, our approach eliminates the need for manual annotations of run-time information, which automates and facilitates the development of complex software, thus improving the software engineering process. For our experiments that demonstrate the accuracy of our approach, we have used a considerable number of programs from various benchmark suites which encompass different realworld application domains. This shows on the one hand the general applicability and on the other hand the high scalability of our ML techniques.

No matter how experienced the programmers are, it is very hard for them to avoid software fault in software projects. How to predict fault in order to reduce risk and enhance the reliability of software is an important challenge in software engineering. With successful application of deep learning in the field of image processing, voice and natural language, it is time to study how to apply deep learning technology in the field of software fault prediction. In this paper, we adopt deep learning technique of Variational Autoencoder(VAE) for software fault prediction. VAE has the ability to generate new samples according to the distribution of original data, which has been used to generate new images. How to use VAE to predict fault of software is studied in this paper. As we known, there is a problem of imbalanced data in software fault prediction. There always exist less data to indicate failure module and much more data to represent non-failure module. How to classify the data in this situation is an issue worthy of study. In this paper, we utilize the ability of generating new samples to produce failure data in order to balance the failure and non-failure samples. We design the structure of VAE by MLP to fit for the data dimension of software fault and the model of VAE is realized on GPU TITAN X. Five typical classifiers are adopted to verify that our idea of using VAE is effective for software fault prediction in practice.

The popular view of software engineering focuses on managing teams of people to produce large systems. This paper addresses a different angle of software engineering, that of development for re-use and portability. We consider how an essential part of most software products - the user interface - can be successfully engineered so that it can be portable across multiple platforms and on multiple devices. Our research has identified the structure of the problem domain, and we have filled in some of the answers. We investigate promising solutions from the model-driven frameworks of the 1990s, to modern XML-based specification notations (Views, XUL, XIML, XAML), multi-platform toolkits (Qt and Gtk), and our new work, Mirrors which pioneers reflective libraries. The methodology on which Views and Mirrors is based enables existing GUI libraries to be transported to new operating systems. The paper also identifies cross-cutting challenges related to education, standardization and the impact of mobile and tangible devices on the future design of UIs. This paper seeks to position user interface construction as an important challenge in software engineering, worthy of ongoing research.

All engineering disciplines rely on standard components to design and build artifacts. The key technical challenge in software engineering is to enable the adoption of such a model to the development of software. The transformation from line-by-line development to component-based development will address many of the industry's persistent productivity and quality problems. Indeed, component-based software development has been a long-standing dream of the software industry, prompting a search for both technical and nontechnical solutions. A successful approach to component-based development requires a comprehensive solution that draws on advances in programming languages, programming paradigms, algorithm analysis, and software design. This paper presents an approach based on the C++ Standard Template Library. More than a traditional library, STL embodies a concrete approach to software design based on a well-defined taxonomy and theory of software components. I present the fundamental contributions of STL to a paradigm of component programming — a component-based software development paradigm in which there is a clear separation between component development and application development. I motivate component programming, give the requirements for components and catalogs, and give an example of component programming applied to the standard Keyword in Context (KWIC) problem. I then summarize the implications of component programming for the software industry and for software engineering education.

Handling instable requirements is an evergreen challenge in software engineering. Instability can involve both reformulation and invalidation of existing requirements. Both cases require modifications to the corresponding fragments of code, whereas the latter one is rather simple, as code fragments “only” have to be removed in a non-invasive way. In both cases, however, we face a time-consuming and error-prone task. In the rest of this section we explore some of the reasons for this complexity and briefly overview the research areas involved in addressing them.

The goals of this teaching workshop are for the learners to leave with a broad view of University curriculum, successes and limitations, and the state of industry; an awareness of grand challenges in software engineering; and an awareness of current approaches to address those challenges.

Today, one of the challenges in software engineering is utilising application lifecycle management (ALM) tools effectively in software development. In particular, it is hard for software developers to engage with the work items that are appointed to themselves in these ALM tools. In this study, the authors have focused on bug tracking in ALM where one of the most important metrics is mean time to resolution that is the average time to fix a reported bug. To improve this metric, they developed a serious game application based on an auction‐based reward mechanism. The ultimate aim of this approach is to create an incentive structure for software practitioners to find and resolved bugs that are auctioned where participants are encouraged to solve and test more bugs in less time and improve quality of software development in a competitive environment. They conduct hypothesis tests by performing a Monte Carlo simulation. The preliminary results of this research support the idea that using a gamification approach for an issue tracking system enhances the productivity and decreases mean time to resolution.

This paper reports on work that is investigating the application of ontology engineering and natural language processing to software engineering. Our focus is the transition from requirements to design which remains one of the main challenges in software engineering. A key reason for why this is so challenging is that the vast majority of requirements documents are informal, written in natural language, whereas the final goal (code) is formal. System models, as an intermediate step between the requirements and code, help understand requirements. Even a seemingly precise requirements document typically contains a lot of inconsistencies and omissions, which become visible when we model the system. Our hypothesis is that these inconsistencies become apparent when we compare the project-specific model with a generic model of the application domain. To test our hypothesis, we need to transform natural language representations of requirements information into a form that facilitates comparison with a domain model. Naturally, we also need a domain model against which to compare and this presupposes a means to construct such models. In the paper, we extract a conceptual model (an ontology) and a behavioural model from different sources. An ontology is generated from a generic domain description, and a project-specific model is generated from requirements documents. For ontology generation, natural language processing techniques are used to aid the construction. By comparing the resulting models, we validate both of them. When inconsistencies are found, we generate feedback for the analyst. The generated feedback was validated on a case study and has proven useful to improve both requirements documents and models.