Self-Adaptation of Software Using Automatically Generated Control-Theoretical Solutions

In the Singapore context, mathematical modelling is often equated with the Model – Drawing Approach – a key pedagogical tool in the Singapore mathematics curriculum. Though related, the two concepts are not identical. The participants in a professional development workshop program on mathematical modelling were initially facilitated through a 1 day workshop to experience what mathematical modelling entailed. This chapter captures the participants’ understanding of mathematical modelling and the value they attached to it as part of the total mathematical learning experience for their students after having undertaken this professional development. Concerns the teachers had about mathematical modelling in the Singapore context are shared.

This study examines the evolution of 11 prospective teachers’ understanding of mathematical modeling through the implementation of a modeling module within a curriculum course in a secondary teacher preparation program. While the prospective teachers had not previously taken a course on mathematical modeling, they will be expected to include modeling as part of the school curriculum under current state standards. The module consisted of readings, analysis of the Common Core State Standards, carefully designed modeling activities, individual and group work, discussion, presentations, and reflections. The results show that while most prospective teachers had misconceived definitions of mathematical modeling prior to the module, they developed the correct understanding of modeling as an iterative process involving making assumptions and validating conclusions connected to everyday situations. The study reveals how the prospective teachers translated the modeling cycle into practice in the context of a carefully designed open-ended problem and the strong connections between modeling activities and promoting mathematical practices.

The discipline of Software Engineering is continuously adapting to new challenges while gaining more and more insights. The age of globalisation has brought about a new movement of internationalisation and localisation. While practitioners fully embrace the efforts, educators only marginally consider the implications for the teaching and learning of Software Engineering. While the relevance of the software deployment context has been widely recognised, the intrinsic values of the development context are less evident. Besides western cultural indicators being omnipresent in software applications, they are deeply rooted in Software Engineering concepts and methods. Standards and models have been established in the absence of possible deviations from other -- e.g. African -- contexts. Educators and authors of common and internationally used textbooks present Software Engineering concepts and methods as universally valid. Thus software engineering graduates all over the world continue to be ill-equipped for specific software development contexts. Moreover the necessity to localise Software Engineering education is illustrated by our vast amount of challenges, experiences and best-practices of teaching Software Engineering in a Sub-Saharan country. In this paper, we introduce a generic framework leading towards a Contextualised Software Engineering education (CSE2).

Design and validation of control strategies requires a knowledge of both control theory and the process to be controlled. These activities can be time consuming if a process is complex, involving many interacting equipments with non-linear characteristics. Simulators have proven to be a powerful tool in the design and validation of control structures for this type of complex process. The aim of this chapter is to describe a dynamic simulator for comminution plants implemented in a commercial simulation platform, and to illustrate its use in the design of control strategies for different stages in the comminution process.

Chapter Eight - Software Development and Application for the Analysis of Cross-Sections

The eighteenth annual International Workshop on Principles of Diagnosis was held in Nashville, Tennessee, May 29–31, 2007. Papers presented at the workshop covered a variety of theories, principles, and computational techniques for diagnosis, monitoring, testing, reconfiguration, fault-adaptive control, and repair of complex systems. This year’s workshop emphasized inter-actions and exchange of ideas and experiences between researchers and practitioners whose backgrounds included AI, control theory, systems engineering, software engineering, and related areas.

A traditional approach to realize self-adaptation in software engineering (SE) is by means of feedback loops. The goals of the system can be specified as formal properties that are verified against models of the system. On the other hand, control theory (CT) provides a well-established foundation for designing feedback loop systems and providing guarantees for essential properties, such as stability, settling time, and steady state error. Currently, it is an open question whether and how traditional SE approaches to self-adaptation consider properties from CT. Answering this question is challenging given the principle differences in representing properties in both fields. In this paper, we take a first step to answer this question. We follow a bottom up approach where we specify a control design (in Simulink) for a case inspired by Scuderia Ferrari (F1) and provide evidence for stability and safety. The design is then transferred into code (in C) that is further optimized. Next, we define properties that enable verifying whether the control properties still hold at code level. Then, we consolidate the solution by mapping the properties in both worlds using specification patterns as common language and we verify the correctness of this mapping. The mapping offers a reusable artifact to solve similar problems. Finally, we outline opportunities for future work, particularly to refine and extend the mapping and investigate how it can improve the engineering of self-adaptive systems for both SE and CT engineers.

As software applications get increasingly connected and complex, cybersecurity becomes more and more important to consider during development and evaluation. Software engineers need to be aware of various security threats and the countermeasures that can be taken to mitigate them. Currently, there is a lack of guidance for software engineers aiming to develop secure web applications. We conducted a design science research study, resulting in a set of guidelines to aid software engineers in developing secure web applications. The set of guidelines was constructed based on interview data with 10 industry practitioners. These guidelines were then evaluated using a survey with 28 respondents. Additionally, we conducted experiments in which we provided a large language model with our guidelines and vulnerability reports as input. The large language model should extend the given vulnerability reports by recommending which of our guidelines can help prevent the given vulnerability in the future. The extended reports were evaluated by two external researchers experienced in cyber security and one author. Our results indicate that developers consider using these proposed guidelines for the development and assessment of secure web applications in different stages of the software development lifecycle. Our results also show that it is possible to automatically enhance vulnerability reports to support developers meaningfully and that the guidelines recommended by the large language model are useful to prevent the respective vulnerabilities in the future.

Too often, computer science programs offer a software engineering course that emphasizes concepts, principles, and practical techniques, but fails to engage students in real-world software experiences. The authors have developed an approach to teaching undergraduate software engineering courses that integrates client-oriented project development and open source development practice. They call this approach the Client-Oriented Open Source Software (CO-FOSS) model. The advantages of this approach are that students are involved directly with a client, nonprofits gain a useful software application, and the project is available as open source for other students or organizations to extend and adapt. This chapter describes the motivation, elaborates the approach, and presents the results in substantial detail. The process is agile and the development framework is transferrable to other one-semester software engineering courses in a wide range of institutions.

A software engineering perspective on environmental modeling framework design: The Object Modeling System

Mobile software application development process must be matured enough to handle the challenges (especially market related) associated with the development of high quality mobile software development. Ever increasing number of both mobile users and mobile applications had presented software engineers with the challenge of satisfying billions of users with high quality software applications to be delivered within deadline and budgets. Always there had been a lot of pressure to develop complex software categorized by thousands of requirements, under resource constrained environment. Requirement prioritization is one of the activities undertaken by software engineer to deliver partial software product to its customers such that most important requirements are implemented in the earliest releases. During next releases some changed and pending requirements are implemented, an activity that generates ripple effects. Such ripple effects need to be tested by executing modified source code against test cases of previous releases (regression testing). Regression testing is a very effortful activity that requires a software tester to select test cases that have high fault detection capability, execute the modified code against selected test cases and performing debugging. This regression testing activity can be lowered to the maximum extend by considering dependencies between requirements during the time of requirement prioritization. Thus requirement prioritization will be carried out not only against aspects like cost, time, risks, business values etc but against dependencies also. The aim is to implement almost all dependent highest priority requirements in current release so that implementation of new requirements is unlikely to have ripple effects. Changes in requirements might not be related to variable usage and definition and might not involve a change in functionality. In such cases there is no need to select already executed test cases of previous versions. Module dependencies can lead to test case selections of previous versions if changes of requirement lead to ripple effects. This paper aims to implement highest priority requirements such that regression testing is performed to minimum thereby improving development process of mobile applications. The proposed technique had been successfully evaluated on Android based notification software application that meets the specification of Aakash tablets.

The Wright brothers' first flight took place in 1903, and for the next 60 years flight was purely a mechanical activity. This all changed in the early 1960s, when computers first began to find their way onto airplanes. The first onboard computers were hybrid electromechanical devices and made use of very specialized and limited instruction sets. There was a substantial lag between the appearance of digital technology in military aircraft and those flown in civilian applications. Although many people view aviation as an extremely high technology field, there is often a lag in technology adoption, particularly in the airborne segment of civil aviation. This lag is the result of conservatism due to safety concerns as well as a need to constrain both the weight and the cost of onboard systems. While slow to embrace the digital age, aviation‐related applications of software engineering are now at the forefront of this new science. Software applications are now found in all phased of aviation and include among the many, aircraft design, flight safety, air traffic control, maintenance, etc. Ever greater levels of automation onboard aircraft and in ATC systems require highly complex designs while demanding the utmost reliability and dependability of the software and the hosting hardware. Time and experience has shown that such reliability is the result of disciplined, well‐planned, thorough development processes. Current regulatory guidance for airborne systems containing software invokes DO‐178B/ED‐12B as the design assurance standard of choice to ensure safe software. Where software blends with hardware to produce firmware in the form of application‐specific integrated circuits and programmable logic devices, a new standard, DO‐254/ED‐80, has been introduced to extend design assurance to this area of software engineering for airborne systems. The software engineering approaches and techniques discussed here are a result of ongoing debate and consensus among the industry, regulators, and researchers. There is much engineering judgment in the techniques described, although there is no empirical basis or measurement of how best these techniques can eliminate safety‐related problems. Models have been developed to predict the latent fault density by correlating the maturity of the development process. Such models have not yet been applied and tested in the aviation industry. It should be noted that as the amount of software has steadily risen in commercial aircraft, the fatal accident rate has steadily fallen over the same time period. While a direct cause–effect relationship has yet to be established between the design assurance approaches discussed in this article and overall system safety, the trends provide significant confidence in our modern aerospace infrastructure.

Designing and developing reliable, robust, well-architected, and easy-to-extend software applications or tools in any field requires conformance to sound principles and rules of software engineering. Intelligent systems, especially AI development tools, are no exception. Although AI has always been a wellspring of ideas that software engineering has later adopted, most of its gems remain buried in laboratories, available only to a few AI practitioners. This paper believes that AI tools should be integrated with mainstream SE tools and thus become more widely known and used. To that end, this paper presents the development of Air, an integrated AI development environment based on model-driven-architecture concepts. Using the philosophy of MDA in Air, familiar and mainstream software technologies are used and expanded with new functionalities

Practical quantum computing is rapidly becoming a reality. To harness quantum computers' real potential in software applications, one needs to have an in-depth understanding of all such characteristics of quantum computing platforms (QCPs), relevant from the Software Engineering (SE) perspective. Restrictions on copying, deletion, the transmission of qubit states, a hard dependency on quantum algorithms are few, out of many, examples of QCP characteristics that have significant implications for building quantum software. Thus, developing quantum software requires a paradigm shift in thinking by software engineers. This paper presents the key findings from the SE perspective, resulting from an in-depth examination of state-of-the-art QCPs available today. The main contributions that we present include i) Proposing a general architecture of the QCPs, ii) Proposing a programming model for developing quantum software, iii) Determining architecturally significant characteristics of QCPs, and \textbf{iv)} Determining the impact of these characteristics on various Quality Attributes (QAs) and Software Development Life Cycle (SDLC) activities. We show that the nature of QCPs makes them useful mainly in specialized application areas such as scientific computing. Except for performance and scalability, most of the other QAs (e.g., maintainability, testability, and reliability) are adversely affected by different characteristics of a QCP.

Software Engineering mainly deals with processes to ensure delivery of software product through systematic control of software development process activities. It enforces an engineering discipline to achieve the basic purpose of software through a development methodology. Process model usually consists of activities which are the part of software development process, software product and the role and responsibilities of people involved in software engineering. Not all the activities are necessary for all the type of application software. Since all the activities are not required, we can study the actual requirement in various types of application software. Various types of application software such study would be very useful for faster software development thereby eliminating unnecessary activities in each phase of software development process. The results of studies will be a set of minimum activities for each type of application software that are necessary for the development of good quality software. The application software may be soft computing software, financial software, artificial intelligence software, business software and so on. Our work does not aim to focus on agile engineering which eliminates documentation but we want to scientifically study towards minimization of process activities. We shall be taking number of software development tasks and perform estimation and for full and minimized process model and see the actual results against estimations. Some tasks for simulation of process model shall also be performed.