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
- I
-
ICI
- Language type:
- Description:
ICI is an interpreted structured language
reminiscent of C. It is essentially
a scripting language, intended for application
development.
ICI's syntax is similar to that of C, but
it provides a high-level data model intended
to reduce programmer effort and errors.
Primitive data types in ICI include
integers, reals, strings, files, safe
pointers, and regular expressions.
Aggregate data types are arrays, sets,
and associative tables. Sets
can be heterogenous, nested, and support
the usual set operations: union, intersection,
etc. All data structures in ICI
are dynamic, and the language environment
provides memory management and garbage
collection. Control structures in ICI
include the usual loops and conditional
statements, plus a simple error
handling construct. The language supports
subroutines and nested modules. All variables
are lexically scoped at the subroutine
or module level, but unlike most
structured languages, ICI allows the
current scope to adjusted (Tcl, for example,
also allows this).
Although ICI is not object-based,
many object programming features can be
emulated in the language by using data
structure inheritance feature called
super-structures.
To support application development, ICI
has C-like file I/O and system interface
support, as well as a high-level event
trigger facility. The language also has
a modest standard library of built-in functions.
There is only one implementation of ICI;
the current version is 2.02, and it
runs on Unix systems, DOS, Windows, Macintosh,
and some other computers. Documentation
is spare and somewhat outdated, and is
available for download but not on-line
browsing.
- Origin:
- See Also:
- Remarks:
ICI is pronounced icky.
An overview by an ICI author places the
language mid-way between scripting languages
like Perl and development languages like
Java. The claim is that ICI is faster than
Perl but slower than Java, a peculiar claim
since Perl and Java each out-perform the
other in different circumstances. Still,
ICI does provide sophisticated data structures
like Perl, but with a comfortable C-like
syntax.
The home of ICI is Canon Information Systems
Research Australia, but the language is
in the public domain.
- Links:
-
- Date:
- Sample code:
/* A program to count words in input files
* (from examples at the ICI web site)
*/
static count_tokens(in)
{
auto count;
count = 0;
while (gettoken(in)) ++count;
return count;
}
if (argc < 2) printf("%d\n", count_tokens(stdin));
else
{
auto f, fn, total;
total = 0;
forall (fn in interval(argv, 1))
{
if (fn == "-")
count = count_tokens(stdin);
else
{
auto count;
count = count_tokens(f = fopen(fn));
close(f);
}
printf("%s %d\n", fn, count);
total += count;
}
if (argc > 2) printf("Total %d\n", total);
}
-
Icon
- Language type:
- Description:
Icon is a procedural language with
high-level semantics for string and
data aggregate processing. The language
definition includes a large number of
operators and funtions for manipulating
strings and sequences, as well as novel
semantics: conventional imperative control
structures and goal-directed backtracking.
Built-in data types in the language
are integers, reals, strings (text),
sets, lists, arrays, associative tables,
files, and records. Icon variables
are typed, but the language
performs automatic type casting, so
it cannot be said to support strong
type checking in the sense of Ada or
Modula-2.
Icon also supports a very simple
form of exception handling; procedures
can return one or many values, or they
can fail. Failures do not automatically
propogate up the procedure call stack as they
do in Java or C++.
Icon is not object-oriented, but an
object-oriented extension called Idol
has been available since 1996.
Icon is normally interpreted, but there
is also a translator that generates
compilable C code from Icon code. Icon
was originally implemented for UNIX, but
has been ported to VMS, MS-DOS, 32-bit MS-Windows,
OS/2, and the Macintosh.
Icon is distributed with a
standard library; most platforms also
support a GUI library. The
Icon distribution also includes example
programs and documentation. Icon
implementations are available free from
the U. of Arizona ftp site.
- Origin:
- See Also:
- Remarks:
Icon is currently an academic project
living at the University of Arizona.
Research topics include OOP extensions,
porting to WindowsNT, optimizing
compiler improvements, and transparent
Internet access.
- Links:
-
-
- Date:
- Sample code:
# Example from New Mexico Tech Icon
# tutorial by John Shipman
procedure Quadratic_Roots ( a, b, c )
# Generates the real roots of ax^2+bx+c=0.
local d # Discriminant
d := b ^ 2 - 4.0 * a * c; # Compute the discriminant
if d > 0 then
{ #-- Two roots
suspend ( - b + sqrt ( d ) ) / ( 2.0 * a );
suspend ( - b - sqrt ( d ) ) / ( 2.0 * a );
} #-- Two roots
else if d = 0 then
suspend - b / ( 2.0 * a );
fail; # No more roots
end
procedure main ()
local root # Holds each root generated by the solver
local count # Counts the number of roots returned
count := 0;
every root := Quadratic_Roots ( 1, -4, 3 ) do
{ #-- The braces {} group the next two statements together
write ( "One solution is: x = ", root );
count +:= 1; # Count the roots generated
}
write ( "The number of solutions was ", count );
end
-
INTERCAL
- Language type:
- Description:
Intercal is a compiled language deliberately
designed to be convoluted,
difficult to program, difficult to read,
unlike all other languages, and yet still
computationally complete.
The syntax of Intercal does not resemble
any other computer language, but does
in some respects resemble the appearance of
a FORTRAN program recovered from a bad
disk sector and then sent through a cheap
fax. Only two primitive data types are
supported: 16-bit and 32-bit unsigned integers.
Intercal supports arrays, but no other
data structures. Intercal provides exactly
five primitive operations on data:
- binary bit-level interleave
- binary bit selection with packing
- unary bit-wise and
- unary bit-wise or
- unary bit-wise exclusive-or
Strangely enough, this set of operators
can be used to build normal integer
arithmetic.
Data-flow constructs in Intercal are
similarly conventional, that is to say, unique.
One kind of Goto is provided that pushes
its return address onto a fixed-size stack.
Mechanisms for disabling statement, both
unconditionally and with fixed probability,
are also provided.
Later versions of Intercal also provide
the unique 'Come From' statement. While
Intercal does not support subroutines,
a similar facility can be constructed with
some effort.
Intercal does provide I/O, after a fashion.
The original edition of the language could
read and write only numbers, and had the
interesting disability of being totally
unable to read in its own output. Later
versions of Intercal provide a bit-oriented
I/O facility that based on a model of the
differential movement of a Turing machine
tape.
The Intercal reference defines a standard
library for operations that are difficult
to implement in the language, like
addition, subtraction, multiplication, and
random number generation.
Intercal was originally implemented for
IBM mainframes, but since about 1990 a
version called C-Intercal has been available
for Unix platforms. An implementation is also
available for MS-DOS. Information about
Intercal is freely available on the web,
and documentation and sample programs are
included with the distribution.
- Origin:
D.R. Woods and J.M. Lyons, 1972.
- See Also:
- Remarks:
Intercal originated as a bad joke by two
computer scientists at Princeton University.
However, their manual for Intercal-72,
as it is now called, was
so hilarious that this horrible
programming language has continued to be
implemented (!) and extended (!!)
fitfully ever since.
Here are a few highlights:
- The original Intercal used overstruck
characters for several operators
- The simplest way to store the value
65536 into a 32-bit variable in Intercal
is DO :1 <= #0$#256.
- The shortest Intercal program known that
can copy its input to its output is 23 lines.
- Intercal has no comment syntax, but it
is possible to get the effect of a comment
by beginning a line with Please Note
by taking advantage of the "Not" in "Note".
- It has been proven that Intercal is
Turing-complete.
Here is one of my
favorite quotes from the original
Intercal manual:
INTERCAL's main advantage over other programming
languages is its simplicity. It has few
capabilities, and thus there are few
restrictions to be kept in mind. Since it is an
exceedingly easy language to learn, one might expect
it would be a good language for initiating
novice programmers. Perhaps surprising,
than [sic], is the fact that it would be more
likely to initiate the novice into a search
for another line of work.
- Links:
-
-
-
-
- Date:
- Sample code:
PLEASE NOTE THIS PROGRAM PRINTS A LIST
PLEASE DO NOT ASSUME THAT THE NUMBERS ARE COMPOSITE
PLEASE NOTE THIS PROGRAM WAS SWIPED FROM LOUIS HOWELL
DO READ OUT #2
DO .10 <- #1
PLEASE COME FROM (23)
DO .11 <- !10$#1'~'#32767$#1'
DO .12 <- #1
PLEASE COME FROM (16)
DO .13 <- !12$#1'~'#32767$#1'
DO .1 <- .11
DO .2 <- .13
DO (2030) NEXT
DO (11) NEXT
(15) DO (13) NEXT
(13) DO .3 <- "?!4~.4'$#2"~#3
DO (14) NEXT
PLEASE FORGET #1
DO .1 <- .12
DO (1020) NEXT
(16) DO .12 <- .1
(12) DO .3 <- '?.2$.3'~'#0$#65535'
DO .3 <- '?"'&"!2~.3'~'"?'?.3~.3'$#32768"~"#0$#65535"'"$
".3~.3"'~#1"$#2'~#3
(14) PLEASE RESUME .3
(11) DO (12) NEXT
DO FORGET #1
PLEASE READ OUT .11
DO COME FROM (15)
DO .1 <- .10
DO (1020) NEXT
DO .10 <- .1
(23) DO (21) NEXT
(22) PLEASE RESUME "?!10~#32768'$#2"~#3
(21) DO (22) NEXT
DO FORGET #1
PLEASE GIVE UP
(2010) PLEASE ABSTAIN FROM (2004)
(2000) PLEASE STASH .2
DO .2 <- #1
DO (2001) NEXT
(2001) PLEASE FORGET #1
DO .1 <- '?.1$.2'~'#0$#65535'
DO (2002) NEXT
DO .2 <- !2$#0'~'#32767$#1'
DO (2001) NEXT
(2003) PLEASE RESUME "?!1~.2'$#1"~#3
(2002) DO (2003) NEXT
PLEASE RETRIEVE .2
(2004) PLEASE RESUME #2
PLEASE DO REINSTATE (2004)
PLEASE RESUME '?"!1~.1'~#1"$#2'~#6
(2020) PLEASE STASH .2 + .3
DO (1021) NEXT
(2030) DO STASH .1 + .5
DO .3 <- #0
DO .5 <- '?"!2~.2'~#1"$#1'~#3
PLEASE DO (2031) NEXT
DO .4 <- #1
PLEASE DO (2033) NEXT
(2033) DO FORGET #1
DO .5 <- '?".2~#32768"$#2'~#3
DO (2032) NEXT
DO .2 <- !2$#0'~'#32767$#1'
PLEASE DO .4 <- !4$#0'~'#32767$#1'
DO (2033) NEXT
(2032) DO (1001) NEXT
(2036) PLEASE FORGET #1
DO .5 <- '?.1$.2'~'#0$#65535'
DO .5 <- '?"'&"!2~.5'~'"?'?.5~.5'$#32768"~"#0$#65535"'"$
".5~.5"'~#1"$#2'~#3
DO (2034) NEXT
DO .5 <- .3
DO (1010) NEXT
PLEASE DO .1 <- .3
DO .3 <- 'V.4$.5'~'#0$#65535'
DO (2035) NEXT
(2034) PLEASE DO (1001) NEXT
(2035) DO FORGET #1
DO .5 <- "?'.4~#1'$#2"~#3
DO (2031) NEXT
DO .2 <- .2~#65534
DO .4 <- .4~#65534
PLEASE DO (2036) NEXT
(2031) DO (1001) NEXT
PLEASE DO .4 <- .1
PLEASE RETRIEVE .1 + .5
PLEASE RESUME #2
- Interlisp
- See:
- Language type:
F - Functional or lambda-based
- Description:
Interlisp was a dialect of Lisp, derived
from BBNLisp, that was used for
research at Xerox PARC. Various
implementations were made for different
computers, the most popular and influential
of which was Interlisp-D.
- Origin:
Teitelman and Masinter, Xerox PARC, 1965-1975
- See Also:
- Date:
- 4 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.