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

By Laszlo Böszörmenyi

Book Overview

by Joseph Weizenbaum Since the dawn of the age of computers, people have cursed the difficulty of programming. Over and over again we encounter the suggestion that we should be able to communicate to a computer in natural language what we want it to do. Unfortunately, such advice rests upon a misconception of both the computer and its task. The computer might not be stupid, but it is stubborn. That is, the computer does what all the details of its pro gram command it to do, i. e., what the programmer "tells" it to do. And this can be quite different from what the programmer intended. The misun derstanding with respect to tasks posed to the computer arises from the failure to recognize that such tasks can scarcely be expressed in natural language, if indeed at all. For example, can we practice music, chemistry or mathematics without their respective special symbolic languages? Yet books about computers and programming languages can be written more or less reasonably, even if they are not quite poetic or lyrical. This book can serve as an example of this art and as a model for anyone at tempting to teach inherently difficult subject matters to others. Klagenfurt, April 1995 Preface Striving to make learning to program easier, this book addresses primarily students beginning a computer science major. For our program examples, we employ a new, elegant programming language, Modula-3."

• Format: Hardcover
• Language: English
• ISBN: 3540579125
• ISBN13: 9783540579120
• Release Date: September 1996
• Publisher: Springer
• Length: 571 Pages
• Weight: 2.20 lbs.
• Dimensions: 9.8" x 1.0" x 6.5"

Customer Reviews

Learn Modula-3 in n Days, for n >> 15

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