"Many programmers gush about how good Modula-3 is, much more so than anyone for any other language. I never heard anyone gush about C++ - it's sheep following the heard." (1998)
"I wish the whole world were programming in Modula-3." (1997)
"I've done detailed work in Apple and X and Windows GDI -- they are all about equally complex. If you look at what Modula-3 did with their windowing system, it's great. It's two orders of magnitude simpler." (1997)
"I'm a fan of garbage collection but because of arbitrary type casting it can't be added onto the C/C++ runtime. [...] I wish we were all programming in Modula-3. But we're not. That's just the way the world has gone." (1997)
"This is sooooo cool! Everytime I use Modula-3, I wonder why the world is stuck on C/C++..." (1997)
"The nature of programming has changed. For many years we were puzzle-solvers, focused on turning algorithms into sets of instructions to be followed by a computer. We enjoyed solving these puzzles, and we often viewed both the complexity of the puzzle and the obscurity of the solution as evidence of our skill. As applications have become more ambitious and programs have grown even larger, programming has become more of a cooperative effort. We form close-knit teams of programmers. We have code walkthroughs and inspections. We test and maintain other people's programs. Aware of our human limitations, we have come to view complexity and obscurity as faults, not challenges. Now we write programs to be read by people, not computers.
There is a pleasure in creating well-written, understandable programs. There is a satisfaction in finding a program structure that tames the complexity of an application. We enjoy seeing our algorithms expressed clearly and persuasively. We also profit from our clearly written programs, for they are much more likely to be correct and maintainable than obscure ones. You will find that it is easy to write clear programs in Modula-3."
"Modula-3 is a fine example of a new language that promises to help build larger programs." (1992)
"Modula-3: It's the most practical technology I've seen for building large distributed applications." (1996)
"The layers in M3 are exceptionally well-behaved, so that it's easy to build on top of them without looking inside. Contrast that with, say Motif, or C++, or any of the sort of "quicksand" development bases." (1997)
"Originally, we had intended to define and implement a safe subset of C. [...] For each major issue that we considered in the context of a safe version of C, we found the issue already satisfactorily addressed by Modula-3."
"In terms of programmer effectiveness, we have found that it takes a day for a competent C programmer to learn the syntax and more obvious semantics of Modula-3, and another few days to become proficient with its more advanced features."
"Portions of the SPIN kernel written in Modula-3 are much more robust and easier to understand than those portions written in C."
"My employer sells something like a 'better debugger' for C and C++, and several of us have observed that if the world's favorite language were (for instance) Modula-3, there would be no need for this better debugger (or for any number of tools that people seem to need for C and C++.) I don't need to worry about building the tools for Modula-3, because they've already been implemented. What remains is to convince people that these tools are worth looking at so that they can discover that they really do exist and really are useful."
"Modula-3: The most humane programming language" (1995)
Paul Vixie has been contributing to Internet protocols and UNIX systems as a protocol designer and software architect since 1980. Early in his career, he developed and introduced sends, proxynet, rtty, cron and other lesser-known tools. Today, Paul is considered the primary modern author and technical architect of BINDv8 the Berkeley Internet Name Domain Version 8, the open source reference implementation of the Domain Name System (DNS). He formed the Internet Software Consortium (ISC) in 1994, and acted as Chairman of its Board of Directors till 2013. The ISC reflects Paul's commitment to developing and maintaining production quality open source reference implementations of core Internet protocols.
In comp.lang.modula3 he wrote:
"Modula-3's chief objective -- which it achieves nicely -- is that code written in it (including arbitrarily complex data structures) tends to look like what it does/is. (Not to mention that Modula-3 code that compiles will tend to work -- whereas C will compile many kinds of line noise and generate pseudorandom object code for you.)
The operative question is not yet "which language is better" but rather, "what attributes make a language better or worse than another?" To professional programmers who work on huge projects as part of distributed teams full of non-wizards, a language that looks like what it does, has very strict compile-time rules, has some run-time rules and has explicit module interdependencies, will seem like a better language than one which gives programmers a lot of power and flexibility. Garage band programmers will tend to prefer the power and flex.
The error which underlies the very existence of this debate is that there is some kind of perfect Platonic form of the computer language, which some real languages reflect more perfectly than others. Plato was brilliant for his time but reality is not expressable in terms of arbitrary visions of perfection, and furthermore, one programmer's ideal is often another's hell." (1995)
"I think that you will find Modula-3 uniquely suited for your
Because of its separation of interface and implementation, it is an ideal language for high level simulations where modules of the system being simulated need to map fairly evenly to modules of the simulator.
I have found that its strong typing and exception support lead to code that does what it looks like it does, perhaps more so than any other language I have used." (1995)
Last Updated: Juli 21, 2003