What do you think?
Rate this book
Concepts, Techniques, and Models of Computer Programming
This innovative text presents computer programming as a unified discipline in a way that is both practical and scientifically sound. The book focuses on techniques of lasting value and explains them precisely in terms of a simple abstract machine. The book presents all major programming paradigms in a uniform framework that shows their deep relationships and how and where to use them together.
After an introduction to programming concepts, the book presents both well-known and lesser-known computation models ("programming paradigms"). Each model has its own set of techniques and each is included on the basis of its usefulness in practice. The general models include declarative programming, declarative concurrency, message-passing concurrency, explicit state, object-oriented programming, shared-state concurrency, and relational programming. Specialized models include graphical user interface programming, distributed programming, and constraint programming. Each model is based on its kernel language—a simple core language that consists of a small number of programmer- significant elements. The kernel languages are introduced progressively, adding concepts one by one, thus showing the deep relationships between different models. The kernel languages are defined precisely in terms of a simple abstract machine. Because a wide variety of languages and programming paradigms can be modeled by a small set of closely related kernel languages, this approach allows programmer and student to grasp the underlying unity of programming. The book has many program fragments and exercises, all of which can be run on the Mozart Programming System, an Open Source software package that features an interactive incremental development environment.
After an introduction to programming concepts, the book presents both well-known and lesser-known computation models ("programming paradigms"). Each model has its own set of techniques and each is included on the basis of its usefulness in practice. The general models include declarative programming, declarative concurrency, message-passing concurrency, explicit state, object-oriented programming, shared-state concurrency, and relational programming. Specialized models include graphical user interface programming, distributed programming, and constraint programming. Each model is based on its kernel language—a simple core language that consists of a small number of programmer- significant elements. The kernel languages are introduced progressively, adding concepts one by one, thus showing the deep relationships between different models. The kernel languages are defined precisely in terms of a simple abstract machine. Because a wide variety of languages and programming paradigms can be modeled by a small set of closely related kernel languages, this approach allows programmer and student to grasp the underlying unity of programming. The book has many program fragments and exercises, all of which can be run on the Mozart Programming System, an Open Source software package that features an interactive incremental development environment.
936 pages, Hardcover
First published January 1, 2004
59 people are currently reading
2028 people want to read
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 15 of 15 reviews
March 17, 2013
I'd read and completed most of the exercises from the Structure and Interpretation of Computer Programs (SICP) a couple of months ago. Then I've stumbled on reviews saying that this book is a logical next step in learning the programming language theory. I don't agree with them. It really doesn't add that much. Many topics and examples are just reiterations of those from SICP.
Chapters concerning concurrent programming are well worth reading, but because of the choice of the language (and its kernel implementation) it's hard to just jump into them. If you're coming from SICP I'd rather recommend reading books on dataflow concurrency and concurrent programming with threads and message passing.
In my opinion CTM is an alternative to, but not a continuation of SICP.
If you're still wondering whether this book is worth reading there's a nice summary of its content on authors page:
http://www.info.ucl.ac.be/~pvr/VanRoy...
Chapters concerning concurrent programming are well worth reading, but because of the choice of the language (and its kernel implementation) it's hard to just jump into them. If you're coming from SICP I'd rather recommend reading books on dataflow concurrency and concurrent programming with threads and message passing.
In my opinion CTM is an alternative to, but not a continuation of SICP.
If you're still wondering whether this book is worth reading there's a nice summary of its content on authors page:
http://www.info.ucl.ac.be/~pvr/VanRoy...
April 29, 2011
Best programming book I ever read! It gets to the heart of the technology, favoring no one language over another. Comprehensive and should be required reading. Explains what object oriented programming is really about and illuminates it's limitations. First three chapters were a god send. Always found something new each time I re-read it. It's like the gift that keeps on giving. Also, it's free online.
January 9, 2012
Took a while, but I finally finished this. Plenty of good concepts in here, starting with dataflow variables (I didn't know the concepts) and building all the way up to distributed systems. Quite incredible to see pretty much all the computation models built up from the ground up with the bare minimum of parts. Breathtaking tribute to how simple programming can be.
It's a textbook, and trying to read it as a book rather than as reference for a semester is pretty dense going. In particular I found the formal definitions not particularly enlightening nor informative for the practicality of programming.
It's a textbook, and trying to read it as a book rather than as reference for a semester is pretty dense going. In particular I found the formal definitions not particularly enlightening nor informative for the practicality of programming.
December 10, 2009
whoa, I never moved this to "read", interesting. i went back through a majority of it this Sunday night, writing an outline for PLT...the writing is exceptional, the kind where you immediately realize this will be a textbook a class above the main. excellent bibliography, rich in historical notes, lots of connections. by far the best material on declarative programming outside of Shapiro+Sterling's The Art of Prolog. i deduct one star because their mozart/oz system reminded me overmuch of squeak/smalltalk, and thus gave recurring offense. regardless, a new bar has been set regarding programming language design from a rather more applied perspective than is usually the case.
together with pierce's Types and Programming Languages (and additionally barendregt's The Lambda Calculus for those born- or reborn-hardcore), this provides a fine graduate semester class on programming language theory and formal semantics.
----
Amazon 2009-04-11.
together with pierce's Types and Programming Languages (and additionally barendregt's The Lambda Calculus for those born- or reborn-hardcore), this provides a fine graduate semester class on programming language theory and formal semantics.
----
Amazon 2009-04-11.
April 15, 2019
Mind blowing in diversity and depth of ideas. For me, it was a great introduction to dataflow programming, and the relational and constraint models.
November 9, 2007
I thought this book would be the holy grail. It is, in a lot of ways. It's an extraordinary book that paves the way for how programming aught to be taught.
It's pragmatic in the sense that it teaches effective problem solving, gradually introducing new ways to accomplish programming tasks. Unlike most intro programming books that only teach within the object-oriented paradigm, CTM teaches OOP as just one way of many. There's a heavy focus on declarative programming and concurrency, and even if you only use popular languages, you'll be able to apply the techniques learned to whatever you're working on.
Additionally, and unlike similar books like the venerable "Structure and Interpretation of Computer Programs," CTM covers the formal underlying semantic model of the Oz programming language, which helps to demystify programming language theory and allows for a more thorough understanding of how your code is translated by the compiler.
My gripes: The Oz language is not elegant in appearance. It is verbose and clunky. This appears to be intentional so as to avoid obfuscation of intent. However, after being introduced to more elegant declarative/functional languages such as Haskell and Scheme, I felt pained to work with a language like Oz. It may seem silly, but the feeling you get while using a language is very important.
Also, the Oz programming environment does not feel mature. It's made to work best in Emacs, which is fine with me, but I had a hard time finding documentation for things like the compiler, and the book doesn't help much with this. The general advice seems to be to "go to the mailing list," but this seems like a bad excuse.
In any case, this book is well worth the money, and I have gone back to it many times. It's the closest we'll get to a modern programming bible.
It's pragmatic in the sense that it teaches effective problem solving, gradually introducing new ways to accomplish programming tasks. Unlike most intro programming books that only teach within the object-oriented paradigm, CTM teaches OOP as just one way of many. There's a heavy focus on declarative programming and concurrency, and even if you only use popular languages, you'll be able to apply the techniques learned to whatever you're working on.
Additionally, and unlike similar books like the venerable "Structure and Interpretation of Computer Programs," CTM covers the formal underlying semantic model of the Oz programming language, which helps to demystify programming language theory and allows for a more thorough understanding of how your code is translated by the compiler.
My gripes: The Oz language is not elegant in appearance. It is verbose and clunky. This appears to be intentional so as to avoid obfuscation of intent. However, after being introduced to more elegant declarative/functional languages such as Haskell and Scheme, I felt pained to work with a language like Oz. It may seem silly, but the feeling you get while using a language is very important.
Also, the Oz programming environment does not feel mature. It's made to work best in Emacs, which is fine with me, but I had a hard time finding documentation for things like the compiler, and the book doesn't help much with this. The general advice seems to be to "go to the mailing list," but this seems like a bad excuse.
In any case, this book is well worth the money, and I have gone back to it many times. It's the closest we'll get to a modern programming bible.
March 14, 2012
Takeaways: (1) dataflow variables (kind of like futures you can wait on even if they've not been defined) make reasoning about concurrency much easier. (2) reasoning about distributed state is possible, but wow. (3) constraint programming is beautiful, and perhaps a bit magical. (4) more available paradigms in a given language seems like a massive, massive win.
Read
December 30, 2019An ABSLOUTE must-read for all software engineers and programmers and especially so if you work with object-oriented or functional programming language.
March 20, 2015
One of those books that you need to read several times to really understand. I've read it once so far, but I loved it.
May 7, 2020
Learn a lot about computational models.
Ideas about the models last, not for framework though.
Ideas about the models last, not for framework though.
July 24, 2025
The point of this book evades me. Is it a book about programming? Software engineering? Algorithms? Language theory? Who is supposed to benefit and what is to be learned from reading this book?
First of all, the semantics of the example language are obscure enough that I doubt it's transferrable to more mainstream languages (and its syntax is quite an abomination, but that's less important). I doubt understanding this language would benefit your average software engineer in using your average production language, whatever is the stage of the engineer's career this book is read at.
Worse, much of the implementation complexity is buried beneath the semantics of the language. For instance, the book demonstrates how to write a mutex or a channel, but it uses the language features like dataflow variables, and all the actual complexity is swept under the implementation's rug. This hides the hard parts—the very parts you'd need to understand if you wanted to implement similar mechanisms in, say, C or Java. So the book doesn’t teach programming in any practical way, nor is it about computer science in the Tanenbaum's books sense.
Then, this book attempts to be rigorous. But I'll just say that its rigor is nowhere near things like TAPL or "Semantics Engineering with PLT Redex", and neither is the clarity of the underlying formal model.
All the same applies to all other areas this book tries to cover. IMO it just fails to deliver on each front it tries to tackle, and it spreads itself thin trying to tackle all of them.
The only remaining point that's supposedly standing out is the unification of quite different paradigms under the same formalism. But, again, it's nowhere close in rigor to your average CS/type theory text, and TAPL does it better. And some extensions of the basic kernel example language feel artificial enough that I can't say the text achieves this aim even from the pedagogical point of view.
Your time is better spent reading TAPL. Or Tanenbaum. Or any of the myriad books on OOP (yes, they try to cover OOP and fail there too). Or Cormen. Or maybe even your favorite sci-fi book.
Ah, and the editing is bad. I get it, the authors aren't native English speakers (and neither am I), but I often found myself understanding some phrases either purely from the context, or from literally translating some out-of-place word to my native language and looking at homonymous meanings (lucky me! the authors' native language is apparently semantically close to mine!). But if I read a book (and not a blog post or an arxiv preprint), I expect the text to be smooth, even if it's a technical book.
First of all, the semantics of the example language are obscure enough that I doubt it's transferrable to more mainstream languages (and its syntax is quite an abomination, but that's less important). I doubt understanding this language would benefit your average software engineer in using your average production language, whatever is the stage of the engineer's career this book is read at.
Worse, much of the implementation complexity is buried beneath the semantics of the language. For instance, the book demonstrates how to write a mutex or a channel, but it uses the language features like dataflow variables, and all the actual complexity is swept under the implementation's rug. This hides the hard parts—the very parts you'd need to understand if you wanted to implement similar mechanisms in, say, C or Java. So the book doesn’t teach programming in any practical way, nor is it about computer science in the Tanenbaum's books sense.
Then, this book attempts to be rigorous. But I'll just say that its rigor is nowhere near things like TAPL or "Semantics Engineering with PLT Redex", and neither is the clarity of the underlying formal model.
All the same applies to all other areas this book tries to cover. IMO it just fails to deliver on each front it tries to tackle, and it spreads itself thin trying to tackle all of them.
The only remaining point that's supposedly standing out is the unification of quite different paradigms under the same formalism. But, again, it's nowhere close in rigor to your average CS/type theory text, and TAPL does it better. And some extensions of the basic kernel example language feel artificial enough that I can't say the text achieves this aim even from the pedagogical point of view.
Your time is better spent reading TAPL. Or Tanenbaum. Or any of the myriad books on OOP (yes, they try to cover OOP and fail there too). Or Cormen. Or maybe even your favorite sci-fi book.
Ah, and the editing is bad. I get it, the authors aren't native English speakers (and neither am I), but I often found myself understanding some phrases either purely from the context, or from literally translating some out-of-place word to my native language and looking at homonymous meanings (lucky me! the authors' native language is apparently semantically close to mine!). But if I read a book (and not a blog post or an arxiv preprint), I expect the text to be smooth, even if it's a technical book.
May 13, 2020
Interesting read, nice introduction
February 22, 2019
đọc 900tr cũng nản thật, may lão cũng làm 1 course trên edx nên mệt quá vào coi vid cũng đỡ :'<
Want to read
March 13, 2009March 9, 2016
Everything you wanted to know about programming language paradigms.
Forms a strong basis to being a true language-agnostic polyglot developer.
Forms a strong basis to being a true language-agnostic polyglot developer.
Displaying 1 - 15 of 15 reviews