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
- R
-
REBOL
- Language type:
F - Functional or lambda-based
- Description:
REBOL is a functional scripting language
with message-passing and
object-oriented features. It is
designed for general application and
network service development.
Intended to support both simple scripts
and larger projects, REBOL has a fairly
large complement of primitive data types:
numbers, time, date, money, strings, booleans,
words (atoms), and more. It also supports
tuples and other primitive data aggregations,
as well as application-oriented types like
files, URLs, and email addresses.
The primary grouping construct in REBOL
is the block, it is used for both
data and code aggregation (the way lists
are used in Lisp and Scheme).
The
evaluation and code structure concepts
of REBOL
resemble those of most other functional
languages. As a first-class functional
language, REBOL stores everything as data
with a definite type; functions and objects
are merely data constructed according to
convention understood by the interpreter.
The REBOL core language has quite a few
advanced features, consult the web sites listed
below for details. Some of the
supported features
are: automatic memory management (gc),
reflection, higher-order functions,
exception handling, and dialecting.
There is only one existing implementation of
REBOL, it is an interpreter that runs on
a wide variety of operating systems.
The system can be downloaded free, or
purchased.
- Origin:
- See Also:
- Remarks:
REBOL stands for Relative Expression-based
Object Language. The design of the language
is purportedly based on five principles:
simplicity, productivity, communications,
independence, and humanity.
Future versions of REBOL are planned, and
may support multi-threading, a GUI
toolkit, Unicode/I18N support, and
multimedia.
- Links:
-
-
- Date:
- Sample code:
REBOL [
Title: "99 Bottles of Beer on the Wall in REBOL"
Author: Neal Ziring
Email: ziring@home.com
Date: 17-Oct-1998
File: %99beer.r
Version: #REBOL-1-0-1
Purpose: "Print the famous iterative beer song"
Comment: {
This is an example of a program in REBOL that
prints the famous 99 bottles of beer on the
wall song. For more information on REBOL
go to the web site www.rebol.com.
This program is deliberately over-complicated
to hot-dog some fancy features of REBOL.
}
]
song: [
Verse [ [if num > 0 [num] else ["No more"] ] " "
[if num == 1 ["bottle"] else ["bottles"] ]
" of beer on the wall,"
1
[if num > 0 [num] else ["No more"] ] " "
[if num == 1 ["bottle"] else ["bottles"] ]
" of beer!"
1
"Take one down, pass it around!"
1
[if num - 1 > 0 [num - 1] else ["No more"] ] " "
[if num - 1 == 1 ["bottle"] else ["bottles"] ]
" of beer on the wall."
2
]
Finale [ "Time to buy more beer!" 1 ]
]
processItem: func [item num] [
if integer? item [loop item [prin newline] ]
if string? item [prin item]
if block? item [ftmp: func [num] item prin ftmp num ]
exit
]
dosong: func [start] [
bottlesleft: start
until [
foreach item song/Verse [processItem item bottlesleft]
bottlesleft: bottlesleft - 1
(bottlesleft == 0)
]
foreach item song/Finale [processItem item 0]
return none
]
dosong 99
-
Reduce
- Language type:
M - Mathematical or Simulation
- Description:
Reduce is a system for computer algebra and
symbolic mathematics, featuring a language
named Reduce in which users can define new
functions and symbolic computation rules.
The expression syntax of Reduce is similar
to that of FORTRAN, but with a variety of
extensions for symbolic operations.
The following data types are supported:
integers, reals, rationals, and complex
numbers, all infinite-precision, strings,
matrices, arrays, and patterns.
Reduce supports definition of procedures and
functions, but has no support for
object-oriented programming or package
structure.
Reduce is written in Lisp, and the source
code for the kernel is normally supplied
with the distribution. There is a
low-level extension language under Reduce
, but above Lisp, called RLisp. RLisp is
used in some versions of Reduce for code
efficiency or to build complicated data
structures.
Reduce is available as a
commercial product for most computer
platforms.
Free demo versions are also available.
- Origin:
Anthony Hearn, RAND Corp, 1963.
- See Also:
- Remarks:
Reduce was one of the earliest portable
symbolic computation systems. Implemented
in a dialect of Lisp called
Portable Standard Lisp, Reduce was widely
used in industry and academia.
While Reduce is not as large or sophisticated
as some more recent symbolic math systems
(e.g. Maple, Mathematica), its long history
and stability have earned it a loyal
following. Also, a great many libraries
for specialized scientific and
engineering calculations have been developed
for it.
While the syntax of Reduce resembles that of
Fortran in some respects, it was originally
based on Algol and actually resembles Algol60
more than it does Fortran.
Formerly, Reduce had been available to
academic institutions for free. The
current version of Reduce is 3.6.
- Links:
-
-
-
- Date:
- Sample code:
A polynomial GCD routine from REDUCE -
Software for Algebraic Computation by G. Rayna.
PROCEDURE EUCLID(A,B,X);
BEGIN
SCALAR R,Q,AA,BB,SA,SB,SR,D;
CLEAR FIRST,SECOND;
AA := A; BB := B;
SA := FIRST; SB := SECOND;
WHILE (R := POLYREM(AA,BB,X)) NEQ 0 DO
<<ON GCD;
Q := (AA - R) / BB;
OFF GCD;
SR := SA - Q * SB;
D := DEN Q;
SA := SB * D; SB := SR * D;
AA := BB * D; BB := R * D>>;
RETURN SB
END;
-
Rexx
- Language type:
- Description:
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.
An ANSI standard for Rexx is available,
the standard was created by the X3J18 committee
and is designated X3.274-1996. A pre-pub
draft is available on-line from
here.
Various superset dialects of Rexx exist, providing
a variety of extensions: ObjectRexx supports
object-oriented programming, and NetRexx
provides a variety of network interface and
I/O facilities.
Both free and commercial implementation of
Rexx are available. Most are interpreters
only, but a few Rexx compilers also exist.
Information about the language is freely
available from IBM, various academic
institutions, and the Rexx Language Association.
- Origin:
M. Cowlishaw, IBM, 1979 - 1985.
- See Also:
- Remarks:
Rexx was originally invented as a sophisticated
command language for IBM mainframe environments (MVS, CMS).
It 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.
- Links:
-
-
-
- Date:
- Sample code:
/* Subroutine example from Ian Collier's tutorial, */
/* stand-in until I get a more extensive example. */
/* Calculate factorial x, that is, 1*2*3* ... *x */
parse pull x .
say x"!="factorial(x)
exit
factorial: /* calculate the factorial of the argument */
procedure
parse arg p
if p<3 then return p
else return factorial(p-1) * p
-
RPG
- Language type:
D - Database or Text-processing
- Description:
RPG, Report Program Generator, is a
high-level database access and text
generation language invented for
mainframe MIS environments.
The RPG language is designed around
the programmer's presumed goal: generating
informative large-scale reports from
mainframe databases. To this end, RPG
supports input forms definition,
database access, and
very extensive output formatting facilities.
Because it is mainly intended for
formatting and presenting data, RPG does
not have very extensive computational
support, but most versions have at least
a minimal set of sequential control-flow
operators, support for subroutines, etc.
Data types in RPG include integers,
fixed-format numbers, reals, strings, and
records. Often, data types and records
are declared as having a particular print
format (like in COBOL) and the compiler
takes care of choosing a suitable internal
representation.
The lexical structure of RPG is column/card
oriented. Programs consist of four
distinct sections: file description, input
formats, calculation, and output formats.
RPG-IV (1994) added another section: the
subprocedures section.
RPG programs are typically compiled.
They must be supported by an extensive
run-time environment that provides I/O
and data management services.
Commercial implementations of RPG
are available from IBM, Lattice, and
other companies. There are no free
implementations. Books are RPG programming
are widely available from commercial
publishers.
- Origin:
- See Also:
- Remarks:
There were several dialects or versions of
RPG over the years: IBM created RPG for the
System/360 (1964), RPG-II for the System/3
(1965), RPG-III, RPG/400 for the AS/400,
RPG-IV, and Visual
Age for RPG. Other companies produced
versions of RPG-II and RPG/400 for
MS-DOS and Windows operating systems.
RPG's support for different kinds and formats
of textual output is very broad. RPG/400
has at least 20 different output field types.
IBM's newest RPG products allow the developer to
create graphical user interfaces for
forms input and output presentation.
- Links:
-
-
-
- Date:
- Sample code:
-
Ruby
- Language type:
- Description:
Ruby is an interpreted scripting language,
fully object-oriented and designed for
easy extensibility.
The syntax of Ruby is simple but bears a
strong resemblance to Perl. All data
types in Ruby are object classes, like in
Smalltalk. Pre-defined data types include
integer and float numeric types, strings,
arrays and hash tables, and structures.
Control constructs in Ruby include a
wide variety of conditionals and
several kinds of loops, along with several
controls structure variations like
break and continue.
Ruby does not have declarations; variables
are weakly typed, and their scope is
denoted by prefixes.
Ruby supports many important OO
features, including classes with
inheritance, class methods, and even
closures. Ruby also supports
exceptions with functionality
similar to that of Java.
Ruby supports a variety of kinds of
introspection, including Java-style reflection
and Lisp-style enumeration of active objects.
The syntax of Ruby's reflection support is
simpler than that of Java.
Ruby does support threading.
There is only one implementation of Ruby;
it is free open-source. Documentation for
Ruby is available on the WWW, and there
are also several published books about
the language.
- Origin:
Y. Matsumoto and others, 1993-95.
- See Also:
- Remarks:
The current version of Ruby is 1.6.5,
as of Sep 2001; it
is available for Linux and other Unix
systems, Windows, and some other
platforms. Ruby is normally distributed
as source code, but pre-compiled binaries
are available for many of the supported
platforms.
While Ruby resembles Perl in many respects,
it differs substantially in its representation
of data. Perl treats numeric data, strings,
lists, and hashes as built-in types, while
Ruby implements everything as objects.
Another interesting aspect of Ruby is its
notion of Modules. A class can implement
any number of modules; they are similar
to Java interfaces and to Flavors Lisp
mix-ins.
There are many extension libraries and
toolkits available for Ruby, including
database, network, GUI, IO libraries.
The Ruby OOP language is at least the 3rd
programming language to bear that name.
The first was a teaching language Ruby
from the late 1960s, it was based on
Markov processes. The second was a
hardware specification language based on
higher-order functions, from the mid-1980s.
- Links:
-
-
-
-
- Date:
- Sample code:
A sample from the Ruby distribution, a simple
sieve.
# sieve of Eratosthenes
max = Integer(ARGV.shift || 100)
sieve = []
for i in 2 .. max
sieve[i] = i
end
for i in 2 .. Math.sqrt(max)
next unless sieve[i]
(i*i).step(max, i) do |j|
sieve[j] = nil
end
end
puts sieve.compact.join ", "
- 5 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.