BastEt 阅读(5277) 评论(5)
HyperNews Home
Using HyperNews (Instructions)
 HYPERNEWS COMPUTER LANGUAGE LIST v1.4

These definitions have been culled from existing programming language sources, the language
designer's web pages, books, articles and language critiques. They are by no means meant to
be the definitive language definitions, but rather quick and painless definitions and links to
available language web sites and newsgroups. My sources are listed in Parts 3 & 5.
Special Thanks to Dr John Stockton.
Corrections, omissions, and any feedback is encouraged and appreciated.
Please support Open Source.

Eric Lebherz March 26, 2002
EricLebherz@yahoo.com


CONTENTS

Part 1 - Definitions of Computer Language Families
Part 2 - Definitions of Computer Languages
Part 3 - Links to Essential Computer Language Web Sites
Part 4 - Links to Computer Language Software
Part 5 - Sammet's 26 Most Significant Programming Languages, By Year
Part 6 - Bibliography
Part 7 - Abbreviations



PART 1 DEFINITIONS OF COMPUTER LANGUAGE FAMILIES

APPLICATIVE LANGUAGES- operates by application of functions to values. A functional
language in the broad sense.

ASSEMBLY LANGUAGES- a symbolic representation of the machine language of a
specific computer.

CONCURRENT LANGUAGES- describes programs that may be executed in parallel. this
may be either: multiprogramming, sharing one processor, multiprocessing- separate
processors sharing one memory distributed.

CONSTRAINT LANGUAGES- languages in which a problem is specified and solved by a
series of constraining relationships.

DATAFLOW LANGUAGE- language suitable for use on a dataflow architecture.
Necessary properties include freedom from side effects, and the equivalence of scheduling
constraints with data dependencies. Examples: Val, Id, SISAL, Lucid.

DECLARATIVE LANGUAGES- operates by making desriptive statements about data and
relations between data. The algorithm is hidden in the semantics of the language. This
category encompasses both Applicative and Logic languages. Examples of declarative
features are set comprehensions and pattern-matching statements.

DEFINITIONAL LANGUAGES- an applicative language containing assignments
interpreted as definitions.

FUNCTIONAL LANGUAGES- in the narrow sense, operates on higher-order functions,
building operators that manipulate functions directly without ever appearing to manipulate the
data.

IMPERATIVE LANGUAGES- operates by a sequence of commands that change the value
of data elements. Typified by assignments and iteration.

INTERMEDIATE LANGUAGE- a language used as an intermediate stage of compilation.
May be text or binary.

LOGIC LANGUAGES- deals with predicates or relationships. Logic languages try
alternatives for each goal in succession, backtracking in a search for a common solution.

METALANGUAGE-a language used for the formal description of another language.

PROCEDURAL LANGUAGES- which states how to compute the result of a given
problem.Each statement in the language tells the computer to do something.A procedural
program is "a list of instructions". Encompasses both imperative and functional languages.

QUERY LANGUAGES- an interface to a database.

SINGLE ASSIGNMENT LANGUAGE- an applicative language using assignments with the
convention that the variable may appear on the left side of an assignment only once within the
portion of the program in which it is active.

SPECIFICATION LANGUAGES- a formalism for expressing a hardware or software
design.




PART 2 DEFINITIONS OF COMPUTER LANGUAGES


A#- OO and functional, a separate component of Version 2 of the Axiom computer algebra
system. Both types and functions are first class values. Designed for compilation to efficient
machine code.

ABC-for personal computing, originally intended as a replacement for BASIC.ABC is easy
to learn (an hour or so for someone who has programmed before) and is easy to use.
Originally intended as a language for beginners, it has evolved into a powerful tool for
beginners and expert alike.
http://www.cni.nl/~steven/abc

ABEL- (Advanced Boolean Equation Language) allows you to enter behavior-like
desriptions of a logic circuit. Developed by Data I/O Corp. for programmable logic devices.
Other hardware desription languages include: VHDL and VERLOG, but ABEL is simpler.
ABEL can be used to describe the behavior of a system in a variety of forms including logic
equations, truth tables, and state diagrams using C-like statements.
The ABEL compiler allows designs to be simulated and implemented into PLD's such as
PAL's, CPLD's, and FPGA's.
http://www.ee.upenn.edu/ra/software/abel/abel.primer.h

ABCL- a family of languages developed by Akinori Yonezauwa and his lab, for OO
concurrent programming. These languages are based on LISP or SCHEME core with
primitives for OO concurrency. The language was further extended to use computational
reflection to manage distributed computing and other language extensions in a way that is as
seamless as possible to the user.

ACCENT- a very high-level interpreted language from Caseware, Inc with strings and
tables. It is strongly typed and has remote function calls.Interpreter

ACTOR- OOL for MS Windows. PASCAL-like syntax. Uses a token-threaded interpreter.
Early binding is an option. Written by Charles Duff of the Whitewater Group. ca 1986.

ACTOR- OOL for MS Windows. PASCAL/C-like syntax. Uses a token-threaded
interpreter. Early binding is an option. Written by Charles Duff of the Whitegroup, 1986.

ADA- powerful, general-purpose language with built-in conccurrency, exception handling,
generic templates, distributed execution, standard and de facto interfaces to other languages
and libraries. ADA compiles to just about any OS out there.
Strongly influenced by PASCAL, and at one time mandatory for Dept. of Defense software
projects at the Pentagon.
ADA is a large, complex block-structured language aimed primarily at embedded computer
applications. It has facilities for real-time response, concurrency, hardware access, and
reliable run-time handling. So much for the pros.
Now the cons: it was designed by committee, its crockish, difficult to use, and overall a
disastrous, multi-billion dollar boondoggle. Hackers find ADA's exception handling and
interprocess communications features particularly hilarious. The kindest thing that can be said,
is that there is probably a good small language screaming to get out of it's elephantine bulk.
http://home.hiway.net/~crispen/ada
comp.lang.ADA

ADL-(Assertion Definition Language) is a formal grammar for descibing the behavior of
interfaces. This very general concept can be applied to any interface for which the behavior
can be described. ADL is a very large C++ compilation, and as such, requires a robust C++
compilation system in order to be built. ADL's development team has had great success with
GNU's GCC compiler.
Developed by X/Open company Ltd and the Suntest Division
of Sun Microsystems Laboratories working closely with MIT's Information Technology
Promotion Agency in the research area of Automated Test Technology.
http://adl.opengroup.org

AGORA- is a prototype-based language solely based on message passing, developed at the
Programming Tech Lab of Brussels Free University, Dept. of Computer Science.
It incorporates features like method based inheritance, reflection and encapsulated
inheritance of objects, and has a clean formal foundation.

AKL- (Agents Kernel Language) concurrent, constraint programming language.
Computation is performed by agents interacting through stores of constraints. This notation
accommodates multiple programming paradigms; in appropriate contexts, AKL agents may
be thought of as processes, objects, functions, relations, and constraints.
Developed at the Swedish Institute of Computer Science.

ALEF- concurrent language for systems programming. It has a C-like syntax, but a different
type system. Exception handling, process management and sychronization primitives, both
shared variables and message passing. A windows system, user interface, OS network,
newsreader, and a mailer.

ALEPH- combines the functional programming technology with the OO paradigm, designed
to be compatable with C++ run-time operations.
Implementation is a multi-threaded interpreter with an automatic protection engine for shared
objects.
ALEPH is a powerful engine associated with a rich library. The interpreter is completely
written in state-of-the-art C++. It has a rich set of features providing run-time compatability
with C++. The engines runs on both 32 bit and 64 bit platforms. It is designed to be portable
across platforms.
http://www.aleph-lang.org

ALF- a language which combines functional and logic programming techniques.
The foundation of ALF is Horn logic with equality which consists of predicates and Horn
clauses for logic programming, and functions and equations for functional programming.
The operational semantics of ALF is based on the resolution rule to solve literals and
narrowing to evaluate functional expressions.
The ALF system is an efficient implementation of the combination of resolution, narrowing,
rewriting, and rejection. Similar to PROLOG, ALF uses a backtracking strategy
corresponding to a depth-first search in the derivination tree. Therefore this operational
semantics is more efficient than PROLOG's resolution strategy.

ALGOL- the youngest, and probably most influential of the three big, classic languages, the
other two being LISP and FORTRAN.
The language is suitable for expressing a large class of numerical processor in a form
sufficiently concise for direct automatic translation into the language of programmed
automatic computers.
The algorithmic language has three different kinds of representations- reference, hardware,
and publication, and the development described is in terms of the language are represented
by a given set of symbols and it is only in the choice of symbols that the other two
representations may differ. Structure and content must be the same for all representations.
http://www.masswerk.at/algol60/report.htm
ALGOL 60- a portable language for scientific computations. ALGOL 60 is small and
elegant. It is block-structured, nested, recursive, and free-form. It was also the first language
to be described in BNF (Backus-Naur Form).
There are three lexical representations: hardware, reference, and publication. The only
structured data types are arrays, but they are permitted to have lower bounds and could be
dynamic. It also has conditional expressions, it introduced =, if, then, else ; very general "for'
loops, switch declaration. Parameters are call-by-name and call-by-value. It has static local
"own" variables. It lacks user-defined types, character manipulation and standard I/O.
Other ALGOL's are: ALGOL 68, ALGOL 68C, ALGOL 68R, ALGOL c, ALGOL W,
ALGOL X, ALGOL Y, ALGOL 58, ABC ALGOL.

ALLOY- is a higher-level programming language appropriate for programming massively
parallel computing systems. It is based on a combination of ideas from functional, OO, and
logic languages.

AMBER- a functional language which adds CSP (Communicating Sequential Processes) like
concurrency, multiple inheritance and pesistence to ML and generalizes it's type system. It is
similar to Galileo. Programs must be written in two type faces, roman and italics. It has both
static types and dynamic types.

AMIGA E- is a powerful and flexible OO/procedural/unpure functional higher language,
mainly influenced by languages such as C++, LISP, ADA. E is a very fast compiler with
speeds of >20,000 lines a minute on a 7 mhz Amiga. It has a inline assembler and linker
integrated into compiler, a large set of integrated functions, great module concept with
includes as modules, flexible type system, quoted expressions, immediate and typed lists,
parametric and inclusion polymorphism, exception handling, inheritance, data-hiding,
methods, multiple return values, default arguments, register allocation, fast memory
management, unification, LISP-cells, GUI-toolkit, (macro) preprocessor, very intuitive and
powerful source-level debugger, and easy library linking.

AML- (Anil's Machine Language) implements a simple, virtual register machine in C++, to
make a portable, powerful, efficient way to solve math problems. Its use is not strictly limited
to math, but that is its main use so far.
Syntax is far easier than normal machine languages as the instruction set is easy to learn and
understand.
http://www.cris.com/~adhawan

Ampere-"Pascal-like, but the typing was extended to confer dimensions (mass, length, time,
current) on variables, to check that the operands of addition-type operators, and the sides of
assignments, matched, and the procedure parameters were dimensionally correct", Dr John
Stockton.
http://www.merlyn.demon.co.uk/othrlang.htm

AMPL- a comprehensive and powerful algebraic modeling language for linear and non-linear
optimization problems, in discrete or continuous variables.
Developed at Bell Labs, AMPL lets you use common notation and familiar concepts to
formulate optimization models and examine solutions, while the computer manages
communication with an appropriate solver. It's flexibility and convenience render it ideal for
rapid prototyping and model development while it's speed and control options make it
especially efficient choice for repeated production runs.

appall (Array Processing Language) language best known for it's use of non-exact symbols,
including a few Greek letters. All operations are either dyadic infix or monadic prefix.
It's a general purpose language distinguished by it's simple and consistent rule, a large set of
built-in capabilities, powerful facilities for defining new operations, and a general and systemic
treatment of arrays.
http://www.acm.org/sigapl/white.htm
comp.lang.APL

AVAIL- multi-polymorphic modular language with highly flexible syntax. Unique inheritance
model allows multiple inheritance, multiple polymorphism, constrained genericity, and
covariant attributes via immutability. due to identityless nature of types, a type can have an
infinite number of supertypes and subtypes.
Developed by Mark van Gulik, in cooperation with Ghoulsoft
Incorporated. Currently in early experimental stage and intended for mission-critical use.
Currently provided as Open Source (all source code available).

AWK- named after it's three inventors: Alfred V. Aho, Brian
W. Kernighan, and Peter J. Weinberger.
Designed to search, match patterns, and to perform action on files. Scans lines one at a time
for matches and patterns specified. Thus, an AWK program consists of a number of patterns
and associated actions.
http://www.crossmyt/hc/htmlchek/awk-perl.html
comp.lang.AWK

B- language intended for recursive, primarily non-numeric applications, typified by system
programming.
A systems language written for UNIX on the PDP-11. Derived from BCPL, and very similar
except for syntax. B was the predecessor of C. Used as the systems language on Honeywells
GCOS-3

BABEL- 1) a functional logic language whose operational semantics is based on lazy
narrowing and provides some higher order features.
2) a subset of ALGOL 60 with many ALGOL W extensions.
3) higher-order functional plus first-order logic language.

BASIC- language originally designed for Dartmouth's experimental timesharing system in the
early 1960's.
A novice can write short BASIC programs (10-12 lines) very
easily, writing anything longer a) is very painful, and b) encourages bad habits that will make
it harder to use more powerful languages well. Dijkstra observed in "selected Writings on
Computing", "It is practically impossible to teach good programming style to students that
have had prior exposure to BASIC: as potential programmers they are mentally mutilated
beyond all hope of regeneration". And whereas every programming language has flaws,
BASIC's are deep and many.
And as another great programmer once said,"This is what happens when a language designed
as an educational toy is taken to seriously".
http://fn2.frrenet.edmonton.ab.ca/~voxel/
comp.lang.BASIC

BAWK- GNU implementation of a superset of POSIX AWK, a pattern scanning and data
manipulation language.

BeBOP- combines sequential and parallel logic programming, OO, and meta-levels. Both
"don't know" non-determinism and stream parallelism. PROLOG theories are first-order
entities and may be updated or passed as messages. Implemented by translation to
NU-PROLOG and PNU-PROLOG.

BEFUNGE- was created in 1993 by Chris Pressey for the purpose of being original,
entertaining, and hard to compile.
In most languages, control flow is restricted to one direction and one dimension only; any
instruction which does not perform an explicit jump actually performs an implicit jump to the
next instruction. BEFUNGE however, allows execution to proceed in less restricted fashion;
the program is stored in a two-dimensional grid and control can flow left or right, or up and
down. this multi-dimensional nature makes programming in BEFUNGE an extremely "visual"
(or maybe spatial) activity.
http://www.catseye.mb.ca/esoteric/befunge/index.html

BETA- a modern OOL with comprehensive facilities for procedural and functional
programming. BETA has powerful abstraction mechanisms that provide excellent support for
design and implementation, including data definition for persistent data. The abstraction
mechanisms include support for identification of objects, classification, and composition.
Abstract mechanisms include class, procedure, function, co-routine, process, exception, and
many more, all unified into the ultimate abstraction mechanism: the pattern.
In addition to the pattern, BETA has sub-pattern, virtual pattern, and pattern variable.
BETA does not only allow for passive objects as in SMALLTALK, C++, and EIFFEL.
BETA objects may also act as co-routines, making it possible to model alternating sequential
processes and quasi-parallel processes. BETA coroutines may also be executed concurrently
with supported facilities for synchonization and communication, including monitors and
rendezvous communication.
Originates from the Scandanavian School of OOL, where the first OOL- SIMULA was
developed by the Norwegian Computing Center, Oslo, in the 1960's. Simula was invented
for writing simulation programs and later was used as a basis for defining a general-purpose
language. Beta development process started in 1975, with the aim to develop concepts,
constructs, and tools for programming. The team consisted of Bent B. Kristensen, Birger
Molle-Pederson, Ole Lehrman Madsen, and Kristen Nygaard.
http://www.daimi.au.dk/~beta
comp.lang.BETA

BEGL (Back-End generator Language) A code generator description language. The input
language for the back-end generator BEG.
ftp://iraun1.ira.uka.de/pub/programming/cocktail

BERTRAND -named after British mathematician Bertrand Russell (1872-1970). rule-based
specification language based on augmented term rewriting. Used to implement constraint
languages. The user must explicitly specify the tree-search and the constraint propagation.
http://nexus.yorku.ca/pub/scheme/scm/bevan.shar

BIGWIG- is a high-level language for developing interactive web services. Complete
specifications are compiled into a conglomerate of low-level technologies such as HTML,
CGI scripts, Javascripts, HTTP authentication, and JAVA scripts.
http://www.brics.dk/bigwig

BISTRO- new programming language that intergrates the best features of SMALLTALK
and JAVA. BISTRO is a variation of SMALLTALK that runs on the JAVA Virtual Machine
that conforms to Sun's JAVA Specifications.
BISTRO perserves much of the simplicity, expressivness and readability of SMALLTALK.
Apart from a few minor differences in puncuation, the method syntax of BISTRO is almost
identical to that of SMALLTALK. Like SMALLTALK, BISTRO offers software
developers the ability to build software models with a syntax that approaches the
expressiveness and readability of natural language.
http://bistro.sourceforge.net

BLISS (Basic language for Implemention of System Software) an expression language. It is
block-structured and typeless with exception handling facilities, co-routines, a macro system,
and a highly optimizing compiler. It was one of the first non-assembly languages for OS
implementation. It gained fame for it's lack of a goto and also lacks implicit de-referencing; all
symbols stand for addresses, not values. CMU BLISS 10 for the PDP10, CMU B LISS 11
and DEC BLISS 32 for the VAX/VMS.

BLUE-OOPL aimed at first year students and beginners. The system addresses the problem
of dealing with the complexity of the concepts associated with OOL's.
Blue is a programming environment and language.
It is very clean, small, and simple OOL.
Blue provides error-checking and reporting that is better than that provided by other
systems. It's environment allows the interactive manipulation of classes and their relationship
to each other graphically or textually. Objects of any class in the project can be created
interactively. In addition, users can interactively call any method of any object. The class
design of the current project is visible on the screen. It encourages student's to consciously
think about design, urging students to introduce classes and their relationships before
small-scale code is written.
The environment includes an integrated edition, a compiler, debugger, class browser, and an
online help system.
BLUE is designed so that the concepts are directly transferable to other OOL, such as C++,
JAVA, EIFFEL, SMALLTALK.
BLUE cannot be a goal in itself. It is not, and never should be, used in real-world industrial
projects.
http://www.cs.ut.ee/~igorko/pl_blue.html

BRIAN-Open Source, high-level, pure OOL, prototype based, scripting language;
SMALLTALK like syntax; some features borrowed from SCHEME, SELF, and
JAVASCRIPT.
http://brain.sourceforge.net

BRILLIANT- one of the five pedagogical languages based on Markov algorithms, used in "
Non-Pariel, a Machine Level Machine Independent Language for the Study of Semantics",
B. Higman, U. of London, 1968.

BSL- (Backtracking Specification Language) a logic programming language fundamentally
different from PROLOG. A non-deterministic ALGOL-like language where variables cannot
be assigned more than once except in controlled contexts. Each BSL program corresponds
to an assertion in first order logic and, and executing the program amounts to proving the
assertion.
Used to write an expert system CHORAL for harmonization of Bach-style chorales.

C- created by Brian W.Kernighan and Dennis Ritchie during the 1970's, and immediately
used to re-implement UNIX on the PDP-11. Briefly named NB. Influenced by BCPL.
Often described with a mixture of fondness and disdain,"A language that combines all the
elegance and power of assembly language with all the readability and maintainability of
assembly language", The New Hackers Dictionary.
90 % or more of errors made by experienced programmers are memory management faults.
http://www.prineas.com/links/C/index.html
http://prineas.com/Links/C/index.html
comp.lang.C

C++ - OOL. Derivative of C, "with classes".Inheritance, polymorphism, encapsulation, data
hiding, reusability, etc, are all aspects of C++ and OOL. Very powerful and fast, but
considered hard to learn.
Developed by Bjarne Stroustrup, who desribes C++ as "a general-purpose programming
language with a bias towards system programming that is better than C; supports data
abstraction, OOP, and generic programming". He also said,"within C++, there is a smaller
cleaner language struggling to get out".
"Main problem with C/C++ is that the programmer is required to do their own memory
management (to declare variables, explicitly manage pointer-chained lists, dimension buffers
and detect or prevent buffer overruns, to allocate and deallocate dynamic storage" Eric S.
Raymond.
Great for software development with support by Borland Builder (and their free compiler
5.5, and debugger), Microsoft SDK Visual C++, and the free ,amazing DJGPP system.
http://www.reality.sgi.com/austern-mti/std-c++/faq.html
comp.lang.C++

C#(sharp)- web-enabled language from microsoft. OO, programmer friendly capabilities
make it vastly easier to learn and use than older languages like C/C++, especially for
developing web applications.
Developed by Anders Hejlsberg who desribed C# as,"a simple, modern, OO, and type-safe
language derived from C and C++
http://www.c-sharpcorner.com

C*- superset of C; OO, data-parallel with synchronous semantics, for the connection
machine. Adds a data type, the "domain" and a selection statement for parallel execution in
domains.

C(GNU-C)- many extensions: compound statements within an expression, pointers to labels,
local labels, nested functions, typeof operator, compound and conditional expressions and
casts allowed as values, long integers, arrays of variable length, macros with variable number
of arguments, nonconstant initializers, constructor expressions, labeled elements in initializers,
case ranges. "Using and Porting GNU CC", R.M. Stallman, DEC. 1992

CECIL- combines multi-methods with a simple classless object model, a kind of dynamic
inheritance, modules, and optional static type checking.
An OOL intended to support rapid construction of high-quality, extensible software. Instance
variables are accessed solely through messages, allowing instance variables to be replaced or
overridden by methods and vice-versa. CECIL's predicate object mechanism allows an
object to be classified automatically based on it's run-time(mutable) state. It's static type
system distinguishes between sub-typing and code inheritance, but CECIL enables these two
to be described with a single set of declarations, streamlining the common case where the
two graphs are parallel.
The design goal is to maximize the programmers ability to develop software quickly and to
re-use and modify existing software quickly. So, all data are objects and objects are
manipulated solely by passing messages. A pure object model ensures that the power of
OOP is uniformly available for all data and all parts of a program.
The CECIL/Vortex system is very slow with a massive resource hunger. 128K of code
compiled from scratch requires approx. 96-128mb of main memory and several hours of
CPU time. A small program takes "only" 20mb of main memory, and 1-2 min of CPU time.
http://www.cs.washington.edu/research/projects/cecilHome.html

CHARITY- is functional in style, that is, programmers familiar with declarative paradigms
should find CHARITY easy to grasp.
It is based on the theory of strong categorical datatypes. These are divided into two
subclasses: the inductive datatypes (built by constructors in the familiar way) and the
coinductive datatypes (broken down by destructors).Programs over these datatypes are
expressed by folds (catamorphism) and by unfolds (anamorphism), respectively.
http://www.cpsc.ucalgary.ca/projects/charity/home.html

CHEETAH- "one of the easiest and fastest programming languages ever". You can make
awesome programs in two lines of code. you can make video games, webpages, etc.
http://www.wattsware.com

CHiLL- (CCiTT High-Level Language) is a general procedural language which is mainly
used in the field of communications. As a general programming language it is by no means
limited to that field.
There is also an OO CHiLL with class extensions, methods, inheritance, and polymorphism.
http://www.informatik.uni-jena.de/languages/chill/chill.htm

CILK- is a language for multi-threading parallel programs based on ANSI C. Cilk is
designed for general-purpose programming, but it is especially effective for exploiting
dynamic highly asynchronous parallelism, which can be difficult to write in data-parallel or
message-passing style.
http://supertech.lcs.mit.edu/cilk/

CLAIRE- is a high-level functional and OOL with advanced rule processing capabilities. It is
intended to allow the programmer to express complex algorithms with fewer lines and in an
elegant readable form.
Parametric classes and methods, OO logic with set extensions, dynamic versioning that
supports easy exploration of search spaces, very rich type system including type intervals and
second-order types (with dual static/dynamic typing). Set-based with an intuitive syntax,
simple OOP, truly polymorphic and parametric programming, powerful yet readable
extensions of DATALOG to express logic conditions.
Has a complete system with compiler, interpreter, tools- tracer, debugger, and object
inspector.

CLARITY- functional schematic language and provides an environment that allows a
programmer to draw a program as a set of directed graphs.

CLEAN- pure and lazy functional language based on the concept of mathematical functions.
A CLEAN function is referential transparent: the result of the function only depends on the
value of the function arguments and on nothing else. This has important consequences: once a
function is working, it will always work. A function will always react in the same way,
regardless when and in which context the function is used. One can reason about CLEAN
functions and the program as a whole by using traditional mathematical reasoning, uniform
substitution and mathematical induction. Has a modular, sophisticated I/oh library.
Although CLEAN does not have assignment, objects can be updated destructivily. It's the
only functional language in the world which has it's own type system, uniqueness typing:
enabling updating of functional arguments destructively!
Although lazy by default, it can easyieasilyly turn into a strict language to obtain optimal
time/space behavior.
Software Technology Research Group introduced (among other things) term graph writing,
lazy copying, abstract reduction and uniqueness typing.
http://www.cs.kun.nl/~clean
CONCURRENT CLEAN- version for loosely coupled parallel architectures. Lazy, purely
functional, strongly typed, modules, functional I/O library.

CLIPS- (C Language Integrated Production System) a language for developing expert
systems, with the inferencing and representation capabilities of OPS5, and support for three
paradigms: forward chain rule-based, OO, and procedural LISP-like syntax. Available for
MS-DOS, comes with source code in C.

CLOS- (Common Lisp Object System) is ideal for projects that are complex or need rapid
prototyping and delivery. OO extension to COMMON LISP, based on generic functions,
multiple inheritance, declarative method combination and a meta-object protocol.
A descendant of COMMON LOOPS and based on Symbolics FLAVORS and Xerox
LOOPS among others.

CLU- OOL in the PASCAL family and designed data abstraction, similar to ALPHARD.
Introduced the iterator: a co-routine yielding the elements of a data object to be used as a
sequence of values in a 'for' loop. A CLU program consists of separately compilable
procedures, clusters and iterators, no nesting. A cluster is a module naming an abstract type
and it's operation, it's internal representation and implementation. Clusters and iterators may
be generic.
http://www.pmg.lcs.mit.edu/CLU.html
comp.lang.CLU

COBOL- (Common Business Oriented Language) a weak, verbose, and flabby language
used to do boring mindless things on dinosaur mainframes. It's name is seldom uttered
without expressions of disgust or horror. Dijkstra observed, "the use of COBOL cripples the
mind; it's teaching therefore should be regarded as a criminal offense". No self-respecting
hacker would ever admit to knowing this language.
http://www.infogoal.com/cbd/cdbhome.htm
comp.lang,cobol
OO COBOL- includes the following abilities: to define classes comprising object definitions
and object functions, to define data encapsulation inside class objects, to define methods for
class objects, to use inheritance and define subclasses, to define data items able to hold
references to objects, to invoke methods on objects, to create and manage objects as
required, and to use objects as a normal part of COBOL programming in developing new
programs and maintaining existing programs.
The concept of conformance in OO COBOL resembles that in EMERALD language.

COLD FUSION- programming environment that uses a tag-based server scripting language:
CFML (Cold Fusion Markup Language), which clearly integrates HTML with XML.
Applications that you develop can be run on any end-user platform. The application will have
scalable deployment, ensuring high performance on even the most demanding websites.
Remote administration tools make management of websites straightforward. Also includes
advanced database connectivity, including support for ODBC, OLE, DB, and native
database drivers for Oracle and Sybase.
A full array of internet protocols, ranging from e-mail to ftp, are tightly integrated into the
programming environment, making them easy to incorporate in applications you develop.
Also includes thorough security features for all phases of software development and
implementation.

COMAL- (Common Algorithmic Language) originally intended as a language for beginners.
It is similar to BASIC, with PASCAL-like structures.

COMMON LISP- huge language. Because of LISP's flexible class system and dynamic
typing, configuring robust systems are easy. If new data types are added, classes and
methods already compiled usually don't have to be reconciled in order to interact properly.
Ideal for large systems that evolve over time.
According to Kennersley,"it is in most respects, the most powerful and well-thoughtout OOL
today".
Excels at dealing with partially specified problems whose essential nature is not fully known at
the outset.
It has been supporting the world's most complex applications since 1958, and it has grown
alot since then.
The White House Electronic Publication System is written in LISP, and so is Yahoo's web
browser editor. It is also used in applications involving financial and investment analysis,
tracking stock market trends, airline scheduling, space exploration, process planning and
scheduling, robotics, chemistry, medicine, and physics. Some companies consider LISP
technology so valuable that they keep their use of it under wraps.
http://www.alu.org/table/contents.htm

COOL-1) (Concurrent Object Oriented Language) an extension of C++ with task level
parallelism for shared-memory multi-processors.
2)CLIPS Object oriented Language.

COMPONENT PASCAL- (OBERON 2) OBERON is the name of a language and an
operating environment created by the Institute for Computing Systems, Zurich. Originally
designed for computer science education by it's implementers Professor Nikalaus Wirth and
J Gutknecht in 1986.
COMPONENT PASCAL is a superset of OBERON 2. Compared to OBERON 2, it
provides several classifications and improvements. The language revision was driven by the
experience with the Black Box Component Framework, and their desire to further improve
support for the specification, documentation, development, maintenance, and refactoring of
component framework.
http://www.plasrc.qut.edu.au/Componentpascal

CORAL- 1) Class Oriented Ring Associated Language. Graphical display and systems
programming on the TX-2. Used rings (circular lists) from the sketchpad.
2) University of Wisconsin at Madison, for deductive database. PROLOG-like syntax with
SQL-like extensions. Many evaluation techniques are supported. Implemented in C++.
3) Royal Signals and Radar Establishment, Malvern, U.K.,real-time system programming
language, a derivative of JOVIAL and ALGOL 60. Strongly associated with MASCOT, a
design technique for real-time systems. Adopted as the British military standard from 1970
until the arrival of ADA versions.

COQ- a higher-order proof system based on the Curny-Howard isomorphism between
propositions and types, proofs and terms in a pure functional language. By restraining to
constructive logic (i.e. no built-in choice axiom) it allows to extract actual programs from
proofs. But, it is not reflective, and there's no way to meta-translate expressions.

CORBA- (Common Object Request Broker Architecture), an architecture that enables
pieces of programs, called objects, to communicate with one another regardless of what
programming language they were written in or what OS they are running on.
Developed by an industry consortium known as the Object management Group (OMG).
There are several implementations of CORBA, the most widely used being IBM's SOM
(System Object Model) and DSOM (Distributed System Object Model).
CORBA has been (among many other implementations) been embraced by Netscape as part
of it's Netscape One (Open Network Environment) platform.

COSY- COSY Infinity is an arbitrary order beam dynamic simulation and analysis code. It
allows the study of lattices, spectographs, beamlines, electron microscopes, and many other
devices. It can determine high-order maps of combinations of particle-optical elements of
arbitrary field configurations. The elements can either be based on a large library of existing
elements with realistic field configurations including fringe fields, or described in detail by
measured data.
Two methods of obtaining information on how to use COSY: the COSY manual, and the
lecture. The lecture is audio, and is downloaded as such, with lecture notes. The COSY
Infinity Reference Manual was written by M.Berz in 1998, Michigan State U.

CWEB- an ANSI C implementation of the Web Literate programming language. version 3.1
by Levy, Knuth, and Marc van Leeuwen is written in and outputs ANSI C and C++.
ftp://ftp.cwi.nl/pub/cweb

DAD- (Declarative ADA Dialect) to aid rapid prototyping of ADA programs. Adds many
features including manipulation of first-order functions, lazy evaluation, and streams.
Implemented as a preprocessor to ADA.

DARK BASIC- is a language that allows you to write games with the speed and power of
Direct X + Direct 3D. Friendly interface provides beginners with the best opportunity to
learn to program.
http://www.darkbasic.co.uk

DELPHI- combines visual, component-based design with an optimizing native code compiler
and scalable database access.
Grandson of PASCAL and both were developed by Professor Nikalaus Wirth.
Lots of support.
Borland compiler, debugger
http://www.borland.com/delphi

DEMETER- adaptive OOP is viewed as a major advance in software technology based on
using well known finite automata and formal language theory to express succinctly and
process efficiently paths sets in architectural graphs (e.g. UML class diagrams). It allows you
to make your software both simpler and more reusable by exploiting regularities which exist
in most OO programs. It reduces software development and maintenance costs significantly.
The more collaborating objects you use in a project, the larger the reduction.
http://www.ccs.neu.edu/demeter/book/book-dow

DIALECT- procedural language inspired by BASIC; supports pre-compilation of code,
exceptions, regular expressions. Cross platform code, capacity to pre-compile code for
rapid execution, IDE with debugger works on desktops and handheld PC's. Support for
sockets, files, GUI elements, printing. Exception handling mechanisms, regular expressions.
http://www.aristar.com/DeveloperTools.html

DRAGOON- a distributed, concurrent, OO ADA-based language developed in the Esprit
DRAGOON Project by Colin Atkinson at the Imperial College in 1989.
DRAGOON supports OOP for embeddable systems and is presently implemented as an
ADA preprocessor.

DYLAN- (Dynamic Languages) general-purpose, high-level programming language. includes
garbage collection, type-safety, error recovery, a module system, and a programmers control
of run-time extensibility of programs. Invented by Apple Computer.
Uses one construct for simple purposes through multi-method dispatch.
DYLAN is dynamic, anything that is not flagged constant can be changed at run-time.
It's common for a DYLAN class to start off using generic (weak) types, and to later refine
the types to be specialized (strong). Functions can have both positional and keyword
arguments.
Compiles like C++, compiler optimizes out much of the object-dispatch and dynamic
overhead that plagued SMALLTALK.
DYLAN classes are simple compared to JAVA or C++. Each class contains some number
of slots, which hold objects. DYLAN's objects are alot like SMALLTALK's: both have
languages with "objects all the way down", even a simple number is an instance of a class.
Doesn't enforce information hiding by class like JAVA or C++, it enforces it by module.
Modules can import, export, and re-export names, and imported names can be mapped to
different names to avoid names clashes.
Supports multiple inheritance without redundantacy, to encourage a mix-in style
programming. Can descend from a base class more than once through multiple inheritance,
but will still only contain one copy of the base class.
In DYLAN, methods don't belong to classes, they are basically functions, organized into
generic functions. Proponents claim that this makes adding functionality much easier than
having to modify classes or create subclasses to add new methods.
http://www.double.co.nz/dylan
comp.lang.Dylan

DYNACE- OO extension to C. DYNACE is a preprocessor, includes files and a library
which extends the C and C++ languages with automatic garbage collection and multiple
threads. It is designed to solve many problems associated with C++ while being easier to
learn and containing more flexible OO facilities. DYNACE is able to add facilities previously
available in languages such as SMALLTALK and CLOS without all the overhead normally
associated with these environments.

E - developed by Mark S. Miller. Began as end-user language and has now morphed into a
secure language.
Runs on top of JAVA. Very SCHEME-like under the hood. Because of this, its lost a bit of
ease of use. It does illustrate some valuable concepts for distributed programming and
security.
E defines and implements a pure object model of secure distributed persistent computation. It
has two parts: 1) Elib- defines the stuff that goes on between objects. Written in pure JAVA
and is currently being used commercially from JAVA. In this form, it simply makes the E
object model available to JAVA programmers. 2) E language- can be used to express what
happens within as object. Is very simple. Object granularity security.
http://www.erights.org

ECLIPSE- combines SEPIA's extended PROLOG technology with MEGALOG's persistent
knowledge base functionality; a substantial subset of CHIP's constraints handling facilities,
several new constraints libraries, and soon or-parallelism as featured in ElipseSys.

Eiffel- a sophisticated language striving for OO purity. It is an advanced OOL that
emphasizes the design and construction of high-quality and reusable software. Classes with
multiple and repeated inheritance, deferred classes, and clusters of classes. Objects can have
both static and dynamic types. The dynamic type must be a descendant of the static
(declared) type. Dynamic binding resolves clashes from the multiple inheritance. Best for
assertions. Has built in support for Design by Contract.
Developed by Bertrand Meyer.
http://www.elj.com
http://www.eiffel.com
comp.lang.Eiffel

EGG- an interpreter for an anonymous computer language in, "A Discipline of Computer
Programming", by Edsger Dijkstra. The interpreter is written by Andrew Cooke.

ELF- is a constraint language based on the LF Logical framework. It is a uniform
Meta-language for specifing, implementing and providing properties of programming
languages and logics.
http://www.cs.cmu.edu/~fp//elf.html

ELASTIC C- is a portable, high-level OO language interpreted with a C-like syntax.
Dynamic typing, automatic real,very fast garbage collection; OO with meta-programming
support (a la SMALLTALK). Functional programming support (SCHEME-like closures
with lexical scoping; heirarchial namespaces, many useful basic types (dynamic arrays,
dictionaries, symbols). Extensible with C (you can add functions, types, classes, methods,
packages); embeddable in C. Small footprint makes it ideal in embeddable systems.
ELASTIC C has been strongly influenced by C, SMALLTALK, SCHEME, and PYTHON
and tries to merge the best characteristics of all these languages, while maintaining it's own
unique personality.
http://www.elasticworld.org

ELLIE- OOL with fine-grained parallelism for distributed computing. Based on BETA,
SMALLTALK, and others. Parallelism by unbounded RPC and 'future' objects.
Synchronization by 'dynamic' interfaces. Classes, methods, blocks and objects all modeled
by first-class 'Ellie objects'. Genericity, polymorphism, delegation, and inheritance.

EMERALD- language and programming system providing both process and object mobility
on a network of workstations.
Objectives- develop and distribute an OOL and system incorporating lightweight object
migration, and investigate the issues in using such languages for distributed application
development, particularly the areas of reliability and availability.
Developed by Norm Hutchinson.
EMERALD is implemented in style similar to JAVA (and PASCAL, and SIMULA, and..).
The EMERALD compiler, which is written in EMERALD, generates byte codes which are
then interpreted by a relatively portable interpreter. The interpreter takes care of finding
remote objects, performing remote invocations, moving objects, and doing both local and
distributed garbage collection.
http://www.cs.ubc.ca/nest/dsg/emerald.html

ENIAC- claimed to be the first computer language. The other contestant for "first" is
PLANKALKUL.
Designed by J. Prosper Eckert and John Mauchly between 1943-45.

EOL-1) Expression Oriented language- a low level language for strings

ERLANG- a programming language specifically designed to build fault-tolerant, distributed
systems which can contain large numbers of current processes.
Concurrent functional language for large industrial real-time systems. Dynamically typed,
pattern matching syntax, recursive equations, explicit concurrency, and asynchronous
message passing. Relatively free from side effects. Transparent cross-platform distribution.
Primitives for detecting run-time errors. Real-time GC modules. Dynamic code replacement
(change code in running real-time systems without stopping systems). Foreign language
interface.
http://www.erlang.org

ESCHER- declarative, general-purpose language which integrates the best features of both
functional and logic programming languages. It has types and modules, higher-practicalorder
and meta-programming facilities, and declarative input/output. It also has a collection of
system modules, providing numerous operations on standard data types such as integers,
lists, characters, strings, sets, and programs. The main design aim is to combine in a practical
and comprehensive way the best ideas of existing functional and logic languages, such as
G諨EL, HASKELL, and LLAMBDA PROLOG. Indeed, it goes well beyond G諨EL in
it's ability to allow function definitions, it's higher-order facilities, it's improved handling
definitions, it's improved handling of sets, and it's declarative I/O. It goes well beyond
HASKELL in it's ability to run partly-instantiated predicate calls, a familiar feature of logic
languages which provides a form of non-deterimism, and it's more flexible handling of
equality. The language also has clean semantics.
http://www.cs.bris.ac.uk/Tools/Reports/Abstracts/1995-ll0y

EuLISP- is a modern OO dialect of LISP whose design was less minimalistic than that of
SCHEME but less constrained by compatability reasons than that of COMMON LISP. In
particular, it has a single namespace for variables and functions (like SCHEME, and unlike
COMMON LISP) and it's type system is perfectly integrated with the object system.
Futhermore, the language makes use of the module system, so that every program may
import only those parts it needs.

EUPHORIA- ( End User Programming Hierarchial Objects for Robust Interpreted
Applications) a simple, powerful, flexible language that is easy to learn.
It is not a true OOL but achieves many of the benefits in a much simpler way.
Dynamic storage location. Objects of any size can be assigned to an element of a Euphoria
sequence (array).
A high-performance, state-of-the-art interpreter that's at least 10-30 times faster than PERL
or PYTHON. Lightening fast pre-compilation. Program is checked for syntax and converted
into an efficient internal form at over 35,000 lines per second (wow!) on a Pentium-150.
Not subject to 64k or 640k memory limitations. You can create multi-megabyte memory of
your computer, and a swap file is automatically used when a program needs more memory
than exists on your computer.
EUPHORIA was released after 3 years of Research and Development and 6 months of Beta
testing. Many of the ideas behind EUPHORIA came from Robert Craig's Masters Thesis in
Computer Science at University of Toronto. That thesis was strongly influenced by the work
of John Backus on functional programming languages.
Complete,royalty-free rights to distribute any programs that you develop; you can make a
single, stand-alone, .exe file from your program (Euphoria is sold in two versions, a free
version where you are limited to 300 lines, and the unlimited version which is $39.00.
http://rapideuphoria.com

FRANZ LISP- a MACLISP dialect of LISP. Developed primarily for work in symbolic
algebra. Written by C.R. Fateman et al, ca 1980.

FMPL- 1) (Frobozz Magic Programming Language)is a prototype based on OOL with
functional features. Event driven. 2) (Formula Calculator-Interactive), for PDP-5,8's a
descendant of AID/JOSS 3) (Forty-One Calculator Language)- language of the HP-41
calculator line.

FORMS/3- general-purpose, declarative, form-based VPL (Visual Programming Language).
It's goal is to provide computational and expressive power in a language featuring a simple,
concrete programming style with immediate feedback. It follows the spreadsheet paradigm:
the programmer uses direct manipulation to place cells on forms, and then defines a formula
for each cell. Such a formula may include constants, references to the cells own value at a
previous moment in time. Cells are referenced by clicking on them. A programs calculations
are determined by these formulas.
http://www.cs.orst.edu/~burnett/Forms3/forms3.html

FORTH- An extensible language and an interactive development methodology.
It's primary uses have been: scientific and industrial applications such as instrumentation,
robotics, process control, graphics and image processing, AI, and business. Principal
advantages include rapid, interactive software development and efficient use of computer
hardware.
Often spoken of as a language because that is it's most visible aspect. But in fact, FORTH is
both more and less than a conventional language; more- all the capabilities normally
associated with a large portfolio of separate programs (compilers, editors, etc.) are included
within it's range and less in that it lacks (deliberately) the complex syntax characteristic of
most high-level languages.
http://dec.bournemouth.ac.uk/forth
http://www.ultratechnology.com
comp.lang.forth

FORTRAN (FORmula TRANslator)- particularly good language for processing numerical
data, but it does not lend itself very well to organizing large programs, the first and still most
widely used.
FORTRAN 1- John Backus, for IBM 704. Design begun in 1954, compiler released April
1957.
FORTRAN ll- added subroutines, 1958.
FORTRAN III- this was only distributed to 20 sites.
FORTRAN IV- IBM 1962, this went well beyond the original definition. For
the IBM 7090/94
Fortran V- preliminary work on adding character handling facilities by
IBM, 1962. Name was never really used.
http://www.nsc.liu.se/~boein/fortran.html
http://fortran.com/fortran/F77_std/rjcnf0001.html
comp.lang.forth
comp.lang.forth.mac

G- 1) combines functional, OO, relational, imperative, and logic programming, their motto
literally is, "you name it, we got it", Oregon State, 1988. " The Multiparadigm Language G",
J. Placer, Computer Languages, 1991. 2) Functional Language with Generic Abstract Data
Types, P.A.G. Bailes, 1987.

GEL- scripting language used in the object-oriented development environment
GainMomentum. 1989.

GENTLE- language for compiler writers. It supports language recognition, definition of
abstract syntax trees, construction of tree walkers based on pattern matching, smart
traversal, simple unparsing for source-to-source translation, and optimal code selection for
microprocessors. GENTLE provides a uniform framework for all these tasks.
http://www.first.grnd.de/gentle

GNU E- is a persistent, OOL developed as part of the Exodus Project. It extends C++ with
the notion of persistent data, program level data objects that can be transparently used
across multiple executions of a program, or multiple programs, without explicit input and
output operations.

G諨EL- a declarative, general-purpose language in the family of logic languages. It is a
strongly typed language, the type system being based on man-sorted logic with parametric
polymorphism. It has a module system. It supports infinite precision integers, infinite precision
rationals, and also floating-point numbers. It can solve constraints over finite domains of
integers and also linear rational constraints. It supports processing of finite sets. Considerable
emphasis is placed on G諨EL's meta-logical facilities which provide significant support for
analysis, transformation, compilation, debugging, and verification.
http://www.cs.bris.ac.uk/~bowers/g鰀el.html

GREEN- is a very new language, it's official birthday was 11/98. It separates subtyping from
subclassing, supports and requires garbage collection, makes classes first-class objects, has a
nice introspective reflection library, and an efficient kind of meta-objects called shells.
Parameterized classes (the C++ templates) and the module system are being designed. The
result will be a very coherent programming language in which all parts fit nicely together with
no ad-hoc patches to make a newly introduced feature work with the rest of the language.

GUILE- and GOOPS (The Guile Object-Oriented Programming System) very close in spirit
to CLOS, but it is adapted from the SCHEME language.
GUILE is the interpreter for the SCHEME language nicely packaged as a library you can link
to your programs. Your program has full access to the interpreter's data structures, so you
can extend GUILE with your own primitives, datatypes, and syntax. The result is a scripting
language tailored to your applications.
The GOOPS extension gives the user a full OO system with multiple inheritance and generic
functions with multi-method dispatch.
The implementation relies on a true meta-object protocol, in the spirit of the one defined for
CLOS.

HASKELL- purely functional programming language. Computation proceeds by replacing
expressions with their values. While all languages incorporate functions to some degree,
HASKELL programs are composed solely of functions. It's based on Lambda calculus,
hence the L used as a logo.
The language is named for logician Haskell B. Curry, whose work provided much of the
logical basis for the language.
Yale has been an integral part of the development and implementation of the HASKELL
language since it's inception, Yale has helped write the HASKELL Report, Wrote a tutorial,
and most recently Paul Hudak has published a textbook on using HASKELL, "The Haskell
School of Expression". Today, the focus of the Yale group is on putting HASKELL to work
in the real world by : using HASKELL to construct a variety of DSL's (Domain-Specific
Embedded Languages). The challenges include 1) the semantic underpinnings of DSL's, 2)
building blocks for DSL construction, 3) Domain-specific analysis and transformation,
4)compiling DSL's,5) deploying DSL technology.
http://haskell.cs.yale.edu /yale
http://haskell.org

HOPE- a small polymorphically-typed functional language. First language to use
call-by-pattern. HOPE was originally strict, but there are versions with lazy lists, or with lazy
constructors but strict functions.

HPCODE- stack-based intermediate language used by Hewlett-Packard in many of it's
compilers for RISC and stack-based architectures. Supports FORTRAN, ADA, PASCAL,
COBOL, and C++. Descended from Stanford's U-code.

HUGO- is a text adventure compiler and run-time engine written by Kent Tessman.

ICI- is a language with dynamic, object-based data model with the flow control constructs
and operators of C. It is designed for use in many environments, including embedded
systems, as an adjunct to other programs and as a text-based interface to compiled libraries.
http://www.zeta.org.au/~atm/ici/default.html

ICON- is a high-level general-purpose language with a large repertoire of features for
processing data structures and character strings.
ICON is an imperative, procedural language with syntax reminiscent of C and PASCAL, but
with semantics at a much higher level.
The OO extension is Idol.
The ICON system is user-friendly and a pleasure to work with, which facilitates code
production.
http://www.cs.arizona.edu/icon/index.html
comp.lang.icon

INFER- a statically-typed dialect of SCHEME. Infer combined many (but not all) of the best
features of SCHEME and ML. Compared with latently-typed languages such as SCHEME,
statically-typed language such as ML and Infer, sacrifice some expressive power in exchange
for the ability to catch many errors at compile-time, the possibility of more efficient execution,
and some system-verified program verification.
By supporting all of the forms and primitives procedures of Scheme, with a Scheme-like
syntax, it is hoped Infer will prove accessible to Scheme programmers. Efficient compilation
of Infer into Scheme is possible, thereby providing compatibility with Scheme programming
environments.

ISWIM- (If You See What I Mean) is a purely functional, sugaring of Lambda calculus, and
the ancestor of most applicative languages. An ISWIM program is a single expression
qualified by "where" clauses (auxiliary definitions including equations among variables),
conditional expressions and functional definitions.
ISWIM was the first language to use lazy-evaluation and introduced the off-side rule for
indentation.

J- is a very high-level general-purpose language, with strong emphasis on functional
programming and array processing. J was designed and developed by Ken Iverson and
Roger Hui, and implemented by Iverson Software Inc.(ICI). J is distinguished by it's simple
and consistent rules, a large set of built-in functions, powerful facilities for defining new
operations, and a general and systematic treatment of arrays. It is ideal for complex analytical
work, modeling, and RAD ( Rapid Application Development).

JADE- is a rich OO software development technology purpose built for transaction-based
enterprise programming, particularly the development of high volume web applications.
Developed by Aoraki Corp. of Australasia.

JAVA- originally called OAK. Developed by James Gosling (Sun Microsystems) who
described it as,"a general purpose, concurrent, class-based OOL". Modular and fully
object-oriented.
From a programmer's standpoint, it is faster and easier and more elegant than other Web
tongues.
Stronger and cleaner than C++ and has been embraced by the hacker communities (well,
part of the community anyhow).
Uneven support on different Web browser platforms, performance issues, and some
deficiencies of some standard toolkits (AWT in particular), are annoying disadvantages.
Microsoft's determined attempts to corrupt the language (which it rightly sees as a threat)
have not helped.
Still, irregardless of MS, JAVA is extremely portable by way of it's VM (Virtual Machine),
although relatively slow, (MS's VM is faster), which interprets the bytecode in a JAVA
program and translates it for use on most any given Operating System. This "write once, run
anywhere" philosophy is understandably attractive to many software developers.
The VM also insulates JAVA programs from the host environments (and vice-versa)
providing a secure implementation which is not available with Microsoft's Active X
technology.
It has taken on a quasi-religious enthusiasm in some circles, as have many computer
languages- The Powerhouse Java Church of the Almighty Bytecode of the Holy Boast. (90%
wink).
http://java.sun.com
http://javalobby.org
comp.lang.java
comp.lang.java.advocacy

JAVA BEANS- provides portability, ease-of-use, and functionality,
making it an ideal vehicle for adding interactivity to Internet and Intranet applications.
Software components are designed and built so that they can be accessed and used in a
variety of different development and run-time scenarios.
JAVA BEANS component software technology is based on JAVA and provides a means of
creating and using JAVA classes as software components.
Abilities include: property management, introspection, event handling, persistence, and
Application Builder support.
comp.lang.java.beans

JAVASCRIPT- a scripting language developed by Netscape to enable Web authors to
design interactive sites. Although it shares many of the features and structures of the full
JAVA language, it was developed separately. JAVASCRIPT can interact with HTML
source code, enabling Web authors to spice their sites with dynamic content.
JAVASCRIPT is endorsed by a number of software companies, and it is an Open Source
product that anyone can use without purchasing a license. It is supported by recent browsers
from Netscape and MS; although IE supports a subset, which MS calls JSCRIPT.
"Within HTML, JAVASCRIPT reigns supreme and is the default script. It has C++ and
JAVA like structures and can port some of the C/C++ and JAVA code. JAVASCRIPT
basically extends the HTML language, but it's scope seems confined to the browser".
http://javascript.com
http://javascript.internet.com

JoCAML- is an experimental extension of the OBJECTIVE CAML language with the
distributed join-calculus programming model. This model includes high-level communication
and synchronizing channels, mobile agents, failure detection and automatic management.

JOY- is a purely functional language. Whereas all other functional languages are based on the
application of functions to arguments, JOY is based on the composition of functions. All such
functions take stack as arguments and produce a stack as value. Consequently, much of JOY
looks like ordinary pastfix notation.

JUICE- is a new technology for distributing executable content across the web. It differs
from JAVA in several important aspects that allow it to out-perform JAVA in many
"downloadable Applets" applications. Juice is meant to be a complement to JAVA, giving
users a choice of either.

K- a concise language with powerful primitives and math notations, a high-performance
engine, GUI, built-in memory management, interprocess communications, web-server
capabilities, and connectivity features.

KALEIDOSCOPE-mixes OOL which mixes imperative and constraint-oriented features.
Similar to Siri. Vaguely related to Prase 2.

KEVO- Proto-type based object-oriented system built around a threaded code interpreter.
Semantically resembles SELF and OMEGA. Syntactically resembles FORTH.

LAGOONA- Peter Frohlich
http://www.ics.edu./%7Efranz/publications/J9703%20ProgLanguageLagoona.pdf

LAMINA- Concurrent object-oriented language. Stanford U. 1988

LAURE- A language for knowledge representation combining object orientation and logic
programming. Set operations, object-oriented exception handling and a polymorphic type
system.

LEDA- Multi-paradigm programming- to provide a framework in which programmers can
work a variety of styles, freely intermixing constructs from different paradigms.Techniques
supported by LEDA include imperative programming, OO approach, logic and functional
programming.
http://www.cs.orst.edu/~budd/leda.html

LENS- Compact language which is an orthogonal combination of three fundamental OO
concepts: late binding (through message passing), (multiple) inheritance, and encapsulation.

LIANA- is a C-like, interpretive, OOL; class library, and an IDE. Aimed at Windows
applications. No pointers, and no multiple inheritance. Garbage collection. "The Liana
Programming Language", R. Valdes, 1993.

LIFE- (Logic, Inheritance, Functions, and Equations) is an experimental language proposing
to integrate three orthogonal programming paradigms proven useful for symbolic
computation. From a beginners standpoint, it maybe perceived as a language taking after
logic, functional,and OOPing. From a formal perspective, it maybe seen as an instance or
rather, a composition of three instances) of a Constraint Logic Programming SCHEME due
to Hoehfeld and Smolka refining that of Jaffer and Lassez.

LIMBO- is strongly typed, provides automatic garbage collection, supports only very
restricted pointers, and compiles into machine-independent byte code for execution on a
virtual machine.
The language is intended for applications running distributed systems on small computers. It
supports modular programming, strong type checking at compile and run-time, interprocess
communications over typed channels, automatic garbage collection, and simple abstract data
types. It is designed for safe execution even on small machines without hardware memory
protection.
http://casl.csa.iisc.ernet.in/OperatingSystems/inferno/Limbo_Ref20/
comp.lang.limbo

LINDA- explores a variety of research topics in parallel and distributed programming
languages, groupware and information systems. Much of the work centers around the Linda
programming language or ideas that have been spawned from work on the Linda system. The
Linda Group, Dept. of Computer Science, Yale University.

LIS- (Language Implementation System) a predecessor of ADA, influenced by Pascal data
structures and SUE's control structures, A type declaration may have a low-level
implementation specification.

LISP- AI's mother tongue, a language based on the ideas of a) variable-length lists and trees
as fundamental data types, and b) the interpretation of code as data and vice-versa.
Invented by John McCarthy at MIT in the late 1950's; it is older than any other HLL still in
use except Fortran. Accordingly, it has undergone considerable adaption. Modern variants
are quite different in detail from the original LISP 1.5.
http://www.xanalys.com/software_tools/reference/HyperSpec
http://www.alu.org/table/contents.htm
comp.lang.lispx

LISP 2- Lisp 1.5 with an Algol 60-like surface syntax. Also optional type declarations, new
data types including integer-indexed arrays and character strings, partial-word
extraction/insertion operators and macros. A pattern-matching facility similar to Comit was
proposed.

LISP 70- a descendant of MLISP and MLISP2. Also known as PLISP and VEL. Useful
for parsing. Only the pattern-matching system was published and fully implemented.
According to Alan Kay, Lisp 70 had an influence on Smalltalk 72.
LISP languages have always been at the forefront because they stressed better semantics
over fancy syntax.

LML- 1)lazy, functional, variant of ML2. Implemented on the G-machine, and used to
implement the Haskell B compiler. Developed at Chalmers U. Tech, Gothenburg, Sweden.
2)logical ML that adds to Lazy ML a data type of "theories" whose objects represent logic
problems. P. Denansart et al,LNCS 456,1990.

LOGO- a language specifically designed for children, to teach them the concepts of
computer programming in a fun and intuitive way.
One of the ideas guiding it's creation was the principle "low floor, high ceiling". This means
that it should be easy for the novice programmer to get started (the "low floor") writing
programs and getting satisfaction doing so, but that the language should be powerful and
extensive in a "sky is the limit" sort of a way (the "high ceiling).
http://www.media.mit.edu/groups/logo-foundation
comp.lang.logo

LOOEE- a language designed for laboratories, but it can be used to program any simple
calculation. If you can break an expression into simple steps involving single operators, you
can program LOOEE. Developed by Scott Warner

LOOKS- 1) Knowledge-Representation System for Designing Expert System in a Logical
Programming Framework.
2) Language for Object-Oriented Kinematics Specifications-imperative, object-oriented
language for specifying motion.

LORE- 1) Object-oriented language for knowledge representation.
2)CGE, Marcousis, Frame-set-based language.

LPC- interpreted, OOPL for flexible and yet efficient application development and
prototyping.

LUA- is a powerful, lightweight programming language designed for extending applications.
Also frequently used as a general-purpose stand-alone language.
LUA is a language engine that you can embed in your application. this means that, besides
syntax and semantics, LUA has an API that allows the application to exchange data with Lua
programs and also extend Lua with C functions.
Lua is implemented as a small library of C functions, written in ANSI C, and compiles
unmodified in all known platforms. The implementation goals are simplicity, efficiency,
portability, and low embedding cost. The result is a fast language engine with a small
footprint, making it ideal in embedded systems.
Lua was designed and implemented at TeCGAF, the Computer Graphics Tech Group of
PUC-Rio, Pontifical Catholic University of Rio de Janario in Brazil.
http://www.tecgraf.puc-rio.br/lua/manual


LUCID- developed by Bill Wadge and Ed Ashcroft, 1995. The language is very much like
BASIC, Pascal, or even LISP.
"The Home Wurld of Intensional Programming"
http://lucy.uvic.ca

LUSTRE- real-time dataflow language for synchronous systems, especially automatic control
and signal processing. A Lucid subset with timing operators and user-defined clocks.
"Outline of a Real-Time Dataflow Language", J.L. Bergerand, 1985.

M4- is a powerful macro-expansion program designed as a preprocessor to stubborn
languages. Its ugly, but its fairly standard, and available on most platforms, including a GNU
version.
The semantics are bad: it uses back-door evaluation in a dynamically-bound global
environment as the only way to program, without anyway to safely quote text.

MAGENTA- designed to be the most redundant language in existence. It has over 80
reserved words, a needlessly convoluted exception system, a threading system that looks
entirely too much like a really weird function syntax, a function call syntax that happens to be
a curse. In short, a perfect design-by-committee language. Developed at Boston College,
March, 1995.

MAGMA- is a radically new system designed to solve computationally hard problems in
algebra, number theory, geometry, and combinatorics. It provides a mathematically rigorous
environment for computing with algerbriac, number-theoretic, combination and geometric
objects.
http://www.maths.usyd.edu.au:8000/comp/magma/overview

MATCHMAKER- a language for specifying and automating the generation of multilingual
interprocess communication interfaces.
MIG is an implementation of a subset of Matchmaker that generates C and C++ remote
procedure call interfaces for interprocess communication between Mach tasks.

MATLAB- is an intuitive language and a technical computing environment. It provides core
math and advanced graphic tools for data, analysis, visualization, and algorithm and
application development.
http://www.engin.umich.edu/group/ctm
http://members.nbci.com/gregersonweb/matlab

MCPL- is a simple typeless language which is based on BCPL. It makes extensive use of
pattern matching, somewhat related to that used in ML and Prolog, and some other features
found in C.

MELD- concurrent, OO, dataflow, modular and fault-tolerant. Comparable to SR.

MELD C- a C based concurrent OO coordination language built on a reflective architecture.
A redesign of MELD. Version 2.0 for Sun 4's and DEC stations.

MENTAT- OO distributed language, an extension of C++, portable to a variety of MIMD
architectures. Fundamentals are : 1) provide easy-to-use parallelism, 2) achieve
high-performance via parallelism execution, 3) facilitate the executions of applications across
a wide-range of platforms.
The MENTAT approach exploits the OO paradigm to provide high-level abstractions that
mask the complex aspects of parallel programming.
Also: Real-time MENTAT- an extension of C++.

MERCURY- is a new logic/functional language which combines the clarity and
expressiveness of declarative programming with advanced static analysis and error detection
features. Its highly optimized execution algorithm delivers efficiency far in excess of existing
logic systems, and close to conventional programming systems.
http://www.cs.mu.oz.au/research/mercury

MEROON- OOL written in Scheme. All objects of Scheme can be seen as Meroon objects
without restrictions on inheritance. Very fast. CLOS-like generic functions.
Self-description features: classes are Meroon objects and can be inspected. Portable.
Named after the developer's son's Teddy Bear.

MIRANDA- the aim of the Miranda system is to provide a modern functional language,
embedded in an "industrial quality" environment. it is now being used at a growing number of
sites for teaching functional programming and as a vehicle for the rapid prototyping of
software.
http://www.cs.ukc.ac.uk/pubs/1995/59

MISA- it's goal is to design a language that includes those paradigm in current languages that
have been proven, and new ones that add support and, hopefully, future technologies.

ML- (Meta-language) is a family of advanced languages with (usually) functional control
structures, strict semantics, a strict polymorphic type system and parameterized modules. The
family includes; Standard ML, Lazy ML, Caml, Caml Light, and various research languages.
Implementations are available on many platforms, including PC's, mainframes, most models
of workstations, multiprocessors, and supercomputers.
ML has many users, is taught at many Universities (it's the first language taught at some of
these).
http://www.faqs.org/faqs/meta-lang-faq
2) Manipulator Language- IBM language used in handling robots.

MODULA 2- is a programming notation that corrects some of the deficiencies of Pascal. It
is suitable for learning programming, for large projects written and maintained in the fashion
of professional software engineers, and for real-time embedded systems.
http://www.arjay.bc.ca/Modula-2/m2faq.html
comp.lang.Modula2

MODULA 3- is a systems programming language that descends from Mesa, Modula 2,
Cedar. It resembles it's cousins: Object Pascal, Oberon, and Euclid.
The goal is to be simple and safe as it can be while meeting the needs of modern system
programmers.
Modula 3 retains one of Modula 2's most successful features, the provision for explicit
interfaces between modules. It adds objects and classes, exception handling, garbage
collection, lightweight processes (or threads), and the isolation of unsafe features.
Used in industrial and research projects, and for teaching. It encourages good programming
practices and comes with excellent libraries for distributed programming and GUI's.
Supports 25 different OS platforms.
http://www.research.digital.com/SRC/modula-3/html
comp.lang.modula3

MOPS- Michael Hore's robust and powerful public-domain development system for the
Macintosh.
With Forth and Smalltalk parentage, MOPS has extensive OOP capabilities, including
multiple inheritance, and a class library supporting the Macintosh interface.

MOZART- is a major platform (development) for open fault-tolerated distributed
applications, constraint applications, and logic applications. It includes a full-fledged
development environment with many tools and extensive documentation including tutorials.
Applications developed include configuration tools, collaborative graphic editor, browser,
and an extended version of ICQ.
Provides state-of-the-art support in two areas: open distributed computing and
constraint-based inference.
Ideal platform for both general purpose distributed applications as well as for hard problems
requiring sophisticated organization and inference abilities.
An ideal system for self-study. Full source code available. See OZ.
The successor of DFKI OZ is Mozart. Mozart improves on DFKI by offering supported for
distributed programming, more constraint systems, more tools (including debugger and
profiler), much better documentation, a powerful Internet-based module system based on
dynamic linking.
Uses Emacs as programming environment.
http://www.mozart-oz.org

MUMPS- (M) a pretty simple command oriented, general purpose, procedural language
with a fairly powerful string handling and multi-dimensional associative arrays and a very
powerful built-in database.
Also used for managing data and communicating information between widely disparate units
within an organization.
http://www.geocities.com/SiliconValley/7041
comp.lang.mumps

NAPIER 88- is a persistent programming system named after John Napier, that provides the
following facilities: 1) orthogonal persistent-models of data independent of longevity, 2) type
completness- no restrictions on constructing types, 3) higher-order procedures are data
types, 4) parametric polymorphism- generic forms which may be specialized for use, 5)
abstract (existential) data types - for sophisticated protection and viewing, 6) collections of
bindings, 7) a strongly typed stable store, 8) graphic data types, 9) concurrent execution and
data access using threads, semaphores, and transactions, 10) support for reflective
programming- for system evolution.
The Napier 88 system consists of the language and it's persistent environment. The persistent
store is populated and, indeed, the system uses objects within the persistent store to support
itself.
http://www-ppg/dcs.st-and.ac.uk/languages/Napier88

NAWK- (New Awk) pattern scanning and processing language. An enhanced version of
Awk, with dynamic regular expressions, additional built-ins and operators, and user-defined
functions.

NEON- an OO extension of Forth for the Mac. Inheritance, floating point, system classes
and objects for Mac interfacing, overlays. Developed by Charles Duff, now sold by Kriya
Systems, modified, and renamed Yerk.

NESL- is a parallel language developed at Carnegie Mellon by the SCandAL Project. It
integrates various ideas from the theory community (parallel algorithms), the languages
community (functional) and the systems community (many of the implementations techniques).
The most important new ideas are: nested data parallelism- concise code that is east to
understand and debug, while being well-suited for irregular algorithms. A language based
performance model- this gives a formal way to calculate the work and depth of a program.

NET REXX- is a "human-oriented" language designed as an effective and simple alternative
to the Java language. With NetRexx, you can create programs and applets for the Java
environment faster and more easily than with Java. Using Java classes is especially easy in
Netrexx, as different types of numbers and strings that Java expects are handled
automatically by the language.
Inspired by two very different languages, Rexx and Java, NetRexx blends the easy to learn
syntax of Rexx with the robustness and portability of Java. The result is a language which is
tuned for both scripting and application development, and is truly general-purpose.

NEWTON- general-purpose expression language, syntatically Algol-like, with OO and
functional features and a rich set of primitives for concurrency. Used for undergraduate
teaching at Lausanne, Swiss Federal Institute of Technology

NIAL- (Nested Interactive Array Language) a multi-paradigm language that combines
aspects of both functional and procedural languages. Q'Nial is an interactive programming
environment for the Nial interpreter that can be used for application development and
production computing. The Nial Data Engine is an embeddable interpreter available for
Windows platforms.
Nial is a hybrid language combining a functional array language based on Trenchard More's
mathematical treatment of nested arrays, with a procedural language with a familiar control
structures. It has a rich set of language primitives that make it easy to rapidly develop
loop-free data-driven algorithms.
Nial and it's implementations were designed by Mike Jenkins at Queens University in
Canada.
O'Nial is being used for application in decision support, knowledge based systems, scientific
computing and data analysis.

O2- OO database language used in the Altair Project. Implemented as an
interpreter."Advances in OO Database Systems", K.R. Dittrich, 1988.

OAKLISP- a portable OO Scheme, syntactically a Scheme superset. Based on generic
operations rather than functions. Anonymous classes. 1986.

OBERON- invented by Professor Niklaus Wirth and J. Gutknecht, Professor Wirth also
invented or assisted in Pascal, Modula, Delphi, and now Oberon!
A modern, integrated software environment for single-user workstations.
The language is, unsurprisingly, in the Pascal/Modula tradition and a highly effective and
compact OS.
Oberon is the successor of Pascal and Modula 2 and was designed for systems
programming. It was later extended with OO features resulting in Oberon 2. Component
Pascal is a superset of Oberon 2. The desire for additional support for development,
documentation, and refactoring of component frameworks.
Type extensions and text abstract data types. Fast compilation. Optional GUI component
framework called Gadgets available with integrated WWW support.
According to Oberon Microsystems,"the language revision was driven by the experience with
the Black Box Component Framework, and the desire to further improve support for the
specification, documentation, development, maintenance, and refactoring of component
framework".
http://www.oberon.ethz.ch
http://ping.de/sites/edge/VisualOberon.html

OBJ- a family of declarative "ultra high-level" languages. Abstract types, generic modules,
subsorts (subtypes with multiple inheritance), pattern-matching modulo equations,
E-strategies (user control over laziness), module expressions (for combining modules),
theories and views (for describing module interface). For the massively parallel RRM
(Rewrite Rule Machine).

OBJECTIVE C- was designed by Brad Cox, whose primary purpose was to add the main
features on Smalltalk 80 to the C language. His work led to an OOL with a complete
programming environment. No operator overloading, no multiple inheritance, no class
variables. Does have run-time binding.
http://www.tatters.org/computers/objc

OBJECTIVE CAML- developed and distributed by INRIA (Institut de National de
Recherche en Infornatique et Automatique) the main French research institute for computer
science.
Caml is a safe language. The compiler performs many sanity checks on programs before
compilation. That's why many programming errors cannot happen in Caml: data type
confusion, erroneous access into compound values become impossible. In effect, all these
points are carefully verified by the compiler, so that data accesses can be delegated to the
compiler code generator, to ensure that data manipulated by programs may never be
corrupted: the perfect integrity of data manipulated by programs is granted for free in Caml.
Caml is statically type-checked, but there is no need to add type information in programs (as
in Ada, Pascal, or C): type annotations are fully automatic and handled by the compiler.
Predefined data types include: basic types-booleans, floating-point numbers, characters,
strings. And more sophisticated data types: tuples, arrays,sets, lists, queues, stacks, hash
tables, and data streams.
Comes in two flavors: Caml light and Objective Caml. Caml Light is merely a subset of
Objective Caml, designed for teaching and learning the art of programming. In addition to
Caml Light core language, objective Caml features a powerful module system, full support to
OO paradigm, and an optimizing compiler.
Available for PC, Unix, and Mac.
http://caml.inria.fr/ocaml/

OBJECT-ORIENTED FORTRAN 90- is a modern language that introduces many inportant
new features for scientific programming.
While the array-syntax notation has received the most attention, we have found that many
modern software development techniques can be supported by this language, including OO
concepts.
While Fortran is not a full OOL, it can directly support many of the important concepts of
such a language including abstract data types, encapsulation, function overloading, and
classes. Other concepts such as inheritance and dynamic dispatching are not supported
directly, but can be emulated.
Since Fortran 90 is backwards compatable with Fortran 77, new concepts can be
introduced into existing programs in a controlled manner.

OBLIQ- is a lexically-scoped untyped interpreted language that supports distributed OO
computation. An Obliq computation may involve multiple threads of control within an address
space, multiple address spaces on a machine, heterogenous machines over a local network,
and multiple networks over the internet. Obliq objects have state and are local to a site.
Obliq computations can roam over the network, while maintaining network connections.
Luca Cardelli, 1993.
http://www.luca.demon.co.uk/obliq/Obliq.html

OCCAM- a language which facilitates writing parallel programs, allowing the programmer to
specify whether processes are to be executed sequentially or in parallel. Based on CSP, it
was originally developed for the Transputer. Developed at the Oxford University Computing
Laboratory.
http://wotug.ukc.ac.uk/parallel/occam

OCTAVE- GNU Octave is a high-level language, primarily intended for numerical
computations. It provides a convenient command line interface for solving linear and
non-linear problems numerically, and for performing other numerical experiments using a
language that is mostly compatible with Matlab.
Also may be used as a batch language.

OLABL- extends Objective Caml with open sum types, named and operational functional
arguments.

OMEGA- prototype-based OOL. Developed by Gunther Blascek at the Instit fur Praktische
Informatik Gruppe Software, Universitat Linz, Austria. "Type-Safe OOP with Prototypes-
The Concept of Omega".

ONTIC- OOL for an inference system. LISP-like appearance, but based on set theory.
"Ontic: A Knowledge Representation System for Mathematics", D.A. McAllster, MIT Press,
1989.

OPAL- 1) Technical University of Berlin, strongly typed, higher-order, strict application
language, with Algerbriac specification. Uses parameterized structures rather than
polymorphism. 2) language for compiler testing said to be used internally by DEC. 3)
simulation language with provision for stochastic variables. An extension of AutoStart. 4)
previous name for Smalltalk DB. 5) DSP language.
http://uebb.cs.tu-berlin.de/~opal

ORCA- is a language for parallel programming on distributed systems, based on the shared
data-object model. This model is a simple and portable form of object-based distributed
shared memory. Developed by Henri E. Bal, Free University of Amsterdam.

OSCAR- 1) (Oregon State Controverial Aid to Research) interactive numerical calculations,
vectors, matrices, complex arithmetic string operations, for CDC 3300. "Oscar: A User's
Manual With Examples", J.A. Baughman. 2) OOL used in the COMANDOS Project, 1988

OSQL- (Object-Oriented Structured Query Language) functional language, a superset of
SQL, used in Hewlett-Packard's Open ODB Database System.

OZ- high-level language, combining constraint inference with concurrency. Dynamically typed
and has first-class procedures, classes, objects, exceptions, and sequential threads
synchronizing over a constraint store. Supports finite domain and feature constraints and has
powerful primitives for programming constraint inference engines at a high level.
Typical application areas of OZ include: optimization problems like scheduling, time tabling,
placement and configuration, reasoning and knowledge representation, processing of natural
language, simulation, multi-agent systems, and sophisticated GUIs.
The successor of DFKI OZ 2.0 is Mozart. DFKI OZ 2.0 is an interactive implementation
featuring incremental compiler, support for stand alone applications, an OO interface to
Tcl/Tk, and unique graphic tools for constraint programming. It provides an extensive library
of constraint propagators, distributors,and search engines, including special support for
scheduling. Users can add their own constraint propagators through a C++ interface.
It is a high-level PL that is designed for modern, advanced, concurrent, intelligent,
networked, soft real-time, parallel, interactive and pro-active application. Oz provides the
salient features of OOP, including state, abstract data types, objects, classes, and inheritance.
It also features the salient features of functional programming including compositional syntax,
first-class procedures/functions, and lexical scoping, and also provides the salient features of
logic and constraint programming including logic, variables, constraints, disjunction
constructs, and programmable search mechanisms.
Performance is competitive with the best Prolog and Lisp.
http://www.mozart-oz.org

PAL- 1) Paradox Application Language is the language for Paradox, Borland's relational
database. 2)Pedagogic Algorithmic Language is a language for teaching programming,
A.Evans Jr., 1968. 3) PDP Assembly Language for the PDP-8 and the PDP-11. 4) OO
Prolog-like language, K.Akama, Springer 1986. 5) for the AVANCE distributed persistent
OS.

PARASOL- (Parallel Systems Objects Language) OO, supports network and parallel
computing. Modules and exceptions.
ftp://ftp.uu.net/languages/parasol

PARLOG++- object-oriented plus parallel logic, built on top of MacParlog. Developed by
Andrew Davison, Imperial College.
parlog@doc.ic.ac.uk

PASCAL- father of Delphi. Developed by Professor Niklaus Wirth. Originally developed
primarily as a teaching language, but it has more often been recommended as a serious
language. But, according to Brian W. Kernighan the creator of C, it is not suitable for serious
programming,"It is suitable only for small, self-contained programs which have only trivial
interactions with their environment and that make no use of any software written by anyone
else".
Pascal is very good for writing well-structured and readable programs, but it is not as flexible
as C.
http://www.pascal.about.com
http://www.merlyn.demon.co.uk/pascal.htm
http://www.pascal-central.com

PECOS- constraint-based language, built on the OO module of Le-Lisp. "Pecos Reference
Manual", ILOG, Gentilly, France

PERL- (Practical Extraction and Report Language) or fondly as (Pathologically Eclectic
Rubbish Lister) an interpreted language optimized for scanning arbitrary text files, extracting
information from those files, and printing reports based on that information, for writing CGI
programs, for automating routines, on the server end, and "a million other things".
It has been described as the "Swiss Army Chainsaw" of Unix programming. It's motto might
be, "include everything that might help anyone, and to allow many ways to do anything".
Though Perl is very useful, it would be a stretch to describe it as pretty or elegant. People
who like a clean, spare design usually like Python.
Perl 5 provides the additional benefits: simplified grammar- the new yacc grammar is one half
the size of the old one, lexical scoping, arbitrarly nested data structures, modularity and
reusability, OO, embeddable and extensible, POSIX compliant, package destructors and
constructors, multiple simultaneous DBM implementations, regular expression enhancements,
and subroutinues that can now be autoloaded.
http://www.perl.com
http://www.cpan.org

PFL- 1) Persistent Functional Language- a functional database language. A. Poulovasslis,
King's College. 2) Parallel Functional Language- the first concurrent extension of ML using
CCS (more recent ones: Poly/ML, Concurrent ML) S. Holstrom, Pro-Declaration Language
Workshop, London, 1983.

PHOCUS- OO Prolog-like language. "PHOCUS: Production Rules, Horn Clauses, Objects
and Contexts in Unification Based System", 1987, France.

PHANTOM- an interpreted language designed to address some of the problems presented
by large-scale, interactive, distributed applications such as distributed conference systems,
multi-player games, and collaborative work tools. Phantom combines the distributed lexical
scoping semantics of Obliq with a substantial language core.

PHP- is an HTML-embedded scripting language. Much of it's syntax is borrowed from C,
Java, and Perl with a couple of unique PHP-specific features thrown in. The goal of the
language is to allow web developers to write dynamically generated pages quickly, utilizing a
full suite of programming tools.

PICO- a small language with semantics equivalent to Scheme, but a syntax closer to
elementary calculus.

PICT- is a language in the ML tradition, formed by adding a layer of convenient syntactic
sugar and a static type system to a tiny core. The current release includes a PICT-to-C
compiler, reference manual, tutorial, libraries for common data structures, example programs,
and a rudimentary X-based widgett toolkit. The core language, an asynchronous variant of
Milner, Parrow, and Walker's pi-calculus, has been used as a theoretical foundation for a
broad class of concurrent computations. The goal is to identify high-level idioms that arise
naturally when these primitives are used to build working programs, idioms such as basic
data structures, protocols for returning results, higher-order programming, selective
communication and concurrent objects. Developed by Benjamin Pierce, University of
Cambridge.

PIKE- is a dynamic language with a syntax that looks like C. It is simple to learn, doesn't
need long compilation passes and has powerful built-in data types that allow simple and fast
data manipulation. PIKE is GPL, which means that anyone can fetch it for free use, for
almost any reason.

PILE- (Polytechnic Instructional Language for Educators) similar in use to an enchanced
PILOT, but structurally more like PASCAL with AWK-like associative arrays (optionally
stored on disk).

PIRANHA- "Adaptive Parallelism and Piranha", Nick Carriero, Eric Freeman, David
Gelernter, and David Kaminsky, Yale University, 1994.
"Adaptive Parellelism refers to parallel computations on a dynamically changing set of
processors: processors may join or withdraw from the computation as it proceeds.
Networks of fast workstations are the most important setting for adaptive parallelism at
present. Under AP, the set of processors executing a parallel program may grow or shrink as
programs run. Potential gains include the capacity to run a parallel program on the idle
workstation in a conventional LAN-processors join the computation when they become idle,
and withdraw when their owners need them, and to manage the nodes of a dedicated
multi-processor efficiency".

PIRL- (Pattern Information Retrieval Language) a language for diagraph manipulation,
embeddable in FORTRAN or ALGOL, for IBM 7094. S. Berkowitz, Naval Ship Res Dec
Cntr, Washington,D.C.

PIZZA- is a strict superset of JAVA that incorporates three ideas from functional
programming: 1)Parametric polymorphism, 2) Higher-order functions, 3)Algebraic data
types.
PIZZA is defined by translation into JAVA and compiles into the JVM, requirements which
strongly constrains the design space. Thus PIZZA programs interface easily with JAVA
libraries, and programs developed in PIZZA may be automatically converted to JAVA for
ease of maintenance. The compiler is itself written in PIZZA, and may be used as a
replacement for Sun's JAVA compiler. (Except that the Pizza compiler runs faster)
Designed by Martin Odersky and Phillip Wadler, and implemented by Odersky.

PL/B- originally developed in 1972 as DATABUS(R), is currently the primary business
language for over 250,000 workstations in over 40 countries and is supported by at least
nine independent compiler companies on a broad range of hardware and OS. It supports
highly interactive business applications programming in individual and shared network
environment. It has been developed to be easily learned in shorter time frames and by less
experienced personel than a majority of other standard languages. The language structure
lends itself not only to easy code generation, but also to easy automated code analysis and
reengineering for future business programming environment.

PL/I- general-purpose, used for solving problems in a variety of fields such as commerce,
science (including mathematics, physics, chemistry), engineering (civil, electrical, aeronautics),
medicine, and so on. It can also be used for system programming, and the facilities are such
that it is rarely, if ever, to resort to machine-language or high-level programming to solve
problems.
The language of MULTICS, and it's downfall.

PLANKALKUL- May well be the first real computer programming language. The other
nomination for the "first" is ENIAC.
PLANKALKUL was developed by Konrad Zuse between 1943-45, while hiding out in the
Bavarian Alps. His prime motivation was the search for a chess opponent.
Mentioned in the 1978 ACM History of Programming Languages.

PLAIN- (Programming LAnguage for INteraction) PASCAL-like, with extensions for
database, string handling, exceptions and pattern matching. "Revised Report on the
Programming Language PlAIN", A. Wasserman, SIGPLAN, May, 1981

PLIANT- their goal is instead of making a new language with a few new interesting features,
make a very tiny highly modular language with a trivial syntax, where most advanced features
can be written in the language itself, as modules.
PLIANT's philosophy- prior languages focused on either semantics, pretending that a
program is a set of expressions (LISP), and so fail to get efficient handling by a computer, or
focused on efficiency, pretending that a problem is a set of instructions(C) and so fail to get
efficient handling by a human.
PLIANT is a full Development System that resembles an interpreted language since you can
write small pieces of code and run them directly, and also resembles a compiled language
since you can write very efficient programs as with a C or C++ compiler, use most high-level
programming features of OOL's, and the expression power of logical programming
languages.
It also resembles an ideal linker since you can write pieces of a project in various styles, with
each part using the optimum style for it's functional needs, and each part working perfectly
with each other, all with no redundant declarations or added interface code. At high-level
compile time, it uses a model close to logical programming with expressions that are rewritten
several times. But at low-level compiling, and, even more at execution time, it is no longer a
logical environment. Yet PLIANT is a true procedural environment (plenty of side-effects, no
garbage collection) because it is expected to be faster than C.
Key feature is the "Expression" data type, which is both syntactic or typed, depending on
needs of the program that processes the expression. Mainly it enables a smart link between
the high and low level compiling mechanisms.
It may be possible that the "Expression" representation of a program, and the PLIANT
compiling mechanism, are to languages, what many UNIX concepts (files, trees, processes)
are to OS's: the most simple, yet powerful model.
http://pliant.cx
http://freshmeat.net/projects/pliant

POLKA- object-oriented plus parallel logic, built on top of PARLOG. "POLKA: A
PARLOG Object-oriented Language", Andrew Davison, Parlog Group, London Imperial
College, 1988.

POLYGOTH- distributed language, integrated classes with a parallel block structure,
including multiprocedures and fragments. "Operational Semantics of a Distributed OOL and
it's Z Formal Specification", M. Benveniste.

PRESTO- a parallel language for shared memory multiprocessors, implemented as a C++
library. Provides classes for threads, spinlocks, monitors, and condition variables.
PRESTO is an environment for writing object-oriented parallel programs in the C++
programming language.

PROGRESS-(PROgrammed GRaph REwriting Systems) a very high-level language based
on graph grammars. Supports multiple inheritance and type of types, declarative specification
of graphical attributes, visual specification of graph rewrite rules.
Version 8 offers OO client-server application development through easy-to-use, highly
productive, component-based visual development environment.

POOL- (Parallel Object-Oriented Language) developed as a series of languages by Philips
Research Labs.
POOL-2- strongly typed, synchronous message passing, designed to run on DOOM
(Decentralised OO Machine) was a simulated 3D monster hunting game created for IBM
PC's. Original release was Jan 1, 1993.
POOL-I -"A Parallel OOL with Inheritance and Subtyping", P. America et al, SIGPLAN,
OCT,1990.
POOL-T - "Definition for the Programming Language POOL-T", Espirit Project 415, Doc
0091, Philips Research Labs, Eindhoven, Netherlands, June, 1985.

POP- the POP-11 language is similar to LISP in power, but with a more traditional (some
would say more readable) syntax.

POPTALK- a commercial OO derivative of POP, used in the Expert System Muse.
Cambridge Consultants.

POSTSCRIPT- language optimized for printing graphics and text (on paper, film, or CRT).
It is a page description language introduced by Adobe in 1985 and first appeared in the
Apple Laserwriter.
The main purpose was to provide a convenient language in which to describe images in a
device independent manner. This device independence means that the image is described
without reference to any specific device features so that the same description could be used
on any POSTSCRIPT printer without modification.
http://www./cs.indiana.edu/docproject/programming/postscript.html

POWERBUILDER- enables you to quickly build high-performance distributed client/server
applications. Sybase Inc.

PROBE- OOL based on OBJ^LISP. "Proposition d'une Extension Objet Minimale pour
PROLOG", Actes du Sem Prog en Logique, 1987.

PROFAN- is a scripting /batch language and a full programming language in one. It contains
a database development system with an integrated ODBC interface. It also contains an
interpreter and compiler.
http://profan.dnsalias.com

PROGRAPH- programs are constructed by directly manipulating a graphical representation
of the program. The diagrams are the code; there is no translation to a textual language.
PROGRAPH is a fully visual, dataflow-driven programming language designed for RAD
(Rapid Application Development). Users have commented on increases in productivity from
3-5 times over traditional text-based languages such as JAVA, C, and C++
It enables the creation of applications through the linking of icons into diagrams, which
replaces traditional complex blocks of textual code. This improves software quality by
reducing syntax errors. It increases productivity by eliminating lengthy and tedious
compile-link-debug cycles. The result is a web development environment, which has resulted
in a highly productive , low cost, development environment.

PROLOG- (PROgammation en LOGique) is a rich collection of data structures, and a
powerful notation for encoding end-user applications.It has logical and declarative aspects,
interpretive nature, compactness, and inherent modularity.
PROLOG is an ideal prototyping language. It's concept makes use of parallel architectures.
It solves problems by searching a knowledge base (or more correctly database) which would
be greatly improved if several processors are made to search different parts of the database.
It is taught with a strong declarative emphasis on thinking of the logical relations between
objects or entities relevant to a given problem, rather than on procedural steps necessary to
solve it. The system decides the way to solve the problem, including the sequences of
instructions that the computer must go through to solve it.
The "Rose" within the realm of AI. It originally became popular with AI researchers who
know more about "what" and "how" intelligent behavior is achieved. The philosophy behind it
deals with the logical and declarative aspects. PROLOG represents a fundamentally new
approach to computing and becomes a serious competitor to LISP.
http://www.als.com
http://www.ansi.com

PROMETHEUS- is a language designed for logic, mathematics, AI, and string and list
processing.

PROTEUS- a language designed for the specification and development of parallel algorithms.
http://wwwx.cs.unc.edu/research/proteus/proteus.html

PY- is a structured, interpreted language with automatic garbage collection. PY is a mixture
of PYTHON, EUPHORIA,C,BASIC, and JAVASCRIPT.
PY also contains variables automatically created on assignments, no need to declare types,
no difference between function and procedure, forward references, pass by reference.
PY is also interactive- you can enter code at the command line.
Developed by David Cuny.

PYTHON-OOL developed by Guido van Rossum, and named after Monty Python.(No one
Expects the Inquisition) a simple high-level interpreted language. Combines ideas from ABC,
C, Modula-3, and ICON. It bridges the gap between C and shell programming, making it
suitable for rapid prototyping or as an extension of C. Rossum wanted to correct some of the
ABC problems and keep the best features. At the time, he was working on the AMOEBA
distributed OS group, and was looking for a scripting language with a syntax like ABC but
with the access to the AMOEBA system calls, so he decided to create a language that was
extensible; it is OO and supports packages, modules, classes, user-defined exceptions, a
good C interface, dynamic loading of C modules and has no arbritrary restrictions.
The PYTHON newsgroup is extremely helpful and knowledgeable.
http://python.org

Q- a very high-level language based on generalized (lazy) sequences. Lexical scope, some
support for logical and constraint programming. Macros. implemented in C++.

QUEST- 1) a language designed for it's simple denotational semantics. 2) (QUantifers and
SubTypes) language with a sophisticated type systems. Just as types classify values, "Kinds"
classify types and type operators. Explicit universal and existential quantification over types,
type operators, and subtypes. Subtyping is defined inductively on all type constructions,
including higher-order functions, and abstract types. User-definable higher-order type
operators.

R- also known as GNU S, is a system for statistical computation and graphics. It consists of
a language and and a run-time environment with graphics, debugger, access to certain system
functions, and the ability to run programs stored in script files.

REBOL (pronounced REB-UL) is a messaging language that cuts application development
time and length. Represents a powerful new domain in computer languages as context
sensitive. very simple compared to JAVA, C++, or PERL. It is also more robust, reliable,
and readable. Is 100% platform and OS independent, and is available on over 30 platforms.
It is an internet native language, directly handling primary internet protocols such as e-mail,
Web, FTP. Typical applications include Web-site building and maintenance, e-commerce,
file-transfer, list management, newsgroup processing, e-mail filtering and processing, and
Web searches. rebol Technologies.
http://www.rebol.com

REFINE- high-level wide-spectrum specification language. Set theoric data types (sets,
mapping, sequences), first-order logic. Syntax-directed pattern matching, type inference, and
a declarative transformation operator (Pre and post conditions). Implemented as algorithms
which build and transform annotated abstract syntax trees. Compiled into Common LISP.

REGINA- is an implementation of the REXX language running on almost all of the UNIX
platforms, and Digital Equipment's DEC VMS.

RELFUN-(Relational Functional Language) logic programming language with call-by-value
(eager) expressions of non-deterministic, non-ground functions; clauses are Hornish,
succeeding with true, or footed, returning any values, and define operations (relations,
functions) allowing higher-order syntax with arbitrary terms (constants, structures, variables)
as operators.
http;//www.dfki.uni-kl.de/~vega/relfun.html

REXX- a procedural language that allows programs and algorithms to be written in a clean
form. It is easy to use by experts and casual users alike. REXX has been designed to make
easy the manipulation of the kinds of symbolic objects that people normally deal with such as
words or numbers. REXX has the capability to issue commands to it's host environment and
to call programs and functions written in other languages. REXX is also designed to be
independent of it's supporting system software when such commands are kept to a minimum.
Designed by Michael Cowlishaw, IBM (UK).
http://www2.hursley.ibm.com/rexx
http://www-4.ibm.com/software/ad/rexx

RPG- (Report Program Generator) is a language that originated as a report-building program
used in DEC and IBM minicomputer OS's, and evolved into a fully procedural language.
It's latest version RPG lll, is supported by IBM's leading minicomputer system, the AS 400.
Historically, it has probably been the second most used programming language, after
COBOL, for commercial applications on mid-range computers.
http://rpg.netpedia.net

RUBY- developed in Japan by Yukihiro Matsumoto (Matz). An interpreted scripting
language for quick and easy OOP. It is simple, straightforward, extensible, and portable. It
posesses a simple syntax, inspired by EIFFEL and ADA. Also has exceptional handling
features, like JAVA and PYTHON, to make it easy to handle errors. Has the ability to add
methods to a class, and even to an instance during run-time. Features true closures. Not just
unnamed function, but with present variable bindings, a true mark-and-sweep garbage
collector.
OS independent threading. Thus for all platforms on which RUBY runs, you have
multi-threading, regardless of if the OS supports it or not, not even on MS DOS.
Complete, full, pure OOL. Means all data is an object, not in the sense of PYTHON or
PERL, but like SMALLTALK.
More elegant than PERL, less parentheses than LISP.
Free, open source.
http://www.ruby-lang.org/en

S- is a very high-level language and an environment for data analysis and graphics. Written
by Richard A. Becker, John M. Chambers, and Allan R. Wilks of AT&T Bell Lab Statistics
Research Dept. more recently other Bell Lab researchers have made major contributions to a
new modeling capability in S.
The S language is the form in which S users express their computations. The environment
provides facilities for data management, support for many graphics devices, etc.
S is useful for computation in a wide range of applications. It's a very general tool, so that
applications are not restricted to any particular subject areas.
http://www.s-lang.org

SAS- (Statistical Analysis System) started as a statistical language and has changed a great
deal over the years. It now offers solutions for data wharehousing, data mining, data
visualization, application development, along with originally stat formats.
Now works on a wide range of servers and platforms from Windows NT to UNIX.
SAS can be found from the census bureau to the IRS and postal service, and Universities
and Colleges around the world.
http://www.sas.com

SATHER- OOL designed to be simple, efficient, safe, flexible, and non-proprietary.
One way of placing it in the "space of languages" is to say that it aims to be as efficient as C,
C++, FORTRAN, as elegant as and safer than EIFFEL, and support higher-order functions
and iterations abstraction as well as COMMON LISP, CLU, and SCHEME.
It aims to meet the needs of modern research groups and to foster the development of a
large, freely available, high-quality library of efficient well-written classes for a wide variety of
computational tasks.
It was originally based on EIFFEL but now incorporates ideas and approaches from several
languages.
SATHER has garbage collection, statically-checked strong typing, multiple inheritance,
separate implementation and type inheritance, parameterized classes, dynamic dispatch,
iteration abstraction, higher-order routines, exception handling, assertions, preconditions,
postconditions, and class invariants.
SATHER code can be compiled into C code and can efficiently link with C object files.
SATHER does have relatively long compile times.
SATHER K- a sublanguage of SATHER used for introductory courses in OO design and
typesafe programming. Integrates all features of the OO paradigm. Classes can be
implemented as generic, they can be embedded in hierarchical structures (by subtyping), and
they can reuse parts of other classes. The concept of streams gives the opportunity of easy
navigation through highly complex data structures.
pSATHER- is an extension of SATHER, which adds threads and synchronization
mechanisms to the language. Even though pSATHER programs can run on distributed
computer systems, they offer shared memory across all threads.
http://www.gnu.org/software/sather

SCALLOP- a medium-level language for CDC computers, used to bootstrap the first
PASCAL compiler.

SCHEME- is a statically scoped and properly tail-recursive dialect of the LISP programming
language invented by Guy Lewis Steele Jr. and Gerald Jay Sussman. It was designed to have
an exceptionally clear and simple semantics and few different ways to form expressions. A
wide variety of programming paradigms, including imperative, functional, and message
passing style, find convenient expression in SCHEME.
SCHEME has lexical scoping, uniform evaluation rules, and uniform treatment of data types.
It does not have the concept of pointers, uninitialized variables, specialized looping
constructs, or explicit storage management. In SCHEME all data types are equal. What one
can do to one data type, one can do to all data types. There are seven kinds of expressions:
constant, variable reference, procedure creation, procedure application, conditional,
assignment, and sequence.
Numbers are especially interesting in that an integer is a rational and a real is a complex.
SCHEME requires no looping constructs. Any function which calls itself in the "Tail" position
is just a loop.
SCHEME has several important advantages: it's elegantly simple in that regular structure and
trivial syntax avoids "special case" confusion. It's expressiveness means that one spends little
time trying to work around the language, it concentrates on what they want say rather than on
how to say it. It supports a variety of styles (including OO; allows users to better match their
solution style to the style of the problems to be solved.
http://www.schemers.org
http://www,swiss.ai.mit.edu/projects/scheme/index.html

SCREAMER- an extension of COMMON LISP that adds support for non-deterministic
and constraint programming. It consists of two levels. The basic non-deterministic level adds
support for backtracking and undoable side effects. On top of this substrate, SCREAMER
provides a comprehensive constraint programming language in which one can formulate and
solve mixed systems of numeric and symbolic constraints. Together these two levels augment
COMMON LISP with practically all of the functionality of both PROLOG and constraint
logic programming languages such as CHIP and CLP(r). Futhermore, SCREAMER is fully
integrates with COMMON LISP. SCREAMER programs can coexist and interoperate with
other extensions to COMMON LISP such as CLOS and CLIM.
First, SCREAMER code is transformed into COMMON LISP which can be compiled by
the underlying COMMON LISP system. Second, the backtracking primitives require fairly
low overhead. Finally, this overhead is only paid for those portions of the program which
uses the backtracking primitives. Deterministic portions of user programs pass through the
SCREAMER-to-COMMON LISP transformation unchanged.

SCRIPT X- OO, dynamic, time-based, multi-threaded multi-platform language for
interactive multimedia. Kaleida Labs.
http://web.kaleida.com/offical

SED- was first written in 1977 as a stream adaption of the ed editor and was released in
Version 7. Since that time it has been a staple in UNIX distributions. There has been no
significant changes since it's original release.
Due to it's simple yet powerful nature it quickly became an important tool of system
administrators. However, since the advent of PERL, use of SED has dramatically decreased,
so much so in fact, it's survival is questionable.

SEL- 1) Self-Extensible Language, "SEL- A Self-Extensible Programming Language", G.
Molnar. 2) Subset-Equational Language- a declarative language combining sets and
equational programming. Implemented in QUINTUS PROLOG and C, B. Jayarman,
SUNY, 1990

SELF- is an OOL for exploratory programming based on a small number of simple and
concrete ideas: prototypes, slots, and behavior.
Designed for expressive power and malleability. SELF combines a pure, prototype object
model with uniform access to state and behavior. Unlike other languages, SELF allows
objects to inherit state and to change their patterns of inheritance dynamically.
V 4.1 runs on Mac OS 8.6, Mac OS 9, SPARC workstations, and Solaris.
Developed by Sun Microsystems and Stanford University and made available by the SELF
Group in 1995. Sun is no longer involved with the SELF project.
http://self.sunlabs.com
http://www.openself.org

SEQUENCE L- a language for experimentation with declarative constructs for non-scalar
processing.

SEPIA- (Standard ECRC PROLOG Integrating Application) PROLOG with many
extensions including attributed variable (metaterms) and declarative coroutinuing. 1988

SIMULA- the first OOL. Developed in Oslo, Norway by Ole-Johan Dhal and Kristen
Nygaard of the Norwegian Computing Center in the 1960's. It was invented for writing
purposes and was later used as a basis for defining a general-purpose language.
It has been applied to almost all kinds of data processing, and has been implemented on
almost all types of computers, ranging from large mainframes to workstations to PC's.
Among other things, SIMULA introduced important OOP concepts like classes and objects,
inheritance, and dynamic binding.
The language was defined in 1967 in the "SIMULA Common Base Language". The language
definition has been maintained by the SIMULA Standards Group (SSG), and the latest
definition is found in the "SIMULA Standard", adopted by the SSG in 1986.
SIMULA 67- a general-purpose successor to SIMULA 1, in which the simulation support is
defined in OO terms. Introduced the record class, leading the way to data abstraction and
OOP.
http://wwwiisima.fr/asu

SINA- concurrent OOL, 1st language to adopt the Composition Filters Object Model
(CFOM), which is an extension to the OO model and can express a number of concepts in a
reusable and extensible way. CFOM has been developed by the TRESE Project at the
University of Twente Computer Science Dept.

SIRI- OO constraint language using a single abstraction mechanism. A conceptional blend of
BETA and BERTRAND. Similar to Kaleidoscope. B. Horn, 1992.

SISAL- high-performance, portable, parallel programming language. The objectives are to
develop high-performance compilers and run-time systems to simplify the process of writing
scientific programs on parallel supercomputers and to help programmers develop functional
scientific applications.
The SISAL Language Project was developed at the Lawrence Livermore National Lab,
University of California's Institute for Scientific Computing Research.
http://www.llni.gov/sisal/SisalHomePage.html

SMALLTALK- the pioneering OOP system developed by the Software Concepts Group,
led by Alan Kay, at Xerox PARC. It includes a language (usually interpreted), a
programming environment, and an extensive object library.
SMALLTALK took the concepts of class and message from SIMULA 67 and made them
all pervasive. The syntax is very simple. The fundamental construction is to send a message to
an object.
Innovations include the bitmap display, windowing system, and the use of the mouse.
Does not have multiple inheritance so each class can have at most one superclass.
According to the Webopedia, "Although it never achieved the commercial success of other
languages like C++ and JAVA, many consider it to be the only true OOPL, and the one by
which all others must be measured.
LITTLE SMALLTALK- a line-oriented near-subset of SMALLTALK 80 written in C by
Tim Budd. Version 3 runs on UNIX, IBM-PC, Atari, and VMS.
SMALLTALK V- the first widely available version of SMALLTALK, developed by
Digitalk in 1986 for IBM-PC and Macintosh.
http://www.bytesmiths.com
http://www.linuxprogramming.com/languages/Smalltalk

SMSL- (Standard Multimedia/Hypermedia Scripting Language) standard for multimedia
scripting in SGML/Hytime applications. Includes support for HTML scripts, also supports
Java and cgi.

SNAML- designed for both web and WAP site building as well as database connection, is
the kernel of the SNAML Solution. This consists of Professional, Enterprise, and Service
packages of 1) SNAML language, 2) SNAML Studio (an IDE to help rapidly building a
dynamic, consistent, and manageable site), 3) SNAML library (will provide common
functions) 4) SNAML Server (provides connection to http server such as Apache) 5)
SNAML Database (provide connection with database).

SNOBOL- is a special purpose language developed to provide a powerful means of doing
character string manipulated. Accordingly, it has a collection of powerful operations for doing
string pattern matchings. The most common early application of SNOBOL was to write text
editors.
Dynamically typed, has no type declarations and no restrictions on the data type of the value
of any variable. Interpreted.
Was invented at Bell Labs in 1962.
SNOBOL 4- quite distinct from it's predecessors. Declarative with dynamic scoping.
Success and failure used for flow control.
http://people.ne.mediaone.net/philbudne/snobol.htm
http://www.iucf.indiana.edu/Facilities/Computers/Softdir/snobol.html

SNOOPS- an extension of SCOOPS with meta-objects that can redirect messages to other
objects.'SNOOPS: An OOL Enhancement Supporting Dynamic Program Reconfiguration",
SIGPLAN, Oct 1991.

SPANNER- is a glue/scripting/prototyping programming language. It's primary focus is to
glue together components that are written in C++.
http://www.ataman.com/spanner

SQUEAK- is an open, highly portable SMALLTALK 80 implementation whose virtual
machine is written entirely in SMALLTALK, making it easy to debug, analyze, and change.
Quoting from Dwight Hughes, "Squeak extends the fundamental SMALLTALK philosophy
of complete openness- where everything is available to see, understand, modify, and extend
for whatever purpose- to include even the VM. It is a genuine, complete, compact, efficient
SMALLTALK 80 environment (not a toy). It is not specialized for any particular
OS/hardware platform. Porting is easy, you are not fighting entrenched OS dependencies to
move to a new system or configuration. It has essentially been put into the public domain,
greatly broadening potential interest, and potential applications. The core team behind
SQUEAK includes Dan Ingall, Alan Kay, Ted Kaehler, John Maloney, and Scott Wallace.
All of this has attracted many of the best and most experienced SMALLTALK programmers
and implementers in the world".
You can examine source code for every part of the system- graphics, primitives, and the VM
itself. One can make changes immediately without needing to see or deal with any language
but SMALLTALK. Any image file will run on any interpreter even if it was saved on
completely different hardware, with a completely different OS (or no OS at all).
The current SQUEAK interpreter combines a classical SMALLTALK 80 interpreter with a
simple yet efficient 32 bit direct-pointer object memory and incremental garbage collector. It
also includes a BitBLT graphics system that supports 1-, 2-,4-, and 8-bit indexed colors, as
well as 16 and 32 bit RGB colors, together with a "warp drive" that supports fast notation
and other offline transformations, as well as simple antialiasing. Other notable (and equally
portable) capabilities of SQUEAK include 16-bit sound input and output, and support for
sockets and general network access.
Organizations with significant SQUEAK interest include : The Create Project at UCSB,
UIVC, Georgia Tech, INRIA in France, and the University at Madgeburg, and Disney,
although Alan Kay and his core team has recently left their employ for brighter horizons.
To paraphrase the Liberal SQUEAK License: you are allowed to change SQUEAK, write
extensions, build an application, and include some or all of SQUEAK with your products.
You may distribute all of these things along with SQUEAK, or portions, for free or for
money.
If you modify any of the methods or class objects (or their relationships) that come with
SQUEAK, you must post the modifications on a web site or otherwise make them available
for free to others, just as has been done with SQUEAK. The same is true if you port
SQUEAK to another machine or OS.
This SQUEAK bears no relation to the SQUEAK language designed by Bob Pike and Luca
Cardelli in 1985, nor it's successor NewsSqueak.
The members of the SQUEAK newsgroup are a veritable Who's Who of the greatest
programmers the world has to offer.
http://www.squeak.org

SQL- (Structured Query Language) allows us to pose complex questions of a database.
Also provides a means of creating databases. If you know SQL, you can apply this
knowledge to MS Access, SQL server, Oracle, or Ingres and countless other databases.
Works with relational databases (stores data in tables, relations).
http://databases.about.com/compute/databases/cs/sql/
http;//www.codehound.com/SQL

SR- (Synchronizing Resources) is a language for writing concurrent programs. The main
language constructs are resources and operations. Resources encapsulate processes and
variables they share, operations provide the primary mechanism for process interaction. SR
provides a novel integration of the mechanisms for invoking and servicing operations.
Consequently, all of local and remote procedure calls, rendevous, message passing, dynamic
process creation, multicast, and semaphores are supported. SR also supports shared global
variables and operations.

SUNEIDO- Open Source, OOL. Client server relational database and application
framework written in C++ for Windows. Complete package including executable, library,
excellent documentation system and as Open Source, it comes complete with source code.
Designed to create, deploy, and maintain applications easier and quicker, with more features
and less code.
http://www.suneido.com

T3X- presents a small, portable, procedural, block-structured, recursive, almost typeless,
and to some degree, OOL. The goal is to facilitate productivity in exploring and inventing
algorithms.
http://www.homepages.de/home/nmh/welcome.html

Tcl/TK- (Tool Command Language)Tcl, or the "Tool Command Language", is a free
programming language. Tcl provides features such as variables, associative arrays, lists,
procedures, control, namespaces, and it runs on various OS, such as Windows , Linux, Unix
and Macintosh.
 Tcl was originally developed as a reusable command language for computer aided design
([CAD]) tools. The interpreter was implemented as a C library which could be linked into
any application. It is very easy to add new functionality to the Tcl interpreter, so it is an ideal
reusable "macro language" which can be integrated into many applications.
 Tcl is a programming language in its own right, which can be roughly described as a
cross-breed between LISP/Scheme (with less parens) and shells (with more powerful
structuring).Tcl programs are usually called "scripts" because the programs do not need to be
compiled into a machine-readable form. The program you write is executed directly by the
Tcl interpreter. Although the original Tcl interpreters were kind of slow, they now use
byte-code compiling and other modern technology to achieve performance on par with other
Scripting languages like Python or Perl.
 The Tk toolkit is almost synonymous with Tcl. Tk is a high level toolkit for developing
graphical user interfaces (GUIs). You can very easily build a GUI for a Tcl application, or for
a compiled program.
 Many extensions are available for the language, such as IncrTcl which provides a complete
OOP environment, TclHttpd which is a complete web server, Tcl/Java as an interface to the
Java programming language, BWidget a collection of high level composite widgets, and many
others...
 The Tcl newsgroup is extremely helpful and knowledgeable.
 Vincent Wartelle kindly provided this definition.
 http://www.tcltk.com/itcl
http://www.tclfaq.wservice.com/tcl-faq

TECO- early, string-processed language used by the first Emacs. It made maintenance hard,
and also made extensions hard to write.

TELESCRIPT- is a OO, remote PL. It is a platform that enables the creation of active,
distributed network applications. There are 3 simple concepts to the language: agents, places,
and "go". Agents "go" to places where they interact with other agents to get work done on a
user's behalf. Agents are in fact, mobile programs capable of transporting themselves from
place to place in a TELESCRIPT network.

TELOS- 1) The EuLISP Object System- the OO core of EuLISP. Incorporates ideas from
CLOS, OBJVLISP, and OAKLISP. Total merging of types with classes, and
message-passing with normal function application. 2) PASCAL-based AI language.

TEMPO- declarative concurrent programming language based on classical first-order logic.
Improves on usual CLL 9e.g. PARLOG) by explicitly specifing aspects of behavior of
concurrent programs, namely safety properties; gives advantages in writing concurrent
programs and manipulating them while preserving correctness.
http://www.cs.bris.ac.uk/tools/reports/Abstracts/tempo-iclp95.html

THETA- separate type and class hierarchies, multiple supertypes, single inheritance,
constrained parametric polymorphism, and subtype polymorphism.

TOM- an OOL derived from C. The language promotes useful as opposed to reusability. At
the same time, the class is also the unit of design. This implies that to reuse a class, the design
of the class must fit the design in which it will be reused. While this serves planned reuse, it
hampers unplanned reuse. Obviously, unplanned reuse is much more important if widespread
reuse is desired.
Extensions can call methods, variables, and superclass to a class. The source of the original
class is not relevant while it is extended it is not needed and does not need recompilation, nor
is recompilation required for any client code or subclass.
http://gerbil.org/tom

TOP- (Table-Oriented Programming) can be characterized as a programming language or
development method that makes dealing with tables, lists, indexing, sorting, searching,
filtering, and updating a native and direct part of the language.
Can be characterized by using tables to organize program logic, not just data. These tables
are called control tables and they offer benefits over both procedural and OOLs.

TRAITS- early OOL. Supported multiple inheritance and overriding of operations.
"TRAITS: An Approach to Multiple Inheritance Subclassing", G. Curry, 1982.

TRELLIS- formally known as OWL. OO with static type-checking and encapsulation. "An
Introduction to TRELLIS.OWL", C. Schaffert, 1986.

TURBO PASCAL- Borland's PASCAL environment. Perhaps the first integrated
development environment for MS-DOS. Version 1.0 - 3.0 is standard PASCAL with a few
extensions, Version 4.0 and 5.0 provide separate compilation, Version 5.5 is OO, and
Version 6.0 is the TURBO VISION with OOP library. 7.0 added compilation for protected
mode.
http://www.merlyn.demon.co.uk

TURING- OO, combining a programming language and a program development
environment.
TURING is a high-level programming language originally designed in 1982 by race Holt and
J.R. Cordy of the Computer Systems Research Institute at the University of Toronto.
There is a "regular" and an OO version .
http://ooturing.cjb.net
http://www.geocities.com/researchTriangle/7416/oot.htm

TYCOON- polymorphic persistent programming environment for the development of
data-intensive applications in open environment.

UFO- (United Functions and Objects) an architecture-independent parallel programming
language which runs efficiently on a range of parallel platforms.
Combines many of the properties of modern functional and OOLs. It is not purely functional
as it has stateful objects which encapsulates mutable state. However, the pure functional
subset is sufficient for many applications (the UFO compiler is written entirely in this style).
The recommended style for writing programs is to remain within the pure functional subset
except when their is a good case for using stateful objects.

UNLAMBDA- a functional language designed for obscurity.

V- is a new parallel language based on C. V extends C with a new type construction for
vectors and introduces parallelism using an apply-to-each construct and some built-in
primitives. The apply-to-each allows the simultaneous applications of built-in and
user-defined functions at all or some elements of a vector.

VIRT- a general-purpose OOL that provides the new technology of the dynamic data
structure processing. This technology allows you to process dynamic data structures (lists,
trees, and more) effectively without using pointers. It ensures laconic and uniform notation
and allows you to hide memory allocation and deallocation mechanisms.
Developments of this technology has allowed a designing of an efficient, versatile,
easy-to-undertand language capable of solving "orthogonal" problems such as character
calculations, numerical analysis, and logical conclusions.

VISUAL BASIC- released by MS in 1987. It was the 1st Visual Development Tool from
MS, and it was to compete with C/C++, PASCAL, and other well known languages. From
the start, VB wasn't a hit. It wasn't until v2.0 in 1991 that people really discovered the
potential of the language, and with v 3.0 it had become the fastest growing language on the
market.
Overall, you would class VB as a GUI, because as you draw, you write the program. It is
not only a language, but also a complete graphical development environment, this allows
quick development of MS Win applications which have the ability to use OLE objects, such
as an Excel spreadsheet.
VB's main selling point is the ease with which it allows the use to create nice looking,
graphical programs with little coding by the programmer. Unlike many other languages that
may take hundreds of line of programmer keyed code, as the programmer works in the GUI,
much of the program code is automatically generated by the VB program.
http://msdn.microsoft.com/vbasic
http;//www.vb-world.net

VISUAL BASICSCRIPT- a scripting language developed by MS, and supported by IE. A
subset Of MS VB, is a fast, portable, lightweight interpreter for use in Web browsers and
other applications that use MS Active X controls, Automation servers, and JAVA applets.
VBSCRIPT is designed to be a small, lightweight interpreted language, so it does not use
strict types (only variants). Intended to be safe, so it doesn't include file I/O.
Based on VISUAL BASIC, but is much simpler. In many ways, it is similar to
JAVASCRIPT. It enables Web authors to include interactive controls, such as buttons and
scrollbars.
Only works with MS IE. Doesn't work with Netscape navigator. This means that any code
written in VBScript cannot be used by a large proportion of the browsing public. Extremely
shortsighted.
http://www.devguru.com/technologies/vbscript/quickref/vbscript_intro,html

VISUAL C++- as MS/WIN and the benefits of the GUI become widely accepted, the
programming for Windows is in high demand. Programming for Windows is different from
the old-style batch or transaction-oriented programming. An essential difference between
them is that a Windows program processes user input via messages from the OS, while an
MS/DOS program calls the OS to get user input.
VISUAL C++ is a textual language which uses a GUI builder to make programming decent
interfaces easier to the programmer.
VISUAL C++ includes the following tools: MFC (Microsoft Foundation Classes) large and
extensive C++ class hierarchy library, Application Wizard code generator creates working
skeleton, Class Wizard generates code for a new class, Application Studio resource editor
which includes wysiwyg menu editor and a powerful dialog box editor.

WINDUCTOR- scripting language for Windows. it provides automation capabilities via
simulated input and/or COM, template expansion (useful for layout/content separation for
HTML generation). built-in functions for Ftp, HTTO, E-mail, multimedia, and CGI.
http://www.desisoft.com/Windctor

WINTERP- includes a small, portable, OO LISP interpreter (an event-driven version of
Betz/Almy/Tiernay et al's XLISP-PLUS0. WINTERP is the OSF/MOTIF Widget
Interpreter.

WOOL- (Window OOL) small COMMON -LISP-like extension language. Claims to be
the fastest interpreted language in C with run-time types. Version 1 used by the GWM
window manager. Version 2 has an object system.

XLISP- (eXperimental LISP) LISP variant with OO extensions, portable source in C.
ftp://cs.orst.edu/pub/xlisp/

XML- (Extensible Markup Language) similar to HTML. Used for creating
arbitrarily-structured documents and web pages. The language is a filtered version of SGML
(Standard Generalized Markup Language) but more suited for web-delievery with less
overhead common with SGML. Unlike HTML, XML specifies no pre-defined tags. Instead,
the semantics of an XML document are defined by the applications that process them.
XML files are written in ASCII text, so the information contained within an XML document
is exchangeable between otherwise incompatible systems. Although commonly associated
with the Internet, XML is not necessarily limited to such. Since it's main objective is the
organization of data, data exchange between different systems may be easily implemented by
passing XML documents.
The syntax of XML is completely ambiguous and really cannot be standardized. The authors
and clients of the documents must determine how their information is to be stored and
standardized it among themselves. It is a tagged language, much like HTML, however the
tags are not pre-defined. Instead, they are created based on the information contained within.
http://www.w3.org/XML

YAFL- OOL, garbage collected, strict, enhanced portability.
Is a modern coding language, as opposed to a specification or an abstract language. Is also a
high-level OOL and supports inheritance and parameterized classes. Safe and robust.
Includes a full-featured garbage collector.
A software engineering language, YAFL is a strict language, which includes an assertion
mechanism, as well as an original feature called the compiler support.
YAFL can be easily compiled into native or immediate code, it has designed in such a way
that no run-time type checking is needed, without sacrificing any safety features.
http://www.phidani.be/yafl

YERK- named after the Yerkes Observatory, an OOL based on a FORTH kernel with
some major modifications. Originally known as NEON, developed and sold as a product by
Kriya Systems from 1985-89.
Several people from University of Chicago have maintained YERK since it's demise as a
product. Because of possible Trademark conflict, they named it YERK.

YORICK- the language includes scientific visualization functions (with output to your screen),
Postscript or binary, text and binary I/O functions for reading and writing numbers by the
millions, and basic linear algebra functions adapted from the LAPACK libraries. Owing to
YORICK's array syntax, interpreted programs are compact, nearly free of explicit loops,
and can run at speeds up to 20 % of optimized compiled speed. This means it's fast enough
to do respectable calculations by itself, and to be used as a pre and post processor for
state-of-the-art physics simulation codes.
YORICK runs on UNIX workstations or mainframes, Maninyosh Power PC, or 68K
machines, and on Windows 95/NT.
Also available is the emac-based YORICK Development Environment.
http://www.cgd.ucar.edu/cms/pjr/yorick/index.html

Z- the formal specification notation, Z is based on set theory and first order predicate logic.
Developed by PRG (Programming Research Group) at the Oxford University Computing
Lab.

ZPL- OO extension of Z."Z++ an OO Extension to Z", Lano, Z User Workshop, Springer
Workshops in Computing, 1991.

ZUSE- named after Conrad Zuse, the designer of the first modern programming language-
PLANKALKUL. A descendant of ADA, MODULA-2, MESA, and OBERON;
supporting several levels of information hiding.
The ZUSE type system includes fully hidden types (similar to MODULA-2 opaque types but
without any implementation restriction), semi-open pointers, extensible record types (similar
to OBERON public projection types but without the compiler hint), enumeration types, and
extensible subrange types. A type can also be protected by specifing the operation that
particular modules may perform (similar to C++ friend classes and ADA private types).
ZUSE also includes hidden and extensible constants and hidden inline procedures. In order
to support the higher levels of information hiding the implementation employs partial
intermediate code linking.

XSCHEME- SCHEME with OO extensions. Source in C. Versions for PC, Macintosh,
Atari, and Amiga.



PART 3
ESSENTIAL COMPUTING LANGUAGE LINKS (in no particular order)

1) Programming Languages (236 examples in 97 languages)
http://www.unikarlsruhe.de/~uu9r/lang/html/lan.en.html

2) University of Michigan Language Guide
http://www.engin.umd.umich.edu/CIS/course.des/cis400

3) 99 bottles of beer in 220 different languages
http://www.ionet.net/~timtroy/funhouse/beer.html

4) Catalog of Free Compilers and Interpreters
http://www.idiom.com/free-compilers
An essential site for all programmers.

5) Dictionary of Programming Languages
http://cgibin.erols.com/ziring/cgi-bin/cep/cep.pl

6) The Language List
http://cui.unige.ch/langlist
An amazing effort by Bill Kennersley. The most complete list on the web. 2350 at last count.

7) Tunes Review of Computer Languages
http://tunes.org/review/Languages.html

8) Open Directory- DMOZ Directory project
http://dmoz.org/Computers/Programming/Languages
Has links in other languages.

9)Programming Languages for the PC
http://hem.passagen.se/zeela/

10) Review of Existing Languages
http://www2.tunes.org/review/languages.html

11) Programming Language Critiques
http://www.people.virginia.edu/~sdm7g/LangCrit
Some good links here.

12) Mark Leone's Home Page
http://www.cs.indiana.edu/~mleone/
Programming research Links

13) Programming Languages
http://www.ps.uni-sb.de/~mehl/cs/languages.html

14) Advanced Programming Languages
http://lsi.uniovi.es/~labra/APL.html

15) An Introduction to Programming Languages
http://www.andrewcooke.free-online.co.uk/andrew/writing/lang.html
Targeted at people who know one language and are interested in learning another.

16) Programming Languages
http://www-users.cs.umn.edu/~rieck/language.html
Problems with some dead links.

17) Programming Languages
http://publiclogica.com~stepneys/cyc/p/prog.htm
"For those who think the world begins and ends with C++ and JAVA, here's an incomplete
list of programming languages with descriptions".

18) The Retrocomputing Museum
http://www.tuxedo.org/~esr/retro/
The freaks, jokes, and fossils of computing history. Curators are Eric S. Raymond and John
Cowan.

19) Programming Language Table
http://www.spr.com/library/0langtbl.htm

20) Computer Science Bibliography
http://sunsite.informatik.rwth-aachen.de/dblp/db/index.html

21) FOLDOC- Free On-Line Dictionary Of Computing
http://foldoc.doc.ic.ac.uk/foldoc/index.html

22)Programmer's Oasis- Languages and Program Development Environments
http://users.utu.fi/sisasa/oasis/oasis-lang.html

23) Yahoo's Programming Languages
http://dir.yahoo.com/Computers_and_Internet/programming_languages/

24) Programming Language Ranking
http://web.yl.is.s.u-tokyo.ac.jp/enquate/vote.html
Vote on your favorite, and check the results.

25)Programming Languages
http://www.cs.walkato.ac.nz/~marku/language.html

26)Collected Information on 2350 Computer Languages
http://www.heuse.com/coding.htm
This is a different site then Bill Kennersley's, and has a search function by year.

27)Web Programming Languages
http://www.objs.com/survey/lang.htm

28)Programming Language List
http://oop/rosweb.ru/other/
2189 languages.

29)Gary's Encyclopedia; Computer languages
http://members.aa.net/~swear/pedia/languages.html

30)Fun With Computer Languages
http://www.vicksburg.com/~bryant/funnies/funny7.html
Some needed humor.

31)Cetus Links
http://www.cetus-links.org/
18,534 links on Objects and Components. Very well done and informative. Great place to
start.

32)Programming Language Resources
http://www.cs.cmu.edu/afs/cs.cmu.edu/user/mleone/web/language-research.html

33)Programming Language Critiques (new version)
http://galen.med.virginia.edu/~sdm7g/LangCrit
(Older Version, different author)
http://www.ai.mit.edu/people/pdp8/critiques/critiques.html

34)Internet FAQ Archive
http://www.ps.uni-sb.de/~mehl/cs/languages.html

35)Professor Gary T. Leavens, The Teaching About Programming Language Project
http://www.cs.iastate.edu/~leavens/teaching-prog-lang/home.html

36)Cameron Laird's Personal Notes on Ferment among Scripting Languages
http://starbase.neosoft.com/~claird/comp.lang.misc/core_enhancement.html

37)Dr John Stockton
http://www.merlyn.demon.co.uk
Pascal,Delphi,Ampere.


PART 4 LINKS TO COMPUTER LANGUAGE SOFTWARE

1)Freshmeat
http://www.freshmeat.net

2)Sourceforge
http://www.sourceforge.net

3)Dave's
http://davecentral.com

4)GNU
http://www.gnu.org

5)Linux
http://www.linuxapps.com

6)Iconix
http://www.iconixsw.com

7)Tucows
http://www.tucows.com

8)Cnet
http://www.cnet.com

9)Dr. Dobbs
http://www.ProgrammersVault.com

10)Gnome
http://www.gnomeapps.com

11)Apple Development Tools
http://developer.apple.com/tools

12)Programming Junkies
http://programmingjunkies.com

13)Web Tools
http://webdevelopersjournal.com/software/webtools.html

14)Developers City
http://developercity.cjb.net

15)The Programming Sharehouse
http://progsharehouse.com/index.pl

16)TX Text Control- is an ActiveX component that allows developers to add
advanced text processing features to their applications with minimum effort.
http://www.textcontrol.com


PART 5 Dr. SAMMET'S 26 PROGRAMMING LANGUAGES

1957 - FORTRAN
1958 - ALGOL
1959 - LISP
1960 - COBOL
1962 - SIMULA
1964 - BASIC
1966 - ISWIM
1970 - PROLOG
1972 - C
1975 - PASCAL
1975 - SCHEME
1977 - OPS5
1978 - CSP
1978 - FP
1980 - dBASE ll
1983 - SMALLTALK 80
1983 - ADA
1983 - PARLOG
1984 - STANDARD ML
1986 - C++
1986 - CLP (R)
1986 - EIFFEL
1988 - CLOS
1988 - MATHEMATICA
1988 - OBERON
1990 - HASKELL




PART 6 BIBLIOGRAPHY (in no particular order)

1)Andrew S. Tanenbaum
Modern Operating Systems
Prentice Hall 1992
Inventor of Minix, one of the inspirations for Linux

2)Maurice J. Bach
The Design of the Unix Operating System
Prentice Hall 1992

3)Brian W. Kernighan, and Dennis M. Ritchie
The Unix Programming Environment

4)F. P. Brooks
The Mythical Man-Month: Essays on Software Engineering
Addison-Wesley 1975
Good advice on how not to program, witty, informative.

5)Thomas J. Bergin and Richard G. Gibson
History of Programming Languages
Addison-Wesley 1995

6)Donald E. Knuth
The Art of Computer Programming
Volume 1- Fundamental Algorithms 3rd Edition 1997
Volume 2-Semi-Numerical Algorithms 3rd Edition 1997
Volume 3- Sorting and Searching 2nd Edition 1998
These books are MUST HAVES

7)Richard L. Wexelblat , Editor
History of Programming Languages
Academic Press 1981

8)Donald E. Knuth, Editor
Selected Papers on Computer Science
Cambridge University Press 1995

9)William Strunk and E.B. White
Elements of Style 3rd Edition
Allyn and Bacon 1979

10)Bjarne Stroustrup
The C++ Programming Language 1991 2nd Edition
Addison-Wesley
The C++ Bible, by the Creator of C++.

11)F.J. Corbato
On Building Systems That Will Fail
Avoiding Complexity and Striving for Simplicity
ACM, Volume 34, June, 1991
By the Father of Timesharing Addresses

12)Butler Lampson
Hints for Computer System Design
IEEE Software Volume 1 1984
Dated, but many good hints by one of the worlds best codemasters

13)David Taylor
Object-Oriented Information Systems
Planning and Implementation
John Wiley and Sons 1992

14)Clayton Walnum
Borland C++ Tips, Tricks, and Traps
David P. Ewing, Que Corp 1994

15)William S. Davis
Operating Systems A Systematic View
Addison Wesley #rd edition 1987

16)Mark Chambers
Procomm Plus
Inituitive Communications 1992

17)Alan Simpson
Understanding dBase lll Plus
Sybex 1986

18) Dean W. Gonzalez
Ada Programmer's Handbook and Language Reference
Benjamin/Cummings Publishing 1991

19)Think Pascal
Object-Oriented Programming Manual
Symantec 1991

20)C++
Development System for Power MacIntosh
Compiler Guide, User's Manual, Language Guide
Symantec 1995

21)Sherry J. Martin
Using Alpha Four
Que Corporation 1992

22) Murdock, Ross, Claggett
Information Systems for Modern Management 3rd Edition
Prentice Hall 1971

23)Neil Dale and Chip Weems
Pascal, Introduction to Pascal and Structured Design 2nd Edition
D.C. Heath and Co. 1984

24)Chuck Spahr
Object-Oriented Programming Power
Microsoft Press 1991

25)Michael Morrison
Presenting Java Beans
Sams Publishing 1997

26)Ellen Siever
Linux in a Nutshell
O'Reilly & Associates, Inc.

27)David Hunter, Ph.D.
The Essentials of C++
Research & Education Associations

28)Ivan Van Laningham
Python in 24 hours
Sams Publishing

PART 7 ABBREVIATIONS

ADL - Architecture Description Language
ADO - ActiveX Data Object
ADSL- Asynchronous Digital Subscriber Line
ADT - Abstract Data Type
AGP - Accelerated Graphics Port
ALU - Arithmetic/Logic Unit
ANSI- American National Standards Institute
AP - Adaptive Parallelism
ASP - Active Server Pages
API - Application Programming Interface
ASCII- American Standard Code for Information Interchange
ATH - Adobe Type Manager
BASIC- Beginners All-Purpose Symbolic Instruction code
BBS - Bulletin Board Service
BIOS- Basic Input Output System
BPS - Bits Per Second
BRU - Backup and Restore Utility
BWCC- Borland Windows Custom Control
CAD - Computer-Aided Design
CDF - Channel Definition Format
CERT- Computer Emergency Response Team
CGA - Color Graphics Adapter
CIFS- Common Internet File System
COM - Component Object Model
CMOS- Complimentary Metal Oxide Semiconductor
CORBA-Common Object Request Broker Architecture
CPAN- Comprehensive Perl Archive Network
CPU - Central Processing Unit
CU - Control Unit
CVS - Concurrent Versions System
DAO - Data Access Object
DBC - Design By Contract
DDE - Dynamic Data Interchange
DCOM- Distributed Component Object Model
DES - Data Encryption Standard
DFSG- Debian Free Software Guidelines
DHCP- Domain Host Configuration Protocol
DLC - Data Link Control
DLL - Dynamic Link Library
DNS - Domain Name System
Dpi - Dots per Inch
DRAM- Dynamic Random Access Memory
Dsl - Digital Subsciber Line
DSSA- Domain Specific Software Architecture
EDI - Electronic Data Interchange
EFF - Electronic Frontier Foundation
EGA - Enhanced Graphics Adapter
EJB - Enterprise Java Beans
ELKS- Embeddable Linux Kernel Subset
EMF - Expanded Memory Specification
EOF - End of File
EPSF- Encapsulated Postscript File Format
ETD - Element Type Declarations
EUV - Extreme Ultraviolet
FAQ - Frequently Asked Questions
FDS - Fundamental Data Structures
FDM - Frequency-Division Multiplexing
FMTYWTK-Far More Than You Wanted To Know
FSF - Free Software Foundation
FTP - File Transfer Protocol
FUD - Fear, Uncertainty, and Doubt
GCC - GNU C Compiler
GDI - Graphic Device Interface
GIF - Graphics Interchange Format
GNOME- GNU Network Object Model Environment
GPF - General Protection Fault
GPL- GNU Public License
GUI - Graphic User Interface
GUID -Globally Unique Identifier
HDD - High Density Drive
HDML- Handheld Devices Markup Language
HDSL -High Bit Rate DSL
HLL - High-Level Language
HMA - High memory Area
HTML- Hyper Text Markup Language
HTTP - Hypertext Transfer Protocol
IAB - Internet Architecture Board
IANA- Internet Assigned Numbers Authority
ICAAN-Internet Corp for Assigned Names And Numbers
IDE - Integrated Development Environment
IDL - Interface Definition Language
IDSL- ISDN DSL
IEEE-Institute of Electrical and Electronic Engineers, Inc.
I/O - input/output
IME - Input Method Environment
IP - Internet Protocol
IPC - Interprocess Communication
IRQ - Interrupt Request Line
ISDN- Integrated Services Digital network
ITS - Incompatible Timesharing System
JANET-Joint Academic Network
JAR - Java ARchive
JPEG- Joint Pictures Experts Group
JVM - Java Virtual Machine
KB - Kilobyte
LAN - Local Area Network
LBNL- Lawrence Berkley National Laboratory
LDAP- Lightweight Directory Access Protocol
MB - megabyte
MDA - Monochrome Display Adapter
MDI - Multiple Document Interface
MIME- Multi-purpose Internet Mail Extensions
MOO - MUD OO
MMU - Memory Management Unit
MPC - Multimedia Personal Computer
MPEG- Motion Pictures Experts Group
MPL - Mozilla Public License
MS DOS- Microsoft Disk Operating System
MSIL- Microsoft Intermediate Language
MSN - Microsoft Network
MUD - Multi-User Dungeon
NAP - Network Access Point
NC - Network Computer
NCP - Network Control Protocol
NCSA- National Center For Supercomputing Applications
NIC - Network Information Center
NID - Network Intrusion Detector
NFS - Network File System
NNTP- Network News Transfer Protocol
NS - Nanosecond
OOA - Object-Oriented Analysis
OODM- Object-Oriented Design Methods
OLE - Object Linking and Embedding
OO - Object-Oriented
OOL - Object-Oriented Language
OOP - Object-Oriented Programming
OPS - Open Profiling Standard
ORB - Object Request Broker
OS - Operating System
OSD - Open Software Description
OSI - Open Source Initiative
OWL - Object Windows Library
PAP - Password Authentication Protocol
PANS- Public Access Network Services
PCB - Printed Circuit Board
PCI - Peripheral Component Interconnect
PDA - Personal Digital Assistant
PDF - Portable Document Format
PDL - Program Design Language
PERL- Practical Extraction and Report Language
PNG - Portable Network Graphics
P3P - Platform for Privacy Preferences
PGML- Precision Graphics Markup Language
PGP - Pretty Good Privacy
PICS- Platform for Internet Content Selection
PIF - Program Information File
PING- Packet Internet Gopher
PLC - Programmable Logic Controller
PnP - Plug-n-Play
POSIX-Portable Operating System Interface
POP - Post Office Protocol
POTS- Plain Old Telephone Service
PPP - Point-to-Point Protocol
PPTP- Point-to-Point Tunnelling Protocol
PRI - Primary Rate Interface
PSDK- Platform Software Development Kit
PVC - Permanent Virtual Circuit
QEL - Quotation Exchange Language
RAD - Rapid Application Development
RADSL- Rate Adaptive ADSL
RAID-Redundent Arrays of Independent Disks
RAM - Random Access Memory
RCS - Revision Control System
RFC - Request For Comments
ROM - Read Only Memory
RPM - Red Hat Packet Manager
RSAC- Recreational Software Advisory Council
RSVP- ReSerVation Protocol
RTF - Rich Text Format
RTL - Register Transfer Language
SAN - Storage Area Network
SCSI- Small Computer Systems Interface
SDMI- Secure Digital Music Initiative
SDSL -Symmetric High-rate DSL
SET - Secure Electronic Transactions
SIMM- Single-in-line Memory Module
SLIP- Serial Line Internet Protocol
SMTP- Simple Mail Transfer Protocol
SOAP- Simple Object Access Protocol
SQL - Structured Query Language
SSL - Secure Sockets Layer
STD - Standard Template Library, State Transition Diagram
SWIG- Simplified Wrapper and Interface Generator
TA - Terminal Adapter
Tcl - Tool Control Language
Tcp - Transmission Control Protocol
TDM - Time-Division Multiplexing
TEI - Text Encoding Initiative
TIFF- Tagged Image File Format
TLD - Top Level Domain
TOC - Table of Contents
TSR - Terminate-and-Stay Resident
TTP - Trusted Third Party
TUI - Text User Interface
UDSL- Universal High-bit Rate DSL
UML - Unified Modeling Language
URI - Uniform Resource Identifier
URL - Uniform Resource Locator
UUCP- Unix-To-Unix Copy Protocol
VFS - Virtual File System
VGA - Video Graphics Array
VM - Virtual Machine
VML - Vector Markup Language
VOIP- Voice Over IP
VPN - Virtual Private Network
VRAM- Video Random Access Memory
VRML- Virtual reality Modeling Language
W3C - World Wide Web Consortium
WAP - Wireless Access Protocol
WDM - Wavelength-Division Multiplexing
WIDL- Web Interface Definition Language
WML - Wireless Markup Language
WORM- Write Once Read Many
WYSIWYG- What You See Is What You Get
XML - Extensible Markup Language
XMI - XML Metadata Interchange Format
XPointer- XML Pointer Language
XSL - eXtensible Stylesheet Language

评论列表
周星星
re: 计算机语言列表,看看你知道哪些,下次可以在简历上加些你“精通”的种类
“下次可以在简历上加些你“精通”的种类”
--- up!
oshj
re: 计算机语言列表,看看你知道哪些,下次可以在简历上加些你“精通”的种类
哈哈,有没有这样的牛人?
能达到这水平的:
精通如下字母开头的语言:ABCDEFGH
熟悉如下字母开头的语言:IJKLMNOP
了解如下字母开头的语言:QRSTUVWX
剩下的不知道属于哪种类别:YZ
(仅仅每隔一段时间修改一下它们的语法规则)

dlutyuanhongl
re: 计算机语言列表,看看你知道哪些,下次可以在简历上加些你“精通”的种类
嘿嘿,若真有那样的人,那就真是 牛——————人了。
pro21ms4
re: 计算机语言列表,看看你知道哪些,下次可以在简历上加些你“精通”的种类
     好多都没听过。。。。
醉柠檬
re: 计算机语言列表,看看你知道哪些,下次可以在简历上加些你“精通”的种类
7猫:
CWEB- an ANSI C implementation of the Web Literate programming language. version 3.1 
by Levy, Knuth, and Marc van Leeuwen is written in and outputs ANSI C and C++.

今天看c接口和实现。有literate programming的概念。google一下。发现是algorithm guru  Donald Knuth发明的方法。顺便学习一下了。 不知道你们用不用的。

发表评论
切换编辑模式