Building a Distributed Spreadsheet in Modula-3

Mr. Kominek introduces us to the Modula-3 language and shows us how it can be used for cross-platform programming.

Back when Borland introduced Turbo Pascal 1.0, Philip Khan did something shrewd: he included the source code for a simple spreadsheet, which is why many programmers bought the product. At a time when Lotus 1-2-3 was the killer application, nothing was more enticing than a glimpse of its key data structure—the sparse matrix.

Of course, the spreadsheet is no longer leading edge. So what might its updated version be? Judging by recent market fanfare, I'd say a spreadsheet that is distributed, multi-platform and web-aware. How would you go about building one?

Delphi, the most recent incarnation of Pascal, is not a bad choice—provided you can live within Windows alone. For us, however, Linux compatibility is a must. You could try to master the intricacies of CORBA, but that standard is now engaged in a turf war with Microsoft's DCOM, a creature of even more convoluted behavior. However, there is another choice available to the Linux programmer.

The Modula-3 language and its surrounding system offer a simple, clean, mature and robust tool for writing distributed applications. (See the sidebar “A Brief Biography”.) In this article I'll highlight the steps necessary for building a distributed spreadsheet. My goal is not to provide a full-fledged product, but rather a framework of code that illustrates all the key components.

A Distributed Application Framework

There are three senses in which a piece of software can be considered “distributed”.

  1. The data and computation can be divided into separate processes. In particular, the data can be viewed from multiple clients (GUI viewers), even though it is stored elsewhere.

  2. The executables can reside on separate machines—for instance, a pair of Linux servers supporting some mixture of Windows and Linux clients.

  3. The work can be distributed between people. You and I may be collaborating remotely on the same spreadsheet, with precautions taken to ensure that I don't overwrite your entries by mistake.

Compared to traditional applications, distributed software is harder to design and get right. In spite of this, it allows for growth and flexible organization.

Software Ingredients

Three basic ingredients are required by our task:

  1. A spreadsheet object: Initially, it is enough to use a two-dimensional array. Once our application is up and running, experience will help refine the object's interface. Later, the fixed array can be replaced with a sparse matrix.

  2. A display widget: Having the user interface separate from the data eases modifications and simplifies the task of cross-platform deployment.

  3. Connecting glue: The spreadsheet object and display widget need to be able to talk to each other.

In Modula-3, Network Objects provide the connecting glue. The beauty is that as far as your code is concerned, invoking an object somewhere on the Net is nearly as easy as one inside your own program. Most of the hard work is done for you.

About Modula-3

As a modern, general purpose systems programming language, Modula-3 is lean in design, yet practical and powerful. Applications range from the fun things (multiuser games), to the serious (operating systems), to the deadly serious (911 call centers). Ten years of use has made the reference compiler solid and dependable.

Current implementations exist for Win32 and popular incarnations of Unix. The Linux port, in particular, receives constant attention. Several versions are available for download, including the full source tree. (For pointers, see the sidebar “Modula-3 Resources”).

Beyond openness, the language has numerous features to recommend it, including:

  • A clean, Algol-derived syntax

  • Explicit support for modules and interfaces

  • A mechanism for calling external C code and libraries

  • Both traditional and object types (with single inheritance)

  • Built-in threads and mutexes for multi-threaded programming

  • Assertions and exceptions to support error handling

  • An incremental garbage collector to simplify memory usage

If this reminds you of Java, that's no accident. Though the syntax of Java is derived from C++, many key improvements descend directly from Modula-3. One implementation of Modula-3 even allows mix-and-match integration with Java.

Features located in “the first ring out”, though not defined in the language itself, include:

  • Quake, a simplified build language that replaces make

  • Standard libraries of algorithms and container objects

  • A lightweight database component

  • A multi-platform windowing system with user interface toolkit

  • Network objects

Network objects allow us to proceed in stages. First, a spreadsheet can be constructed as a single executable. Next, as multiple processes running on one machine. Finally, as multiple processes running over multiple machines. The jumps between stages are small.