Why Modula-3? Modula-3 is an example of what are called "strongly typed" programming languages. This means they enforce type consistency very strictly at compile time. It takes longer to get a clean compile, but this is much more than offset by shorter debug times. Early experience with strong typing showed that it detects about half of all programming errors at compile time. More importantly, for those programming errors it detects, it guarantees there are none in your code, once you get a single clean compile. For other errors, i.e. those that are not found until runtime, it takes anywhere from trillions to infinitely many test cases to even discover the existence of errors with the same degree of certainty as a single compilation. Strong typing works by moving many programming errors from the runtime-detected to compile-time-detected category. The most popular programming languages are not strongly typed. This gives rise to much longer "debug" times and to much buggier software being released to users. Poorly-typed languages require that programmers show a higher level of discipline, in order to cope with programming tasks. Unfortunately, it is an observable fact that programmers, both students and professionals, who do not have significant experience with strongly typed languages show the lowest level of this very discipline. Within a few years after the introduction of strong typing, it became clear that they somehow mold the thinking process of their users in beneficial ways. Eventually, programmers end up making fewer of the compile time errors in the first place. Moreover, when they move from a strongly-typed language to a weakly-typed one, they carry this more disciplined thinking with them, making fewer errors even in the weak language. Strong typing was developed in the late 1960s. It enjoyed increasing popularity for a while, but more recently, industry has been returning to the poorer languages of yesteryear. With occasional exceptions, the only justification anyone will give for this is that they are following the crowd. In the 1980s, universities taught using strongly-typed languages, in spite of industry's preferences, in order to create the good thinking habits these languages engender. More recently, academia has caved in to pressure and become enablers of industry's addictions. Strong typing is now becoming even more important as computing security problems grow. The overwhelming majority of reported bugs that allow security breaches are buffer overrun bugs. A strongly-typed programming language would prevent all of these from doing significant damage (although only at runtime). Modula-3 is an object-oriented language that is not only strongly-typed, but for what it does, it is unusually simple. It has the highest economy of concept of any programming language. It has considerably more in the way of useful features, yet its definition is six, eight, or ten times smaller than C++, Java, and Ada, all object-oriented languages of similar nature. It is a widespread problem that programmers do not understand their programming language. They try to get something to compile or to give a desired result by random experiments, never sure of the real meaning of what they have written. Nobody could argue that Modula-3 is easy to understand. But languages with nearly an order of magnitude bigger reference manuals are even an order of magnitude more difficult to understand. Programmers who try to work without understanding their language are lacking essential competence for their jobs. Modula-3 gives you a better chance of understanding what you write, despite the fact that you will have to learn some new syntax for some old concepts. During your career in software development, you will have to learn many new programming languages. Today, the industrial world is very narrowly focussed on just a few fad programming languages. But the selection of languages that are in widespread use will inevitably change several times during your career. The changes you will encounter with each new language will be a mixture, ranging from slightly different syntax for the same familiar concepts, through substantively different treatments of familiar ideas, to fundamentally new concepts. Modula-3 reflects this spectrum in typical ways. In Modula-3, you will see different syntax for things that are well-known to you. The syntax will be unfamiliar to you, but much more explicit and clear about what the language constructs really mean. You will be able to take a better understanding of these constructs with you, when you go back to C or C++, making better sense of their sometimes highly inconsistent syntax. More deeply, you will discover how to distinguish fundamentally different data types that are confused in the incomplete type system of C. Finally, you will learn several completely new programming language concepts, including modular programming, information hiding, and the object-oriented concepts. In CS 810, we will look at Modula-3 and C++ side by side, feature by feature. You will gain an understanding of strong vs. weak typing, consistent, explicit, and separable syntax vs. confused concepts, economy of concept vs. excessive complexity, complete vs. incomplete specification, and high-level language programming vs. mixed-level programming. This will help you develop thinking habits that will enable you to produce programs with fewer bugs and with less work. These habits will carry with you, even when you have to use the more popular but poorly-designed programming languages. Because of your better understanding of their language design flaws and pitfalls, you will be much better able to avoid being bogged down by them. The benefits will accrue to you both in programming assignments in your classes and, more importantly, when you are on the job full time, and expected to keep schedules and produce quality work.