Customer Reviews

Concepts, Techniques, and Models of Computer Programming

5 star:		(6)
4 star:		(1)
3 star:		(1)
2 star:		(0)
1 star:		(1)

 

 

This book is a real mind-bender that illuminates paths for computer design at both the conceptual and practical levels I'd never travelled down before.

The notion that one language can be so flexible as to accomodate both the syntax and semantics of so many different computational models, or paradigms, took some unlearning of bad programming practice before its power, elegance and potential began to sink in.

It also explodes the myth that "pure" languages -- i.e., pure OO, or pure functional, etc., languages--have some kind of innate advantage over so-called "hybrid" languages. In fact, "hybrid" (or as the authors would prefer to call them, "multi-paradigm") languages come out of this book looking even more powerful than the "pure" ones, insofar as they allow the programmer to use the right model for each task, instead of trying to make OO fit, for instance, in places where it doesn't fit so well.

The idea here is that each computational model represents a completely different way of approaching a domain problem. Used by themselves, each has its niche. For instance, everybody knows OO is good for domain modelling and busines objects. Prolog-type languages are good for applications that need to apply rules over a set of data. Functional languages are great in mathematical applications. And so on. What is new here is that one can program in an environment in which all of these tools are available in a single core semantics that seamlessly weaves these computational models into a complementary whole. Used together judiciously, with an eye toward program correctness, they make things possible that have long been considered very hard -- for instance, constraint programming.

Mozart-Oz, the underlying technology, is a strange language when you first look at it. It's hard at first to get used to concepts like "higher-order programming" or "by need execution" or "lazy execution" if you are the programming grunt in the field of most modern IT shops, forced by bosses to code in your standard fare -- Java, C#, VB, etc. If OO in Java is like the hammer that makes everything look like a nail, in Mozart-Oz you have a language that is like walking into Ace hardware store, a swiss army knife of a language (conceptually speaking) that challenges you to become a highly skill code craftsman, not just a programmer.

But, if only for the personal growth you will experience grappling with the concepts in this book, I recommend it very highly even to "non academic" programmers (like myself) as well as to any advanced student of computer science. It may be painful, you may scratch your head in places where the concepts just seemed to leap over your cranium, but if you are patient, do the exercises (and at least think about what it would take to tackle some of the research projects), you will grow.

Unfortunately, you may find the languages you work on to be rather confining, and maybe even boring, after you get a whiff of what multi-paradigm programming can do. More likely, however, is that you will grasp very clearly how the language you code in today works, and that can only make you a better software engineer. So do it-buy this book!

Modern programming has become fragmented into a variety of computational models (OO, functional, imperative, etc), and a variety of languages supporting those computational models. Neophyte programmers are typically introduced to just one of these models, and only learn the other, "less natural" models later. With CTM, Van Roy and Haridi take an alternative approach. They teach programming as an integrated discipline, and demonstrate the underlying links between the different computational models. By the time the reader is done with the book they will have a much better understanding of the discipline of programming, and will be well-equipped to decide which model is best suited to the task at hand. Reading CTM is an extremely worthwhile experience for anyone wishing to achieve a deep understanding of the art and science of programming.

CTM has been compared to Abelson and Sussman's "Structure and Interpretation of Computer Programs". They are similar, in the sense that they both provide the reader with a deeper understanding of programming than most programming texts. However, the content of both books is quite different, and it is definitely worth reading both.

Another book that I feel makes a good companion to CTM is Hoare's (sadly hard to come by) "Unifying Theories of Programming". It covers a lot of the same material as CTM, but in a much more theoretical sense. Where CTM is concerned with practical programming, Hoare is concerned with mathematical underpinnings. The two complement each other nicely.

In 1976 Edsger W. Dijkstra elevated programming to an intellectual discipline and taught us how to reason about what we now call "imperative programming". To illustrate his methodology Dijkstra solved challenging problems with unforgetably beautiful, yet simple and powerful example programs that are as relevant today as they were forty years ago. Since then, programming has splintered into paradigms, methodologies and suffers from baroqueness, perpetuation of obsolete conventions and other practices that restrict the full expressive power of programming "as a whole".

In 2004 Van Roy and Seif Haridi have given us a glimpse of what programming can be like without unnecessary restrictions imposed by paradigms and other heavy baggage caused by politics, ideology and historical inertia. Using the remarkably mature implementation of the Mozart system and the conceptually clean, simple, elegant, yet powerful programming language Oz, Van Roy and Haridi show us how dogmatic heavy baggage falls away when we can look at programming as a whole and choose the best programming concepts that the solution of a problem requires. Such a program becomes simpler, more elegant and therefore less error prone than an equivalent solution that is restricted to a specific paradigm.

Ever wondered why it takes so long to pick up your first programming language, when it's C++ or Java? Ever wondered why Object-oriented Programming feels so difficult to get right, even after years of experience?

This books is an amazing study of various programming paradigms (or models, as the authors call them). It starts with the most minimal features required in a programming language, discusses their impact on how you write small programs and then moves on to bigger concepts.

Until you've read this book, you might not realise that multi-threaded object-oriented programming is such a powerful model that it can be used to easily write a lot of real-world applications but this power also makes it tough to master the model because of the many ways you can abuse it. The more powerful a model gets, the more difficult it becomes to verify its correctness without additional tools like debuggers, profilers, etc.

Most importantly, this book can teach you two important things:

* Multi-paradigm programming is more natural (i.e. easier to understand and model real-world concepts in) than 'pure' programming
* Use the least powerful model that can solve the problem at hand naturally (i.e. you don't end up writing a lot of code to work around the model's limitations)

A third thing that they don't enumerate but imply quite obviously is a program design methodology that involves writing large parts of the application using a less powerful and more deterministic model, while harnessing the power of more capable models only for those few components of the application that absolutely need them.

The popular "shared-nothing" architecture for web applications, backed by a concurrent shared-state store (RDBMS, mostly) is one example of such an approach.

The only shortcomings of this book that I found were the rather difficult installation of Mozart programming environment used to illustrate the book's concepts, and IMHO a shortage of sample problems that illustrated the usage of more advanced models.

I love this book so much, I'm buying it again. After having spent years reading it on and off, and working every problem, I've managed to wear out the spine. Since I intend to continue to work with Oz, the fascinating language that is used as the main example, I'm going to get myself a fresh copy!

Before I read this book, I had already been blown away by Scheme, C++, ML, and Haskell. I had studied Java, C#, Ruby, Perl, and a smattering of Lisp, Prolog, Erlang, and historical languages. I thought I knew just about everything about programming languages, and just wanted to learn more about constraint programming. But I found that every chapter of this book, even the ones on paradigms I thought I knew well, was fascinating.

Much of the book is concerned with dataflow programming, which is a refreshing and clever addition to functional programming that works very well with concurrency. I learned a lot about different forms of concurrency, and the tradeoffs between analyzability and expressiveness. The exercises on transactions were illuminating, and relational (logic) programming suddenly makes a lot more sense.

My only regret is that the chapter on constraint programming is a bare introduction. After the thorough coverage of other topics, I was left wanting to know more.

I will also point out that some of the code is a bit terse, doing a little too much in too little space, with too-simple variable names, often single letters. I suspect this may have been done to fit code samples on the page. I'd like to see longer, more clearly explained versions posted on the web site. The authors were ambitions with the scope of the book, so it's hard to imagine cramming in even more careful explanations. The reader will be rewarded by exploring the exercises, and asking questions on the mailing list.

I can not rate this high enough. This is one of the best books on programming I have ever read.

It uses a language called Oz, which, while a very powerful language, will probably never be used to develop professional software. However if you read, and understand this book you will be able to write better programs in any language. It covers many different programming paradigms, and while as far as I know, Oz is the only language that explicitly supports all of them, it discuses other languages that support each of them, and knowing them all will make you a better programmer in any language.

This book is fantastic! It's like a more "fleshed out" version of Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science). It uses a neat (if somewhat weird) language called Oz, which has a number of interesting features, which are used to demonstrate the concepts of the book. Much like SICP, this book is a real masterpiece, elegantly composed and explained.

I've had a course w/Abelson's textbook (see ed. review). So this one was for "fun". I've just started so, perhaps I'll finish and have something more positive to say. After the first chapter I DO have some comments. My PC runs MS Vista. This book relies heavily on (and is intertwined with) the Mozart platform for the OZ programming language. Go to the Mozart.org website and you'll find that the brand spankin "new" version 1.4.0 doesn't run on Vista. The site appears to be litle used and a year old (Ver. 1.4 was introduced July '08). So you have to load an earlier version. Install it. Whoops! It doesn't run. You need to install emacs (emacs? I'll try to repress my sneer. I used emacs. emacs, especially under a unix or command line environment is great - of course that was 20 years ago) Its improved since then, and with a bow to the fanatics who will swear by it, it is great, once you learn all of the control key combinations. Otherwise it is a distraction from learning the concepts you bought the book to learn. The Mozart site references an out of date version. Go to the emacs site and get the latest. So, install emacs 23.1 (as of 8/13/2009). Mozart still won't run. You have to go to My computer - Properties - Advanced Settings - and create a new system variable "OZEMACS" with a value of the path & executable. For instance, I set my emacs up under C:\Program Files [...] There are two choices for executables [...] Some site or another I visited called for runemacs. So I used that. Your milage may vary. I shortened the folder name that emacs created upon installation and moved the whole thing also. (BTW the location of the advanced Tab is for Vista Home Premium svc pk 2 and is approximately correct - but I'm relying on memory so it may not be an exact match to whats on the screen. In windows explorer I right clicked then chose properties then on the left chose advanced something or other). I think there are several tabs to chose from. Hopefully above info is enuff. [...] has instructions for XP which seem to work also for Vista. (except for the XEmacs stuff) Since the program is critical for getting much out of the book, the fact that it took me several hours to set this up is inexcusable. The language, I conclude is losing support and will die the death most languages do. Since the book is so intertwined with the language and the Compiler platform, you can't review one without the other.
Vista has been out too long for it not to be fully supported - at least with detailed instructions how to install on it. By the way it is not IMHO a good idea to be manually adding system variables. make a note to expunge it once you finish with Oz.
So just the hassle (yeah I'm that old) of the installation was a two star knock down. Chapter one seems quite confused. It starts out with a little bit of recursion. Why, I don't know. The authors do say Ch 1 is a taste of things to come, but the level of presentation is 1st year stuff, so far. Way too much about Oz lists without any obvious reason why. The review that said the presentation was slow is correct. But for a 2nd year text book, perhaps that was what was intended. (BTW the claim that {Browse x} doesn't work in Vista is wrong - I tried it and it seems to, but I didn't do anything complicated yet - using {Show x}instead is a pain.) I'm still looking forward to lerning a bit bout some of the language paradigms that I was not exposed to way back when. And it could be that this level of presentation is "my speed" - If I really like the book ultimately I'll come back and update this review.

This book is the worst book that I've ever read on computer programming. Although I appreciate the concepts presented in the book, when you try to read the examples, you will end up in an infinite loop rereading the text because the book is very wordy and the algorithms aren't explained in simple plain English.

The diagrams are misplaced. They are placed at the start of a previous page instead of the current page.

The book is paced in such a way that you need to have taken a course on Automata Theory and Operating Systems.

If you want to suffer in a Computer Programming Languages class, DON'T BUY THIS BOOK.

The authors should have used simple examples to demonstrate the paradigms of computer programming but the examples they presented requires you to become an M.S. Computer Science student first.

The codes doesn't make sense.

Relying help from a friend is the best way than to read this thick, intricate book.