Model construction, evolution, and use in testing of software systems

The ubiquity of software places emphasis on the need for techniques that allow us to ensure that software behaves as we expect it to behave. The most widely-used approach to ensuring software quality is unit testing, but this is arguably not a very efficient solution, since each test only checks that the software behaves as expected in one single scenario. There exist more advanced techniques, like property-based testing, model-checking, and formal verification, but they usually rely on properties, models, and specifications. One source of friction faced by testers that want to use these advanced techniques is that they require the use of abstraction and, as humans, we tend to find it more difficult to think of abstract specifications than to think of concrete examples. In this thesis, we study how to make it easier to create models that can be used for testing software. In particular, we research the creation of reusable models, ways of automating the generalisation of code and models, and ways of automating the generation of models from legacy unit tests and execution traces. As a result, we provide techniques for generating tests from state machine models, techniques for inferring parametrised state machines from code, and refactorings that automate the introduction of abstraction for property-based testing models and code in general. All these techniques are illustrated with concrete examples and with open-source implementations that are publicly available

Model construction, evolution, and use in testing of software systems

The ubiquity of software places emphasis on the need for techniques that allow us to ensure that software behaves as we expect it to behave. The most widely-used approach to ensuring software quality is unit testing, but this is arguably not a very efficient solution, since each test only checks that the software behaves as expected in one single scenario. There exist more advanced techniques, like property-based testing, model-checking, and formal verification, but they usually rely on properties, models, and specifications. One source of friction faced by testers that want to use these advanced techniques is that they require the use of abstraction and, as humans, we tend to find it more difficult to think of abstract specifications than to think of concrete examples. In this thesis, we study how to make it easier to create models that can be used for testing software. In particular, we research the creation of reusable models, ways of automating the generalisation of code and models, and ways of automating the generation of models from legacy unit tests and execution traces. As a result, we provide techniques for generating tests from state machine models, techniques for inferring parametrised state machines from code, and refactorings that automate the introduction of abstraction for property-based testing models and code in general. All these techniques are illustrated with concrete examples and with open-source implementations that are publicly available

SKot: A web-based Structured Code Editor for introductory programming in Kotlin

The use of Structured Code Editors such as Scratch for introduction to programing, especially at a younger age is prevalent in modern education systems. Transitioning to text-based editors sometimes proves to be challenging for beginners especially when it comes to learning the syntax of a modern language. This work goes into the research on Structured Code Editors and delves into the implementation of a Projectional Editor that presents the code to the user as it would appear in a text-based editor in a modern programing language such as Kotlin, while preserving syntactical correctness during edits. A web-based editor, named SKot for Structured Kotlin was implemented using JavaScript (JSON, React and Redux). A technique for implementing the Projectional Editor using these technologies is described in detail. Then, SKot is compared to other modern code editors and further work is proposed to improve it.O uso de Editores Estruturados de Código como o Scratch para introdução à programação, especialmente em idades mais jovens, é prevalente nos sistemas de educação modernos. A transição para editores de código baseados em texto pode ser desafiante para iniciantes, principalmente no que diz respeito à aprendizagem da sintaxe de uma linguagem moderna. Este trabalho explora a investigação atual sobre Editores Estruturados de Código e explica a implementação de um Editor Projecional que apresenta o código ao utilizador com a mesma aparência que teria num editor de texto numa linguagem de programação moderna, como Kotlin, enquanto preserva a correção sintática durante edições. Um editor no web browser, chamado SKot (Structured Kotlin), foi implementado usando JavaScript (JSON, React e Redux). Uma técnica para implementar o Editor Projecional usando estas tecnologias é descrita em detalhe. Por fim, o SKot é comparado com outros editores de código modernos e descreve-se trabalho futuro relativo a melhoramentos no mesmo

Business optimization through automated signaling design

M.Ing. (Engineering Management)Abstract: Railway signaling has become pivotal in the development of railway systems over the years. There is a global demand for upgrading signaling systems for improved efficiency. Upgrading signaling systems requires new signaling designs and modifications to adjacent signaling systems. The purpose of this research is to compare manually produced designs with design automation by covering the framework of multiple aspects of railway signaling designs in view of business optimization using computer drawings, programming software language and management of signaling designs. The research focuses on design automation from the preliminary design stage to the detailed design stage with the intention of investigating and resolving a common project challenge of time management. Various autonomous methods are used to seek improvement on the detailed design phase of re-signaling projects. An analysis on the project’s duration, resources and review cycles is conducted to demonstrate the challenges that are faced during the design of a project. Signaling designs are sophisticated and crucial in an ever-changing railway environment. As a result, there is a demand for efficiency and knowledge within railway signaling to achieve successful completion project target dates. A quantitative approach is used to identify the gaps leading to delays and best practices are applied using a comparative analysis to remediate on any snags that may potentially extend the project duration. The results illustrate that the resources required when automating detailed designs are reduced by two thirds for cable plans and book of circuits and reduced by one third for source documents. Successively, the projects benefit with reduced organizational resources, reduced design durations and reduced design review cycles. This research concludes that software integration of the signaling designs due to the efficiency and innovation of the selected computer drawing software and programming software language such as AutoCAD required less resources for computer drawings that are generated using automation tools compared to computer drawings that are generated manually. The resources required when automating the generation of signaling detailed designs are reduced for cable plans, book of circuits and source documents. This means that the business is optimized by utilizing less resources and subsequently delays are reduced during the design stage

Physical Plan Instrumentation in Databases: Mechanisms and Applications

Database management systems (DBMSs) are designed with the goal set to compile SQL queries to physical plans that, when executed, provide results to the SQL queries. Building on this functionality, an ever-increasing number of application domains (e.g., provenance management, online query optimization, physical database design, interactive data profiling, monitoring, and interactive data visualization) seek to operate on how queries are executed by the DBMS for a wide variety of purposes ranging from debugging and data explanation to optimization and monitoring. Unfortunately, DBMSs provide little, if any, support to facilitate the development of this class of important application domains. The effect is such that database application developers and database system architects either rewrite the database internals in ad-hoc ways; work around the SQL interface, if possible, with inevitable performance penalties; or even build new databases from scratch only to express and optimize their domain-specific application logic over how queries are executed. To address this problem in a principled manner in this dissertation, we introduce a prototype DBMS, namely, Smoke, that exposes instrumentation mechanisms in the form of a framework to allow external applications to manipulate physical plans. Intuitively, a physical plan is the underlying representation that DBMSs use to encode how a SQL query will be executed, and providing instrumentation mechanisms at this representation level allows applications to express and optimize their logic on how queries are executed. Having such an instrumentation-enabled DBMS in-place, we then consider how to express and optimize applications that rely their logic on how queries are executed. To best demonstrate the expressive and optimization power of instrumentation-enabled DBMSs, we express and optimize applications across several important domains including provenance management, interactive data visualization, interactive data profiling, physical database design, online query optimization, and query discovery. Expressivity-wise, we show that Smoke can express known techniques, introduce novel semantics on known techniques, and introduce new techniques across domains. Performance-wise, we show case-by-case that Smoke is on par with or up-to several orders of magnitudes faster than state-of-the-art imperative and declarative implementations of important applications across domains. As such, we believe our contributions provide evidence and form the basis towards a class of instrumentation-enabled DBMSs with the goal set to express and optimize applications across important domains with core logic over how queries are executed by DBMSs

Painter training in virtual reality: conceptualization, design, and implementation

This thesis describes the conceptualization, design, and implementation of a tool which simulates the activity of spray painting, intended to augment the training of industrial spray painters at John Deere. Spray painting is a difficult task, and current methods of training do not result in the desired level of trainee expertise and performance. Through close cooperation with stakeholders at John Deere, a virtual reality-based simulation tool has been created, which provides a realistic recreation of the spray painting experience---particularly the feedback offered by the behavior and visual appearance of paint sprayed onto a surface. This paper discusses the motivation, intent, structure, and technical details which define and direct that simulation.;A number of technologies were used in this simulation, and a number of algorithms developed, in order to provide an accurate and effective reproduction of the spray painting experience. These include the use of a physical paint spray gun, the software modeling of various system components and their interactions with each other, the creation of several different tools and features for feedback and review, and the detailed simulation of both the behavior and the visual appearance of wet paint applied to a surface, in accordance with the specific attributes of the paint. These features provide feedback similar to---and in some cases greater than---the feedback available during the actual paint spraying process, allowing a trainee to develop the skills necessary to ensure proper paint application without incurring the monetary, material, and environmental costs associated with physical painting

Identifying and introducing interfaces and callbacks using Wrangler

Duplicating code can make it easier to read in some contexts, but in general it is detrimental in several ways: it increases the compilation time, the size of the source code and, more critically, the cost of maintenance and the probability of introducing new bugs during maintenance. We can avoid code duplication by introducing abstraction for reusable functionalities. This is an established and desirable practice, but it can take considerable effort and it is error prone by itself, which acts as a deterrent. In this paper, we provide two ways of automating abstraction through refactorings. The first way (that we call iterative) allows developers to introduce an abstraction layer by choosing manually the parts to abstract (one at a time), and the refactoring does the necessary code manipulations. The second way (that we call integrated) takes a partial mapping that identifies equivalent nodes of the ASTs of two modules, and automatically abstracts the mapped common parts to a separate module with a common interface, through the introduction of the template pattern. Implementation for both of the refactorings, their dependencies, and a matching algorithm to infer partial mappings between two ASTs, are available as part of the open-source refactoring tool Wrangler for Erlang