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:
Get a full dump of the dictionary:
List of Names
- Language type:
Unified Functions and Objects (UFO) is an
object-oriented functional language
designed for implicit parallelism.
The syntax of UFO is fairly simple and
lexical aspects are reminiscent of Algol.
All UFO functions
are side-effect-free, but the bodies
of functions allow local variables.
Fundamental data types supported by the
language include integers, floats,
chars and strings,
and booleans. Arrays are also supported,
with list expressions for generating
numeric and other sequences.
Control flow constructs include conditional
expressions and loops; the loop constructs
can generate arrays automatically.
UFO supports class definition with
single inheritance, virtual classes, and
stateless classes (similar to Java
interfaces). Generic, or parameterized,
functions and classes are also supported.
In its role as a functional language, UFO
allows the programmer to define
higher-order functions and build up
Scheme-like functional mechanisms.
UFO has a modest library of built-in classes,
and I/O facilities.
UFO is available free from the authors,
it is currently at version 1.0.
- See Also:
UFO is essentially an academic project,
meant to show how functional and OO
features can be combined in a language
that allows automatic identification
and exploitation of concurrency.
The current (1.0) implementation
compiles UFO down to the dataflow
intermediate language UFlow.
Unlike a pure functional language,
UFO does support stateful classes with
procedures, but they are not the
usual way of programming.
- Sample code:
** An example numerical integration program
** from the UFO1.0 Tutorial by J. Sargeant.
polyf (x : Float) : Float is
2*x*x + 6*x + 1
trap(f: Float -> Float; a,b,approx : Float; n : Int) : Float is
h = (b - a) / n;
return approx/2 + h*
initially s = 0.0;
for i in [1 to n step 2] do
x = a + i * h ;
new s = s + f(x) ;
integrate(f : Float -> Float; a, b: Float) : Float is
initially done = false;
n = 1 ;
integral = (f(a) + f(b)) * (b - a) / 2;
while not done do
next_integral = trap(f, a, b, integral, 2 * n) ;
new n = 2 * n ;
new done = abs(next_integral - integral) < 1.0e-4
new integral = next_integral
main : String is
"Integral is " ++ print(integrate(Float|polyf, 1.0, 6.0) ++ "\n"
- Language type:
T - Threaded or stack-based
Until is an interpreted dialect of Forth
designed for portability and for use as
an embedded extension language.
Unlike most Forth implementations,
Until is designed to provide easy access
to underlying operating system services,
and to be easily integrated with C programs.
Source code for the Until implementation
is supposedly available, targetted mainly
at MS-DOS but supposedly portable to Unix
- See Also:
Development of Until seemed to
stop sometime in the mid-1990s.
- 2 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 firstname.lastname@example.org
[Ziring MicroWeb Home]
Dictionary and script maintained by Neal Ziring, last major modifications 3/18/98. Most recent
additions to dictionary and master list, 1/00.