Welcome to the Dictionary of Programming Languages, a compendium
of computer coding methods assembled to provide information and
aid your appreciation for computer science history.
Browse the dictionary by clicking on a section:
A
B
C
D
E
F
G
H
I
JK
L
M
N
O
P
QR
S
T
UV
WXYZ+
Get a full dump of the dictionary:
List of Names
Short Form
Full Form
- O
-
Oberon
- Language type:
- Description:
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.
Commercial versions of Oberon also
exist.
- Origin:
Wirth and Gutknecht, ETH Zurich, 1985-88.
- See Also:
- Remarks:
The Oberon language and system are
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.
While Oberon has a community in the US,
it seems to be more popular in Europe.
The Juice plug-in for running web
applets in Oberon is available at the
Juice link below. It claims to be
faster than Java.
- Links:
-
-
-
-
- Date:
- Sample code:
(* Oberon module to read in numbers *)
(* average them. *)
MODULE Stats;
IMPORT Texts, Oberon;
TYPE
Stat* = POINTER TO StatRec;
StatRec *= RECORD
count: LONGINT;
total: REAL;
END;
PROCEDURE (s: Stat) Add* (REAL val);
VAR this: Stat;
BEGIN this := s;
this.total := this.total + val;
this.count := this.count + 1;
END Add;
PROCEDURE (s: Stat) Reset*;
VAR this: Stat;
BEGIN this := s;
this.total := 0.0;
this.count := 0;
END Reset;
PROCEDURE (s: Stat) IsValid*: BOOLEAN;
VAR this: Stat;
BEGIN this := s;
RETURN (this.count > 0);
END Reset;
PROCEDURE (s: Stat) Average*: REAL;
VAR this: Stat;
BEGIN this := s;
IF this.IsValid^() THEN
RETURN 0.0
ELSE
RETURN (this.total / this.count)
END Average;
END Stats;
- Objective-C
- See:
- Language type:
- Description:
Objective-C is an object-oriented language
based on C; its object support is based
on a dynamic message-passing model.
Objective-C
provides a range of OOP features:
inheritance, dynamic method invocation,
delegation, metaclasses
and dynamic object creation, a form of
garbage collection, simple persistence,
and a kind of polymorphism.
Objective-C does not support multiple
inheritance, and concurrency is not
part of the language.
The syntax of Objective-C is very similar
to C, but with additions. Unlike
C++, Objective-C does not add OOP semantics
to traditional C syntax; instead, new
syntax specifically for message passing
and class definition provide OOP support.
Objective-C offers the same data types
as C: integers and floats, arrays, structures,
unions, and pointers. Objects are a new
type; Objective-C uses a rooted class
hierarchy: all classes inherit from a root
Object class. This fact is heavily
employed by the Objective-C standard
class library.
Brad Cox invented Objective-C in the
mid-1980s as an OO
extension to C, intended to bring C
programmers some of the benefits offered
by Smalltalk. The language was
used by NeXT in the 1989-94 timeframe as
the application and library
programming language for
the NeXTSTEP and OpenStep operating systems.
Objective-C has been implemented as a C
preprocessor and as a native compiler.
At least one commercial and one free
compiler are available. Information on
Objective-C exists on the Internet but
is not easy to find.
- Origin:
- See Also:
- Remarks:
Objective-C is a very clean and simple
OOP extension to C. It is far more
dynamic than C++, allowing the easier
construction of class libraries, GUI
interfaces, and event-driven systems.
However, a free compiler for Objective-C
was not generally available until 1992,
by which time C++ had begun to dominate
commercial OOP.
The set of Objective-C class libraries
offered with the NeXT machine in 1990 was
very powerful and comprehensive;
a testament of Objective-C's expressive
power and convenience.
Objective-C is the primary programming
language for Apple's new NeXT-based OS,
Rhapsody.
- Links:
-
-
-
-
- Date:
- Sample code:
-
Obliq
- Language type:
- Description:
Obliq is an object-oriented interpreted
scripting language that supports
distributed multi-threaded computation.
The syntax of Obliq is similar to that of
Modula-3, but simpler and with no
support for type declarations. Obliq is
basically untyped, variables and fields
can hold any kind of value.
Basic data types include booleans,
integers, reals, characters, strings,
and arrays. Obliq supports a
complete set of sequential control structures
including conditional, iteration, and
exception handling forms,
as well as special control forms for
concurrency (mutexes, guarded statements).
A fairly large set of standard libraries
are defined for Obliq. These libraries
provide support for math operations, I/O,
persistence, thread control, graphics,
and animation.
Distributed computation in is object-based.
Objects can hold state, and that state is
local to a particular process. Scope of
objects and other variables is purely
lexical. Objects
can call methods of other objects, even if
those objects are on another machine on the
network.
Obliq objects are simply collections of
named fields (like Self's named slots), and
support inheritance by delegation (like Self).
The Obliq language system is an
interpreter written in Modula-3, and
employing Modula-3's network objects
capabilities. Obliq is included free
with the DEC Modula-3 distribution,
and pre-compiled binaries for some
platforms are also available. A manual
and many journal articles about the
language and its applications are
available on the web.
- Origin:
- See Also:
- Remarks:
Obliq was designed to make distributed
computation simple and easy for the
programmer, while providing program
safety and transparency with strict
lexical scoping.
The distributed computing in Obliq
is based on the powerful
network object facility provided by
Modula-3. Unlike Modula-3, however,
Obliq is interpreted and untyped, which
makes it very flexible and friendly.
Like most interpreters, Obliq supports
evaluation of dynamically generated code.
In the distributed computation context,
this means that Obliq can support mobile
agents and roaming computations.
Another common use for Obliq is 3D
animations. The standard library
provides sophisticated graphical
object rendering. This feature of
Obliq has been used to make some really
cool animations of algorithm execution.
- Links:
-
-
-
- Date:
- Sample code:
Since Obliq is normally used for distributed
computation, this example code has two parts:
Server side:
(* A server for computing factorials. *)
module FactServer;
let fact =
net_export("fact","",
{ m =>
meth(s,n)
if n is 0 then 1 else n * s.m(n-1) end
end
});
Client side:
module FactClient;
let fact = net_import("fact","");
fact.m(13);
-
occam
- Language type:
P - Parallel or Multi-programming
- Description:
Occam is a simple parallel computing language
developed to express many kinds of
parallel programs easily and directly.
Originally intended for the INMOS Transputer,
a chip built to support fine-grain
multi-processing, Occam has been implemented
for several processor and software architectures.
Syntactically, Occam is quite simple,
structure is expressed with a few simple
keywords and with indentation. Occam
supports a modest set of data types:
ints, reals, bytes, strings, and arrays.
(The original
version of Occam didn't support reals.) In
addition to simple data types, Occam defines
some kinds of parallel computing primitives
as types: channels and timers.
The semantics of Occam are based on the notion
of 'processes'. A process can be any
kind of computation (e.g. a := b + 6) and
can run in parallel with other processes.
The language provides structure to allow
processes to execute in parallel or
sequentially. Parallel processes
communicate with channels; these channels
must be declared, like variables, and
can enforce synchronizations (something
like an Ada rendezvous, but simpler and
more flexible). The language also
includes advanced facilities for multiplexing
channels and replicating processes.
Occam's model for parallel computation is
based on the seminal research by C.A.R. Hoare
and his language CSP.
The current version of the Occam language
definition is 2.1. Previously available only
as a commercial system from INMOS, various
free implementations of Occam are now
available for various platforms. Check
the links below for information and downloads.
Some of the available compilers are really
occam->C translators. Occam reference
manuals and examples are available for
download.
- Origin:
David May et al 1982, 1987.
- See Also:
- Remarks:
Occam is a fascinating little language, with
a very lean and spare set of features that
result in a powerful whole.
The language
included special features for making occam
programs efficient on the Transputer
architecture, but they're very cleanly
integrated with the rest of the syntax.
When INMOS was acquired by SGS-Thompson,
the parent company donated a lot of the
occam technology to the research community,
including utility libraries for the language.
The occam For All project, begun
in 1995, aims to provide free and
architecture-neutral occam systems and tools
for programming researchers and industry.
Occam is considered to be a good language
for learning parallel computing concepts.
It is high-level enough to be usable,
general enough for the knowlege to be
transferable to other system, and low-level
enough that you can still get into trouble.
- Links:
- Date:
- Sample code:
-- Pipelined parallel sort in occam
--(from Pountain and May, A Tutorial
-- Introduction to Occam Programming)
VAL numbers IS 100 :
[numbers + 1] CHAN OF INT pipe:
PAR
PAR i = 0 FOR numbers
input IS pipe[i] :
output IS pipe[i+1] :
INT highest :
SEQ
input ? highest
SEQ j = 0 FOR numbers - 1
INT next:
SEQ
input ? next
IF
next <= highest
output ! highest
next > highest
SEQ
output ! highest
highest := next
SEQ i = 0 FOR numbers -- get unsorted
INT unsortednumber : -- numbers
SEQ
input ? unsortednumber
pipe[0] ! unsortednumber
SEQ i = 0 FOR numbers -- dump sorted
INT sortednumber : -- numbers
SEQ
pipe[numbers] ? sortednumber
output ! sortednumber
- OPS5
- Language type:
L - Rule-based or logical
- Description:
OPS5 is a production rule programming
language for AI research
and building expert systems. The
OPS family of rule-based systems
culminated with OPS5, which has been
widely used for AI instruction and
application development.
An OPS5 program consists of a set of
production rules. Each rule has a
precedent, or set of conditions which
govern application of the rule, and an
antecedent which define actions to take
upon triggering the rule.
OPS5 supports both forward-chaining
and backward-chaining control models.
Data in the OPS5 model is handled as a set
of global state variables and records which
can be modified by the rules.
Production rules reside in "production memory",
while data values reside in
"working memory".
Primitive data types are numbers and
symbols (symbols also serve as strings).
OPS5 is weakly typed, like Lisp:
variables are not declared to have a
particular type, but can hold any type of
data placed in them.
Working memory contains objects that
bear attributes: these attributes can hold
primitive data values, vectors, or
references to other objects.
OPS5 has been largely superseded by newer
expert-system shells (such as CLIPS)
and rule-based languages (such as OPS83).
The first version of OPS5 was coded in Lisp.
Later versions were written in C for speed.
Both commercial and free academic
editions of OPS5 existed during the 1980s.
Free implementations
of OPS5 (C and Lisp) are supposedly
available.
Documentation on the language is not
easily available on the net.
- Origin:
Charles Forgy et al, 1977.
- See Also:
- Remarks:
The syntax and semantics
of OPS5 are highly specialized
for the task of writing rule-based systems
that model real-world situations.
The division of the programming model
into "production" and "working" memory
was based on cognitive psychology frameworks
of human thought processes: long-term
memory is equated to domain knowledge and
corresponds to production rules, and
short-term memory is equated to facts
about the situation at hand and corresponds
to objects in working memory.
In any OPS5 program, the toughest part is
ensuring that the right domain-specific
rule is applied to the working memory at
the right moment. OPS5 supports various
grouping and priority schemes to allow the
programmer to guide the execution of rules;
applying these facilities can be tricky.
- Date:
- Sample code:
; An OPS5 program that implements a model of
; rock climbers, from exercise solutions of
; "Expert Systems Programming in OPS5"
(literalize rock-climber
age ; young or old
style ; timid or bold
)
(p old-not-bold
(rock-climber ^age old ^style <> bold)
--->
(write (crlf) that is plausible))
(p bold-not-old
(rock-climber ^age <> old ^style bold)
--->
(write (crlf) that is quite possible))
(p error::old-and-bold
(rock-climber ^age old ^style bold)
--->
(write (crlf) There are no old, bold rock climbers))
(make rock-climber ^age young ^style bold)
-
Orca
- Language type:
P - Parallel or Multi-programming
- Description:
Orca is a parallel-programming language based
on a shared-object data model, designed to
be compiled, and intended for portable
application development across a variety
of multiprogramming architectures.
The syntax of Orca is based on that of
Modula-2, and Orca supports the same
sequential control constructs that
Modula-2 does. Primitive data types in
Orca include characters, integers, and
reals.
Orca also supports arrays, and a
high-level graph type. The programmer
can define new Abstract Data Types (ADTs),
with data attributes and operations.
Orca is a strongly-typed language, designed
so that the compiler can catch a wide variety
of semantic errors.
The fundamental notion for parallelism in
Orca is that running programs on
different processors can share arbitrary
data structures, but that operations on
those structures are automatically
indivisible. This is essentially a
simple model for distributed objects,
and provides the
programmer with a good deal of flexibility
in implementing the elements of a parallel
system, while removing some of the low-level
worries encountered with
message-passing systems.
An alpha distribution of Orca can be
obtained from its principal developer,
Dr. H.E. Bal at Vrije University.
Information about the system on-line
consists mostly of journal and conference
papers about Orca and its original target
platform, Amoeba.
- Origin:
Bal, Kaashoek, Tannenbaum et al, 1985-90.
- See Also:
- Remarks:
Orca provides a high-level shared data model
for parallel programming, in contrast to
systems that employ explicit
message passing (e.g. Occam)
and those that use paged
shared virtual memory.
Orca is used as a research vehicle for
exploring parallel algorithms and
mechanisms for efficient data handling in
parallel systems.
The current implementations of the Orca
run-time environment are built to run on
top of a service layer named Panda.
The Panda virtual machine
provides communication and
thread support, hiding the system-dependent
details of these services from running
Orca programs. Orca runs on a variety
of parallel computers, as well as
Solaris and other general-purpose Unix
systems.
An early version of Orca was used as the
expository language in the book
Programming Distributed Systems.
- Links:
- Date:
- Sample code:
# An example object from the paper
# "Experiences with the Orca Programming Language"
# by Bal and Wilson
OBJECT IMPLEMENTATION buffer;
CONST MAXSIZE = 10; # Maximum size of the buffer
# Local state of the object:
buf:ARRAY[integer 0..MAXSIZE-1] OF integer; # the buffer itself
in, out: integer; # index of next element to put/get
size: integer; # current size
OPERATION put(x: integer);
BEGIN
GUARD size ! MAXSIZE DO # blocks until there is room
buf[in] := x; # store element
in := (in + 1) % MAXSIZE; # bump input index
size +:= 1; # increment size
OD;
END;
OPERATION get(x: OUT integer);
BEGIN
GUARD size ? 0 DO # blocks while buffer is empty
x := buf[out]; # retrieve element
out := (out + 1) % MAXSIZE; # bump output index
size -:= 1; # decrement size
OD;
END;
END;
-
Oz
- Language type:
- Description:
Oz 2 is a declarative
concurrent programming language
that supports object-oriented and
functional
programming with constraint propagation.
It was created as a research
vehicle for advanced language design, AI,
and concurrent system design.
Primitive simple data types in Oz include
integers,
reals, characters, strings, booleans, atoms,
threads, objects, and functions.
The language also supports a flexible set
of aggregate types: records, tuples, lists,
and arrays.
All predefined Oz types are arranged in a
type hierarchy, and inheritance relationships
in the hierarchy can be used as part of the
type system and constraint rules.
Oz supports the usual sequential control
structures, like conditionals and loops, as
well as parallel versions of them. It also
has exception handling constructs.
The Oz object system supports encapsulation,
inheritance, generics, and other OOP features.
Like most functional languages, Oz has
full automatic memory management and
garbage collection. Like most
parallel programming languages, it has
synchronization primitives for serializing
access to objects. Thread creation in
Oz 2 is always explicit.
Oz uses a constraint programming system
called finite domain constraint
propagation. Constraint propagation
runs concurrently with other program
activities.
Oz 2 has been implemented on Unix systems
and Windows, a distribution may be obtained
from DKFI in Germany. Good documentation is
available at the language's web site.
- Origin:
G. Smolka with Schulte, Henz, Muller, Wurtz et al, DFKI, 1994-97.
- See Also:
- Remarks:
The current Oz language is Oz 2.0. The
original Oz 1 was less capable and
somewhat different than its successor,
in that it had an extremely fine-grain
concurrency model, and a much less
capable constraint propagation system.
Oz 3, which is under development, is
supposed to be a lot like Oz 2.
Oz 2 supports GUI programming by allowing
calls to the Tk graphics toolkit.
- Links:
-
-
- Date:
- Sample code:
- 7 entries retrieved.
Descriptions in this dictionary are ©1997-99 Neal Ziring. Some
examples copyright of their respective authors. Some
technologies and languages are trademarked. Permission to
copy descriptions is granted as long as authorship credit is preserved.
Comments on this dictionary, corrections and suggestions, are all welcome.
Please use email, the address is ziring@home.com
[Ziring MicroWeb Home]
[Dictionary Start]
[Sign Guestbook]
Dictionary and script maintained by Neal Ziring, last major modifications 3/18/98. Most recent
additions to dictionary and master list, 1/00.