FEAST/1 final report

The FEAST/1 project was conceived in 1994 following formulation of the hypothesis that the software evolution process is a feedback system and must be treated as such to achieve major process improvement. The overall goals of the project were to: provide objective evidence of the presence and impact of feedback and systems dynamics in the software process demonstrate that they can be exploited for managing and improving industrial processes produce justification for more substantial study of the feedback perspective and its implications This paper gives the specific objectives that were identified for the project and describes work carried out, difficulties encountered and results achieved

Design Criteria to Architect Continuous Experimentation for Self-Driving Vehicles

The software powering today's vehicles surpasses mechatronics as the dominating engineering challenge due to its fast evolving and innovative nature. In addition, the software and system architecture for upcoming vehicles with automated driving functionality is already processing ~750MB/s - corresponding to over 180 simultaneous 4K-video streams from popular video-on-demand services. Hence, self-driving cars will run so much software to resemble "small data centers on wheels" rather than just transportation vehicles. Continuous Integration, Deployment, and Experimentation have been successfully adopted for software-only products as enabling methodology for feedback-based software development. For example, a popular search engine conducts ~250 experiments each day to improve the software based on its users' behavior. This work investigates design criteria for the software architecture and the corresponding software development and deployment process for complex cyber-physical systems, with the goal of enabling Continuous Experimentation as a way to achieve continuous software evolution. Our research involved reviewing related literature on the topic to extract relevant design requirements. The study is concluded by describing the software development and deployment process and software architecture adopted by our self-driving vehicle laboratory, both based on the extracted criteria.Comment: Copyright 2017 IEEE. Paper submitted and accepted at the 2017 IEEE International Conference on Software Architecture. 8 pages, 2 figures. Published in IEEE Xplore Digital Library, URL: http://ieeexplore.ieee.org/abstract/document/7930218

Using Statistical Analysis of FLOSS Systems Complexity to Understand Software Inactivity

Understanding how systems evolves can reveal important pieces of information that can help open source stakeholders to identify what can be improved in the software system’s internal organization. Once software complexity is one of the most important attributes to determine software maintainability, controlling its level in the system evolution process makes the software easier to maintain, reducing the maintainability costs. Otherwise, uncontrolled complexity makes the maintenance and enhancement process lengthy, more costly and sometimes it can contribute to the system abandonment. This work investigates the evolution of complexity in discontinued FLOSS projects, through statistical analysis with data obtained from analisis of SonarQube Software. SonarQube is an open-source software quality tool that analyzes the project’s source code and give the developers a feedback about the internal status of what is being developed. After several analyses, the outcome showed interesting results. A substantial portion of inactive FLOSS projects do not seem to be able to keep up with the extra work required to control the systems complexity, presenting a different behaviour of thesuccessful active FLOSS projects. Though, some inactive FLOSS projects do have a complexity evolution that resembles with the curves belonging to active projects.Keywords: Software Complexity, FLOSS, software inactivity, open source success

Graph Based Verification of Software Evolution Requirements

Due to market demands and changes in the environment, software systems have to evolve. However, the size and complexity of the current software systems make it time consuming to incorporate changes. During our collaboration with the industry, we observed that the developers spend much time on the following evolution problems: designing runtime reconfigurable software, obeying software design constraints while coping with evolution, reusing old software solutions for new evolution problems. This thesis presents 3 processes and tool suits that aid the developers/designers when tackling these problems.\ud The first process and tool set allow early verification of runtime reconfiguration requirements. In this process the UML models are converted into a graph-based model. The execution semantics of UML are modeled by graph transformation rules. Using these graph transformation rules, the execution of the UML models is simulated. The simulation generates a state-space showing all possible reconfigurations. The runtime reconfiguration requirements are expressed by computational tree logic or with a visual state-based language, which are verified over the generated state-space. When the verification fails a feedback on the problem is provided.\ud The second process and tool set are developed for computer aided detection of static program constraint violations. We developed a modeling language called Source Code Modeling Language (SCML) in which program elements from the source code can be represented. In the proposed process for constraint violation detection, the source code is converted into SCML models. The constraint detection is realized by graph transformation rules. The rules detect the violation and extract information from the SCML model to provide feedback on the location of the problem.\ud The third process and tool set provide computer aided verification of whether a design idiom can be used to implement a change request. The developers tend to implement evolution requests using software structures that are familiar to them; called design idioms. Graph transformations are used for detecting whether the constraints of the design idiom are satisfied or not. For a given design idiom and given source files in SCML, the implementation of the idiom is simulated. If the simulation succeeds, then the models are converted to source code.\u

Improving the Gherkin specification language using aspect-oriented techniques

In the highly dynamic markets in which software customers operate, it is crucial that the software development process is able to incorporate the customers in the feedback loop, supporting the evolution of specifications and ensuring that software is according to the customers’ requirements. A specification language frequently used for this purpose is Gherkin — a very simple language with three main keywords: Given, When, Then. The semantics of these keywords are loosely defined as given some precondition, when a particular event occurs, then some postcondition is expected to hold. Other than these three keywords, the specification writer can use natural language and it is then up to the developer to translate the specification into executable tests.peer-reviewe

A Three Cohort Study of Role-Play Instruction for Agile Project Management

Agile Project Management methods and processes that emphasize action and feedback over planning continue to gain prominence for Information Systems projects. This topic is an ideal candidate to lead the evolution of project management instruction from teaching “about” to learning “how to.” This paper describes a role-play simulation to instruct students in Agile project methods. This simulation is inspired by the Scrum Software Development Process and has as its goal to teach key Agile project management competencies using first hand experiences. A study of efficacy across three cohorts of students is presented to contrast the role-play instructional method with reading and lecture

Development of 3D animated video application for computer evolution

This project is aimed to design and develop a 3D animated video application for computer evolution. The development of a 3D animated video application of computer evolution aims to help educators present the topic of computer evolution to students in a simple and more creative method. At the same time, this application can also increase students' interest and understanding of the topic of computer evolution. A literature review was conducted to further assist in designing products that are suitable for the latest generation. The ADDIE model was used in the development of this product. The ADDIE model has five phases, namely analysis, design, development, implementation, and evaluation. In the analysis phase, the developer makes an analysis of the problems that occur and an analysis of the software and hardware requirements. For the design phase, the developer creates a storyboard that is used as a reference during product development. In the development and implementation phase, the developer develops a product based on a pre-designed storyboard. Products are developed using selected hardware and software. The evaluation and testing process was performed by five experts in the field of creative multimedia from the Faculty of Technical and Vocational Education. Three experts played a role in the evaluation of the product interface design. Meanwhile, two more experts are in the role and content design evaluation of the developed products. The instrument used was an expert checklist form. The collected data were analyzed using frequency and percentage methods. Through the results of the study, all experts gave good and positive feedback on the 3D animation video application of computer evolution developed

Towards Self-Adaptive Discrete Event Simulation (SADES)

Systems that benefit from the ongoing use of simulation, often require considerable input by the modeller(s) to update and maintain the models. This paper proposes automating the evolution of the modelling process for discrete event simulation (DES) and therefore limiting the majority of the human modeller’s input to the development of the model. This mode of practice could be named Self-Adaptive Discrete Event Simulation (SADES). The research is driven from ideas emerging from simulation model reuse, automations in the modelling process, real time simulation, dynamic data driven application systems, autonomic computing and self-adaptive software systems. This paper explores some of the areas that could inform the development of SADES and proposes a modified version of the MAPE-K feedback control loop as a potential process. The expected outcome from developing SADES would be a simulation environment that is self-managing and more responsive to the analytical needs of real systems

A situational approach for the definition and tailoring of a data-driven software evolution method

Successful software evolution heavily depends on the selection of the right features to be included in the next release. Such selection is difficult, and companies often report bad experiences about user acceptance. To overcome this challenge, there is an increasing number of approaches that propose intensive use of data to drive evolution. This trend has motivated the SUPERSEDE method, which proposes the collection and analysis of user feedback and monitoring data as the baseline to elicit and prioritize requirements, which are then used to plan the next release. However, every company may be interested in tailoring this method depending on factors like project size, scope, etc. In order to provide a systematic approach, we propose the use of Situational Method Engineering to describe SUPERSEDE and guide its tailoring to a particular context.Peer ReviewedPostprint (author's final draft