Multi-platform user interface construction

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.

Designing complex system composed of many different subcomponents is a major challenge in software engineering. This paper deals with the system theoretical aspects of this problem and as a typical example discusses a CAD system for printed circuit boards and application specific integrated circuits. The appropriate infrastructure (framework) for such a system, consisting of a user interface, a data management facility as well as a design management component is presented in detail.KeywordsPrint Circuit BoardSchematic EntryASIC DesignVertical DecompositionDesigning Complex SystemThese 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.

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.

In the last years, the types of devices used to access information systems have notably increased using different operating systems, screen sizes, interaction mechanisms, and software features. This device fragmentation is an important issue to tackle when developing native mobile service front-end applications. To address this issue, we propose the generation of native user interfaces (UIs) by means of model transformations, following the modelbased user interface (MBUI) paradigm. The resulting MBUI framework, called LIZARD, generates applications for multiple target platforms. LIZARD allows the definition of applications at a high level of abstraction, and applies model transformations to generate the target native UI considering the specific features of target platforms. The generated applications follow the UI design guidelines and the architectural and design patterns specified by the corresponding operating system manufacturer. The objective is not to generate generic applications following the lowest-common-denominator approach, but to follow the particular guidelines specified for each target device. We present an example application modeled in LIZARD, generating different UIs for Windows Phone and two types of Android devices (smartphones and tablets).

An operating system (OS) is a piece of software that, after being first loaded by a boot programme, governs all other application programs in a computer.The application programs request services from the operating system using a specific application programme interface (API).A user interface, such as a graphical user interface (UI) or command-line interface (CLI), allows users to interact with the operating system directly as well (GUI).An operating system is extremely useful for computer applications and software development.Without an operating system, each application would have to develop its own user interface (UI) and all the required code to control the computer's low-level tasks, such as managing disc storage, network connections, and other tasks.This would greatly increase the size of every application and make software development challenging, especially in light of the wide range of underlying hardware options.

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.

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.