Textbook in PDF format

The French School of Programming is a collection of insightful discussions of programming and software engineering topics, by some of the most prestigious names of French Computer Science. The authors include several of the originators of such widely acclaimed inventions as abstract interpretation, the Caml, OCaml and Eiffel programming languages, the Coq proof assistant, agents and modern testing techniques.
The book is divided into four parts, reflecting the diversity of interests in the French community and each of them corresponding to an area in which it has made major contributions over several decades:
• Software engineering (Part I)
• Programming language mechanism and type systems (Part II)
• Theory (Part III)
• Language design and programming methodology (Part IV)
Object-oriented programming, software components and multi-agent systems are some examples of approaches for software design and development with significant impact. Both offer abstractions for organizing software as a combination of software elements, with a common objective of facilitating its evolution (first of all, replacement and addition of elements). In this chapter, our initial objective is to conduct a comparative analysis between software components and multi-agent systems (in the following, we will use terms, respectively, components and agents). Some decisive advance is the discipline of late binding such as in Smalltalk, i.e. the procedure to be invoked will be determined according to the class of the actual object invoked, and not according to the declaration of the type of the variable that references it. This means that the binding of the procedure, and therefore the selection of the action, is delayed at runtime and not statically resolved at compile time, such as in C++ early binding discipline. (Actually, C++ introduced virtual functions to partially alleviate this limitation, but this partial solution cannot benefit from further redefinitions of methods once the library has been compiled, therefore in opposition to Bertrand Meyer’s open-closed principle.
The French School of Programming: A Personal View
Part I Software Engineering
“Testing Can Be Formal Too”: 30 Years Later
A Short Visit to Distributed Computing Where Simplicity Is Considered a First Class Property
Modeling: From CASE Tools to SLE and Machine Learning
At the Confluence of Software Engineering and Human-Computer Interaction: A Personal Account
Part II Programming Language Mechanisms and Type Systems
From Procedures, Objects, Actors, Components, Services,to Agents
Semantics and Syntax, Between Computer Science and Mathematics
Some Remarks About Dependent Type Theory
Part III Theory
A Personal Historical Perspective on Abstract Interpretation
Tracking Redexes in the Lambda Calculus
Confluence of Terminating Rewriting Computations
Part IV Language Design and Programming Methodology
Programming with Union, Intersection, and Negation Types
Right and Wrong: Ten Choices in Language Design