Abstract

The programming language Oberon was designed around 1988 with the intent to create a simple, yet powerful vehicle for effective teaching. Clarity of concepts, economy of design, and rigorous definition were the main goals. It was designed and implemented by (only) J. Gutknecht and N. Wirth within about 2 years, and it followed in spirit its ancestor Algol 60.

Within this time, also a modern operating system was implemented. Together with the compiler, with a text system and a graphics editor, it was described in a single, comprehensive book of 500 pages.

The book soon ran out of print. But 25 years later, requests arose to republish this work. The main obstacle was that the used, then modern microprocessor had vanished. It appeared as unavoidable to design a new compiler. We did so, but not for any popular, complex, commercial part, but for a simple design of our own, extending the project down into the realm of hardware. The decision was facilitated by the availability of configurable components, so-called Field Programmable Gate Arrays, non-existent 25 years ago.

This processor follows the principles propagated by the Reduced Instruction Set Computer movement of the 1980s, in particular the ARM. We call it the RISC. It is a 32-bit architecture with 16 main registers and some 16 instructions.
The RISC was implemented on a Spartan-3 low-cost development board, which adds 1 MByte of memory, ample for the entire Oberon System. The old disk store is represented by a small SD-card. In order to establish an entire computer, only a monitor, a keyboard, and a mouse are required.

Abstract

We recall the world of computers and computing as it presented itself in the early years, starting in 1960. It was the time of stand-alone, main frame, large, bulky computers. They were programmed in assembler code, in Fortran or Cobol, the first programming languages for numerical applications and for accounting. A milestone was set by the IBM 360, introducing the concepts of computer family and of computer architecture. Also, it merged the two segregated worlds of scientific and commercial computing. The language PL/1 was supposed to merge Fortran and Cobol. Input was a batch of punched cards, output endless line paper. No interaction was possible.

Then followed the era of minicomputers, first conceived for laboratory application. They were still built around discrete components (transistors), but were used by single persons - not through batch processing. They were operated from terminals, first teletypes, later displays with 25 lines of 80 characters.

After a period in which time-sharing systems became prominent (having given rise to the concept of operating system), it followed the era of microcomputers. They used 8-bit single chip processors, made possible by integrated components (chips, TTL technology). They brought computing into homes and schools, but largely remained toys. They also made the language Pascal popular.

The real breakthrough - and in my view the beginning of the computer age - was instigated around 1980 by microcomputers sufficiently powerful for genuine computing tasks. The desktops were later followed by laptops, fostered by continuing miniaturization of circuits. They are now as complex with millions of transistors as supercomputers were only 25 years ago.

This explosion of computing capability, together with the advent of the Internet, brought an expansion of applications and growth of demands, which challenge the programming engineers beyond limits. We hesitatingly speculate about the developments in the near future.

Abstract

Electronic circuits used to be specified by diagrams which more or less represented their physical layout. As circuits became very complex, the limitations of diagrams became apparent. Over time, they were replaced by textual descriptions, giving rise to Hardware Description Languages (HDL). One of the prominent HDLs is Verilog, closely mirroring the appearance of C.

Around 1990 we designed the HDL Lola adopting the same goals as for the PL Oberon: A simple and economical vehicle for teaching. The effort was encouraged by the advent of FPGAs, re-configurable components. We implemented Lola for the FPGAs of Concurrent Logic and of Algotronics, which since then have vanished.

Now we have unearthed and revived Lola and built a compiler. But unlike before, its output is not a configuration file to be loaded onto the chip, but a translation into Verilog. Here we present the gist of Lola-2 and its compiler. Finally we ponder about the differences between HDLs and PLs in general. Are they fundamental? And what are they?