Abstract not found

Abstract. The goal of domain-specific languages (DSLs) is to increase the productivity of software engineers by abstracting from low-level boilerplate code. Introduction of DSLs in the software development process requires a smooth workflow for the production of DSLs themselves. This requires technology for designing and implementing DSLs, but also a methodology for using that technology. That is, a collection of guidelines, design patterns, and reusable DSL components that show developers how

COTS peripherals are heavily used in the embedded market, but their unpredictability is a threat for high-criticality real-time systems: it is hard or impossible to formally verify COTS components. Instead, we propose to monitor the runtime behavior of COTS peripherals against their assumed specifications. If violations are detected, then an appropriate recovery measure can be taken. Our monitoring solution is decentralized: a monitoring device is plugged in on a peripheral bus and monitors the peripheral behavior by examining read and write transactions on the bus. Provably correct (w.r.t. given specifications) hardware monitors are synthesized from high level specifications, and executed on FPGAs, resulting in zero runtime overhead on the system CPU. The proposed technique, called BusMOP, has been implemented as an instance of a generic runtime verification framework, called MOP, which until now has only been used for software monitoring. We experimented with our technique using a COTS data acquisition board. 1.

System-on-Chip (SoC) is a promising paradigm to implement safety-critical embedded systems, but it poses significant challenges from a design and verification point of view. In particular, in a mixed-criticality system, low criticality applications must be prevented from interfering with high criticality ones. In this paper, we introduce a new design methodology for SoC that provides strong isolation guarantees to applications with different criticalities. A set of certificates describing the assumed application behavior is extracted from a functional Architectural Analysis and Design Language (AADL) specification. Our tools then automatically generate hardware wrappers that enforce at run-time the behavior described by the certificates. In particular, we employ run-time monitoring to formally check all data communication in the system, and we enforce timing reservations for both computation and communication resources. Verification is greatly simplified because certificates are much simpler than the components used to implement low-criticality applications. The effectiveness of our methodology is proven on a case study consisting of a medical pacemaker.

This manuscript presents a survey of the theoretical foundations of regular expres- sions and text editors. A thourough introduction to the subjects of symbols, lan- guages, grammars, regular expressions, finite automata, character sets (Unicode), pattern matching, and the inner and outer workings of a text editor is given. The knowledge contained in this survey is then put to good use in presenting a method of compiling regular expressions into efficient finite automata that are well suited for pattern matching tasks in a text editor. The usefulness of pattern matching inside a text editor is also shown, by describing the command sets of modern text editors, such as sam and vim. Finally, a pattern-matching library has been written that can be used in, for example, a text editor. A library implementing an efficient data structure for rep- resenting sequences has also been written. Both these libraries have been used to create an example text editor that uses the pattern-matching library in implement- ing its command set and the data-structure library in implementing its buffering strategy. All pieces of software have been documented using a literate programming style of writing and are included in this manuscript for reference.

The term ‘recursive’ has had different meanings during the past two centuries among various communities of scholars. Its historical epistemology has already been described by Soare (1996) with respect to the mathematicians, logicians, and recursive-function theorists. The computer practitioners, on the other hand, are discussed in this paper by focusing on the definition and implementation of the ALGOL60 programming language. Recursion entered ALGOL60 in two novel ways: (i) syntactically with what we now call BNF notation, and (ii) dynamically by means of the recursive procedure. As is shown, both (i) and (ii) were introduced by linguistically-inclined programmers who were not versed in logic and who, rather unconventionally, abstracted away from the down-to-earth practicalities of their computing machines. By the end of the 1960s, some computer practitioners had become aware of the theoretical insignificance of the recursive procedure in terms of computability, though without relying on recursive-function theory. The presented results help us to better understand the technological ancestry of modernday computer science, in the hope that contemporary researchers can more easily build upon its past.

This chapter discusses the current state of the art, and emerging research challenges, for metamodelling. In the state-of-the-art review on metamodelling, we review approaches, abstractions, and tools for metamodelling, evaluate them with respect to their expressivity, investigate what role(s) metamodels may play at run-time and how semantics can be assigned to metamodels and the domain-specific modeling languages they could define. In the emerging challenges section on metamodelling we highlight research issues regarding the management of complexity, consistency, and evolution of metamodels, and how the semantics of metamodels impacts each of these.