Amiga View

Charles Brannon, Program Editor

Programming In Modula-2

There are a plethora of programming languages for the Amiga, giving programmers and developers a wide choice of programming styles and systems. There are two versions of BASIC (MetaComCo's ABasiC and Microsoft's Amiga BASIC), two C compilers (Manx Aztec C and Lattice C), a macro assembler/editor, two versions of Pascal, and even an implementation of LISP. Numerous programming tools, such as editors and debuggers, are also available.

A relative newcomer to the scene, TDI Modula-2, is now getting some attention. Some programmers consider it easier to learn and use than C--since it shares many of the high-level aspects of Pascal--while still retaining a machine-level interface for maximum efficiency.

Modula-2 is a descendent of the language Modula, which in turn is a descendent of Pascal. Nicklaus Wirth, the inventor of Pascal, designed Modula from the roots of Pascal, but purposely kept it very simple so that it could be used with very small computers--primarily for controlling hardware devices such as robot arms. The original Modula had little application outside a very specialized world, so Wirth put back most of the features of Pascal to create Modula-2. TDI has worked directly with Wirth to implement versions of Modula-2 for the Amiga and Atari ST.

Software Chips

The concept of Modula-2 is echoed in its name. It is a language designed specifically for the techniques of modular programming, just as Pascal was designed to make structured programming convenient and elegant. Modular programming--the art of breaking a large, complex problem into small, independent tasks--is at the heart of all programming, but Modula-2 tries to bring to software the modularity inherent in computer hardware, based on off-the-shelf chips and components. With "software chips," Wirth envisioned, software technology could advance apace with the remarkable speed of hardware evolution.

If software chips are possible, they have to be based on program modules that can be truly independent, hence, individually testable. You can compile a module without having to recompile the entire program. A module, once developed, becomes a "black box" routine that accepts input and/or provides output. You no longer need to know how this module works internally to use it--you just plug it in and go. Writing a program becomes a task of putting together these building blocks in the right way without ever needing to reinvent the wheel. Why solve a problem when someone else has already found the solution?

Modula-2 comes with a standard library containing modules for input/output, math routines, and access to special machine features. You use only the routines you're interested in, and only these routines (and the underlying routines they are based on) need to be included in your compiled code. This lets you control the size of your final program.

You can easily add your own library modules. First, you write the definition module, which simply contains the procedure headers that specify the inputs and outputs of a module. The definition module primarily specifies the names of these procedures. It compiles to a symbol file for use by the compiler. The implementation module contains the actual code of the module. You compile the definition module separately from the implementation module.

You can change and recompile the implementation module without changing the definition module, as long as your procedure headings remain the same. When you re referencing library modules, the compiler can check the compact, compiled symbol file rather than the full-length definition module, speeding up compilation. After compilation, a linker combines your main program with the compiled implementation modules to create the final executable program.

Reminiscent Of Pascal

One of the best ways to learn about a language is to study an example program. The program accompanying this column is written to demonstrate some of the features of Modula-2 without getting bogged down in tricky algorithms. It's a simple guess-my-number game. The RandomNumbers module thinks of a number from 1 to 100. The program then gives you ten tries to guess the number, helping out with hints. If you guess too high, the program recommends that you try a smaller number. If you guess -too low, you should try a higher number.

Here's how the program works. The first line declares the name of the module. Next, the IMPORT statements specify which external library calls we'll be using. Then we declare the variables. We define the procedure SkipEOL, used to strip away the rest of a line after getting a single-character response. The main loop follows, enclosed by the keywords BEGIN and END. (All Modula-2 keywords must be typed in uppercase, which can be annoying.)

Most of the program looks very much like Pascal, especially the use of : = for assignments and the required semicolon at the end of each logical line. Also, you won't find GOTO anywhere in this or any Modula-2 program. Instead, you can control looping and program execution with statements like LOOP-EXIT-END, WHILE-END, REPEAT-UNTIL, and IF-THEN-ELSE-END.

You might be interested to know that this program compiles in 35 seconds when the source code is stored in the RAM disk; it takes 37 seconds to compile when the source code is stored on a floppy disk. Linking takes 45 seconds from the RAM disk, and just one minute from a floppy disk. This is quite a bit faster than Lattice C and compares well with Aztec C.

There's much more to Modula-2 than this discussion can encompass. The language even permits procedures to run as multitasking programs. Our example doesn't show how easily Modula-2 can take advantage of the Amiga operating system--even a small program would be too large to demonstrate here--but the interface is similar to C's, using Pascal-style RECORDs instead of C structures. It's possible to develop modules that support the Amiga operating system on a higher level, using calls like Screen(320,200,5) to open a custom screen as opposed to filling in the blanks of a NewScreen structure, opening the Intuition library, and calling OpenScreen( ). Some high-level modules are included in the library. When these modules are developed and shared between Modula-2 programmers, Amiga programming in Modula-2 can seem almost as easy as in BASIC, but with every advantage of a modern compiled language.