Simone Martini’s research while affiliated with University of Bologna and other places

In this chapter, we will tackle the problem of managing sequence control, an important part in defining the execution of program instructions in a generic abstract machine’s interpreter.

In this chapter, we discuss the functional programming paradigm, where computation proceeds by term rewriting and not through modification of the state. Languages of this paradigm, at least in their “pure” form, do not use the concept of memory and therefore there is no side effect. Once an environment is fixed, an expression always denotes the same value. We will discuss the pure paradigm in the first sections, explaining its fundamental aspects. Real functional programming languages, however, merge these “pure” ingredients with many other mechanisms. We will, at this point, be in a position to discuss the reasons why the functional programming paradigm is interesting with respect to ordinary imperative languages. We will touch on the SECD machine, an abstract machine for higher-order functional languages which is the prototype of many real implementations. The chapter concludes with a more theoretical section that provides a succinct introduction to the lambda-calculus, a formal system for computability that inspires all functional languages and which has been a constant model for the design of programming languages.

In this chapter, we discuss object-oriented languages. We attempt to present the linguistic aspects which concern objects and their use, starting with a presentation of objects as a way to gain data abstraction in a way that is both flexible and extensible. This will lead us to describe the concepts of objects and classes, and, then, those of encapsulation, subtypes (that is a compatibility relation based on the functionality of an object), inheritance (that is the possibility of reusing the implementation of a method previously defined in another object or for another class), and dynamic method selection. Having examined these characteristic aspects in detail, we will study some extensions to linguistic solutions that are available in commercial languages, referring, in particular, to the concepts of subtype, polymorphism and genericity.

The evolution of programming languages can be seen in large measure as a process which has led, by means of appropriate abstraction mechanisms, to the definition of formalisms that are increasingly distant from the physical machine. In this context, names play a fundamental role. A name, indeed, is nothing more than a (possibly meaningful) sequence of characters used to represent some other thing. They allow the abstraction either of aspects of data, for example using a name to denote a location in memory, or aspects of control, for example representing a set of commands with a name. The correct handling of names requires precise semantic rules as well as adequate implementation mechanisms.

Abstraction mechanisms play a crucial role in computing because they allow us to manage the complexity inherent in most computational systems by isolating the important aspects in a dedicated context. In the field of programming languages, these mechanisms are fundamental, both from a theoretical viewpoint (many important concepts can be appropriately formalised using abstractions) and in the practical sense, because programming languages today use common abstraction-creating constructs. One of the most general concepts employing abstraction is the abstract machine. In this chapter, we will see how this concept is closely related to the that of the programming language. We will also see how, without requiring us to go into the specific details of any particular implementation, it allows us to describe what an implementation of a programming language is. To do this, we will describe in general terms what is meant by the interpreter and the compiler for a language. Finally, will see how abstract machines can be structured in hierarchies that describe and implement complex software systems.

We now consider a subject that is substantially different from those seen in the previous chapters. Up to now, we have considered sequential languages, where at each moment off the execution of a program there is only one active context. However, a significant part of modern programs, from operating system functions to web services, needs to escape this limitation. Indeed, to achieve their purpose, these programs need more than one context of execution, active at the same time, which concur to realize their functionalities. This kind of programming, called concurrent, is the subject of this chapter. After a brief introduction and a few historical notes, necessary to understand the vastness of the current panorama, we will see the main problems that arise when passing from sequential to concurrent programming and the related solutions. We will only outline the main ideas since an exhaustive treatment would require a further volume. Following the guiding principle of this entire text, we will not refer to any specific language for general principles, while we will try to make some notions concrete by examining the case of Java.

In this chapter we analyse a second main paradigm which supports declarative programming: logic programming. This paradigm includes both theoretical and fully implemented languages, of which the best known is surely Prolog. Even if there are big differences of a pragmatic and, for some, a theoretical nature between these languages, they all share the idea of interpreting computation as logical deduction. In this chapter, we will therefore examine these concepts while trying to limit the theoretical part. We also adopt the approach that has characterised the rest of the text while examining this paradigm. We do not mean therefore to teach programming in Prolog, even if we present various examples of real programs, but we do intend to provide enough basis for understanding and, in a short time, mastering this and other logic programming languages.

In this chapter, we will present some of the main ways in which a language can provide mechanisms for defining abstractions over data, more sophisticated than just the definition of new types. Among these mechanisms, we will discuss the so-called abstract data types, which in different forms are provided by many different languages. We then look at modules, a largely similar concept, but which mainly applies to programming in the large. These abstraction mechanisms also constitute an introduction to some themes that we will encounter again with object-oriented programming. The key concepts that we will investigate in this chapter are the separation between interface and implementation and the concepts associated with information hiding.