Spark is a programming language based on Ada. The syntax and semantics of the Ada language are defined in the Ada Reference Manual (ARM, 2012). The SparkReference Manual (Spark Team, 2014a) contains the specification of the subset of Ada used in Spark and the aspects that are Spark specific. As stated in Chapter 1, a major goal of Spark 2014 was to embody the largest possible subset of Ada 2012 amenable to formal analysis. The following Ada 2012 features are not currently supported by Spark:

1. • Aliasing of names; no object may be referenced by multiple names

2. • Pointers (access types) and dynamic memory allocation

3. • Goto statements

4. • Expressions or functions with side effects

5. • Exception handlers

6. • Controlled types; types that provide fine control of object creation, assignment, and destruction

7. • Tasking/multithreading (will be included in future releases)

This chapter and Chapter 3 cover many, but not all, of the features of Ada 2012 available in Spark. We discuss those features that are most relevant to Spark and the examples used in this book.We assume that the reader has little, if any, knowledge of Ada. Barnes (2014) presents a comprehensive description of the Ada programming language. Ben-Ari (2009) does an excellent job describing the aspects of Ada relevant to software engineering. Dale, Weems, and McCormick (2000) provide an introduction to Ada for novice programmers. Ada implementations of the common data structures can be found in Dale and McCormick (2007). There are also many Ada language resources available online that you may find useful while reading this chapter, including material by English (2001), Riehle (2003), and Wikibooks (2014).

Let us start with a simple example that illustrates the basic structure of an Ada program. The following program prompts the user to enter two integers and displays their average.

The first three lines of the program are context items. Together, these three context items make up the context clause of the program. The three with clauses specify the library units our program requires. In this example, we use input and output operations from three different library units: one for the input and output of strings and characters (Ada.Text_IO), one for the input and output of integers (Ada.Integer_Text_IO), and one for the input and output of floating point real numbers (Ada.Float_Text_IO).

This text is an introduction to the study of NIP (or dependent) theories. It is meant to serve two purposes. The first is to present various aspects of NIP theories and give the reader sufficient background material to understand the current research in the area. The second is to advertise the use of honest definitions, in particular in establishing basic results, such as the so-called shrinking of indiscernibles. Thus although we claim no originality for the theorems presented here, a few proofs are new, mainly in chapters 3, 4 and 9.

We have tried to give a horizontal exposition, covering different, sometimes unrelated topics at the expense of exhaustivity. Thus no particular subject is dealt with in depth and mainly low-level results are included. The choices made reflect our own interests and are certainly very subjective. In particular, we say very little about algebraic structures and concentrate on combinatorial aspects. Overall, the style is concise, but hopefully all details of the proofs are given. A small number of facts are left to the reader as exercises, but only once or twice are they used later in the text.

The material included is based on the work of a number of model theorists. Credits are usually not given alongside each theorem, but are recorded at the end of the chapter along with pointers to additional topics.

We have included almost no preliminaries about model theory, thus we assume some familiarity with basic notions, in particular concerning compactness, indiscernible sequences and ordinary imaginaries. Those prerequisites are exposed in various books such as that of Poizat [95], Marker [81], Hodges [56] or the recent book [115] by Tent and Ziegler. The material covered in a one-semester course on model theory should suffice. No familiarity with stability theory is required.

History of the subject. In his early works on classification theory, Shelah structured the landscape of first order theories by drawing dividing lines defined by the presence or absence of different combinatorial configurations.