Domain-specific languages can significantly speed up the development of software applications. However, it usually takes a few iterations of the language design before it achieves such power. At the same time, many domains tend to evolve quite often today, which implies that domain-specific languages have to evolve accordingly. Thus, being able to evolve a language in a painless manner is crucial. Unfortunately, current state-of-the-art research does not provide enough answers on how to efficiently evolve domain-specific languages. We present an approach to evolving a language in order to reduce the amount of code cloning it introduces. The approach specifically targets those languages whose design causes users to create many duplicated code segments. We target domain-specific languages as they tend to be more challenging to evolve due to their specifics, but the approach may be applicable to general purpose programming languages as well. The approach was tested on a real-world domain-specific language that is used in a financial domain. We proposed three improvements and current users helped us evaluate them. We found that the proposed improvements would reduce code cloning, which provides evidence that the approach can be used in a real-world environment. Furthermore, this work provides a solid basis for further research in the area of application of code cloning detection results. In particular, code cloning detection results and the ideas we presented show potential to be extended and used to facilitate domain analysis.

Flecs is a framework for facilitating rapid implementation of communication protocols. Forwarding functionality of protocols can be modeled as a combination of packet processing components called abstract switching elements or Ases. The design of Ases is constrained by the axioms of communication which enables us to formally analyze forwarding mechanisms in communication networks. Ases can be connected in a directed graph to define complex forwarding functionality. We have developed Flecs on top of the Click modular router. The compilers in the Flecs framework translate protocol specifications into its Click implementation. We claim that the use of our framework reduces the implementation time by allowing the programmer to specify Ases and the forwarding configuration in a high-level meta-language and produces reasonably efficient implementations. It allows rapid prototyping through configuration, as well as specialized implementation of performance-critical functionality through inheritance.

Flecs is a framework for facilitating rapid implementation of communication protocols. Forwarding functionality of protocols can be modeled as a combination of packet processing components called abstract switching elements or Ases. The design of Ases is constrained by the axioms of communication which enables us to formally analyze forwarding mechanisms in communication networks. Ases can be connected in a directed graph to define complex forwarding functionality. We have developed Flecs on top of the Click modular router. The compilers in the Flecs framework translate protocol specifications into its Click implementation. We claim that the use of our framework reduces the implementation time by allowing the programmer to specify Ases and the forwarding configuration in a high-level meta-language and produces reasonably efficient implementations. It allows rapid prototyping through configuration, as well as specialized implementation of performance-critical functionality through inheritance.

Domain-specific languages can significantly speed up the development of software applications. However, it usually takes a few iterations of the language design before it achieves such power. At the same time, many domains tend to evolve quite often today, which implies that domain-specific languages have to evolve accordingly. Thus, being able to evolve a language in a painless manner is crucial. Unfortunately, current state-of-the-art research does not provide enough answers on how to efficiently evolve domain-specific languages. We present an approach to evolving a language in order to reduce the amount of code cloning it introduces. The approach specifically targets those languages whose design causes users to create many duplicated code segments. We target domain-specific languages as they tend to be more challenging to evolve due to their specifics, but the approach may be applicable to general purpose programming languages as well. The approach was tested on a real-world domain-specific language that is used in a financial domain. We proposed three improvements and current users helped us evaluate them. We found that the proposed improvements would reduce code cloning, which provides evidence that the approach can be used in a real-world environment. Furthermore, this work provides a solid basis for further research in the area of application of code cloning detection results. In particular, code cloning detection results and the ideas we presented show potential to be extended and used to facilitate domain analysis.

This dissertation is dedicated to the problem of device driver reliability. Software defects in device drivers constitute the biggest source of failure in operating systems, causing significant damage through downtime and data loss. Previous research on driver reliability has concentrated on detecting and mitigating defects in existing drivers using static analysis or runtime isolation. In contrast, this dissertation presents an approach to reducing the number of defects through an improved device driver architecture and development process. In analysing factors that contribute to driver complexity and induce errors, I show that a large proportion of errors are due to two key shortcomings in the device-driver architecture enforced by current operating systems: poorly-defined communication protocols between drivers and the operating system, which confuse developers and lead to protocol violations, and a multithreaded model of computation, which leads to numerous race conditions and deadlocks. To address the first shortcoming, I propose to describe driver protocols using a formal, state-machine based, language, which avoids confusion and ambiguity and helps driver writers implement correct behaviour. The second issue is addressed by abandoning multithreading in drivers in favour of a more disciplined event-driven model of computation, which eliminates most concurrency-related faults. These improvements reduce the number of defects without radically changing the way drivers are developed. In order to further reduce the impact of human error on driver reliability, I propose to automate the driver development process by synthesising the implementation of a driver from the combination of three formal specifications: a device-class specification that describes common properties of a class of similar devices, a device specification that describes a concrete representative of the class, and an operating system interface specification that describes the communication protocol between the driver and the operating system. This approach allows those with the most appropriate skills and knowledge to develop specifications: device specifications are developed by device manufacturers, operating system specifications by the operating system designers. The device-class specification is the only one that requires understanding of both hardware and software-related issues. However writing such a specification is a one-off task that only needs to be completed once for a class of devices. This approach also facilitates the reuse of specifications: a single operating-system specification can be combined with many device specifications to synthesise drivers for multiple devices. Likewise, since device specifications are independent of any operating system, drivers for different systems can be synthesised from a single device specification. As a result, the likelihood of errors due to incorrect specifications is reduced because these specifications are shared by many drivers. I demonstrate that the proposed techniques can be incorporated into existing operating systems without sacrificing performance or functionality by presenting their implementation in Linux. This implementation allows drivers developed using these techniques to coexist with conventional Linux drivers, providing a gradual migration path to more reliable drivers.

In the experimental ITER fusion reactor, currently under construction in Cadarache, France, components close to the plasma will get activated and contaminated over time. Therefore, these components will need to be maintained remotely in a so called hot cell facility. The maintenance will be executed according to step-by-step procedures, with every procedure meticulously validated and formally described in an Operation Sequence Description (OSD). To support formal validation, OSDs are to be captured in an ITER-dedicated Structured Language (SL), a form of domain specific programming language. The Remote Handling Study Centre (RHSC), located at FOM institute DIFFER, Nieuwegein, The Netherlands, has an ITER Remote Handling Control Room representative setup which connects to a virtual ITER Hot Cell back-end environment. In this setup, Remote Handling maintenance scenarios and procedures can be tested under realistic conditions. In this thesis, a Structured Language for ITER maintenance is proposed, implemented as a prototype to capture several realistic operational sequences from existing projects, and integrated in the RHSC workflow. The Structured Language programs are converted to schedulable tasks, by inferring their resource usage and time duration from the structured task descriptions. These tasks are then scheduled using a proposed set of scheduling heuristics. The resulting schedule is subsequently submitted to many simulated executions, with random variation in the execution time of individual tasks. The variation that is applied in the execution time, is based on representative task execution times was measured for a recent and repetitive set of maintenance tasks performed at JET. It is shown that inserting a certain amount of slack in the schedule improves its robustness. ITER maintenance scheduling should account for uncertainty by including slack in the resulting planning.

Programs written in managed languages are compiled to a platform-independent intermediate representation, such as Java bytecode. The relative high level of Java bytecode has engendered a widespread practice of changing the bytecode directly, without modifying the maintained version of the source code. This practice, called bytecode engineering or enhancement, has become indispensable in transparently introducing various concerns, including persistence, distribution, and security. For example, transparent persistence architectures help avoid the entanglement of business and persistence logic in the source code by changing the bytecode directly to synchronize objects with stable storage. With functionality added directly at the bytecode level, the source code reflects only partial semantics of the program. Specifically, the programmer can neither ascertain the program's runtime behavior by browsing its source code, nor map the runtime behavior back to the original source code. This research presents an approach that improves the utility of source-level programming tools by providing enhancement specifications written in a domain-specific language. By interpreting the specifications, a source-level programming tool can gain an awareness of the bytecode enhancements and improve its precision and usability. We demonstrate the applicability of our approach by making a source code editor and a symbolic debugger enhancements-aware. / Master of Science

While Domain-Specific Languages (DSLs) offer greater expressiveness for domain-specific tasks than General-Purpose Languages (GPLs), they have smaller communities behind them and fewer resources available. This is often reflected in the quantity and quality of available tooling for DSLs as compared to GPLs. This disparity is particularly evident in the case of DSL in-editor support where developers have become accustomed to features such as syntax-highlighting, auto-completion, and context-aware renaming. Developing such tooling for DSLs is challenging due to the significant effort required to implement features from scratch. To address this problem, this thesis proposes Lever , a framework for building editor support for DSLs. To reduce implementation cost and stay lightweight, Lever utilizes existing language artifacts (the grammar and the existing tooling). It uses a rule-based system that adds the necessary semantics to map the Concrete Syntax Tree (CST) to a language agnostic Abstract Syntax Tree (AST) and Symbol Table (ST). Lever enables cross-editor compatibility through the usage of the Language Server Protocol (LSP). The practical use of Lever is demonstrated through a case study on building editor support for the P4 DSL. Furthermore, a comparison with Langium and MPS in implementing language support for the Protobuf DSL reveals that Lever offers greater ease of use and functionality for this use case. / Thesis / Master of Applied Science (MASc) / Domain-Specific Languages (DSLs) are specialized programming languages made to solve domain specific problems. They are powerful and efficient tools for developers working within those specific domains. However, creating editor support for DSLs (e.g., syntax highlighting, code completion), is challenging due to their smaller user bases and complexities involved in development. For this reason, developers using DSLs often lack the tooling they have become accustomed to with General-Purpose Languages (GPLs). This thesis addresses these challenges by proposing the Lever framework, a lightweight and adaptable solution for building language support tooling targeting DSLs. Lever leverages existing artifacts and a rule-based system to provide editor support, making DSLs more accessible and user-friendly. A case study using Lever to build editor support for an industry DSL demonstrates its practical application, while a comparison of implementing language support for the Protobuf DSL with Lever , Langium, and MPS highlights Lever ’s superior ease of use and functionality.

Massively Parallel Processors provide significantly higher peak performance figures than other forms of general purpose processors. However, this comes at a cost to the developer, who needs to deal with an increasingly complicated piece of hardware, for which applications need to be tweaked and optimised to achieve high performance. Domain-specific languages have been proposed as a potential solution to this complexity problem: generating GPU applications from high-level, declarative specifications. This thesis explores two related ideas: firstly, is it practical to synthesise DSLs from high-level languages, and secondly, how can we simplify the creation of such DSLs? This thesis proposes a novel approach whereby rather than considering single domains, we consider collections of collaborative domains in order to share common features and thus reduce the cost of development. We achieve this using a DSLs-within-a-DSL approach: a custom designed host language, into which extensions may be embedded. In order to ground our approach in a real case-study, we propose, design and develop a DSLs-within-a-DSL framework for bioinformatics. We use a restricted recursive functional language as the host language, and embed new DSLs into this language. Importantly, we describe how we can use a combination of novel and adopted automatic parallelisation techniques to synthesise a massively-parallel program for a GPU. This automatic parallelisation, achieved through the discovery of a schedule, and program synthesis techniques using the polyhedral model, interacts productively with our embedded extensions. To further simplify development, we provide a series of customisable heuristics for defining GPU parameters such as the block size (number of threads), grid size and location in the memory hierarchy of data-structures. This encapsulates GPU expertise within the compiler itself. We finally demonstrate that the total combination of these techniques results in applications with competitive performance, at much lower development cost and greater flexibility than comparable hand-coded applications.

Numerous studies indicate that amongst the various types of security threats, the problem of insider misuse of IT systems can have serious consequences for the health of computing infrastructures. Although incidents of external origin are also dangerous, the insider IT misuse problem is difficult to address for a number of reasons. A fundamental reason that makes the problem mitigation difficult relates to the level of trust legitimate users possess inside the organization. The trust factor makes it difficult to detect threats originating from the actions and credentials of individual users. An equally important difficulty in the process of mitigating insider IT threats is based on the variability of the problem. The nature of Insider IT misuse varies amongst organizations. Hence, the problem of expressing what constitutes a threat, as well as the process of detecting and predicting it are non trivial tasks that add up to the multi- factorial nature of insider IT misuse. This thesis is concerned with the process of systematizing the specification of insider threats, focusing on their system-level detection and prediction. The design of suitable user audit mechanisms and semantics form a Domain Specific Language to detect and predict insider misuse incidents. As a result, the thesis proposes in detail ways to construct standardized descriptions (signatures) of insider threat incidents, as means of aiding researchers and IT system experts mitigate the problem of insider IT misuse. The produced audit engine (LUARM – Logging User Actions in Relational Mode) and the Insider Threat Prediction and Specification Language (ITPSL) are two utilities that can be added to the IT insider misuse mitigation arsenal. LUARM is a novel audit engine designed specifically to address the needs of monitoring insider actions. These needs cannot be met by traditional open source audit utilities. ITPSL is an XML based markup that can standardize the description of incidents and threats and thus make use of the LUARM audit data. Its novelty lies on the fact that it can be used to detect as well as predict instances of threats, a task that has not been achieved to this date by a domain specific language to address threats. The research project evaluated the produced language using a cyber-misuse experiment approach derived from real world misuse incident data. The results of the experiment showed that the ITPSL and its associated audit engine LUARM provide a good foundation for insider threat specification and prediction. Some language deficiencies relate to the fact that the insider threat specification process requires a good knowledge of the software applications used in a computer system. As the language is easily expandable, future developments to improve the language towards this direction are suggested.