The number of languages spoken around the world is about 7000. The number of programming languages that have been invented is much greater than that. If you are going to program, you should be ready to become a polyglot. For example, you will probably use one language to generate or analyze data, another one to store or retrieve the data from a database, another one to plot the results, another one to communicate with a shell to access the underlying operating system and the hardware, and yet another to publish your results; you will also need to learn how to use an editor or an interactive environment. You will almost certainly use several general-purpose programming languages over your career. You will find that learning fundamental programming concepts makes it easier to learn other languages.

Most of us begin by learning a programming language; beyond that, we learn bottom-up: we learn several languages sequentially, and figure out what they have in common as we go along. Programming language explorations takes this approach in a systematic way.

The book explores programming concepts as implemented in 12 modern languages--JavaScript, CoffeeScript, Lua, Python, Ruby, Julia, Java, Clojure, Elm, Erlang, Go, and Swift. Along the way, several programming paradigms come into play: procedural, object-oriented, and functional programming come to mind. Language properties investigated in the book can be grouped as follows: functions, types, expressions, control flow, concurrency, modularity, and metaprogramming. Operators, immutability, multiprocessing, and other related properties are also covered.

Each language is described in terms of some of its properties; a property found in more than one language may not be looked at in all languages that exhibit it. For example, coroutines are explored in Lua but not in Julia. The guiding principle is an emphasis on the language conceptual underpinnings, and, by extension, on the art of programming. For each language, the authors carefully point out the features not covered.

To tackle this book, the reader should be comfortable with at least two programming languages, ideally based on different paradigms--for example, an object-oriented language and a functional language. If you meet this requirement, you will find this book an excellent roadmap to the landscape. The writing is concise but clear; code is eminently illustrative and abundant, and, in combination with accompanying explanations, transparent, even if occasionally cryptic (depending on experience, though, your mileage may vary). The reader will have ample opportunity to follow up on each language as desired: exercises are plentiful and well-thought-out. References to related printed and online material are abundant and carefully selected. An excellent summary of each chapter of the book, errata, updates, and additional resources are available on the book’s website [1].

The programming languages aficionado will enjoy reading this book--every word of it. I recommend it for self-study and for courses in programming languages.

I’d like to conclude with two observations:

Chapter 7 deals with Clojure--specifically, with the Clojure version that targets JVM, the Java Virtual Machine. Neither ClojureCLR, a native implementation of Clojure on the Microsoft Common Language Runtime of the .Net environment, nor ClojureScript, the version that emits JavaScript code compatible with the Google Closure compiler, are mentioned.

I was disappointed that the book mentioned declarative programming very briefly, but did not elaborate at all. I have found that declarative programming, implemented in a well-designed language and used in a congenial domain, allows application development quicker, by orders of magnitude, than with any other programming paradigm. And you must approach programming in a very different way, unlike any other. As Alan Perlis said, a language that doesn’t affect the way you think about programming is not worth knowing.

More reviews about this item: Amazon