Concepts in Programming Languages

This book is a required text for a class; it is exactly what I needed. As usual, buying textbooks on the Kindle has been a great (and economical) solution. Now if I can get all of my professors to allow electronic devices in class, everything will be perfect.

One of the best, clearest and well-structured introductory textbooks I’ve ever read. Every bit as relevant today as it was back in 2002. Explains closures and stack/heap management really well.

INTRODUCTIONFirst the disclaimer: This reviewer is neither a computer scientist nor a mathematician, but I strongly enjoy reading those subjects anyway, and can perhaps be more open minded about such a controversial textbook as this one. That said, I am reading this textbook in late fall of 2012, and at this writing am in late chapter 4, reading about denotational semantics. So far, this book has been fairly interesting and not difficult for this reader. Please check the Amazon 'Look Inside' utility for more viewable details about this book.GENERAL CONTENTSHere are the complicated basic contents: Preface-ix / PART 1 Functions and Foundations // 1 Introduction-3 / 2 Computability-10 / 3 Lisp: Functions, Recursion, and Lists-18 / 4 Fundamentals-48 // PART 2 Procedures, Types, Memory Management, and Control // 5 The Algol Family and ML-93 / 6 Type Systems and Type Inference-129 / 7 Scope, Functions, and Storage Management-162 / 8 Control in Sequential Languages-204 // PART 3 Modularity, Abstraction, and Object-Oriented Programming // 9 Data Abstraction and Modularity-235 / 10 Concepts in Object-Orientated Languages-277 / 11 History of Objects: Simula and Smalltalk-300 / 12 Objects and Run-Time Efficiency: C++ -337 / 13 Portability and Safety: Java-384 // PART 4 Concurrency and Logic Programming // 14 Concurrent and Distributed Programming-431 / 15 The Logic Programming Paradigm and Prolog-475 // Appendix A Additional Programming Examples-509 / Glossary-521 / Index-525READING THIS BOOKAs I survey this book, it does appear in a rather strange order of subjects, but as a mathy person, its somewhat mathematical approach is welcome. For example, section 4.2 summarizing lambda calculus was one of the more clear treatments of that arcane formalism I've seen. LC can be quite difficult and awkward, as I have read quite a bit about it from other sources. Section 4.3 seemed to dive us rather far into denotational semantics with little background preparation. Not ideal. Finished chapter4 mid day Tue 13Nov12.Started reading this book on Wed 31Oct12.Chapter 1 is straightforward background, as expected.Chapter 2 is a tiny 8-page treatment of computability theory, my strongest personal specialty.Chapter 3 is an interesting and fairly detailed discussion of a near-original version of the rampantly hacked LISP mostly functional language. The only programming language this reader has is the current MIT version of Scheme, a combination of LISP with block structured programming ported from one of the Algols.Chapter 4 'Fundamentals' was mentioned in my 2nd paragraph above. A long chapter covering some compiler issues, then the good intro to lambda calculus, and the a bit over our heads treatment of denotational semantics. Finally section 4.4 discussed functional vs. imperative languages, with John Backus' 1977 Turing Award thoughts as a major theme. A fascinating section! Finishing chapter 4 on Tues 13Nov12 also completes Part 1 of this book.Large start of good chapter 5 and Part 2 of this book on Thu 15Nov12. This chapter is on Algol-related languages, including Algol 60, Algol 68, Pascal, and super popular C. Much of the chapter starts Mitchell's first go at the ML language, criticized by some reviewers. ML is somewhat multi-paradigm, so probably is a decent choice to use quite a bit. ML features intensely strong type checking, which I rather like about it. Finished chapter 5 Sat 17Nov12 afternoon.Started absolutely numbing chapter 6 on type theory on Sun 18Nov12 afternoon. Can't imagine anything much more boring than the way Prof Mitchell wrote this chapter on this important subject. Mostly restarted on Monday, after taking a look at Michael Scott's 100pg chapter 7 on types, and this chapter 6 became normally interesting for this book after all. However, section 6.3 on type inference mostly lost me, so I nearly stopped reading this book in that section late morning on Tue 20Nov12. On Sat 1Dec12 afternoon, while reading chapter 9, I came back to read section 6.4 on type polymorphism and overloading, and also 6.5 on type equality that I skipped earlier. Finished the backtracking chap 6 read on that Saturday night.Started interesting-looking chapter 7 on scope and related issues on mid day Fri 23Nov12. About as interesting as chapter 6 mostly wasn't. Much of the chapter deals with interesting stack diagrams for various kinds of algorithms. Finished this very good chapter on Tue 27Nov12 afternoon. I noticed with this chapter especially, strong parallels to the great SICP book: Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science), which I read well into hyper long chapter 2 in Mar-Apr 2012, and have restarted reading SICP in section 2.2 on Mon 28Jan13.Long chapter 8 on control in sequential languages was started mid day of Wed 28Nov12. Blasting thru this rather interesting chapter quickly. It features discussions of exceptions and continuations mainly for Mitchell's favorite, ML, but also somewhat for C++ as a second language that handles these issues differently than ML's version. Near final 'Force' and 'Delay' techniques apply most straightforwardly to my own Scheme language and other versions of Lisp. Chapter 8 and Part 2 of this book complete on Fri 30Nov12 afternoon.Big start on chapter 9 on modularity and abstraction and part 3 of book on Fri 30Nov12 evening. Continuing that fair chapter, while going back to read skipped sections 6.4 and 6.5 in the next couple of days. Resumed chap 9 daytime Sun 2Dec12. Chapter getting tedious for this reader in its 9.3 modularity section. Skipped much on C++ in section 9.4 to finish most of tedious chapter 9 Tue 4Dec12 afternoon.Started chapter 10 on general object-oriented concepts, also on Tue 4Dec12 afternoon. Chap 10 shall be my last chapter to read in this book. For me, chapter 10, similarly to chapter 9, tends to be a tedious read. It appears that this reader might have done better to quit reading at end of Part 2 of this textbook. Chapter 10 and my reading of this book complete at 18:55 on Wed 5Dec12. Touched up the black marker over the cats and put the book back on shelf that night.Chapters 2, 3, 4, 5, 7, 8 have been the more interesting ones for this reader.In early 2017, intending to reread some of this book and perhaps read further in later chapters, the hardcover of this Cambridge textbook started to seriously come off of the book! This is unheard of and is deeply disappointing!FOLLOW-UP READINGAfter going thru chapter 10 of this good book by John Mitchell, I've started the great Types and Programming Languages, which is a somewhat mathematical/logical 600 page text on computational type theory. Thru chapter 13 at least, this follow-on book by Benjamin Pierce is excellent for this reader. After reading most of both the present book by Mitchell and the Type Theory book by Pierce, that reading enabled me to restart reading SICP in early chapter 2, finishing that chapter on Thu 7Feb13, and continuing it with much better understanding than a year ago's reading in that great book.JOHN C. MITCHELL'S EARLIER TEXTBOOKIn Jun 2013, i bought the author's 1996 and 850 page Foundations for Programming Languages (Foundations of Computing). That is a difficult but quite interesting book covering a whole lot of both semantics and type theory of programming languages. Small amounts of that previous Mitchell likely landed in sections of chapters 4 and 6 of the present 2002 textbook. On Wed 11Jun14 I did start reading 'Foundations for Programming Languages' as it is my simplest book covering quite a bit of programming language semantics.

I really enjoyed reading Concepts in Programming Languages.The book covers a little bit of everything. It includes an introduction to mathematical foundations such as computability theory and lambda calculus, but I found it quite readable (at the time when I was reading it, which was early during my undergraduate studies). It also includes a tiny bit on the semantics of programming languages (that is, how to describe the meaning formally), which is another important concept from the mathematical foundations of programming languages.Then it talks about many programming languages and concepts that come from them and are interesting including LISP (which is a basis for Clojure), ML (a basis for Microsoft's F#) but also Simula and Smalltalk (two fundamental OO languages that inspired all modern OO languages, both dynamic such as Ruby and static such as Java). It also talks about C++ and Java (practical OO languages with quite different approach). There are also a few notes about different approaches to concurrency (quite important nowadays!) and logical programming (an iteresting alternative).It doesn't go into much details and covers wide range of topics, which I consider as a benefit if you want to read it to get a broad overview of the programming language theory. The book actually motivated my current interest in programming languages :-).

The content is good, but if you're thinking about reading this within the Kindle software on an Android device, be prepared to do A LOT of clicking on the images and resizing them. The images throughout the book are tiny! You then have to hold and click or double click/tap on them and then they come up in another window - where you can do some pinch and zoom to a point. I lose the context of the reading having to do this and there are a lot of images. I have a Mac and the Kindle software on that doesn't have this problem. Service told me that this was a publisher problem and not the Kindle software.Secondly, there are no page numbers. Some Kindle books have them and I find that I like definitive page number instead of some number thousand of some number thousand. I don't like it, but you may. Just thought I'd mention it.

Very helpful book. I used it for class, and I was forced to read it, but I really am glad that I read it like I was supposed to. It gives really good information on programming languages in a way that is easy to read and understand.

I read this book out of interest in programming languages theory. I did not want to read a pure theoretical book but wanted to get an understanding on how important concepts are currently implemented in various different languages. This book does this job quite effectively. It also has a puritan theoretical flavor that I liked. It used ML for explaining important concepts and I think that is a right choice. It also has pointed out many good references at the end of every chapter in case one may want to explore more about a topic. The topics covered here are very relevant to Engineers particularly to understand the possibilities the set of all languages can provide. The same author has a theory book. However, that book is mainly for researchers in programming languages.

I used this book in CS 242. It was a great class; and this is one of my favorite books ever!