1971: Pascal
First described in a published report in 1971, it affected almost every
block-structured language designed since (e.g. Ada). Niklaus Wirth continued to design programming
languages, including the Modula family. Its popularity could never have been imagined by Wirth when
he began development of Pascal in 1968, mainly after a necessity for a good teaching tool.
Pascal is a simple block-structured language originally designed for computer science education.
Pascal features strong type checking, simple I/O facilities, a good set of primitive data types,
arrays, fixed and variant records, conventional control structures, and simple dynamic memory
management.
Pascal requires discipline from the programmer: all types, data, and subroutines in a Pascal program
must be declared prior to use. Everything is lexically scoped, to allow for maximum compile-time type
checking. The language has good support for programmer-defined data types and subtypes, which are also
subject to strong checking. Structure of a Pascal block is somewhat rigid, elements must appear in a
certain order preceded by their identifying keyword: labels, constants, types, variables and functions,
then body code.
The original Pascal language borrowed some structural ideas from Algol, but also included novel
syntactic and semantic features intended to foster good structured programming technique (or at least
what was considered sound structured development technique in the 1970s). The choice of features and
the limited external interface facilities helped make Pascal very portable. However, the initial
design was very spare, it didn't include strings, only arrays of characters, and it had a very small
complement of built-in utility functions. These omissions led developers of Pascal language
implementations to add extensions to help programmers accomplish real work, and unfortunately every
vendor's extensions were more-or-less proprietary -- the Pascal language lost some of its portability.
Amazingly, while it is very strict in most ways, Pascal still supports a 'goto' statement. Pascal does
not support object-oriented programming, persistence, or multi-tasking. A 1975 variant of Pascal
called "Concurrent Pascal" had good support for multi-tasking and other advanced features.
During the 1970s and 1980s, Pascal became fairly widely used, especially in the early days of the IBM
PC and the Macintosh. A great many students of computing in the 80s cut their teeth on Pascal programs.
Both free and commercial Pascal compilers exist. The most popular commercial compiler, and ine
language implementation, is "Turbo Pascal" from Borland. Pascal is normally compiled, either to
machine e or virtual machine bytecodes of some sort. Source-level Pascal interpreters also exist,
and translators from Pascal to other languages.
One of the most interesting aspects of Pascal is its relative poverty of features. Compared to its
rough contemporary PL/I, Pascal is a tiny language. This contrast helped frame a debate that has raged
in computer science circles ever since: should languages be kept small and simple (with complex
facilities provided by external libraries), or should they be made large and complex to provide all
features that programmers require. Many later block-structured and object-oriented language designers
would be forced to choose one of these two camps. Oberon, for example, is small and spare, depending
on libraries for advanced features. Perl, in contract, is complex and loads many useful features in
the language itself. Recent languages like Java adopt a compromise position: keep the language simple,
but standardize the supporting libraries to prevent incompatible implementations.
In most programming areas, Pascal has been superseded by newer, object-oriented languages, such as C,
C++, and Java.
Click to view a sample Pascal program
1971: B
With its roots based in BCPL (see 1967), B is a new computer language designed and
implemented at Murray Hill, New Jersey, by Dennis M. Ritchie and K. L. Thompson. B is suited for
non-numeric computations, typified by system programming, which usually involve many complex logical
decisions, computations on integers and fields of words, especially characters and bit strings, and no
floating point. B programs for such operations are substantially easier to write and understand than
GMAP programs. The generated code is quite good, with a small, unrestrictive syntax that is easy to
compile. Because of the unusual freedom of expression and a rich set of operators, B programs
are often quite compact.
Unfortunately B is short lived, as within a year it spawns C, which will eventually incorporate
everything that B already does.
Click to view a sample B program
1971: sh
Since the early days of Unix, many different shells have been created: C shell,
Tenex C shell, Korn shell, Bourne-Again Shell, and many others. Unix shell languages are interpreted,
as a rule. A variety of 'shell compilers' have been written over the years, these typically translate
a shell script into a C program with extensive reliance on a support library.
The developement of sh, aka Bourne Shell, is no different from other shell scripting languages.
Created in 1971 by Steve Bourne, the shell has been included on all Unix and Linux systems, and
more-or-less complete versions are available for many other systems. Eventually, this would become
part the development of Perl in 1987.
The Bourne shell scripting language was one of the original command languages for the Unix operating
system. It is a simple interpreted language, but widely used for automating complex tasks and
assembling multi-step functionality from individual Unix tools. It offers extensive special syntax and
features for running programs and handling their I/O. One of the most influential of these constructs
was the "pipe", a simple syntax for connecting the output of one program to the input of another.
sh syntax is line-oriented, and has very limited data typing and scoping features. Variables are
usually called 'parameters'. The only data type for parameters is string. Parameters are global and
dynamically scoped. The shell language supports a modest but complete set of control-flow constructs:
bounded and free loops, if-then-else, and a powerful case statement. Sh also supports a rudimentary
error handling facility for catching asynchronous interrupts. Modern versions of sh support named
functions, which may not be nested. Function parameters are the only non-global variables. Strangely,
sh has no support for computation, all computations must be carried out by calling Unix utilities
like test and expr. The basic boolean construct in sh programming is the success or failure of
program execution.
Click to view a sample sh program
1972: Prolog
The first implementation of Prolog, developed by Alain Colmerauer and Phillip
Roussel appears after work had begun in 1971. A Prolog program can accomplish amazing things with a
very short amount of code. The logic paradigm is a very powerful one for certain problem domains, but
unsuitable for some others.
PROLOG stands for PROgramming in LOGic. Prolog was a progenitor of the study of 'logic programming,' a
computer science area concerned with languages and systems for logical inference, proof techniques,
and very high-level programming systems.
A typical program consists of a set of facts, and a set of rules that specify how to satisfy goals
related to those facts. Prolog supports a small but rich variety of data types: numbers, strings,
symbols, lists, and composite objects (analogous to records). You never really execute a Prolog
program directly, in the sense that you might run a C program; instead, you ask the Prolog system
questions. By attempting to answer the questions, the Prolog system examines facts, invokes rules, and
may manipulate data or perform computations. The programmer does not directly control the execution
sequence of the Prolog system as it seeks to satisfy a goal, although he can exert some influence. In
this sense, Prolog must be considered a declarative language and not a procedural one.
Prolog is among the first computer programming systems to employ the logical formalism of unification.
It also utilizes recursive goal seeking with backtracking, a common AI technique. Unfortunately,
unification and backtracking can be computationally expensive, and early Prolog implementations were
very slow. Newer implementation techniques, as well as language features that let the programmer guide
the search to some extent, have given modern Prolog much better performance.
Logic programming such as Prolog, has been proposed as the basis for 5th generation computing: a
vision of massively parallel computers providing true AI. A great deal of research into parallel
resolution and logic databases w erformed in the US, Europe, and especially in Japan under their
huge 5th Generation project. Logic programming research continues, but grandiose visions of logic as
a panacae were given up in the mid-1 990's.
Click to view a sample Prolog program
1972: C
Developed by Dennis M. Richie while working at Bell Labs in Murray Hill, New
Jersey, the language of C, a fairly low-level block structured language with good support for system
programming. It had fair arithmetic support, simple data structures, subroutines, conventional flow
control constructs, naked memory pointers, simple but useful I/O facilities, and a powerful macro
preprocessor. Richie had developed C for the new Unix system being created around the same time, and
because of this, Unix and C go hand in hand. However, C would not be limited to just Unix as
language would become widely used in PC, Mac, mainframe, and other computing environments.
Based in two lesser known languages of B (see 1971) and BCPL (see 1967), C signified the next major
step in programming languages as it also seemed to improve on the already popular Pascal. Although
there is no direct link between C and Pascal, all of the features that made Pascal so popular were
there, including CASE statements and pointers. Because of the extensive use of pointers, C was made
fast and powerfull at the expense of being hard to read. None the less, the improvements it had over
Pascal started a major wave of change from former Pascal users.
C is a powerful language for writing tight, fast, highly tuned code in a language far more portable
than assembly. C is low-level enough to write device drivers, and high-level enough to write GUI
libraries. It has no I/O facilities defined as part of the syntax. Modularity in C is limited to one
level of subroutines: all C names exist either at the global scope, file scope, or subroutine local
scope. C has no built-in support for separation of module interfaces from module implementation, but a
flexible set of conventions for employing the macro preprocessor to separate "header" files and "body"
files has evolved to support this paradigm. Primitive data types supported in modern standard C are:
several sizes of integers, reals, characters, pointers, and arrays. C does not have strings per se,
but the language does have the convention that an array of characters ending with a nul (0) character
can be treated as a string. Data aggregation types in C are structures (records) and unions.
The ANSI C standard, created in 1990, defines better data type handling and subroutine declarations for
C, as well as standardizing on minimum I/O and other library facilities. The standard also defines an
extensive but low-level standard library, including I/O mechanisms. The standard library was not
really designed, it evolved out of the standard library functions supplied with C implementations on
Unix systems.
C will become extremely popular in academic and industrial computing from the late 1970s through to the
early 1990s, where even today it still enjoys a huge user community. The influence of C and UNIX on
each other, and the pair of them on the rest of computing, cannot be underestimated. C also had a
profound impact on the WWW as the first web servers and web clients were all written in C.
Click to view a sample C program
1975: Tiny BASIC
A relatively unknown language called Tiny BASIC is released by Bob Albrecht and Dennis Allison (implementation by Dick Whipple and John Arnold). It runs on a microcomputer with just 2 KB of RAM. A 4-KB machine is sizable, which left 2 KB available for the program.
1975: Scheme
Developed at MIT, Scheme, a dialect of LISP, was created with functional and
procedural language aspects. Unlike original LISP, Scheme is lexically scoped, but like LISP it is
dynamically typed. Scheme is used to teach computer science principles, as well as for writing
various compilers, AI systems, and many other kinds of programs.
Scheme provides a wide set of data types: symbols, various numeric types, characters and strings,
lists, vectors, bit strings, records, association lists and hash tables, and various functional/lambda
types (curried procedures, closures, promises, etc). Scheme has comprehensive I/O facilities based on
an abstraction called "Ports." As a Lisp dialect, Scheme naturally supports lambda expressions. It
also has a full set of sequential control-flow constructs: a variety of selection, iteration, and
block special forms. Scheme also has a comprehensive error handling mechanism.
Click to view a sample Scheme program
1975: The Microsoft Empire Takes Shape
With the release of their own version of BASIC (see 1964), Bill Gates and Paul Allen being the company known today as Microsoft. They sell it to MITS (Micro Instrumentation and Telemetry Systems) on a per-copy royalty basis. MITS is producing the Altair, an 8080-based microcomputer at the time.
1975: RATFOR
B.W. Kerninghan describes RATFOR which stands for RATional FORTRAN. It is a preprocessor that allows C-like control structures in FORTRAN. RATFOR is used in Kernighan and Plauger's "Software Tools," which appears a year later.
1977: MUMPS
The ANSI standard for MUMPS (Massachusetts General Hospital Utility
Multi-Programming System) is released. Soon aft er it becomes standardized and commercialized, people
started calling it 'M' because it was cooler and didn't evoke an unpleasant disease.
MUMPS (aka M) is a procedural, interpreted language with extensive features for event-driven
programming, text handling, and database manipulation. The language syntax is very simple, but quirky.
A program written in M consists of commands which operate on variables. These variables can be simple
numbers, records, lists, or enormous databases. Persistent variables are called 'globals' and usually
live in the database. Access to globals is transparent, freeing the programmer from worrying about
many database management issues.
The usual sequential control structures are present in MUMPS, but in somewhat idiosyncratic forms.
Although the usual arithmetic operators are included, MUMPS's real strength is in its string handling.
It has a flexible set of commands for pattern matching, sorting, and manipulating strings (although
not as extensive as SNOBOL or Icon).
Originally mostly used in medical informatics (partly as a result of NIH encouragement in the early
1970s), and it remains very popular for building clinical databases worldwide. MUMPS users groups and
technical associations are active, and an international M conference is held each year. Since the
advent of the WWW, MUMPS has been used to write web servers, web/database interfaces, and other CGI
services, even though the base language standard supports only text-based screens.
Click to view a sample MUMPS program
1978: Awk
Awk is an interpreted string-processing language developed at Bell Labs. It quickly
assumed its place as the utility language of choice for small UNIX data transformation and parsing
programs. Awk offered powerful regular expression pattern matching, handy line-oriented program
structure, and enough conventional language features to let you get your work done. Awk did not
support any kind of modularity nor type checking. Awk remains moderately well-known in the UNIX
community, but has been largely superseded by the more powerful Perl programming language in 1987.
In a typical Awk program, sections of code are applied to lines of data input as matched by regular
expressions. Later versions of Awk supported multiple input files as well as subroutines and other
advanced features.
Awk is reputed to be one of the best languages in which to write a program that will be
incomprehensible to any reader, even its own author. A version of 'new' awk (circa 1985) is supplied
with most UNIX systems. The most powerful and portable awk implementation is GAWK (Gnu Awk), available
from the Free Software Foundation. Awk is a part of the POSIX Command Language and Utilities standard.
Click to view a sample Awk program
1979: Rexx
Originally invented as a sophisticated command language for IBM mainframe
environments (MVS, CMS), Rexx has gained some popularity as a programming language with expressive
power and convenience. In the Windows environment it competes with Visual Basic, Java, Perl, and Tcl.
In the UNIX environment is competes with Perl, Tcl, Java, and various shells. On IBM OS/2 Rexx is
probably the most popular scripting language.
Rexx is an block-sturctured procedural language commonly used for application development, integration,
and extension. Designed primarily for ease of use, the Rexx language is weakly typed and has a very
plain, uncomplicated syntax. Rexx supports strings, numbers, and associative arrays as its data
structure. The numbers can be unlimited-precision. The language includes conventional control
structures: if-then-else, counted and free loops, and a case statement form. It supports recursive
functions, and also supports evaluation of run-time code (like Lisp, Perl, and many other interpreted
languages.) Some commercial implementations of Rexx support the creation of GUIs and interaction with
database management systems.
Various superset dialects of Rexx exist, from Rexx 1.00 in 1979 to Object Rexx in 1997, that provide
a variety of extensions. ObjectRexx, for example, supports object-oriented programming, and NetRexx
(released in 1991) provides a variety of network interface and I/O facilities.
Click to view a sample Awk program
1980: Modula 2
Originally conceived by Niklaus Wirth in 1977, Modula 2 was officially released in
1980. It is designed to support the construction and maintenance of real application software systems,
unlike its predecessor Pascal. Modula 2's support for concurrency and dynamic memory management are
also better than Pascal, allowing the programmer more flexibility. The syntax of Modula-2 is also
less rigid than that of Pascal, allowing the programmer to declare variables and other items nearer
to where they are used. Lastly, Modula-2 support function signature type checking across module
boundaries.
Modula-2 is a procedural, block-structured language intended for application programming and computer
science education. It was designed to foster good software engineering practices, and also to remedy
some of the shortcomings of its predecessor, Pascal. Modula-2 has very good support for program
modularity: named modules, separate compilation, and data hiding. It also featured strong type
checking, a variety of conventional data types, dynamic arrays, and concurrency.
Thanks to the advantages Modula 2 had over Pascal, it enjoyed some degree of adoption in the early
1980's, especially for software engineering education. Many commercial compilers were written for it,
eventually covering most platforms such as Unix systems, PCs, and VMS, and even some cross-compilers
for embedded systems. Modula-2's features and semantics had substantial influence on the design of Ada.
Unfortunately, while Modula-2 allows construction of abstract data types, it does not support
inheritance and therefore was not able to fully support the paradigm of object-oriented programming
that became popular in the late 1980's.
Click to view a sample Rexx program
1980: C with Classes
With OOP (Object Oriented Programming) developing in the late 70's, Bjarne
Stroustrup develops a set of languages, collectively referred to as "C With Classes". These are
extensions to C which was released in 1972, providing advanced features such as dynamic variables,
multitasking, interrupt handling, forking, and strong, low-level input/output. "C With Classes"
server as the breeding ground for C++ which would be released in 1983.
1982: The Foundation of Adobe and PostScript
A Page Description Language (PDL) based on work originally done by
John Gaffney at Evans and Sutherland in 1976, PostScript evolved through "JaM" ("John and Martin",
Martin Newell) at XEROX PARC. Its current form was finally implemented by John Warnock after he and
Chuck Geschke founded Adobe Systems, Inc. in 1982.
PostScript is a threaded interpreted language with stack-based semantics. While usable for
general-purpose computation, PostScript was specially designed to drive graphic devices, initially
printers, and has a large set of operators for rendering onto a page. In terms of syntax and semantics,
PostScript resembles Forth: operators use data from a stack, and place their results back on the
stack. PostScript data types include floating-point numbers, strings, fonts, files, vectors, and
symbols. Defined procedures are simply code sequences stored in dictionaries.
The essence of PostScript is its model of execution. In a threaded interpreted language, a program
simply consists of a series of tokens. The interpreter processes each token in turn, with no
look-ahead or complex parsing needed. Supporting this style requires storage for intermediate results,
PostScript uses several stacks: a code stack, a data stack, and a dictionary stack. (There is also a
special stack just for graphical contexts, as needed for the rendering model, making a total of four
stacks.) Threaded interpreted languages can be difficult to use, but they offer the advantage that
interpreters for them can be very compact and fast. As PostScript was originally designed to execute
inside a printer or similar device with very little memory, compactness was an important design
criterion.
A program in PostScript can communicate a document description from a composition system to a
printing system in a device-independent way. PostScript is an unusually powerful printer language
because it is a full programming language, rather than a series of low-level escape sequences. It is
also noteworthy for implementing on-the fly rasterisation, from Bezier curve descriptions, of
high-quality fonts at low (e.g. 300 dpi) resolution (it was formerly believed that hand-tuned bitmap
fonts were required for this task).
PostScript's combination of technical merits and widespread availability has made it the language of
choice for graphical output.
Click to view a sample PostScript program
1983: Ada
Originally designed for the US Dept. of Defense, with intentions to support
large-scale programming and promote software reliability, Ada is released in 1983. Named in honor of
Lady Ada Lovelace (1815-1852), a friend and confidante of Charles Babbage, Ada is a block-structured
language with many object-oriented programming features that include: nested procedures, nested
packages, strong typing, multi-tasking, generics, exception handling, and abstract data types.
Ada is a fairly complex language that has a conventional but very rich Pascal-like syntax, with many
specialized features. The best aspects of Ada are its support for generics (templates), its support
for task synchronization, and its very good exception handling. Its worst features are its complex
syntax, and the poor performance of the code generated by most early compilers.
Primitive data types supported by Ada include a variety of numeric types, booleans, characters,
references, and enumerated symbols. Arrays, records (structures), and strings are Ada's composite
types. With its emphasis on program safety, it is not surprising that Ada is a strongly typed
language: all data elements must be declared as storing a particular type or subtype, and type
enforcement is strictly applied both within and between modules.
Ada is very strictly standardized and well documented as a language. Ada compilers undergo stringent
validation with an official test suite. At least one free Ada compiler and several good commercial
ones are available. Initially standardized in 1983, Ada will be superseded by a new standard in 1995.
The two versions are now known as Ada-83 and Ada-95.
Click to view a sample Ada program
1983: C++
In July of 1983, the first implementation of C++ appears. The name is coined by
Rick Mascitti.
C++ is a fairly complicated object-oriented language derived from C. The syntax of C++ is a lot like C,
with various extensions and extra keywords needed to support classes, interitance and other OO
features. C++ was originally developed as an extension to C, but quickly evolved into its language.
Despite some of the flaws it has inherited from C, C++ is a very popular language for application
development on Unix systems and PCs.
The C++ programming language offers a very broad range of OOP features: multiple inheritance, strong
typing, dynamic memory management, templates (generics), polymorphism, exception handling, and
overloading. Some newer C++ systems also offer run-time type identification and separate namespaces.
Because of this, C++ is one of the most mature and certainly the most widely-implemented
object-oriented language. However, it is missing some features that are considered obligatory in a
new OOP language design: concurrency, persistence, automatic garbage collection, and reflection. In
exchange for these deficiencies, C++ gives some things that system programmers especially like:
determinism and control. Since very little needs to happen behind the scenes in C++ programs, they
have low overhead and good performance.
C++ also supports the usual features expected of an application language: a variety of data types
including strings, arrays and structures, full I/O facilities, data pointers and type conversion. The
C++ Standard Template Library (STL) offers a set of collection and abstract data type facilities.
Because it is derived from C, C++ has a number of features that support unsafe and defective software.
The more recent C++ standards do support safe casts, but this feature is not yet universally available
or employed. Also, C++ has dynamic memory allocation, but does not have garbage collection; this
allows programs to mis-use and leak memory. C++ also supports dangerous raw memory pointers and
pointer arithmetic. These low-level facilities are useful in some situations, but can increase the
time needed for software development.
Efforts at unifying the C++ language were begun in 1989. C++ was finally standardized by the ISO and
ANSI in November, 1997.
Click to view a sample C++ program
1983: C Compilers
In late 1983 and early 1984, Microsoft and Digital Research both release the first C compilers for microcomputers.
1986: Actor
Charles Duff releases Actor, an object-oriented language for developing Microsoft Windows applications
1986: Eiffel
An object-oriented language intended for general application programming, Eiffel is
designed in large part to support program safety and orderly software development, whose goals were
also embraced by the Ada community.
Superficially similar to C, the syntax of Eiffel offers a broad range of OO programming features:
inheritance, polymorphism, assertions, exception handling, packaging, generics, and strong type
checking. The class definition syntax is designed to support a software engineering approach called
"Design by Contract".
Eiffel is available from Interactive Software Engineering, Inc. Their commercial Eiffel system
compiles Eiffel to interpretable bytecodes (similar to the way Java is compiled), but for efficiency,
the bytecodes are usually translated into C code and compiled with platform-specific C compilers.
Newer versions of the Eiffel system include support for interfacing to other languages, and to
popular distributed computing schemes like COM and CORBA.
Despite Eiffel's simplicity, power, and good performance, it has not met with the broad acceptance of
C++ or Java, because there have not been a variety of free, portable Eiffel compilers. In addition,
programming with Eiffel requires significant coding discipline.
Click to view a sample Eiffel program
1987: Perl
Although there is no international standard for Perl syntax, the language
definition is informally set forth in "Programming Perl, 2nd Edition", by Larry Wall in 1987.
"Perl" stands for "Practical Extraction and Reporting Language," a reference to the purpose for which
the Perl interpreter was originally created: system administration and data reduction. It is an interpreted scripting language with extensive facilities for data manipulation and rapid
application development. Perl is basically block-structured, but also supports object-oriented
programming. The Perl language does not support the traditional notion of records or structs.
Instead, associative arrays (hashes) are provided to serve all such purposes. Similarly, Perl supports
object-oriented programming, but does not stipulate an object storage format.
Perl has gone through several major evolutionary phases. The current language version is Perl5, but
some pockets of Perl4 use still exist. Perl5 is backward-compatible with 4. In the feature list below,
features that are specific to Perl5 are marked with an asterisk.
In Perl5, code is parsed and compiled into very high-level bytecodes prior to interpreted execution.
This approach, and extensive optimization of the Perl interpreter and run-time engine, allow Perl
scripts to achieve very high performance. Perl currently does not support multi-threading, although
efforts are underway to add this important feature.
Perl is very popular in the UNIX community, and gaining acceptance in the Microsoft Windows developer
community. There is only one Perl language system; written in C to be very portable, it runs on all
UNIX platforms, 32-bit Windows, VMS, and many other systems. Perl is free. Books, tutorials, and
on-line resources for Perl are widely available, and generally of good quality. Add-on modules and
pre-built scripts for Perl are also widely available, with more being written all the time. Add-ons
for Perl are so numerous and in such wide demand that an organized replicated archive system for them
exists: the Comprehensive Perl Archive Network (CPAN).
Click to view a sample Perl program
1988: Oberon
As a follow-up to Modula-2, Niklaus Wirth finishes Oberon, a language and system
that is designed to be compact, efficient, and highly productive. In terms of compactness, the entire
Oberon distribution with compiler and libraries and operating environment fits onto 7 floppy disks.
Oberon is a procedural, block-structured language with many object-oriented features. It was designed
for computer science education, but is also suitable for general-purpose application programming.
Oberon has a Pascal-like syntax, but its semantics are richer than Pascal's. An Oberon system consists
of the Oberon language compiler along with a comprehensive operating environment.
The Oberon language offers the following features: strong type checking, separately compilable modules,
type extension and type-bound functions for OOP, run-time type identification, dynamic memory
management with garbage collection, regular complement of numeric, string, and array data types, and
dynamic module loading. Oberon, like Pascal, enforces the rule that every thing must be declared
before it is used. There are some features of other object-oriented languages that Oberon does not
offer: operator overloading, multiple inheritance, abstract interfaces, and reflection.
Several versions of the Oberon system and language exist. Oberon V4 (System 2) is the classic,
text-based system. Oberon System 3 is the newer, GUI system with advanced OOP features like
persistence and generic message passing. Oberon/F is a version of the language for embedded systems
and other 'black-box' applications. Implementations of the ETH free Oberon system are available for
some Unix systems, Linux, PCs, and Macintosh, while some commercial versions of Oberon also exist.
Click to view a sample Oberon program
1990: J
Kenneth Iverson and Roger Hui present J at the APL90 conference in 1990. Like
Iverson's earlier developed language of APL, J programming is normally conducted as an interactive
session. This is not surprising when you consider that a single line of APL or J can be the equivalent
of a large subroutine in a conventional language.
J is a interpreted mathematical/functional programming language very closely related to APL. Basically,
it is a dialect of APL with the same functionality, but employing the ASCII character set instead of
APL's original unique character set. One of the primary obstacles to the use of APL is the bizarre
font needed to display APL's notation. J removes that difficultly by employing 1- and 2-character
mnemonics for the monadic and dyadic operators in APL.
Click to view a sample J program
| History Index | Back: 1951-1970 | Next: 1991-2001 |