Recent years, a large focus on fundamental principles in the design, analysis, implementation of programming languages and programming interfaces has been conducted. A novel research of the basic structure of programming languages, including data types, control structures, naming conventions is presented. To give insight into different programming language paradigms, such as functional, imperative, object-oriented and logic paradigms, several reports are given. Procedural programming is represented as a flow chart where a linear sequence of statements is defined for the program to complete. When this sequence is followed, data is manipulated by the program to create the desired execution.
The combination of parametric polymorphism and inclusion polymorphism in programming language Java is complicated, particularly so for Generic Java. It is described how to adapt the type inference process of Java to obtain better error diagnostics for generic method invocations. This subject is discussed in detail in the first section of this book.
The following five chapters of the book present new approaches in well-known concepts in programming languages, such as functional and logic programming, distributed arrays and `stricterness’. The remaining content of this book focuses on the advances of object-oriented programming paradigm and specific logical and algebraic methods used in programming and the principles of programming languages. The specific advances discussed in this book include the use of concurrency and kernels in programming languages. The particular design of a flow visualisation framework is discussed in the final section of this book.
Locality-aware algorithms over distributed arrays can be very difficult to write. It is shown how a dependently-typed programming language can aid in the development of these algorithms and statically ensure that every well-typed program will only ever access local data. Such static guarantees can help catch programming errors early on in the development cycle and maximise the potential speedup that multicore machines offer.
Adapting a strictness analyser to have it take into account explicit strictness annotations can be difficult. Straightforward extensions of analyses based on relevance typing are likely to either be unsafe or fail to pick the fruits of increases in strictness that are introduced through annotations. A more involved adaptation of relevance typing is proposed, that can be used to derive strictness analyses that are both safe and effective in the presence of explicit strictness annotations. The resulting type system provides a firm foundation for implementations of type-based strictness analysers in compilers for lazy programming languages such as Haskell and Clean.
Generalized Algebraic Data Types are a generalization of Algebraic Data Types with additional type equality constraints. These found their use in many functional programs, including the development of embedded domain specific programming languages and generic programming. To make the integration of GADTs in languages easier, an orthogonal specification for GADTs is presented. This specification exploits the Church encoding of data types to describe GADT matches in terms of conventional lambda abstractions.
Representation theorems relate seemingly complex objects to concrete, more tractable ones. The advantages of the abstraction power of category theory is taken and a datatype-generic representation theorem is provided. More precisely, a representation theorem for a wide class of second-order functionals which are polymorphic over a class of functors is derived. Types polymorphic over a class of functors are easily representable in languages such as Haskell, but are difficult to analyse and reason about.
A probabilistic approach to the search strategy for declarative debugging is presented, which focuses on diagnosing wrong answers in pure Prolog programs but the approach can be adapted to other languages (for example, functional languages) and bug symptoms. Drawing information from source code and the execution of passed and failed test cases, different search heuristics are combined using probability theory.
Method inlining is one of the most important optimizations in method-based just-in-time (JIT) compilers. It widens the compilation scope and therefore allows optimizing multiple methods as a whole, which increases the performance. However, if method inlining is used too frequently, the compilation time increases and too much machine code is generated. This has negative effects on the performance. The effect of trace inlining on the performance and the amount of generated machine code is evaluated.
Reports upon ten years of experience in the development and application of model-driven technology are provided. The technology in question was inspired by work on formal methods: in particular, by the B toolkit. It was used in the development of a number of information systems, all of which were successfully deployed in real world situations. Section 10 reports upon three systems: one that informed the design of the technology, one that was used by an internal customer, and one that is currently in use outside the development organization.
Reversibility is incorporated into structured communication-based programming, to allow parties of a session to automatically undo, in a rollback fashion, the effect of previously executed interactions. This permits to take different computation paths along the same session, as well as to revert the whole session and start a new one.
An important issue in concurrency is interference. Rely/guarantee approaches have been shown to be useful in specifying and reasoning compositionally about concurrent programs. The use of a “possible values” notation is explored for reasoning about variables whose values can be changed multiple times by interference.
Research software often consists of individual, isolated prototype applications. Utilizing previously implemented techniques, researchers are able to combine visualization options in new ways that typical research prototypes cannot. The software application can be made available to the domain expert for evaluation and future use. These goals are in part realized by utilizing recent advancements in game design technology and by leveraging features available with recent graphics hardware. In contrast to most research prototypes, the system presented in the last section handles real-world simulation datasets by interfacing directly with the commercial package called tecplot, whereat the effectiveness and scalability of the approach is also discussed.
