Customer Reviews

Programming in Modula-3: An Introduction in Programming with Style

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

 

 

Modula-3 is one of the great milestones in programming language design.
It is not, as one of the reviewers of this book has said,
a language whose deficiencies were corrected by C++.
On the contrary, Modula-3 was developed after C++ (in the late 80s) and
in fact corrects many of the deficiencies of that language. Many
of the features of Java and C# were lifted more or less intactly
from Modula-3, and the designers of Java have regretted that
they didn't lift more, as they have had to add generics later.

That being said, this is a terrible book. It is poorly organized
and poorly written.
Greg Nelson's "Systems Programming with Modula-3" is the best book, and most of it is available for
free on the Web. Harbison's "Modula-3" is a good introduction
for someone who just wants to know how to write basic programs
in the language. Unfortunately neither of these books is in
print any longer...

Excellent teaching guides are easy to read and understand. They're fun and only heighten interest in learning. Programming in Modula-3:An Introduction in Programming with Style by Laszlo Boszormenyi and Carsten Weich is NO INTRODUCTION. They're explanations are difficult to follow. In addition, it fails to enlighten the reader. I would not recommend this book to a fellow student or programming hobbiest who's just looking to learn a little bit more about Modula-3. I'm disappointed there aren't more Modula-3 programming books.

This definitely is not the book I would use if you are forced to learn modula-3. I say forced to learn because it is hardly used, if ever in the industry. I had to learn it due to a programming class. This book has horrible examples, and god-awful explanations. If you have a PhD in Computer Science then this book is for you. For the 99.999% of the worlds population find another book that's not by these authors.

Published by Springer, this text is a comprehensive treatment of programming in general and Modula-3 in particular. The book is a thorough and very well organized introduction to Modula-3 (just what you would expect from Springer), but in no way is it a tutorial for light reading (just what you would expect from Springer). Springer books are often inaccessibly advanced, targeted at university graduate students and professors, and this one is no exception. However, even if you're a hobbyist you can still find this book useful, but like anything worthwhile you must be willing dedicate some time to it.

The book covers all the Modula-3 language constructs including OOP, recursive algorithms, persistent data structures, and concurrent threads. The reading is occasionally dry and sometimes idiomatically strange, but you must keep in mind that the English edition is a translation of the German edition.

Modula-3 is a member of the Niklaus Wirth family of programming languages that includes Pascal, Modula-2, and Oberon. These languages are characterized by very strict, strong, static, explicit typing. The hard work in learning one of these languages is getting your first few programs to compile, but the nice part is that once your program compiles, no matter how large it becomes there is a good chance it will run correctly (well, a better chance than with a language like C++ or PHP). In particular, if you're a fan of Pascal, Ada, Haskell, or ML, and you've been looking for a modern procedural/OOP language, then you will like Modula-3 and this book is a good place to start. However, if you're more accustomed to a loosely structured scripting language like Perl or PHP, or to a dynamically typed language like Python, Ruby, Lisp, or Scheme, or to a weakly typed language like C or C++, then the Modula-3 language will frustrate you much more than this book will.

If you're a computer scientist, Modula-3 is a must-learn. It's certainly the best designed procedural/object-oriented language in existence. It gives you all the high-level features of an applications language: OOP, namespaces, a large base library, automatic memory management (i.e., garbage collection), plus low-level features of a systems language: pointers, encapsulation of unsafe code, direct hardware access, and extra things like first-class functions and garbage collected threads. Spend some time with this book and you'll learn more than just how to write Modula-3 programs, you'll learn about programming in general, and you'll learn about programming languages.

I think the biggest problem with the book is the typeface used for the program examples: the publisher used a proportional sans-serif typeface in order to fit the examples onto the page, but this makes many of the examples a very dense read (thankfully, the examples are complete and plentiful, starting with the classically minimal "Hello, world!" program). Also, the authors' frequent use of syntactic patterns to formalize the language constructs can seem to obfuscate the text. The book covers only a few of the large number of libraries that comes with a standard Modula-3 distribution, so in many cases you're left to read the HTML documentation provided with the compiler. The good news is that if you download the Critical Mass CM3 compiler, you will get a lot of HTML documentation.

If you do use the CM3 compiler (it's a good one to start with, but installation in MS Windows is non-trivial; in Linux it's no problem), then you must be aware that there are some differences between the book and CM3. The program examples use the SIO package, but the SIO package is no longer bundled with CM3, so you must use the IO package instead. Replace each call to the 'PutText' procedure with 'Put' and you should be able to get started. Other differences between the book and the CM3 implementation can be gleaned from the HTML documentation. Be sure to start with the CM3 tutorial: you will find it in the cm3/doc/tutorial/m3 directory.

If you are familiar with Springer books, then you know what you're getting into. If not, then you might consider a lighter book instead.

If possible, try to avoid the Modula III language all together. Although it encompasses mostly all of the concepts that C++ has, C++ is an outgrowth from the mistakes of Modula III.

I do NOT recommend using this book. It is grossly unorganized and their explanations are convoluted, not detailed, assumes that the user is using SRC Modula III and that the reader has a programming background (although the authors claim otherwise).

I also do not recommend this book to anyone, due to the fact Modula-3 is not even worth learning. Even if it was, this would not be the book at all to read.