Summary of projects by N. Wirth, 1962 - 1999

Efforts to identify and combine the essential and fundamental concepts of programming languages, in particualr of ALGOL 60, led to Wirth's dissertation under the guidance of Prof. H. D. Huskey at the University of California at Berkeley, and to the definition of the language Euler. The language was implemented on the IBM 704 computer. After publication the project was continued at Stanford University and resulted in an improved implementation on the Burroughs B5000 computer. This work led the foundation for the method of the microprogrammed, stack-oriented interpreter, first tested on an IBM 360/30 computer. This method became widespread much later and was to play a key role in the implementation of high-level languages on microcomputers. Another important aspect of this research was the development of efficient, general parsing methods, and the systematic coupling of semantic interpretation with syntactic analysis. The so-called precedence grammars originated in the context of this project.

The work on Euler attracted the interest of the IFIP Working Group 2.1. This group had the task of promulgating and further enhancing ALGOL 60. Three proposals for a successor language were submitted in 1965. In the decisive meeting at Warsaw in the fall of 1966, the proposal of A. van Wijngaarden was elected to be further pursued. In 1970, it eventually became ratified by IFIP as ALGOL 68. Whereas it represented a radically new language, Wirth's proposal had been less ambitious and based on the idea to extend ALGOL 60. A compiler was implemented for his (subsequently modified) proposal, and it later became used (under the name Algol W) at many universities operating IBM 360 computers. It contributed significantly to uphold the ideas of ALGOL 60.

Since Algol-W was implemented on one of the first IBM 360 computers, and because only an assembler and a Fortran compiler were available, which both were deemed as unsuitable, Wirth conveived a so-called system implementation language. It was supposed to facilitate and speed up the Algol effort, and at the same time it was to be simple enough to avoid a large effort for its own implementation. These goals were fully achieved, and the resulting language PL360 unexpectedly became used at many other installations too. It was the prototype for other, similar developments for other computer architectures.

Freed from the constraining influence of a working group's consensus, Wirth developped the language Pascal in Zurich. The basis was Algol-W and the desire to have a language that would satisfy the requirements of system design (compilers, operating systems, etc.). Also, there was to be a basis of clear concepts and structures, definable axiomatically and independently of any particular computer, as the language was to be suitable also for teaching in an academic environment. Pascal has satisfied these requirements; it is today one of the most widely used languages in computer science education. The first Pascal compiler was designed in Zurich for the CDC 6000 computer family, and it became operational in 1970. Already in 1972 Pascal was used in introductory programming courses.

In 1970, the Federal Institute of Technology (ETH) acquired a large-scale computer system. In its selection, priority was given to the efficient processing of numerical problems (number crunching). Whereas the concept of time-sharing spread everywhere else, the chosen CDC Cyber system's software was ill-suited for this mode of operation. Under the direction of Wirth and with the cooperation of the ETH Computation Center, the time sharing system Venus emerged in 1970. It met the stringent requirement of not infringing on the effectiveness of the batch processed number crunching tasks. Wirth programmed the Venus text editor; the system, although by now obsolescent, is still in daily use at ETH. It made it possible to introduce the concept of time-sharing to ETH, without which a modern computation center would be unthinkable.

It had always been a major goal in the development of Pascal to demonstrate that structured languages need not be inferior to the predominant Fortran, if sufficient attention and care was paid to their implementation. But it soon became clear that industry had no interest in undertaking this demonstrations, although such engineering projects typically should fall into industry's domain. A second Pascal compiler effort was therefore launched at ETH. The new compiler produced code that was as good as that generated by commercially developped Fortran compilers. Furthermore, this project served as a test for the method of stepwise program refinement propagated by Wirth. A fringe benefit was the welcome capability to satisfy requests to help implement Pascal on other computers, as these requests from other universities became more frequent. The solution lay in replacing the new compiler's code generator by one producing code for a hypothetical architecture that was easily implemented on other machines in the form of a hand-coded interpreter. This architecture, stack-based, became known as the P-machine, its instruction set as P-code. (P for portable). It bacame the basis of the large majority of Pascal implementations which first appeared on large-scale computers (IBM, Univac, DEC, Siemens). But the genuine break-through occurred after microprocessors became widely available and it became clear that Pascal-P implementation was feasible for them (UCSD- Pascal).

Programming languages are mathematical theorems. They represent a methodology of programming, of abstract machine construction. In 1973, Wirth started a project to investigate the basic concepts of designing systems with concurrent processes, i.e. of multi- programming. The emerging design rules (guidelines) inevitably led to the formulation of language constructs expressing the generation and synchronization of concurrent activities. Their embedding in an environment of a minimal support language led to Modula. Implementation was conducted on a PDP-11 computer. A first successful application was the system Hexapus that allowed to connect minicomputers in laboratories with the Computation Center and is still in popular use today.

During a sabbatical year spent at the Xerox Palo Alto Research Center, Wirth was confrontred with an entirely new concept in computer usage: the personal work station. Without the least doubt, the personal work station was superior to the conventional computation center almost wherever computers were used: for the computer scientist, the system designer, in the office, the laboratory, and in particular also in the class room. Unquestionably, the advances in microelectronics would make it possible to manufacture personal work stations economically within the next five years. Whoever had a work station at his disposal would be ahead in the development of software suitable to this new mode of operation. In 1977, Wirth initiated a research project to develop a powerful work station: Lilith. A primary objective was to combine the design of hardware and software. Thereby the project expanded into an integrated design effort for hardware, microcode, operating system, compiler, and elementary application programs. The new mode of highly interactive usage required new concepts concerning the operating system and editors.

Inspite of the enormous task, the goal was successfully reached within three years thanks to the intensive and dedicated work of up to seven assistants. Today, 60 Lilith computers are in daily use at the Institute at ETH, and about 250 more in universities and in industry (e.g. Burroughs, Floating-Point Systems, TRW, Tektronix, Signetics) in the USA. Lilith demonstrated that a workstation can be a powerful, convenient, and even economical tool not only in the office, but in applications which so far had been the exclusive domain of large scale computers, such as computer-aided design.

Apart from the operating system and the compiler, interactive editors belong to the basic software of a system intended for program development. Editors were to be designed in entirely new ways; after all, the challenge lay in making optimal use of the new facilities offered by the hardware, the high-resolution, bit-mapped screen, and the mouse as a position input device. Both the prototype text editor Dina and the editor Sil for line drawings were programmed by Wirth himself. Dina was the ancestor of the later document preparation systems Andra and Lara which allow arbitrary text layout and the use of many fonts, and Sil is heavily used to draw all kinds of diagrams, in particular circuit diagrams.

Perhaps the most significant contribution of the Lilith project was that it made it possible to conceive solutions that would not have been thinkable with commercially available products. The first 10 Liliths were installed in 1980, five years before similar systems were marketed.

Among other things, it was the conscious restriction to use a single programming language only that made the completion of the Lilith project possible in such a short time. Wirth decided to design a revision of Pascal, sacrificing upward compatibility in return for the advantage of avoiding Pascal's deficiencies: Modula-2. The principal new concepts were:

• The module as a unit of program which can be compiled separately.
• The coroutine as the basic buiding block for systems involving concurrent processes.
• An encapsulated set of types and procedures which allow access to machine-specific objects.

The first Modula-2 compiler was completed at ETH in 1979. It was implemented on a PDP-11 computer and then ported onto Lilith. The interest in Modula-2 soon grew, because it offered considerable advantages over Pascal, particularly in the construction of large systems developped by teams. The compiler was distributed to several hundred universities and places in industry, and soon there were companies offering their own developments (Logitech, Volition Systems, Tartan Laboratories). The advantages of Modula-2 were above all paying off in the development of the Lilith software itself. The compiler, the entire operating system, the editors, and all utilities were programmed exclusively in Modula-2. This demonstrated that the confinement to a single language is not only possible but even advantageous.

The personal workstation gains enormously in value, if it is connected with other stations via a network. Impersonal stations, so-called servers, are of great importance, such as printers and central file stores. Under the direction of Wirth, a network interface was developped for Lilith, based on the principle of Ethernet. This 3 Mbit/s computer network was the first of its kind in Switzerland.

Although Wirth had experienced the impressive versatility and the undisputable advantages of laser printers at Xerox in 1976, he had to wait until 1982 to obtain such a device at an affordable price. He acquired the first laser printer of this kind in Europe (Canon LBP-10), designed the hardware and software interface for Lilith, and thereby showed that Lilith was an ideal real-time computer to drive a laser printer's video signal, powerful enough to generate the 6 million raster dots of a printed page while the page is moving past the printer's drum. Under pressure to publish a book on Modula-2, he also programmed the document formatter system Skylla/Zeus, with which it was possible to produce the camera-ready original of the book.

Over the years it became evident that the available Modula-2 compilers, including the one from ETH, were less than optimal, and through mediocre performance sometimes deterred users to take full advantage of Modula-2. Wirth decided to develop a new compiler from scratch by himself. It is based on the simple principle of one-pass compilation, whose application had become possible because of the large memories of modern computers, and which eliminates most of the slow accesses to secondary storage devices. The new compiler is remarkable because of its clear structure, its compactness and its efficiency. The program is about 5000 lines long, compared to 10'000 of its predecessor and 100'000 of comparable Ada compilers, and it compiles itself in less than 2 minutes, compared with half an hour required by its predecessor. These advantages are not only visible in the compiler's use, but they demonstrate that powerful modern languages do not necessarily require giant, complex translators, as is so often claimed.

Five years after Lilith, a second project was started to develop a new workstation. Not the design of a new processor architecture stood in the foreground, but rather the acquisition of know-how in the structure and use of modern hardware technology, also in conjunction with software development. Hence, the computer was to be based on a commercially available microprocessor. The choice fell to the NS32000 family of National Semiconductor (then still called the 16000). After the completion of a prototype with the 32016 processor, both Wirth and codesigner H. Eberle felt that a new design should be based on a 32-bit scheme. The second prototype was therefore built around the NS32032 part, the first genuine 32-bit processor on the market. The memory consisted of 64 256K-DRAM and 32 novel, dual-port 64K-VRAM chips, the latter implementing the frame buffer for the 1024×800 bit-mapped display with minimal bus interference.

In early 1986 33 Ceres-1 computers were built by Hardmeier & Co. in Winterthur, and subsequently tested in our Institute, proving that our goals for robustness and cost effectiveness were well reached. They were immediately put into daily use for research and teaching. A second series was built in the following year.

Progress in semiconductor technology had accelerated to a degree that after only a few years much more powerful machines could be built, even with reduced cost. In 1987-88, Ceres-2 was developed, mostly by B. Heeb under Wirth's supervision. It was based on the NS32532 processor, delivering a sevenfold increase in power over Ceres-1. The use of 1M-bit DRAMs facilitated the enlargement of memeory to 4 or 8 MBytes. 20 Ceres-2 machines were built by the same company in 1988.

The third model, Ceres-3, was designed in 1989 with the purpose of providing a low-cost workstation for student laboratories. The ratio of power vs. cost was of foremost concern. The station, built around the NS32GX32 processor, also had to operate without any moving parts in order to minimize maintenance cost and noise. No fan was to be used for cooling. The goals were met, and in 1990 100 Ceres-3 were built, all of them by a single engineer in four months. Since then, the machines are in use in offices and mostly student laboratories, connected by a network and served by a Ceres-1 server machine.

A sabbatical year at the Xerox Palo Alto Research Center (1984-85) brought Wirth into closer touch with the Cedar Operating System, developed in the preceding years at PARC. This was perhaps the first system truly tuned to the needs of personal workstations, and freed from the framework inherited from central computers with a batch processing mode. In daily use, however, Cedar showed all too clearly the symptoms of large software developed by large groups of people: it was bulky and unreliable. It had already become so complex, and its structure had become so intertwined that it was most difficult, if not impossible, to understand it. Wirth decided to undertake the development of a new system, based on concepts suggested by Cedar, but with the firm goal to keep its size such that it could be well understood as a whole, and could be explained in detail in the literature and in courses. Together with J. Gutknecht he worked on the conception and the detailed programming for the following 3-4 years, after which the basic, but easily extensible system was operational.

Although it was planned to use Modula-2 to implement the Oberon System, it soon became evident that a fundamental facility needed for extensibility was lacking: type extension. It was decided to also discard various facilities of lesser importance of Modula-2, and to construct a new, derived language and its compiler. Being an integral part of the project, the language also obtained the name Oberon.

Language and System soon became the standard tools in the Institute for software development, and in particular the development of system extensions. Wirth himself developed and programmed a graphics editor and software for the network connecting the Ceres workstations. A particular challenge was the design of a server station for printing, file distribution, and electronic mail, all together under the constraint of Oberon's single process property. Using a simple, clear concept proved to be a large benefit; the server operates without failure continuously for years.

Similarity and difference between hardware and software design always had intreagued Wirth as a topic. With the emergence of programmable logic devices, the gap between the two fields narrowed. A project to familiarize a team with the new possibilities was established, and research in design methods using the new devices was started. It led to a set of design tools, including a specification language (Debora, B. Heeb), its compiler with several «back ends» for printed circuits boards, PLDs, and FPGAs. The usefulness of these tools was demonstrated by applying them in the construction of a workstation (Chamaeleon, also Ceres-3). The construction process starting from a textual specification and ending with a board layout and PLD programs was automated, and it required almost no manual intervention.

Wirth realized early, that FPGAs would be particularly useful as a field for experimentation in learning digital circuit design, replacing expensive, pluggable circuit modules by programmable cells. He equipped 25 Ceres-3 workstations in a student laboratory with an FPGA and uses them intensively in a digital design class. Along with a new project in tool design went the formulation of his language Lola, specifically tailored to the need of teaching in a systematic manner, dispensing with the myriads of side-issues inherent in commercial HDLs. The tool set consists of a compiler converting the program (circuit) text into an abstract data structure suitable for further processing, an editor for constructing circuits implemented by the FPGA, i.e. for generating a layout, and a checker comparing the specification in Lola with the layout.

In 1995 Wirth joined a project undertaken at the Institute of Automatic Control and Measurement. The goal was the development of a system to allow a model helicopter to fly autonomously a preprogrammed path. Wirth designed an on-board computer system with a Strong-ARM processor at its core. Aside from the hardware, he also programmed various software tools, including an Oberon subset compiler with additional features for real-time programming. The computer board was built by I. Noack.

The resulting computer system, called Olga, made use of experience with programmable gate arrays, and used the novel Xilinx-Algotronix 6200 fine-grained FPGA for the generation and sensing of pulse-width modulated signals to control the servos. Furthermore, the computer was connected to a compass, a global positioning system (GPS), and a data link via several standard RS-232 interfaces. This system resulted in a drastic reduction of weight and power consumption, and an increase in computing performance compared to the one used before, inspite of the fact that floating-point arithmetic was to be programmed based on integer arithmetic.

The helicopter carrying Olga weighs about 15 kg and is powered by a 35ccm engine. Wirth pushed for a second project based on a downsized helicopter model with a weight of less than 5 kg and a conventional 10ccm engine. This was realized with a considerably smaller computer board, but the same Strong-ARM core and software base. The large FPGA was replaced by several small PLDs. This project, Horla, was confined to the more modest goal of using the computer only to stabilize the inherently unstable craft, while position, speed and direction would remain under remote control by the pilot.

Both projects collected in a remarkable way the various techniques and tools on which Wirth had worked during the past decade: Compiler, operating system, programmable devices (FPGA, PLD) and their design tools including the language Lola, and circuit design in general. Both projects were successful, although only after several years of effort - and patience.

Wirth became professor at ETH in 1968. In 1970, he and his colleague C.A. Zehnder presented a proposal for the introduction of a curriculum in computer science. A second attempt to establish the subject as an academic discipline failed again in 1974. A new Department was finally established in 1981, and Wirth became its head from 1982 to 1984, and again 1988-1990.

Meanwhile, the computer science courses continued to be directed primarily towards the students of mathematics and electrical engineering. Wirth had a strong influence on the contents of the introductory courses and gave form to many of the advanced courses. Several times his lecture material condensed into books which became translated into many languages: Systematic Programming (1972), Algorithms and Data Structures (1975), Compiler Construction (1976). Also his books Pascal - User Manual and Report (1974), Programming in Modula-2 (1982), Programming in Oberon (1992), and Project Oberon (1993) are widely read.

копия http://www.inf.ethz.ch/personal/wirth/projects.html от 28.12.2013