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.

Peter Van Roy has an agenda; it's something like a universal, orthogonal language for discussing the programming paradigms landscape. Oz is his technical-side attempt at that agenda, and CTM is his discourse-side attempt.

It's not a substitute for SICP or K&R or Code Complete or Pragmatic Programmer or TAPL, but it has things (a nuanced awareness of concurrent logic programming languages, for example) that those do not touch.

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.

Great for learning the various paradigms of computer programming languages, like Functional or Object Oriented, but without the typical, dogmatic approach. Instead they build with the declarative model, defining syntax and semantics, and building each new paradigm on top of this to meet new needs, like concurrency.

Kindle format is useless, looks like a PDF document. Unreadable on smaller devices.

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!

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.

Incompatible with both my Paperwhite and the Kindle app on Android.

Je met 5 étoiles à ce produit car :

La livraison a été effectué très rapidement ! Certainement grâce à Amazon prime. De plus le colis était intact et très bien protégé par son packaging.

L'ouvrage m'est d'une très grande utilité, d'autant plus que j'ai le privilège d'avoir un le cours donné par Monsieur Van Roy en personne ! il contient tout ce qu'il y a à savoir sur Oz et la compréhension est assez accessible avec un anglais technique.

The book is in great shape. It was very well packed and arrived in time. It was great to do business and I highly recommend the seller.

The authors cover a wide variety of programming concepts like functional programming, logic programming, object-oriented programming, concurrency, etc. The explanation is very clear. However, the language is useless outside of this book. It's supposed to be a research language, but the clunky codebase (Scala+ancient LLVM) goes untouched for long periods of time. The language itself has some weird quirks: the kind of code we write in the emacs development environment is very different from the code we write for standalone programs; it's the clunky semantics of "declare". The examples in the exercises are rather boring. They do the bare minimum to help us learn the programming technique, but I rarely went at them thinking they are going to be fun to solve.

Das Buch beschreibt alle Programmierparadigmen und behandelt sie mit der frei im Internet verfügbaren Software Mozart / Oz mit einer Programmiersprache. Es vereint also alle Paradigmen in einem Buch bzw. einer Programmiersprache.

この本は、ポストSICPと一部の専門家から言われているものです。内容的にもSICPより出版年数が新しいために、網羅している部分が広いですね(*1)。視野を広げるためには大変よい本というのが第一印象です。SICPほど演習問題の山ってものではないです。いろんな言語がありますけど、それぞれにあった利用方法を理解しやすくなります。その言語に即したプログラミング方法をつかみやすくなるってことです。あとはオートマトンのことを少し知っておくと理解の助けになります。

さて、この洋書ですが、かなり大きいです。大辞典を持ち歩いてるような感じですからね。英語については、平素ですが９００ページ超えですから、それなりの覚悟は必要でしょう。幸い訳書も出てきてますから、英語に自信がないという場合は訳書の方が良いかもしれません。

この本で採用されているoz/mozart言語はいろんなパラダイムを説明するために作られたような教育用の言語という印象で、慣れてきたら擬似コードを見てるような感じです。少々個性はありますが、さほど負担にはなりません。ただ、oz/mozartを自分のPCにインストールするときは、oz/mozartシステムのIDEの役目を果たしてるemacsが必要だったり、64bit OS(*2)ではインストール後の工夫が必要だったりしますので、インストールが難しいと感じたときはvirtualboxやvmwareのような仮想環境にUbuntu(32bitOS版)をいれて、

- sudo apt-get install mozart mozart-doc mozart-stdlib

とターミナルで実行すれば、インストールは何も悩まずに行えます。(emacs同様にインストールする必要がある。）学習する際に一番最初の壁が処理系のインストールというのはよくあることですが、そんな所で無駄に時間を使うのはやめたほうがいいです。あくまでも学習のために利用することになるでしょうからね。

(*1) concurrencyの説明は充実してる。SICPの出た当時よりか重要度が増してるから詳しくなってるのでしょう。GUIのことも説明されています。

(*2) linuxの64bit版でしたら、インストール先のplatformディレクトリ(/usr/local/mozart/platform)に移動して sudo ln -s linux-i486 unknown-unknown で動きます。windowsやmacのことは知りません。

補足情報：

著者がedx.orgでこの本に関連するコースを2014/2月からはじめるみたいです。”LouvainX Paradigms of Computer Programming” というキーワードで検索して見つけてね。（リンクは貼れなくなったので貼らないです。） どんな授業になるのかなぁ？と思ったので、さらに調べてみたら youtubeのPeter Van Roy氏のチャンネルにコース用の動画らしきものを公開してますね。 oz言語を利用して行ってる点を見るとこの本の解説動画というふうにも捉えることができるでしょう。また、courseraでおこなわれてるMartin Odersky氏(scalaの作者）らがscalaを使った2つ目のコース(Principles of Reactive Programming)でこの本がSuggested Readingsに含まれてますね。