Programozás | Programozás-elmélet » Dictionary of Programming Languages

Welcome to the Dictionary of Programming Languages, a compendium of computer coding methods assembled to provide information and aid your appreciation for computer science history. Browse the dictionary by clicking on a section: A B C D E F G H I JK L M N O P QR S T UV WXYZ+ Get a full dump of the dictionary: List of Names Short Form Full Form A ABC Language type: S - block-structured Description: ABC is an interpreted procedural language designed to be a higher-level replacement for BASIC. The design of the language was originally based on a task analysis of programming work; ABC and its development environment were designed to make the work easier. ABC features a small, orthagonal set of data types, and a simple goal-oriented syntax. The data types are: strings, unlimit-precision numbers, records, lists, and associative arrays. Data handling is mostly performed by specialized commands that manipulate the lists, tables, and records. The language also has a substantial set of

high-level operators and I/O statements. To facilitate top-down programming, ABC supports refinement, a mechanism for declaring operations in-line and defining them later in the code. ABC the language is not really distinct from its programming environment (some dialects of Basic, and many of Lisp, also have this property). Expressions or statements in ABC can be part of function or predicate, or can be given directly to the environment for immediate execution. ABCs high-level operators and data structures allow many kinds of computations to be expressed very succintly. ABC has been used to write simple natural language parsers and databases ABC is available for some Unix systems, MS-DOS, and for the Macintosh. Some information is available on the web, and there are also books about the language. Origin: Geurts and Pemberton, 1987, after Geurts and Meertens, 1975-82 See Also: Basic Perl Rexx Logo S Remarks: The ABC environment is persistent, in the sense that any variable, function or

predicate defined during a session remains for later sessions until the user explicitly deletes it. This is similar to the persistence feature of the S data analysis language. One oddity of ABC is that it uses indentation to describe control structure nesting. Most languages use special markers of some kind to delimit areas of code (for example, BEGIN and END in Pascal), but ABC derives the semantic structure of the code from the amount of whitespace preceding source lines. Links: Introduction to ABC ABC download area Date: Last updated 12/6/97 Sample code: This example from the ABC web site indexes a document that is stored as a line-numbered array. HOW TO RETURN index doc: PUT {} IN where FOR line.no IN keys doc: TREAT LINE RETURN where TREAT LINE: FOR word IN split doc[line.no]: IF word not.in keys where: PUT {} IN where[word] INSERT line.no IN where[word] ACSL Language type: M - Mathematical or Simulation Description: ACSL - Advanced Continuous Simulation Language Originally a

simple FORTRAN preprocessor for continuous-system modelling, ACSL has been used since 1980. The language is a hybrid of system specification elements and procedural processing blocks. Newer ACSL products present a visual front-end but still use a FORTRAN-like syntax for the programs themselves. ACSL is a proprietary language, available from MSA Software. Origin: Mitchell and Gauthier Associates, 1981 See Also: SLAM FORTRAN Remarks: ACSL is used mostly be specialists in the areas of engineering design, biomedical modeling, and real-time system visualization. ACSLs primary strength is its ability to model complex systems with highly tuned numerical integration algorithms. ACSL is a commercial product, but demo versions of various ACSL systems are available from MGA. Sample code: PROGRAM ONE WHEEL " Simple model of a dynamical system " written in ACSL 1, circa 1982. INITIAL CINTERVAL CINT = 0.05 ALGORITHM IALG = 4 $ "RK3" CONSTANT X1IO = 0.0, X2IO=00, X1DIC=00, X2DIC =

00 CONSTANT M1 = 25.0, M2=20, DF=1000, K2=5000 CONSTANT TDONE = 15.0 K1 = 1000.0 END $ "OF INITIALIZATION" DYNAMIC DERIVATIVE X3= STEP(0.0) X1D = INTEG((-DF/M1)*(X1D-X2D) - (K1/M1)(X1-X2), X1DIC) X2D = INTEG((-DF/M1)*(X1D-X2D) - (K1/M1)(X1-X2), . (K2/M2)*(X2-X35.0), X2DIC) X1 = INTEG(X1D,X1IO) X2 = INTEG(X2D,X2IO) END "OF DERIVATIVE SECTION" TERMT(T .GE TDONE) END "OF DYNAMIC SECTION" END "OF PROGRAM" Ada Language type: O - Object-oriented Description: Ada is a block-structured language with many object-oriented programming features. It was originally designed for the US Dept. of Defense, and was intended to support large-scale programming and promote software reliability. Some of Adas features include: nested procedures, nested packages, strong typing, multi-tasking, generics, exception handling, and abstract data types. Primitive data types supported by Ada include a variety of numeric types, booleans, characters, references, and

enumerated symbols. Arrays, records (structures), and strings are Adas composite types With its emphasis on program safety, it is not surprising that Ada is a strongly typed language: all data elements must be declared as storing a particular type or subtype, and type enforcement is strictly applied both within and between modules. Ada supports a full complement of sequential control structures, as well as comprehensive exception handling. Ada is very strictly standardized and well documented as a language. Ada compilers undergo stringent validation with an official test suite. At least one free Ada compiler and several good commercial ones are available. Ada was named in honor of Lady Ada Lovelace (1815-1852), a friend and confidante of Charles Babbage. Ada was initially standardized in 1983, and was superseded by a new standard in 1995. These two versions are now known as Ada 83 and Ada 95. Origin: Jean Ichibah et al, 1978-1983. See Also: Pascal Algol Modula-2 Jovial CMS-2 Java

Remarks: Ada is a fairly complex language. It has a conventional but very rich Pascal-like syntax, with many specialized features. The best aspects of Ada are its support for generics (templates), its support for task synchronization, and its very good exception handling. Its worst features are its complex syntax, and the poor performance of the code generated by most early compilers. (by the late 1980s, compilers had improved, and modern Ada compilers generate code as fast or ever faster than that emitted from C or Fortran compilers). Note that Adas semantics include range checking on all integer types, and bounds checking on all arrays; these program safety constraints slowed down early compilers (later ones got better at it, and also added support for compiler directives and pragmas that disabled certain checks in final release code). Ada compilers tend to be very very strict, but if you ever got your program to compile you could be pretty sure it would at least do something

comprehensible (unlike, for example, C). Originally, Ada was designated as the ONLY language to be used for US DoD software development. This policy never really caught on, and by 1997 the rule was rescinded. Basically, the Defense Information Systems Agency (DISA) realized that even a language as painstakingly designed as Ada could not be a panacea. Links: AdaPower.com Ada resource page in Switzerland ACM SIGADA Ada Core Technologies Ada at DDC-I Date: Last updated 1/8/03 Sample code: -- simple programming with floating-point #s with Ada.Float Text IO; use Ada.Float Text IO; procedure Think is A, B : Float := 0.0; -- A and B initially zero; note the period I, J : Integer := 1; begin A := B * 7.0; I := J * 3; B := Float(I) / A; Put(B); end Think; Alef See: C Language type: S - block-structured Description: Alef is a compiled concurrent programming language similar in appearance to C, designed for network application development under the Plan 9 operating system. Data types supported

by Alef include various sizes of integers, reals, chars, string, tuples, structures, unions, arrays, and channels. The language supports definition of abstract data types and parameterized (generic) ADTs and functions. Alefs control constructs include a comprehensive set of conditional, goto, and loop statements, as well as error handling and parallel task synchronization. Alef also features a unique explicit tail recursion statement. Alef has been ported to a wide variety of hardware with the Plan 9 operating system, and also to SGI IRIX. The Alef language development system is available as part of the Plan 9 distribution. Spare but well-written documentation is available on-line. Origin: P. Winterbottom et al, Bell Labs (Lucent), 1995? See Also: C Limbo Remarks: While it resembles C in lexical flavor, Alef has a very different data type and execution model: it supports typed pointers (so-called fat pointers), parallel processes, guarded blocks, abstract data types, run-time type

information, and other high-level facilities that C does not have. Alef supports both pre-emptive multiprocessing (with its proc type) and cooperative co-routines (with its task type) Links: Plan 9 distribution page Plan 9 Users Guide Date: Last updated 11/7/99 Sample code: /* An Alef program to parse numbers out of * the string returned from /dev/time, and * print them from a separate proc. This is * a rather lame conglomeration of several * examples from Bob Flandreas Alef * Users Guide */ tuple(int, uint, byte*) strtoui(byte* str, int base) { int val; while(*str != 0 && whitespace(str)) str ; if(str == nil || *str == 0) return(0, 0, str); while(*str && !whitespace(str)) { if(!validdigit(*str, base)) return (-1, val, str 1); /* extract digit into val / str ; } return(1, val, str); } void receive(chan(uint) c) { int s; s = <-c; print("%d ", s); if (s == 0) terminate(nil); } void main(void) { chan(uint) c; alloc c; proc receive(c); int ret; uint val; int

fd; byte *p, buf[128], newp; fd = open("/dev/time", OREAD|OCEXEC); if (fd >= 0) { read(fd, buf, sizeof(buf)); for(p = buf; *p; p = newp) { (ret, val, newp) = strtoui(p, 10); if(ret >= 0) c <-= val; if(ret == 0) break; } } } Algol Language type: S - block-structured Description: Algol (for Algorithmic Language) was a very early block-structured compiled language developed a committee, and implemented by computing pioneer John Backus. It was designed for general-purpose industial and scientific programming. Dialects of Algol include the original Algol58, Algol60, Algol68, ABC Algol, Algol W, S-Algol, and many other variants. Algol58 was originally called the "International Algebraic Language" (IAL) Data types supported by Algol60 include booleans, various sizes of integers and reals, and strings. Support for strings was limited in standard Algol, but later dialects and implementations added more support. Algol60 was strongly typed in the sense that the

compiler checked parameter types in expressions and subroutine calls. It did not permit the declaration of new data types or data structures Arrays are the only composite data type in Algol60. Algol60 supported highly regular block structure and a complete set of control structures: if-then-else, case, while loops. One of Algols main contribution to programming was the introduction of block nesting and lexical scoping of local and block variables. Algol60 did not support any kind of general memory management or dynamic memory allocation. Various implementations of some Algol dialects are still available commercially. Information on the web seems sparse, but some documentation of Algol68 is available. Of course, many old programming books describe the language. Origin: J. Backus and P Naur, 1958-60 See Also: Algol68 Pascal Simula PL/1 C Jovial CLU Remarks: Algol itself is no longer widely used, but it had a profound effect on computer language design from 1958 onwards. Many of the

features that today we consider essential in a general-purpose language were first proposed for Algol60 or Algol68. Algol60 was probably the first computer language whose syntax was completely described with a formal grammar prior to writing the compiler! :) Algol60 as originally defined had no language statements specifically for I/O, which is common today but unique back in the late 1950s. One interesting aspect of Algol60 was its support for two kinds of subroutine parameter passing: call-byvalue and call-by-name. The call-by-name method, which allowed Algol to support a kind of dynamic scoping (a la Lisp) was supported with a slow but flexible mechanism called a thunk. The Unisys A-series computers were built especially to run Algol, and featured a machine language based on a part of the Algol standard. Links: http://www.gregpubcom/algolhtml http://www.cscoloradoedu/~humphrie/pl/algol60html Unisys Algol compiler description Unisys Software documentation (incl. Algol) U. of Michigan

Algol Description Date: Last updated 11/7/99 Sample code: // the main program, calculate the mean of // some numbers begin integer N; Read Int(N); begin real array Data[1:N]; real sum, avg; integer i; sum:=0; for i:=1 step 1 until N do begin real val; Read Real(val); Data[i]:=if val<0 then -val else val end; for i:=1 step 1 until N do sum:=sum Data[i]; avg:=sum/N; Print Real(avg) end end Here is a better example, written in the Algol60 publication language, from Jean Sammet courtesy of Glyn Webster. procedure problem (a, b); value a, b; integer a, b; begin integer k; real e; for k := 2 × (a ÷ 2) 1 step 2 until b do begin e := if prime(k) then sqrt(3 × k sin(k)) else sqrt(4 × k cos(k)); if prime(k) then putlist(k, e, prime) else putlist(k, e, nonprime) end end problem; Algol68 See: Algol Language type: S - block-structured Description: Algol68 was a greatly expanded and enhanced version of the Algol block-structured language. Many capabilities were added to the sound

framework of Algol60 to create a much more capable language for general application and systems programming. Algol68 introduced a large number of new features over previous versions: formalized syntax and semantics, parallel programming constructs, new data types and structuring methods, and type declarations. Primitive data types supported by Algol68 include booleans, chars, strings, integers, reals, complex numbers and references. Dynamic arrays, structures, and unions are available for building complex data structures Algol68 also supports separate compilation modules, as Algol60 did. Also like its predecessor, Algol68 is very strongly typed. A few implementations of Algol 68 and various dialects of it exist, including some for PCs and mainframes. Origin: A. van Wijngaarden et al, 1965-68 See Also: Pascal Ada Simula C Remarks: The original 1968 specification was revised in 1973, and it is this later specification that currently defines Algol68. The semantics of Algol68 require

dynamic memory management and garbage collection. Here is a list of some additional features that Algol68 added to Algol: o o o o complex numbers bit patterns indefinite-length strings flexible (resizable) arrays o modules and separate compilation The official syntactic and semantic definition of Algol68 was extremely complex, and used nomenclature unfamiliar to many computer programmers in those days (and today, for that matter). This helped make the language seem unfriendly and unaccessible to many practitioners. Links: Algol68 for OS/2 Some info about Algol68 Overview of Algol68 Date: Last updated 2/28/98 Sample code: mode node = struct ( int val, ref node left, right); ref node nonode = nil; loc ref node start := nonode; proc insert = (int v, ref ref node place) ref node: if place :/=: nonode then if v < val of place then insert(v,left of place) else #v > val of place# insert(v, right of place) fi else place := heap node := (v, nonode, nonode) fi; APL Language type: M

- Mathematical or Simulation Description: APL is an interpreted mathematical language characterized by its terse syntax and bizarre non-ASCII character set. It is very strong in all forms of arithmetic and matrix manipulation APL was invented in the 1960s, and has enjoyed some modest popularity ever since. Commercial and free APL implementations exist for most modern platforms. The original APL has been partly superseded by advanced variants, such as APL2, J, Origin: Iverson et al, IBM, 1960s See Also: J Matlab S Remarks: According to its fans, its expressive power allows a skilled programmer to create complex applications in a very short time. Sometimes, entire complex mathematical analyses can be coded in a couple of lines of code However, APLs unconventional structure and odd character set make it challenging to learn and master. Today, APL is used mainly in niches in the scientific, financial, and econometric communities. Links: FTP download area for APL, at Waterloo Official APL

Information site at ACM http://www.dyadiccom/ http://www.vectororguk/ Date: Last updated 2/20/98 Sample code: Unfortunately, the peculiar character set used by APL precludes placing a code example here. Sorry AppleScript Language type: C - Command or Scripting Description: AppleScript is a procedural, structured command language designed for the Apple Macintosh environment. It can be used to control programs, network operations, and user interfaces under MacOS. AppleScript scripts are compiled into some kind of intermediate code prior to execution. The syntax of AppleScript is meant to resemble spoken language: verbs, nouns, prepositions, and adjectives. A program consists of statements, terminated by end-of-line (like Tcl, csh, and other command languages; of course, there is a line continuation character). AppleScript offers a small complement of primitive data types: integers, reals, and strings. All manipulable entities in AppleScript are represented as objects, these objects

have various properties, and can accept certain commands. Composite data types, lists and records, are also considered to be objects in AppleScript. AppleScript is an object-oriented programming language, new object classes, called script objects, can be defined within the language. (New classes can also be defined by binary object modules called scripting extensions.) Values in AppleScript are typed, but variables are not; AppleScript does not enforce strong type checking. The language offers a conventional set of procedural control flow constructs, supports subroutines, and offers rudimentary error handling. For object-oriented programming, AppleScript supports single inheritance and delegation, as well as simple polymorphism. MacOS 7.5 was shipped with AppleScript 11, MacOS 8 is shipped with 112 Tutorials and documentation about AppleScript are available on the Internet, as well as example scripts and powerful extensions. The language itself is available from Apple or bundled with

some Macintosh applications, but utilities, editors, and other tools for developers are available free. Origin: Apple Computer, 1993 (MacOS System 7), 1994 (MacOS 7.5) See Also: HyperTalk VBScript Remarks: AppleScript is intended to turn MacOS into a completely customizable extensible work environment. Unix systems have shell languages for writing powerful command scripts, and Windows has OLE automation and Active Scripting for allowing applications to control each other; AppleScript serves both purposes (sort of). A scriptable application can be activated and controlled by AppleScript code. A recordable application can use the AppleScript system to record user actions as macros. Since the system shell, the Finder, is scriptable, AppleScript can control the overall operation of the computer. AppleScript is a descendant of Apples HyperTalk scripting language, in terms of syntax and general appearance. It is much more powerful than HyperTalk, however, and is not confined to a single

application as HyperCard was. An extensions to AppleScript is called an OSAX (meaning Object Scripting Add-on?). There is some controversy about what plural to use. Links: AppleScript Language Guide (V2, official) Scriptweb (Apple scripting resources) AppleScript FAQ List AppleScript FTP Area Date: Last updated 12/14/97 Sample code: -- Use the Finder to close all applications -- (by Joshua D. Baer) property specialApps : {"Finder"} tell application "Finder" set allApps to name of processes end tell repeat with someParticularApp in allApps if specialApps does not contain someParticularApp then tell application someParticularApp activate quit end tell end if end repeat Autolisp See: Lisp Language type: A - Application/Macro Description: Dialect of Lisp used as the extension language for AutoCAD(tm) and other products from Autodesk. Supported primarily for AutoCAD versions 11-13 In addition to normal Lisp features, Autolisp offered extensive facilities for

manipulating objects in a CAD drawing in CAD files, and for interacting with the user through the AutoCAD interface. Popular in the Autodesk user community. Origin: Autodesk, late 1980s See Also: Elisp Xlisp Remarks: In 1997, Autolisp was superseded by ActiveX automation (VB) as the primary extension mechanism for AutoCAD. Links: http://www.autodeskcom/autocad/ http://www.cisohio-stateedu/text/faq/usenet/CAD/autolisp-faq/tophtml http://www.cadshackcom/lispfilehtm Date: Last updated 12/7/97 Sample code: ;; Very simple example of interactive extension ;; for AutoCAD (Defun c:SF2ACRE () (setq SF (getreal "Enter area in square feet: ")) (setq AGREAGE (/ SF 43560.0)) (alert (strcat " The area in acres is " (rtos ARGEAGE 2 2))) ) Awk Language type: D - Database or Text-processing Description: Awk is an interpreted string-processing language developed at Bell Labs in the early 1970s. It quickly assumed its place as the utility language of choice for small UNIX data

transformation and parsing programs. Awk offered powerful regular expression pattern matching, handy line-oriented program structure, and enough conventional language features to let you get your work done. Awk did not support any kind of modularity nor type checking. In a typical Awk program, sections of code are applied to lines of data input as matched by regular expressions. Later versions of Awk supported multiple input files as well as subroutines and other advanced features. A version of new awk (circa 1985) is supplied with most UNIX systems. The most powerful and portable awk implementation is GAWK (Gnu Awk), available from the Free Software Foundation. Awk is a part of the POSIX Command Language and Utilities standard. Origin: Aho, Kernighan, & Weinberger, 1976-77 See Also: Perl Remarks: Awk remains moderately well-known in the UNIX community, but has been largely superseded by the more powerful Perl programming language. Awk is reputed to be one of the best languages in

which to write a program that will be incomprehensible to any reader, even its own author. Links: http://www.deloriecom/gnu/docs/gawk/gawk tochtml http://www.cisohio-stateedu/hypertext/faq/usenet/computer-lang/awk/faq/faqhtml http://www.leoorg/pub/comp/platforms/pc/msdos/programming/awk/indexhtml Date: Last updated 11/7/99 Sample code: BEGIN { if ("$#argv"==1) Col="$1"; else Col=1 } {Total = $Col; }; END { printf "Total for column %d with %d items: %d ", Col,NR,Total } B BASIC Language type: S - block-structured Description: The Beginners All-purpose Symbolic Instruction Code (BASIC) was designed by two graduate students at Dartmouth to be an easy first language for programming neophytes. Though the first version was compiled, most Basic systems were interpreters. Original Basic had a simple syntax that included a line number for every source line. Control structure mostly consisted of GOTO ### and GOSUB ###; simple conditional and bounded loop

constructs were also available. Original Basic provided numeric, string, and array datatypes, but no structures or objects Basic has enjoyed steady popularity and usage since about 1965, and has evolved greatly since then. Modern Basic dialects, such as Visual Basic, eschew line numbers, support objects, libraries, GUIs, databases, optimizing compilers, garbage collected dynamic memory management, and much more. Basic was and still still is loosely typed, and has poor support for enforcing program portability. Dialects and subsets of Basic are often designed as extension or macro languages for programming systems on PCs. Origin: John Kemeny & Thomas Kurtz, Dartmouth, 1963-64 See Also: Visual Basic LotusScript CorelScript VBScript VBA Remarks: It is very easy to learn and use Basic, but the language is not well adapted for large-scale programming. Also, the deficiencies in the early versions of the language lead to a splintering of the Basic community in the 1980s. Basic originally

ran on the IBM 704. Later, it was very popular on DEC PDP-11 computers, especially under their RSTS time-sharing OS. On Microsoft operating systems, Visual Basic is extremely popular because its development environment offers easy GUI development without the discipline needed for languages like C++ or Java. Various Basic dialects are also used for business programming, such as BBx and PowerBasic There are many commercial implementations of Basic available, mostly for PCs and Macs. On UNIX systems, tasks that might once have been done in Basic have largely been taken over by Perl. Contrary to popular belief, Microsoft did not invent Basic, nor was Basic invented for PCs. There is an ANSI standard for minimal Basic, X3.60-1978 Links: http://tijger.fysruunl/~bergmann/basichtml http://www.microsoftcom/vbasic/ http://intermid.com/basic/indexhtm http://www.basicgurucom/ http://members.aolcom/mkwebsite/indexhtml Sample code: REM Very very simple QBasic program PRINT "My Menu" PRINT

"Press 1 to clear the screen, or 2 to say Hello!" INPUT "What do you want to do"; choice IF choice = 1 THEN GOTO clrscr IF choice = 2 THEN GOTO hello clrscr: CLS PRINT "Done." END hello: PRINT "Hello, hello, hello!" END BCPL Language type: S - block-structured Description: BCPL was an early block-structure procedural language, fairly low-level, and used for system and small application programming in the early- and mid-1970s. BCPL is an operator-typed language; the data types of variables are defined by the operators applied (rather than being declared for the variable, as in Algol). Data items were untyped cells labeled with identifiers Data types supported by BCPL included integers, reals, bit patterns, I/O streams, various kinds of references, and vectors. Strings could only be used as constants The language supported simple control constructs like loops and conditionals, as well as means to declare subroutines and functions. The BCPL

system library, which evolved along with the language, provided I/O support and very simple memory management. Early versions of BCPL were machine native compilers, but nearly all recent versions have been translators. In other words, the BCPL compiler translates the BCPL code to an abstract machine language called INTCODE. The INTCODE data is then interpreted by a simple, fast virtual machine (typically coded in assembly language, C, or a mixture of the two). There were several academic implementations of BCPL in Britain. Free versions are available today for various Unix systems, the Amiga, MS-DOS, and other operating systems. Origin: Martin Richards, Cambridge University, 1966-67. See Also: C Algol Remarks: BCPL was the inspiration for two systems programming languages developed at Bell Telephone Laboratories in the 1970s: B and C. BCPL was originally designed in the UK, but was first implemented at MIT. At some British universities, it was used in the 1970s to teach programming to

undergraduates. The name BCPL stands for Basic Combined Programming Language. Many of the ideas in BCPL were taken from Algol60. Links: An Overview of BCPL BCPL Download area at Cambridge Date: Last updated 12/20/97 Sample code: // Routine to compute a checksum of a // named file, simplified from a compiler example. GET "libhdr" LET start() = VALOF $( LET args = LET instream = LET outstream = LET sum = VEC 50 0 0 314159 IF rdargs("FROM/A,TO/K", args, 50) = 0 DO $( writes("Bad arguments for CHECKSUM*n") RESULTIS 20 $) instream := findinput(args!0) IF instream = 0 DO $( writef("cant open %s*n", args!0) RESULTIS 20 $) selectinput(instream) UNLESS args!1 = 0 DO $( outstream := findoutput(args!1) IF outstream = 0 DO $( writef("cant open %s*n", args!1) endread() RESULTIS 20 $) $) $( LET ch = rdch() IF ch=endstreamch BREAK sum := (13*sum + ch) & #xFFFFFFF $) REPEAT UNLESS outstream=0 DO selectoutput(outstream)

writef("%n*n", sum) out: endread() UNLESS outstream = 0 DO $( selectoutput(outstream) endwrite() $) RESULTIS 0 $) Befunge Language type: T - Threaded or stack-based Description: Befunge is an interpreted low-level programming language that uses a unique data model and instruction set to perform computations on a coordinate grid. The Befunge machine model stipulates the existence of a pushdown stack, and a two-dimensional grid of cells. Each cell can hold a data item, which may be treated as an instruction or as data, depending on program execution. The "Instruction Pointer" can move in any of four directions: up, down, left, or right Befunges instruction set includes stack manipulation, arithmetic, rudimentary I/O, conditional branches (both horizontal and vertical), and many other operations. In Befunge-93, the grid was fixed in size: 80x24, but Befunge-97 allows an unlimited-size grid. In Befunge-93, the data types supported were 32-bit integers and bytes, but

Befunge-97 supports only machine-width integers. Befunge-97 also supports a broad set of interpreter directives (very roughly analogous to assembler directives or C preprocessor directives) to help the programmer take advantage of the larger grid. Several free implementations of both old Befunge-93 and newer Befunge-97 exist, some explicitly for PCs and at least one that is highly portable (based on Perl). Fairly good documentation and some example programs are available on the web. Origin: Chris Pressey, 1993. See Also: TECO INTERCAL Forth Orthogonal Remarks: Befunge with its relatives probably has a fair claim to being the weirdest programming language yet implemented. Even more mind-boggling is that it garnered enough of a community to warrant a second, expanded language definition and several additional implementations. In general, a Funge is a programming language based on a tiling coordinate space of cells and allowing arbitrary motion of the Instruction Pointer. Befunge is a

2-dimensional cartesian Funge Other popular possibilities are Unefunge (1-D) and Trefunge (3-D). It has been hypothesized that Befunge-97 is Turing Complete, but no proofs seem to be available. Links: Funge documentation resources Pascals Befunge Site (with FAQ & download) Visual Befunge-93 for Windows page Date: Last updated 3/2/98 Sample code: A Befunge program to compute a square root (by Jason Reed): v>00p10p>00g:10g/v ^:&< |:-1p00/2+< >93*^ >00g.@ A Befunge program to generate random integers (by Ken Bateman): 088+>v >+^1@ 1 -. >? ^: ^+: ^ BETA Language type: O - Object-oriented Description: BETA is a powerful object-oriented language intended for application development. It evolved in the Scandanavian object-oriented programming community, which helped originate object-oriented programming with Simula. BETA language features include: strong type checking, inheritance, concurrency, object persistence, runtime type identification, garbage

collection, polymorphism, and GUI support. The syntax of BETA is somewhat like Pascal and somewhat like C. Punctuation symbols are used for many syntactic elements in place of keywords, giving the code a terse, compact appearance. Origin: Madsen et al, Aarhus Univesity, 1983 See Also: Simula Java C++ Eiffel Oberon Remarks: BETA is an attempt to produce an all-around useful language with clean syntax and semantics, starting from a clean slate. The breadth of features in the BETA system is impressive, although the terse syntax may make the language a little hard to learn. A commercial implementation of BETA is available from Mjolner Informatics for most platforms. They also have a free evaluation version. BETA has been the vehicle for research into adding multi-programming and distributed computation to object-oriented languages. Mjolner and Aarhus U make a great deal of BETA documentation available, most of it in PDF or Postscript. Links: http://www.mjolnerdk/

http://www.cisohio-stateedu/hypertext/faq/usenet/beta-language-faq/faqhtml ftp://ftp.daimiaaudk/pub/beta/ Sample code: (* Link describes a linked list ) Link: (# succ: ^Link; (* tail of this Link ) elm: @integer; (* content element of this Link ) Insert: (* Insert an element after this Link ) (# E: @integer; R: ^Link; enter E do &Link[]->R[]; (* R denotes a new instance of Link ) E->R.elm; (* E=R.elm *) succ[]->R.succ[]; (* tail of this Link = tail of R ) R[]->succ[]; (* R=tail of this Link ) #) #) (* Test the linked list ) (# head: @Link do 1->head.Insert; 2->head.Insert; 6->head.Insert; 24->head.Insert; ( * head = (0 24 6 2 1) ) #) BLISS Language type: S - block-structured Description: Bliss was a low-level procedural language developed and used by Digital Equipment Corp. for system programming. Widely used by DEC in development of OS software and tools for PDP, DECsystem, and VAX lines of computers roughly 1971-1988. No longer widely used Bliss

supported various datatypes, but did not enforce strong type checking. It had a very powerful macro system that was heavily used in system coding, but which made crafting a compiler for the language more difficult. Because it was intended as a system programming language, it had features that allowed the programmer to do what is taught in the 1990s as the compilers job: register allocation, data structure packing definition, etc. Origin: Wulf, Russell et al, DEC, 1970? See Also: C Remarks: For the most part, BLISS was available only as a commercial product from DEC. There was one free compiler for the PDP-10, and DEC later released a BLISS-32 compiler to customers as an OpenVMS addon. Research on BLISS was done at DEC and at CMU. Because BLISSs useful lifetime does not intersect that of the WWW, it seems that very little information is available. BLooP Language type: S - block-structured Description: BLooP was a very simple recursive block structured language invented by Douglas

Hofstadter for his book Godel, Escher, Bach. It features simple subroutine structure, very simple number and boolean handling, and recursion. The interesting aspect of BLooP was that it offered only bounded loop constructs, and was therefore incapable of expressing certain general recursive computations. Origin: Hofstader, 1979 (implementation: Cowan, 1994) See Also: FLooP Remarks: Though Hofstadter doesnt mention it in GEB, BLooP is similar to early exercises in exploring the computational model of "Random Access Machines". Note the use of CELL(0) <= 2 and similar constructs Though BLooP was never intended to be more than an academic exercise, an implementation of BLooP in Perl was made. Unfortunately, I cant seem to find it It is interesting to note that, in order to limit the power of this language to only primitive recursive functions, and also not-so-coincidentally to make the halting problem for BLooP solvable, Dr. Hofstadter had to severly restrict the feature set

of BLooP: no GOTOs, no While loops, etc. Links: http://www.geocitiescom/ResearchTriangle/6100/gebhtml Implementation download Date: Last updated 12/6/00 Sample code: From GEB, Chapter 13: DEFINE PROCEDURE "GOLDBACH?" [N]: BLOCK 0: BEGIN CELL(0) <= 2; LOOP AT MOST N TIMES: BLOCK 1: BEGIN IF {PRIME?[CELL(0)] AND PRIM[MINUS[N,CELL(0)]]}, THEN: BLOCK 2: BEGIN OUTPUT <= YES; QUIT BLOCK 0; BLOCK 2: END CELL(0) <= CELL(0) + 1; BLOCK 1: END BLOCK 0: END C C Language type: S - block-structured Description: C is a fairly low-level block structured language with good support for system programming. C is renowned as the language of the UNIX operating system, but in fact is widely used in PC, Mac, mainframe, and other computing environments. The original C programming language, as described by Kernighan and Ritchie, had fair arithmetic support, simple data structures, subroutines, conventional flow control constructs, naked memory pointers, simple but useful I/O facilities,

and a powerful macro preprocessor. C was standardized, finally, in 1990; currently the ANSI ISO/IEC 9899 (as amended) defines the C language. The ANSI standard defines better data type handling and subroutine declarations for C, as well as standardizing on minimum I/O and other library facilities. Primitive data types supported in modern standard C are: several sizes of integers, reals, characters, pointers, and arrays. C does not have strings per se, but the language does have the convention that an array of characters ending with a nul (0) character can be treated as a string. Data aggregation types in C are structures (records) and unions. The C language has no I/O facilities defined as part of the syntax. The ANSI C standard defines an extensive but low-level standard library, including I/O mechanisms. The standard library was not really designed, it evolved out of the standard library functions supplied with C implementations on Unix systems. C is a powerful language for writing

tight, fast, highly tuned code in a language far more portable than assembly. C is low-level enough to write device drivers, and high-level enough to write GUI libraries Modularity in C is limited to one level of subroutines: all C names exist either at the global scope, file scope, or subroutine local scope. C has no built-in support for separation of module interfaces from module implementation, but a flexible set of conventions for employing the macro preprocessor to separate "header" files and "body" files has evolved to support this paradigm. C was extremely popular in academic and industrial computing thoughout the late 1970s through the early 1990s, and still enjoys a huge user community. The influence of C and UNIX on each other, and the pair of them on the rest of computing, cannot be underestimated. C also had a profound impact on the WWW: the first web servers and web clients were all written in C. Free and commercial C implementations are widely

available; one of the most popular free implementations is the GNU C Compiler (gcc). Information about the language is widely available on the web and in books Origin: Ritchie and Thompson, 1972-73; Kernighan and Ritchie, 1978 See Also: C Objective-C Algol BCPL Remarks: Dozens of fine books on C exist, the language is very well documented, and literally thousands of support libraries, toolkits, and code generators exist to aid the C programmer. Even though C has been somewhat displaced, perhaps justly so, by more advanced cousins like C it is still one of the most popular programming languages. A large number of free and commercial C compilers exist. Many UNIX systems are bundled with a C compiler (some people would say that, to be a true UNIX system, the box MUST include a C compiler). The great power and flexibility that C affords the programmer is its greatest strength and its greatest threat. Many programmers, from beginner to expert, find themselves "bitten" by Cs

implicit semantics, terse syntax, weak data type enforcement, and cavalier attitudes about memory references. Actually, C can be so terse, and its preprocessor is so easy to abuse, that a folklore has grown up around unreadable and incomprehensible C code. While many programmers disparage C for its lack of type safety and other advanced features, it is noteworthy that many if not most of the advanced functional, OO, and declarative languages created in the 1990s were first compiled or interpreted by C. Links: Association of C and C Users Intl Obfuscated C Code Contest C Users Journal C/C area at Yahoo! Date: Last updated 5/27/98 Sample code: #include <stdio.h> /* count lines of standard input / main(int argc, char *argv[]) { char lbuf[256]; int lcnt; for(lcnt = 0; fgets(lbuf,sizeof(lbuf) - 1, stdin); cnt printf("%d lines ", lcnt); exit(0); ); } C# Language type: O - Object-oriented Description: C# is an object-oriented language derived from C, with some features

from C++, Java, and Visual Basic. C# was designed by Microsoft, initially as part of their .net initiative Microsoft claims that C# offers the power and richness of C++ with the productivity of Visual Basic. As a language in the C family, C# offers the usual complement of primitive types: integers, reals, booleans, and characters. It also supports objects and arrays Unlike Java and C++, C# hides some of the distinction between primitive types and object types by automatically boxing and and unboxing primitive as objects. C# is strongly types and provides extensive compile-time and run-time checking; unlike Java, C# supports C-style unsafe pointers, but only within specially designate code sections. C# supports a string type that is an object, but otherwise tightly integrated with the rest of the language (just like Java). C# supports single inheritance, overloading, overriding, reflection, and polymorphism. Overriding must be done explicitly. Because C# was intended mainly to support

development on Windows operating systems, the C# object model is designed to correspond directly with Microsofts COM/DCOM object mode. C# also supports an interesting mechanism, called properties, that allow a coder to expose object methods but permits the user of those objects to treat them as object data attributes, reminiscent of CORBA IDL and the Self language. Other features supported by C# include structs, indexers, operator overloading, and control over parameter passing. C# is also designed to run on Microsofts Common Language Runtime (CLR), a Windows-oriented set of standard packages and object libraries. These standard packages available to C# include a wide variety of data structures, I/O facilites, network support, system interaction support, GUI objects (highly Windowsspecific), web services, COM, and much more. C# fully supports exception handling, although exceptions are not always used consistently in the standard packages. C# provides garbage collection and automatic

memory management. For creating code for handling GUI events and other external triggers, C# offers a novel form of delegation. This is probably the most complex feature of the language, and has not counterpart in C++ or Java, although Objective-C has something equivalent. Another novel features of C#, which is actually part of the Common Language Runtime, is the notion of Attributes. Attributes are meta-data about code, communications from the programmer to the compiler and run-time system. In C, such things are often done with pragmas and non-standard keywords; in Java, marker interfaces are used. Attributes are much richer than any similar capability in comparable languages They also add a very complex facet to the language, one which many developers will not need. Fortunately, it is possible to write many C# programs without uses attributes at all. Currently, the only full implementation of C# is provided by the Microsoft .net compilers Microsoft makes a command-line compiler

available free, under the unintuitive name of the ".Net Framework SDK" Other implementations are under development. Origin: Microsoft, 1999 See Also: C C++ Java Remarks: C# uses a single-rooted object hierarchy, just like Java does. This helps to simplify the creation of collection data types. Oddly, C# also integrates support for traversal of collections into the syntax of the language itself, with the "foreach" loop statement. While C# is a solid programming language that can stand on its own merits, most of the information available about the language ties it closely to the Microsoft Common Language Runtime. Under the CLR, code is compiled into an intermediate language, unimaginatively named IL, and the IL code is stored in selfdescribing binary assemblies. Abstractly, these assemblies can be thought of as code archives Concretely, they are really Microsoft PE-format executables. Exactly how the IL code executes is up to the implementor of the execution

environment; in Microsofts environment, the IL is translated into Intel machine code on a per-function basis. C# supports multi-threading, although the integration of threading and thread synchronization into the C# language is not as elegant as Javas approach. Many books and web sites are available for those that want to learn C#. Links: C# Help site C# Language Specification C# Resources C# Programming Index Date: Last updated 12/8/01 C* See: C Language type: P - Parallel or Multi-programming Description: C* is a dialect of C featuring extended syntax and semantics for supporting parallel processing. It was designed for application development on the Connection Machine line of SIMD massively parallel computers. Two fundamental added features distinguish C* from standard C: parallel data elements, and parallel computation domains. Each variable in a C* routine is either a mono (scalar) or a poly (parallel) variable. The programmer can define any number of named domains, with

domain-local parallel and scalar variables, and then define computations that take place in those domains. C* supports the same data types and control structures as C. C* is a commercial product, it was sold along with the Connection Machine CM2 and CM5 systems. No documentation seems to be available on the web. Origin: Thinking Machines Corp, 1987. See Also: Lucid Sisal Occam Remarks: The Connection Machine CM2 was an idiosyncratic parallel processing machine, typically sporting 16384 65536 simple processors each with local memory, and a simple interconnection scheme. Typically, it was used as a co-processor to a more conventional computer, like a VAX, which loaded programs into the CM and provided I/O services. The facilities of C* allowed the programmer to approach the machine at a high level, at the cost of not supporting some of the machines more specialized capabilities. C* was supported by a library of commonly used parallel algorithms written at a lower level, like sort and

search routines. Connection machines are no longer widely used, and C* is not well known. It was somewhat influential in the parallel computing community. Links: Connection Machine Services Date: Last updated 3/25/98 Sample code: // Adapted from the paper "The C* Parallel // Programming Language" by Andrews and Barszcz, 1992. // Skyline Matrix Problem solution #define N 4 #define BIG 1024 domain Matrix { float a; int i; int j; } A[N][N]; domain RHS { float b; int i; } B[N]; domain Skyline { float s; int i; int j; } SKY[BIG]; domain Vector { float element; int start; } I[N], J[N]; void main() { int k,l,m; float x[N], element; float rowsum, pivot; int NonZeros; readMatrix(); [domain RHS].{ i = (int)(this - &B[0]); } [domain Matrix].{ int offset = (int) (this - &A[0][0]); i = offset / N; j = offset % N; } for(k = 0; k<N; k ) { rowsum = 0; [domain Matrix].{ if (i == k) rowsum B[k].b = rowsum; } NonZeros = map(); = a; } /* put matrix in skyline form? / for(k=0;

k<(N-1); k ) { [domain Skyline].{ if ((i ==k) && (j==k)) Pivot ,= s; if (((i>k) && (j==k)) && (I[i].start <= k)) { s = s / Pivot; I[i].element = s; } if (((i==k) && (j > k)) && (J[j].start <= k)) J[j]element = s; if (((i > k) && (j > k)) && ((I[i].start <= k) && J[j]start <= k)) s = s - (I[i].element * J[j].element); } } for(k = (N-1); k > 0; k--) { [domain Skyline].{ if (((i <= k) && (j ==k)) && (J[k].start <= k)) J[j].element = s; } x[k] ,= B[k].b / J[j]element; [domain Skyline].{ if ((i < k) && (J[k].start < k)) b = b - (J[j].element * x[k]); } } [domain Skyline].{ if (i == 0 && j == 0) Pivot ,= s; } x[0] = B[0].b / Pivot; printf("x "); for(k = 0; k<N; k ) printf("%f ",x[k]); } C++ Language type: O - Object-oriented Description: C++ is a fairly complicated object-oriented language derived from C. The syntax of C++ is a lot

like C, with various extensions and extra keywords needed to support classes, interitance and other OO features. C++ was originally developed as an extension to C, but quickly evolved into its language. Despite some of the flaws it has inherited from C, C++ is a very popular language for application development on Unix systems and PCs. The C++ programming language offers a very broad range of OOP features: multiple inheritance, strong typing, dynamic memory management, templates (generics), polymorphism, exception handling, and overloading. Some newer C++ systems also offer run-time type identification and separate namespaces C++ also supports the usual features expected of an application language: a variety of data types including strings, arrays and structures, full I/O facilities, data pointers and type conversion. The C++ Standard Template Library (STL) offers a set of collection and abstract data type facilities. Because it is derived from C, C++ has a number of features that

support unsafe and defective software. The more recent C++ standards do support safe casts, but this feature is not yet universally available or employed. Also, C++ has dynamic memory allocation, but does not have garbage collection; this allows programs to mis-use and leak memory. C++ also supports dangerous raw memory pointers and pointer arithmetic. These low-level facilities are useful in some situations, but can increase the time needed for software development. Efforts at unifying the C++ language were begun in 1989. C++ was finally standardized by the ISO and ANSI in November, 1997. Information on C++ is widely available on the WWW, but language has no official home on the Web. Many C++ implementations exist, some of them follow the old tradition of translating C++ into C, while others are native compilers. A few free C++ compilers exist, the most notable of which is the GNU C/C++ compiler, GCC. Origin: Bjarne Stoustrup, AT&T Bell Labs, 1982-85. See Also: C Objective-C Ada

Eiffel Remarks: C++ is one of the most popular programming languages available today; in 1997 it was estimated that 1.5 million people knew how to write C++ code. The language is popular for several reasons: o o o o o o it is pragmatic it is powerful it resembles C which was also very popular it is used to write system and application programs for UNIX and MS-Windows, good compilers for it are available both for free and commercially there are plenty of good books about it available C++ is one of the most mature and certainly the most widely-implemented object-oriented language. Even so, it is missing some features that are considered obligatory in a new OOP language design: concurrency, persistence, automatic garbage collection, and reflection. In exchange for these deficiencies, C++ gives some things that system programmers especially like: determinism and control. Because very little need happen behind the scenes in C++ programs, they have low overhead and good performance. C++

has a number of notable features that make it powerful, but which make it easy to write undecipherable unmaintainable programs. First, it supports operator overloading for almost every operator in the language, include [] and () and and ->. Second, it support raw pointers Third, it supports both implicit and explicit type conversions, both built-in and programmer-defined. Fourth, it supports the C macro preprocessor Fifth, it allows the programmer to control the degree of data hiding enforced by object classes. Taken together, these features offer the programmer the ability to do great things, and but the potential for writing really awful code [Note: this is not theoretical -- Ive personally used and misused all of these features.] A wide variety of add-on libraries and utilities for C++ developers are available. Good compilers are available for all platforms. Links: C++ Report magazine The ISO/ANSI C++ Standard Ask the C++ Pro C++ FAQ lists Yahoo! C/C++ resources Date: Last

updated 6/30/2000 Sample code: // This is just a placehold until I write a // better example. #include <iostream.h> #include <String.h> main(int argc, char *argv[]) { String *s1; s1 = new String("Hello World!"); cout << *s1 << endl << "Length is:" << s1->length() << endl; } Cecil Language type: O - Object-oriented Description: Cecil is a pure object-oriented programming language developed at the University of Washington. Cecil was designed as part of the larger Vortex project at UW, and it is intended to provide a framework in which large, extensible software systems can be developed more easily. Some other goals of the project are orthagonality, efficiency, and ease-of-use. The Cecil language is based on a simple object model that supports multiple inheritance and multi-methods, dynamic inheritance, and optional static type checking. Unlike most OOP systems, Cecil allows subtyping and code inheritance to be used

separately, thus allowing run-time or external extension of object classes or instances. Like Objective-C, all object services in Cecil are invoked by message passing, and the language supports run-time class identification. These features allow Cecil to support dynamic, exploratory programming styles. Parameterized types and methods (generics, polymorphism), garbage collection, and delegation are also supported. Cecil also supports a module mechanism for isolation of independent libraries or packages. Cecil does not presently support threads or any other form of concurrency. A standard library for Cecil is also part of the project, it includes various collection, utility, system, I/O, and GUI classes.< The latest version of the Cecil language definition is 2.1, dated 3/97 Cecil currently runs on Unix and Linux systems. Origin: Craig Chambers, 1992. See Also: CLOS Java BETA C++ Eiffel Modula-3 Objective-C Dylan Remarks: Cecil has served as a research vehicle for object-oriented

programming techniques and for compilation techniques for dynamic object-oriented languages. The Vortex compilation system handles Cecil, a subset of Java, C++, and Modula-3. Its interesting to note that Vortex Version 2 is bootstrapped - the compiler is written in Cecil. Cecil/Vortex is a research vehicle, it is not clear whether the Cecil language will ever be well-suited for production application programming. It is also interesting to note that the official documentation for Cecil does not seem to include a single example program. Sample code: -- Adapted from Cecil Project v2.0 distribution tests method copy file using streams(name1@:string, name2@:string):void { let f1:unix file := open file(name1, open for reading); let f2:unix file := open file(name2, create for writing); (name1 || " is " || if(f1.is unreadable, {"not "}, {""}) || "readable"). print line; (name2 || " is " || if(f2.is unreadable, {"not "},

{""}) || "readable"). print line; while({ f1.before end }, { f2next := f1next; }); close(f1); close(f2); } let var name1 := ask("Name of input file: "); let var name2 := ask("Name of output file: "); print("Copying using streams."); copy file using streams(name1, name2); print line(" done."); CFML Language type: C - Command or Scripting Description: Cold Fusion Markup Language is a web scripting language designed to support dynamic page creation and database access in a web server environment. It is part of the commercial product Cold Fusion Web Application Server. The syntax of CFML is exceptional among executable scripting languages: it consists mostly of HTML-style tags for all statements and control structures. CFML is a weakly-typed language that supports only a few primitive types: integers, real numbers, strings, and dates. Several aggregate types are supported: arrays, lists, and associative arrays (also called

structures) Control structures supported in CFML include conditionals, several kinds of loops, and simple exception handling. Like many scripting languages, CFML supports dynamic interpretation of string data as code CFML does not offer the ability to define subroutines, but it does support defining custom tags which can serve in a similar capacity. Documentation about CFML is easy to obtain on the WWW. The only implementation of CFML is in commercial products from Allaire. Origin: J.J Allaire, 1995 See Also: PHP VBScript MAWL Remarks: In addition to execution state, the CFML environment offers persistent state through its application abstraction. The HTML-style tag syntax of CFML is sometimes inconveniently verbose. To alleviate this, the designers of CFML 4.0 added a mini-language named CFScript that offers assignment, simple controls structures, and CFML expression syntax within a single enclosing pair of tags. CFScript is roughly comparable to some other server-side scripting

languages like ASP and server-side Javascript. The current version of CFML, as of the late 1999, is 4.01 In addition to the basic language, it comes with wide support for database systems and SQL, common application protocols, regular expressions, and host system facilities. Links: Cold Fusion docs download Cold Fusion Adviser House of Fusion Date: Last updated 11/20/99 Sample code: A simple example of defining the body of a custom tag (from the CFML 4.0 documentation) <CFSWITCH EXPRESSION="#ThisTag.ExecutionMode#"> <CFCASE VALUE="start"> <CFIF StructIsEmpty(attributes.EMPINFO)> <CFOUTPUT>Error. No employee data was passed</CFOUTPUT> <CFEXIT METHOD="ExitTag"> <CFELSE> <!--- Add the employee ---> <CFQUERY NAME="AddEmployee" DATASOURCE="cfsnippets"> INSERT INTO Employees (FirstName, LastName, Email, Phone, Department) VALUES <CFOUTPUT> ( ‘#StructFind(attributes.EMPINFO,

"firstname")#’ , ‘#StructFind(attributes.EMPINFO, "lastname")#’ , ‘#StructFind(attributes.EMPINFO, "email")#’ , ‘#StructFind(attributes.EMPINFO, "phone")#’ , ‘#StructFind(attributes.EMPINFO, "department")#’ ) </CFOUTPUT> </CFQUERY> </CFIF> <CFOUTPUT><HR>Employee Add Complete</CFOUTPUT> </CFCASE> </CFSWITCH> CHILL Language type: S - block-structured Description: CHILL is a block-structured compiled language, standardized by the ITU, and designed for building large robust software systems. It is used mostly in the telecommunication area Intended for supporting large software development efforts, CHILL is a fairly large and complicated language. Its data type system is derived from that of Algol68; CHILL offers various numeric types, array and other composite types, references, and various function, I/O, and process synchronization data types. The language is strongly

typed: all data objects and expressions are typed and type checking is enforced. CHILL supports a full set of sequential control-flow operators: conditional, iteration, and goto. Strangely, early versions of CHILL did not support real numbers, only integers. It also provides full multi-programming and multi-processing support, as well as I/O and timing features. The syntax of CHILL is similar to related block-structured languages like Pascal and Algol. It has a large set of reserved words. CHILL supports features for building complex, reliable software systems: concurrency, exception handling, and real-time response guarantees. Several commercial CHILL programming systems exist, but the only free implementation seems to be GCC. Some information about CHILL is available on the web, but the actual language standard must be purchased from ITU or ISO. Origin: CCITT, 1976. See Also: Pascal Algol68 Ada Remarks: CHILL stands for CCITT HIgh Level Language; the language was defined by a

committee of telecommunication company representatives in 1972-75. The 1993 CHILL standard is ITU-T Recommendation Z.200 In the mid-1990s, object-oriented features were added to CHILL. The resulting extended language is sometimes called CHILL96. Links: The International CHILL Homepage GCC 2.9x supports CHILL Date: Last updated 2/22/01 Sample code: -- still looking for a good code example Cilk See: C Language type: P - Parallel or Dataflow Description: Cilk is a dialect of C extended with fine-grain parallelism. It was developed at M.IT as series of research projects studying parallelism and parallelizing compilers. All the fundamental data types and program structures supported by C are also available in Cilk. However, Cilk adds several new keywords to C to support dynamic, asynchronous multithreading The main facilities that Cilk adds to C are the ability to spawn function calls in parallel, and the ability to synchronize the parallel calls. Cilk is available free in source form from

the Cilk Project web site. It runs on multi-processor Unix and Linux systems, and has also been ported to Windows NT. Origin: Joerg, Leiserson, et al, MIT, 1995 See Also: C C* CSP Java SISAL Remarks: The current Cilk system is implemented as a Cilk-to-C translator, supported by a machine-dependent multithreaded runtime and scheduler. Note that Cilk was designed for shared-memory multi-processors, not loosely-coupled distributed systems. While Cilk was developed in academia, it is robust enough for developing sizable systems. Cilk programs have won or placed in several programming competitions. Links: Papers and Documents on Cilk DARPA project description Cilk for Windows NT Date: Last updated 11/7/99 Sample code: A Fibonacci example from the Cilk 5.2 reference manual #include <cilk.h> #include <stdlib.h> #include <stdio.h> cilk int fib(int n) { if (n < 2) return (n); else { int x, y; x = spawn fib(n - 1); y = spawn fib(n - 2); sync; return (x y); } } cilk int

main(int argc, char *argv[]) { int n, result; n=atoi(argv[1]); result=spawn fib(n); sync; printf("Result: %d ", result); return 0; } CLAIRE Language type: O - Object-oriented Description: Claire is an object-oriented language with powerful functional and logic rule programming features, intended for language research and specialized application programming. As an object-oriented language, Claire does support definition of classes and simple (single) inheritance. The class system is just a part of the complex type system that Claire supports, and which programmers can use to set up complex rules and conditions on subroutines. The syntax of Claire is terse, it makes heavy use of punctuation and grouping characters, like {} and :>, as well as a set of reserved words similar to that of C. The syntax is also very sensitive to correct use of white space. The primitive data types in Claire include various numeric types and strings, as well as program types like classes and

rules. Aggregate data types built into the language are lists, sets, and generalized (associative) arrays. Claire supports the usual sequential control constructs like conditionals and loops, plus exception handling. The language also supports implicit control flow in the form of searching of rules (like Prolog). Programs are composed of modules, which define separate name spaces. Modules can be defined statically or created dynamically. Claire has simple I/O facilities for reading and writing data. It does not have any support for multi-threading or extensive operating system interactions (which probably helps it stay portable). The current version of Claire, as of early 2003, was 3.2, with 33 just released The Claire implementation is written in C++ and Claire, and runs on Unix, PCs, and Macintosh. The Claire compiler, interpreter, and tools are available for free download in source form. Documentation is also available, along with scholarly papers about applications of the language.

Origin: F. Laburthe, Y Caseau, ENS Paris, 1995 See Also: Leda LIFE Prolog ML Modula-3 Self Remarks: The CLAIRE programming language was developed at the Ecole Normale Superieure in France, as a followup to a more complex programming system named LAURE. The name stands for Combining Logic, Assertions, Inheritance, Relations, and Entities. Current application areas for Claire seem to be combinatorial optimization and scheduling. The language itself does not define GUI facilities, but the current Claire implementation does support a Tcl/Tk interface library. Links: CLAIRE papers and documentation Download area for CLAIRE and documentation Commercial CLAIRE Date: Last updated 1/10/03 Sample code: // Very simple Fibonnacci example adapted from v2.1 // "Introduction to the CLAIRE Programming Language" begin(fib module) fib[n:(0.10)] : integer := (if (n < 2) 1 else fib[n - 1] fib[n - 2]) test() -> (for i in (0 . 10) printf("fib(~S) = ~S ",i,fib[i]) end(fib

module) Clean See: Concurrent Clean Language type: F - Functional or lambda-based Description: Clean was the name for an early form of Concurrent Clean, a pure functional language designed at the University of Nijmegen. Click on the link above to view the entry for Concurrent Clean Date: Last updated 1/2/98 CLU See: Algol Language type: S - block-structured Description: CLU is a compiled imperative language with extensive features for defining and employing abstract data types. It was intended for general application development, and also as a research vehicle in computer language design. As was a descendant of Algol, CLU offered syntax that was similar to Algol60 in many respects, but it added data type abstraction, exception handling, and other advanced features. The name "CLU" is short for "CLUster", this was chosen because a CLU program normally consists of procedures, clusters, and interators. CLU supported a number of advanced features for structured

languages for its day, including garbage collection, a form of inheritance, iterators, strong typing, generics, and exception handling. The research operating system SWIFT was written in CLU, as were other tools and utilities. A free CLU compiler named PCLU is available from MIT. There is also a CLU->C translator named clu2c available from Tokyo Tech. Some information about CLU is available on the web, but not much Origin: B. Liskov et al, 1974-77 See Also: Pascal Ada Modula-2 Lisp Simula C++ Remarks: CLU was mostly a research vehicle for experimenting with data abstraction and other language design issues. Some of its ideas, especially in the area of exception handling, have been adopted in newer languages like Ada and Java. The ideas for CLU were derived from a programming methodology, also defined by Barbara Liskov and her colleagues, that emphasized abstract data types and modularity. While CLU is syntactically similar to Algol, its data storage semantics are more like those

of mainstream Lisp (and, much later, Java). All objects in a CLU program live in the heap, and memory management is automatic. This sort of a approach does eliminate much of the semantic complexity associated with multiple forms of programmer-managed object storage observed in C++. Links: ftp://ftp.lcsmitedu/pub/pclu/ Date: Last updated 2/28/98 Sample code: % Driver and function to compute factorials % from the PCLU distribution. start up = proc () pi: stream := stream$primary input() po: stream := stream$primary output() while true do stream$puts(po, "Enter an integer (or RETURN to exit): ") s: string := stream$getl(pi) if string$empty(s) then break end n: int := int$parse(s) except when bad format: stream$putl(po, "Illegal integer") end stream$putl(po, int$unparse(n) || "! = " || int$unparse(factorial(n))) except when negative: stream$putl(po, "Integer must be positive") when overflow: stream$putl(po, "Overflow") end end end start up

factorial = proc (n: int) returns (int) signals (negative, overflow) if n < 0 then signal negative end if n = 0 then return(1) end return(n*factorial(n-1)) resignal overflow end factorial CMS-2 Language type: S - block-structured Description: CMS-2 is a general-purpose programming language used almost exclusively for real-time and embedded applications for the US Navy. A CMS-2 module consists of two sections: a global declarations "SYS-DD" block and a code "SYS-PROC" block. Both global and local data, as well as procedures, can appear in the SYS-PROC block Depending on the compiler, there are various facilities for source code inclusion and cross-module linking. Data types in CMS-2 include: integer, fixed-point and floating-point numbers, fixed-length strings, and enumerations. Identifiers are strongly typed, but unlike Pascal and Ada most versions of CMS-2 had facility for type declaration. The only aggregate data type in CMS-2 is the array CMS-2 has a

conventional complement of imperative control-flow statements, but with peculiar syntax. Loop statements offer special exit/resume facilities; it is even possible to resume a loop after having exited it! CMS-2 also offers several kinds of index jump table statements (like Fortrans computed GOTO but more complicated). Over a dozen implementations of CMS-2 were created in the 1970s and 1980s for various US Navy system architectures. A few are still available for sale today through the Navy NUWC There do not appear to be a free compiler. Origin: Rand Corporation, US Navy, 1974? See Also: Ada Jovial Fortran Remarks: At the time of a major survey in 1995, it was found that over 14M SLoC of CMS-2 had been written for US military systems. (This is compared to 325M SLoC for C and 43M for Ada) Over its useful life from about 1976 to 1986, there were several dialects and variants of CMS-2. Mostly, they were divided by the processor word size of the target military CPU: CMS-2/Y and CMS-2/M

were for 16-bit machines, and CMS-2/L for 32-bit. CMS-2 was notorious for being difficult to parse correctly, and for offering programmers numerous ways to write incorrect or confusing code. For example, aliasing of data values could be specified at the word, array, or bit levels. The MTASS/M and MTASS/I code development environments were developed for CMS-2. Today, documentation and reverse-engineering tools for CMS-2 are still available, mostly in support of the US Navys Y2K code conversion efforts. No documentation on the language seems to be available on the WWW, although it can be found for sale. Links: NSS/SECR Product Info page CMS-2 to Ada translation Date: Last updated 10/19/98 Sample code: Insufficient documentation for producing a reasonable example. COBOL Language type: S - block-structured Description: COBOL, the COmmon Business-Oriented Language, has been in continuous widespread use since the early 1960s. The name says it all; this language was designed to meet the

needs of banks, manufacturers, bureaucracies, and other big organizations with data handling and report generation requirements. Its verbose quasi-english syntax, and formidable output formatting capabilities make COBOL unique, and well-suited to its niche. A COBOL program normally consists of four divisions: identification, environment, data, and procedure. COBOLs environment division is an attempt to make programs more portable by forcing the programmer to enumerate all in one place the resources and facilities that the program would require. Traditional COBOLs feature set is idiosyncratic: only static data structures are supported, numeric variables can be binary or decimal, with extensive support for range checking and output formatting, extensive string manipulation support, and simple flow-control constructs. Record structures and arrays are the primary means for organizing data, but no pointers or references are available. The language is very often employed along with a

database, and most implementations include extensive database support. COBOLs support for complicated calculations is modest, and some implementation dont even support recursion. COBOL was first defined in 1960, really standardized by ANSI in 1974, and the standard was revised in 1985. The current standard is ISO/ANSI 85, but a new standard is in review and should be issued in 1998 The new standard will have various OOP features and more comprehensive computational features. The intent is to modernize COBOL while preserving the extensive worldwide investment in COBOL software. Several high-quality, mature commercial COBOL compilers are available, mostly for mainframe and Unix platforms. DOS and Windows COBOL compilers also exist, but there do not seem to be any free or shareware compilers (not surprising given the ANSI standards size and complexity). Origin: US DOD GPO, 1960; CODASYL Committee, 1960. See Also: PL/1 Remarks: To a computer scientist trained with languages like Pascal,

Scheme, Fortran, and C, a COBOL program seems remarkably bloated and ineffectual. It has been stated that there is more COBOL code on our planet than any other single language, and COBOL programming is still taught in business schools worldwide. Adm. Grace Hopper is regarded as the primary progenitor of COBOL; her pioneering work on business- oriented computer languages in the 1950s (including FLOW-MATIC) was instrumental in the definition of COBOL in 1959-60. Businesses huge investment in COBOL through the 1970s, 80s, and early 90s has become a huge potential problem with the approach of the year 2000. COBOLs facilities for numeric data storage, input, and output are heavily oriented toward pictures, templates of the presentation format of a number. Much of the COBOL software written prior to about 1990 used two decimal digits to represent the year in any date. This creates a potentially catastropic ambiguity in 2000. COBOL programming expertise is in great demand as companies

scramble to assess and correct their legacy systems. Links: COBOL Home Page ILSs COBOL Gold Mine Flexus COBOL Page COBOL FAQ COBOL Standards WG Date: Last updated 12/1/97 Sample code: IDENTIFICATION DIVISION PROGRAM-ID. SUM-OF-PRICES AUTHOR. TERENCE-PRATT SOURCE. PROGRAMMING-LANGUAGES-2ND-EDITION-1984 ENVIRONMENT DIVISION. INPUT-OUTPUT SECTION. FILE-CONTROL. SELECT INP-DATA ASSIGN TO INPUT. SELECT RESULT-FILE ASSIGN TO OUTPUT. DATA DIVISION. FILE SECTION. FD INP-DATA LABEL RECORD IS OMITTED. 01 ITEM-PRICE 02 ITEM PICTURE X(30). 02 PRICE PICTURE 9999V99. 02 FILLER PICTURE X(44). FD RESULT-FILE LABEL RECORD IS OMITTED. 01 RESULT-LINE PICTURE X(132). WORKING-STORAGE SECTION. 77 TOT PICTURE 999999V99, VALUE 0, USAGE IS COMPUTATIONAL. 77 COUNT PCITURE 9999, VALUE 0, USAGE IS COMPUTATIONAL. 01 SUM-LINE. 02 FILLER VALUE SUM =PICTURE X(12). 02 SUM-OUT PICTURE $$,$$$,$$9.99 02 FILLER VALUE NO. OF ITEMS =PICTURE X(21) 02 COUNT-OUT PICTURE ZZZ9.99 01 ITEM-LINE. 02 ITEM-OUT PICTURE X(30). 02

PRICE-OUT PICTURE ZZZ9.99 PROCEDURE DIVISION. START. OPEN INPUT INP-DATA AND OUTPUT RESULT-FILE. READ-DATA. READ INP-DATA AT END GO TO PRINT-LINE. ADD PRICE TO TOT. ADD 1 TO COUNT. MOVE PRICE TO PRICE-OUT. MOVE ITEM TO ITEM-OUT. WRITE RESULT-LINE FROM ITEM-LINE. GO TO READ-DATA. PRINT-LINE. MOVE TOT TO SUM-OUT. MOVE COUNT TO COUNT-OUT. WRITE RESULT-LINE FROM SUM-LINE. CLOSE INP-DATA AND RESULT-FILE. STOP RUN. Common Lisp See: Lisp Language type: F - Functional or lambda-based Description: Lisp is a quasi-functional language characterized by s-expression syntax and lists as it primary data structure. Common Lisp is a standardized dialect of Lisp, intended to be highly portable and serve the needs of the Lisp programming community. Most Lisp implementations today are compliant (more-or-less) with the Common Lisp standard. As a standard, Common Lisp defines the following facilities for the language: o o o o o o o o o o o o o Basic data types: symbols, numbers (integer, rational,

float, complex), characters Lists and an extensive set of list operations Arrays (vectors, strings, bit-vectors) and array functions Hash tables and functions for them Various other specialized data types: property lists, paths, streams, readtables, structures Lexical and dynamic scoping Control structure and function definition forms A very rich Macro system Packages and modules basic I/O, file handling facilities, file system interface Compiler usage and environment OOP for Lisp: The Common Lisp Object System (CLOS) Exception handling Common Lisp grew out of an effort, begun in 1981, to unify the fragmented Lisp community. The first Common Lisp book was written by Steele in 1984. In 1985, an effort was started to standardize the language in a formal setting, which led to the development of an ANSI standard in 1993 and an ISO standard in 1994. Both commercial and free implementations of Common Lisp are widely available. Origin: Guy L. Steele et al, 1984, 1990 Chapman, ANSI

sub-committee X3J13, 1991. See Also: Interlisp Scheme Remarks: Common Lisp is a fairly big and complex language. Almost all of it is a coalesence of other Lisp dialects: Interlisp, Franz Lisp, MacLisp, Flavors Lisp, and others. One of the biggest contributions of the Common Lisp standard was adding a comprehensive object-oriented programming facility to the language; prior to the definition of CLOS each kind of Lisp had its own OOP method (Flavors, LOOPS, etc.) The 1990 book Common Lisp the Language, 2nd Edition, by Guy Steele, is famous for its clear and complete treatment of the language. Links: Common Lisp the Language book Lisp FAQ Lists ANSI Standard (in Postscript) CMU Lisp Repository Date: Last updated 12/13/97 Sample code: ;; An example of array search from the common ;; lisp standard (defun finder (obj vec start end) (let ((range (- end start))) (if (zerop range) (if (eql obj (aref vec start)) obj nil) (let ((mid ( start (round (/ range 2))))) (let ((obj2 (aref vec mid))) (if

(< obj obj2) (finder obj vec start (- mid 1)) (if (> obj obj2) (finder obj vec ( mid 1) end) obj))))))) Concurrent Clean Language type: F - Functional or lambda-based Description: Concurrent Clean is a purely functional strongly-typed language meant for distributed and parallel-processing application development. It can use a lazy evaluation model, and supports higher-order functions; it also supports interfacing with legacy nonfunctional languages and systems. Basic data types supported by Clean include integers, reals, strings, boolans, lists, tuples, arrays, and higherorder functions. Like Hope and other modern functional languages, Clean allows multiple typed rules to be defined for a given function name; a pattern-matching process applies the correct function rule for a particular set of arguments. To allow modification of state information and interfacing with non-functional languages, Clean employs a polymorphic uniqueness type inferencing system. Clean supports

several advanced facilities: currying and higher-order functions, module support with separate interface and implementation, algebraic functions with quantified variables, and even a simple compile-time macro facility. The U. of Nijmegen implementation of Clean is the only one (as of early 1998); it is available free for Macintosh, Windows, Linux and Sun Unix. The portable compiler generates textual ABC-bytecodes (roughly RTL-level), which the platform-specific Clean code generator then translates to a native executable. Fairly good documentation about the language is available at the Clean home site, but most of it is in downloadable PDF rather than HTML. Origin: Nöcker, Plasmeijer, Smetsers et al, Univ. of Nijmegen, 1984-91 See Also: Haskell Miranda Hope ML Remarks: Cleans development was first driven by research into graph re-writing and type inference in a pure functional language. Later, the language was directed toward supported distributed processing applications Concurrent

Clean is still under development. For example, an object-oriented I/O and GUI library with support for object transfer and persistence was recently added. Also, a nice interactive development environment is available; it is written in Clean itself. Links: Concurrent Clean download area Another overview of Clean, at U. of Berlin Date: Last updated 1/2/98 Sample code: // Solution to Hammings problem in Clean, // generate an infinite sorted stream of numbers // of the form (2^n)*(3^m)(5p). From the examples // distributed with Concurrent Clean v1.2 Ham::[Int] Ham = y where y = ((*) 5) y)] merge merge merge merge [1:merge (merge (map ((*) 2) y) (map (() 3) y)) (map [] [] = [] f [] = f [] f = f f=:[a:b] g=:[c:d] | a<c = | a==c = | otherwise = [a:merge b g] merge f d [c: merge f d] Start::[Int] Start = take NrElements Ham NrElements :== 300 // Size of finite sample to take. Concurrent Pascal See: Pascal Language type: P - Parallel or Multi-programming Description: Concurrent

Pascal is a dialect of the structure Pascal language, extended to support abstract data types, multitasking, and monitors. It was intended for operating system programming and research The syntax of Concurrent Pascal was essentially the same as that of original Pascal, except for the added concurrency and ADT features, and a few features omitted. The language is strongly typed and safe: variant records and pointers as defined in original Pascal are not supported. Concurrent Pascal adds the following fundamentally new features to Pascal: process types, monitors, class types (no inheritance), init and cycle statements, and queues. Some fundamental features of Pascal were dropped: recursion, goto statements, packed arrays, pointers, and file types. Original versions of Concurrent Pascal were implemented on various mini-computer and mainframe hardware in the 1970s. No versions seem to be available on the web Origin: P. Brinch Hansen, 1974 See Also: CSP Algol68 Simula Ada Java Remarks:

According to its creator, Concurrent Pascal was created to satisfy the following beliefs: o o o o Concurrent programms can be written exclusively in high-level language [Note: PL/I and C dont count as high-level -- too unsafe!] Time-dependent programming errors must be detected during compilation A concurrent programming language must support a programming discipline that combines data and procedures into modules. A programming language should be abstract and secure [safe]. The high-level and formally defined process and synchronization constructs of Concurrent Pascal had a profound influence on the programming world, especially the operating system and real-time programming. The fundamental idea of monitors that Hansen introduced with the language was adopted in some fashion by many later, major languages including Modula, Ada, and Java. and Date: Last updated 3/7/98 Sample code: { A small example monitor and process from Hansens 1993 } { paper given at HOPL-II. } type linebuffer =

monitor var contents : line; full : Boolean; sender, receiver : queue; procedure entry receive(var text : line); begin if not full then delay(receiver); text := contents; full := false; continue(sender); end; procedure entry send(text : line); begin if full then delay(sender); contents := text; full := true; continue(receiver); end; begin full := false; end; { linebuffer } type printerprocess = process(buffer: linebuffer) var param : ioparam; text : line; begin param.operation := output; cycle buffer.receive(text); repeat io(text,param,printdevice) until param.status = complete; end end; CORAL 66 See: Algol Language type: S - block-structured Description: Coral66 was a compiled structured programming language, of the Algol family, used for real-time system development. Not much is available about Coral, but it is described as a small, simple language derived from Algol and Jovial. It supported conventional control structures, subroutines, and machine data types like integers,

floats, and pointers. It also included a facility for adding in-line assembly code, possibly due to its typical use for writing embedded control software. Coral was implemented for many different mini-computers in the 1970s, and was also available on the VAX under VMS. No free Coral66 compilers seem to be available today Origin: Royal Signals & Radar Establishment, Malvern UK, 1964-66. Woodward et al, 1970. See Also: Jovial Algol68 Ada C Remarks: Coral was used extensively for embedded system and application development in the UK military establishment, from the late 1960s until about the mid-1980s. It was superseded by Ada Of the the difficulties reported for Coral was that the language as standardized (1970) was inadequate for many development tasks, so different compiler vendors added their own incompatible extensions. Links: Description of Coral66 Date: Last updated 3/1/98 CorelScript See: Basic Language type: A - Application/Macro Description: CorelSCRIPT is a dialect of

Basic that serves as the macro extension language for many products from Corel Corp, including their line of graphics products. While the syntax of CorelSCRIPT is nearly identical to that of Microsofts Visual Basic, it is distinguished by the large number of built-in functions that it provides for the end-user. In versions of CorelDraw 60 and later, for example, essentially every function the drawing tool can perform is available to the CorelSCRIPT programmer. Also, Corel tools can compile scripts to speed execution; this capability is somewhat unusual for an application macro language. Like the Visual Basic language systems it resembles, CorelSCRIPT is compatible with MS-Windows OLE automation facility, allowing a CorelSCRIPT program to invoke and control any OLE-capable Windows application. CorelSCRIPT is a commercial product available only with Corel Corporation products. Meager information about the language is available on the WWW. Origin: Corel Corporation, 1994. See Also:

Visual Basic VBScript PerfectScript VBA Remarks: As application extension languages go, CorelSCRIPT is pretty good. The documentation provided by Corel is excellent. With the acquistion of WordPerfect by Corel, the application extension language PerfectScript is expected to be replaced by Corel Links: Tutorial on CorelSCRIPT in PhotoPaint CorelSCRIPT Tutorial Date: Last updated 12/10/97 Sample code: WITHOBJECT "CorelPhotoPaint.Automation7" .SetDocumentInfo 96, 96 .MaskSelectAll .EditCopy .ImagePapersize 192, 96, 0, 0, 5, 255, 255, 255, 0 .MaskInvert .EditPasteIntoSelection .MaskChannelAdd "Alpha 1" .MaskBorder 4, 1 .ImageBCI -20, 0, 0 .EndColorEffect .MaskChannelToMask 0, 0 offset% = 50 BEGIN DIALOG Dialog4 182, 79, "Corel SCRIPT Dialog" SPINCONTROL 91, 12, 76, 18, offset% TEXT 28, 17, 55, 11, "Offset amount:" OKBUTTON 56, 50, 69, 21 END DIALOG X = Dialog(Dialog4) .EffectOffset 0, offset%, TRUE, 0 .MaskRemove END WITHOBJECT csh Language type: C

- Command or Scripting Description: Csh is an interpreted command and scripting language designed and implemented as part of the BSD Unix development effort. It was primarily designed as an interactive command language, but is also widely used to automate system administration and software development tasks in Unix environments. Csh supports only one primitive data type: strings. Csh has arithmetic operators that can treat strings as integers in some constructs. Like other Unix shell language, csh has two scopes for variables: local and exported (environment). All local variables in a csh program have the same data type: a vector of strings All environment (exported) variables have the same data type, string, as required by Unix. Statements in csh are normally delimited by line boundaries, but semicolons may also be used. Control flow constructs supported by Csh include if-then-else, two kinds of loops, goto, a case statement, and a very simple interrupt handling statement. All of the

flow control constructs, as well as the expression syntax, are modeled roughly after those in the C programming language. Unlike most other programming language, csh has no explicit syntax for subroutines. Instead, each separate csh source file can be treated as a kind of subroutine Csh is available on essentially all Unix and related operating systems. Despite its wide use, good tutorials on C shell programming are not widely available on the web. Good books on shell programming are available See Also: sh C Tcl Perl Remarks: An advanced variant of csh, called the Twenex csh (tcsh) is also very popular. Tcsh supports the same programming features as its parent csh, but provides special interactive use features. Csh is one of the most contentious of the differences between the two main camps of the Unix world. The "System V" camp espouses general use of the Bourne shell (sh) and its derivatives such as the Korn shell (ksh). The "Berkeley" camp espouses general

use of the C shell and its derivatives In the 1990s this debate became largely moot because all the popular shells became available on all Unix platforms. Csh and its cousin tcsh are primarily interactive command interpreters; they can and have been used for programming, though, even when much faster and simpler solutions existed (e.g sh, awk, perl) While csh provides a fair set of program flow constructs, it does not provide very good I/O facilities or controls. This is perceived as a major failing by many Unix cognescenti. For more information about cshs shortcomings, check out the famous csh programming considered harmful article (link below). For serious Unix scripting, csh has been superseded by Perl. Links: Csh manual as a web page Csh Programming Considered Harmful Date: Last updated 2/15/98 Sample code: #!/bin/csh # A simple csh script to find a command on # the directories listed in the environment # variable PATH, and print out information # about it. set cmd=$1 if

("$cmd" == "") then echo "Usage: findcmd commandname" exit 1 endif set cnt=0 foreach dir ($path) set check="$dir/$cmd" if (-x "$check" && ! (-d "$check")) then file $check ls -ldg $check set cnt=$cnt 1 endif end if ($cnt echo exit else exit endif == 0) then "Sorry, command $cmd not found." 1 0 CSP Language type: M - Mathematical or Simulation Description: CSP is a simple and elegant language for describing parallel computations and their interactions. It evolved from a formal notation used to discuss communicating independent entities into a formal language for describing parallel systems, simulating them, and reasoning about them. CSP offers a modest set of conventional computer language features: numberic variables, symbols, and the usual sequential control structures. CSPs strength is in its support for defining parallelism: definitions of processes and communcation buffers. The fundamental notion of a

guarded command was introduced by CSP, and serves as a powerful model for regulating and synchronizing concurrent processes. All of the facilities in CSP were carefully chosen to permit formal proofs about deadlock-freedom and other properties of CSP models. Because CSP was invented as a formal notation, without many practical features, implementations are rare. Information about CSP is available scattered around the Internet, but journal articles and books have much more detail. One commercial implementation of CSP is used for verifying digital logic design Origin: C.AR Hoare, 1978 See Also: occam Linda Ada Remarks: The principles illustrated in CSP helped influence later parallel computation research and parallel programming languages. Links: The Virtual Library CSP Archive Bibliography of papers about CSP FDR2 Product Page Date: Last updated 12/12/97 Sample code: CSP solution to the Dining Philosophers problem, example, code by Dan Richardson after example definition in Hoares

CSP book. PHIL = *[ .During nth lifetime THINK; room!enter( ); fork(i)!pickup( ); fork((i 1) mod 5)!pickup; EAT; fork(i)!putdown( ); fork((i 1) mod 5)!putdown( ); room!exit( ); ] FORK = *[ phil(i)?pickup( ) -> phil(i)?putdown( ); [] phil((i - 1) mod 5)?pickup( ) -> phil((i - 1) mod 5)?putdown( ); ROOM = occupancy:integer; occupancy = 0; *[(i:0.4)phil(i)?enter( ) -> occupancy := occupancy 1; [] (i:0.4)phil(i)?exit( ) -> occupancy := occupancy - 1; MAIN = [room::ROOM || fork(i:0.4)::FORK || phil(i:0.4)::PHIL] cT Language type: S - block-structured Description: cT is an algorithmic scripting language intended for building animations, user interfaces, and multimedia presentations. Data types supported by cT include integers, reals, strings, booleans, arrays, and a variety of multimedia types. Control structures include if-then, simple loops, simple subroutines, and event-driven execution cT is supported by a large library of built-in commands for handling images, videos,

sounds, fonts, and other kinds of graphics data, file I/O, network communication, and system interfacing. For portability, cT programs are compiled into a binary intermediate form, to be run by the "cT executor". This is similar to the approach used by Java, except that re-compilation on each platform is recommended. The cT language is supported by a comprehensive programming environment that provides incremental compilation, interactive debugging, and a visual editor. cT is available free for Unix systems (X11) from CMU. It is available commercially for Windows and the Macintosh. Origin: Andersen, Sherwood et al, Carnegie-Mellon, 1990-94 See Also: Tcl HyperCard Visual Basic Remarks: The syntax of cT programs is rather linear and a little cryptic. The code structure seems to have been designed for to allow easy reading and writing by the cT development environment. cT was originally developed at Carnegie-Mellon, but was picked up by Physics Academic Software. Another

company, WorldWired, is also working on a version. Links: CMU cT web page WorldWired software cT demo page cT for Unix systems FTP area at CMU Date: Last updated 1/25/98 Sample code: * A subroutine to draw 1-d chaos, from a * sample program by Bruce Sherwood. unit chaos f: pop, rate $$ population and growth rate i: n, TRIES=40, base=8 i: usecolor f: h, s, v calc usecolor := (zncolors >= 8 base) palette zred,100,0,0,zwhite if usecolor loop n := 0,7 $$ make hues from blue to red getrgb 240[1-(n 1)/8],100,100; h, s, v palette base n,h,s,v endloop endif color zwhite do graph color zred loop rate := 2.7, 399, 01 calc pop := .1 $$ starting population loop n := 1, TRIES * New population is rate times current population * times a resource-limiting factor (1-pop): calc pop := rate*pop(1-pop) if usecolor color base int(8(n-1)/TRIES) elseif TRIES-n > 8 reloop endif gfill rate,pop;rate .01,pop 005 endloop endloop Curry Language type: F - Functional or lambda-based Description: Curry is a

fairly recent functional logic programming language, developed as a research vehicle to test ideas in the areas of narrowing, unification, and nondeterminism. It has also been used to teach logic and functional programming principles. The syntax of Curry is complex, compact, and similar to that of Haskell. Each statement of a Curry program is an equation or predicate. Executing a Curry program consists of simplifying equations and expressions until a particular specified goal is reached or a particular solution is obtained. Primitive data types supported by Curry include booleans, integers, reals, chars, and strings. Aggregate and specialized data types include tuples, lists, functions, and constraints. Oddly enough, Curry uses the same comment syntax as Ada. The module construct serves to encapsulate libraries of functions, data types, and expressions. The module seems to be the only program structuring facility in Curry Like many functional languages, Curry supports a declarative

I/O model. This kind of model basically represents input and output operations as expressions involving the World. Some of the advanced features of Curry are listed below. o o o o o o o o Functional composition Predicate constraints Nested Expressions Higher-order functions Concurrency Lazy evaluation residuation Narrowing Curry can also call external functions, which offers a way to support the advanced logical model with more traditional programming. As an academic project, implementations of Curry are available free. Documentation is available on the web, but almost exclusively in DVI format. Origin: Michael Hanus,RWTH Aachen, Germany, 1997 See Also: Haskell LEDA Prolog Goedel SML Remarks: The current version of the Curry language seems to be 0.5 The language is still under development, but the most recent version of the language manual is dated 1/99, so the development may have stalled. Several implementations of Curry exist. The most viable one seems to be PACS, the Portland

Aachen Curry System. It is a compiler that translates Curry programs into various intermediate forms: Prolog or Java Free downloads of PACS for UNIX systems are available from RWTH Aachen. Other Curry implementations are interpreters written in Prolog. There has been a trend in the 1990s to try to integrate ideas from some of the most powerful computer programming research paradigms. Curry, like LEDA and NIAL, is an example of this trend Links: Features of Curry TasteCurry WWW interpreter Date: Last updated 8/8/99 Sample code: This is a sorting example from the TasteCurry WWW Curry interface. -- quicksort using higher-order functions: -- filter elements in a list (predefined as `filter): filter :: (a -> Bool) -> [a] -> [a]; filter [] = [] filter p (x:xs) = if p x then x : filter p xs else filter p xs qsort :: [Int] -> [Int] qsort [] = [] qsort (x:l) = qsort (filter (< x) l) D Dylan Language type: O - Object-oriented Description: x : qsort (filter (>= x) l)

Dylan is a dynamic object-oriented language with both procedural and functional features, intended for application development and system programming. It was developed by Apple Computer in the mid-1990s The name stands for DYnamic LANguage. The language syntax for Dylan is original, but structurally resembles Scheme. The language offers inheritance, type-safety, polymorphism, garbage collection, macros, modularity (named modules), reflections, error handling, multi-methods, and extensibility. Data types defined by the language include a variety of numbers, strings, symbols, various collections such as sequences, arrays, vectors, and hash tables. In Dylan, as in Smalltalk, everything is an object. Even numbers are organized into a class hierarchy Functions are also objects, and support a large number of interesting mechanisms including composition, currying, mapping, and reduction. Classes are also objects, with support for dynamic class definition and other advanced OOP techniques.

Dylan facilities for GUI and database programming have been implemented, and most implementations of the language permit interfacing with external C/C++ libraries. Implementations of Dylan are available for most platforms including Unix, Macintosh, and Windows. Dylan has been implemented as an interpreter, as a C front-end, and as a native compiler. Both free and commercial systems exist. Some commercial Dylan implementations provide a visual development environment Origin: Apple Computer, 1992 See Also: Scheme Common Lisp Smalltalk Java C++ Remarks: Apples advanced technology lab east invented Dylan, and wrote one of the first compilers. It was originally intended for the Macintosh, but has been ported to many other computers. The upcoming commercial supplier seems to be Harlequin Group. Dylan has attacted a fair bit of attention in the late 1990s as a good application development language. It has not shown any sign, however, of supplanting C++ or Java. Links: Dylan resources at

Knowlege Tech Gwydion Dylan information Dylan Reference Manual (95 draft) The Dylan Evangelists A Dylan FTP area Date: Last updated 12/16/97 Sample code: // A naive Quicksort in Dylan by Jon Sobel define method quicksort (data :: ) => sorted-data :: ; if (empty?(data) | empty?(tail(data))) data; else collect(head(data), tail(data), #(), #()); end if; end method quicksort; define method collect (pivot, data :: , left-side, right-side) => sorted-data :: ; case empty?(data) => concatenate(quicksort(left-side), pair(pivot, quicksort(right-side))); (pivot < head(data)) => collect(pivot, tail(data), left-side, pair(head(data), right-side)); otherwise => collect(pivot, tail(data), pair(head(data), left-side), right-side); end case; end method collect; Dynace See: C Language type: O - Object-oriented Description: Dynace is an object-oriented extension of the C programming language, designed for general application development. Dynace uses the same base data types and

control constructs as C. It adds the following OOP and other advanced features to C: abstract data types, classes with multiple inheritance, run-time type ids, generics, garbage collection, multi-threading and synchronization, and reflection. Dynace is a weakly typed (actually, value typed) language like Smalltalk -- all objects are run-time type identified and type rules are checked during execution. This is similar to other dynamic OO language systems like CLOS (Common Lisp Object System) and Self. There is currently only one implementation of Dynace, the commercial version from Algorithms Corp. Source code for the language processor is available for download from the corporate web pages, although the product is not freeware. Documentation about the language is also available at the web site Origin: B. McBride, Algorithms Corporation, 1993-96 See Also: Objective-C C++ Smalltalk Java Self Remarks: Scoping in Dynace is tightly associated with source files, somewhat like Java. The

processed C nature of Dynace permits object-oriented, type-checked Dynace code and regular C code to co-exist in the same program! Useful, perhaps, but dangerous. Dynace is still a fairly young product, but it exhibits a good mix of C familiarity with modern features like automatic garbage collection, threads, and inheritance. It resembles Objective-C in some respects, and in fact the creators acknowlege Brad Cox and Objective-C in the Dynace documentation. Because it is implemented a C preprocessor, as C++ once was, Dynace can leverage the widespread availability of C compilers as long as its substantial run-time library can be ported. The synax of Dynace is C with some additional keywords and structures, the manual also recommends some peculiar naming conventions for methods and member data. Links: Dynace download area Date: Last updated 8/9/02 Sample code: /* A simple class to maintain an int built up * from prime factors. Adapted from examples * in the Dynace Manual. */ defclass

BuiltInt { unsigned long iRunningValue; class: int cCntInstances; }; cmeth gNew() { object obj; obj = gNew(super); cCntInstances += 1; ivType *iv; iv = ivPtr(obj); runningValue = 1; return obj; } imeth void addFactor(unsigned long fac) { iRunningValue *= fac; return; } imeth unsigned long getValue() { return iRunningValue; imeth object gDeepDispose, gDispose () { cCntInstances -= 1; } gDispose(super self); return 0; } E Eiffel Language type: O - Object-oriented Description: Eiffel is an object-oriented language intended for general application programming. Its syntax is superficially similar to C. Eiffel offers a broad range of OO programming features: inheritance, polymorphism, assertions, exception handling, packaging, generics, and strong type checking. Eiffel is available from Interactive Software Engineering, Inc. Their commercial Eiffel system compiles Eiffel to interpretable bytecodes (similar to the way Java is compiled), but for efficiency, the bytecodes are usually

translated into C code and compiled with platform-specific C compilers. Newer versions of the Eiffel system include support for interfacing to other languages, and to popular distributed computing schemes like COM and CORBA. Origin: Bertrand Meyers, 1986-92. See Also: C C++ Sather Objective-C Remarks: Eiffel is designed in large part to support program safety and orderly software development, goals also embraced by the Ada community. The class definition syntax is designed to support a software engineering approach called Design by Contract. Despite Eiffels simplicity, power, and good performance, it has not met with the broad acceptance of C++ or Java. Why? Possibly because there have not been a variety of free, portable Eiffel compilers, or possibly because programming with Eiffel requires significant coding discipline. Today, Eiffel is gaining some acceptance, but the market for object-oriented development environments is a crowded one. Links: http://www.cmcfacuk/CLE/

http://www.totalwebcouk/gustave/faq/indexhtm http://www.sigcocom/ Date: Last updated 12/16/97 Sample code: From An Invitation to Eiffel, by Bertrand Meyers class ACCOUNT feature balance: INTEGER; owner: PERSON; minimum balance: INTEGER is 1000 open (who: PERSON) is -- Assign the account to owner who. do owner := who end deposit (sum: INTEGER) is -- Deposit sum into the account. do add (sum) end withdraw (sum: INTEGER) is -- Withdraw sum from the account. do add (-sum) end may withdraw (sum: INTEGER): BOOLEAN is -- Is there enough money to withdraw sum? do Result := (balance >= sum + minimum balance) end feature {NONE} add (sum: INTEGER) is -- Add sum to the balance. do balance := balance + sum end end -- class ACCOUNT Elisp See: Lisp Language type: A - Application/Macro Description: Elisp is a dialect of Lisp that serves as the scripting and extension language for GNU Emacs, a very powerful text editor. Elisp is a full Lisp system, but does not conform closely to any particular

Lisp language standard Because it was designed to support creation of new functionality for the Emacs editor, Elisp has a broad set of string and text handling operations, as well as special functions and data types for controlling the editor and interacting with the user. In terms of syntax, Elisp is close to Interlisp, but the syntax of some Lisp constructs is modified to support in-line documentation of editor functions. Early versions of Elisp lacked many standard parts of conventional lisps, such a macros and floating-point numbers, but newer versions have these features as well as many Common Lisp elements. The Elisp engine, which is really the core of GNU Emacs, is written entirely in C. There is no Elisp compiler, but GNU Emacs can pre-parse Elisp code into simpler byte-codes that speed loading. Origin: Richard Stallman, GNU Project, 1985. See Also: Xlisp Common Lisp Remarks: The GNU Project is an effort to create a wholly free, unencumbered computing environment. Initially

projected to take two years, the project is still going after about 12 years. GNU Emacs (also its close cousin XEmacs) is universally acknowledge as the most powerful text editor ever created. How many other editors can support creation of an entire web browser or threaded news reader or version control system entirely in their extension language? Elisp is a highly usable and friendly Lisp dialect that has enjoyed great popularity as a medium for extending Emacs. GNU Emacs, and hence Elisp, is available on all UNIX systems, as well as 32-bit Windows and many other computers. Elisp is very well documented by a comprehensive manual distributed with Emacs and available on the web. Links: http://funnelweb.utccutkedu/~harp/gnu/elisp/elisp tochtml ftp://archive.cisohio-stateedu/pub/gnu/emacs/elisp-archive/ http://www.fsforg/ http://www.csindianaedu:800/LCD/coverhtml Date: Last updated 12/16/97 Sample code: ;; Simple Elisp example (defconst date-pattern-1

"\(1?[0-9]\)/\([123]?[0-9]\)/\([0-9][0-9]\)" "Regexp for one style of data string") (defun replace-all-dates () "Replace 1/27/93 dates with 27-1-93 dates" (interactive) (let ((mcount 0)) (while (re-search-forward date-pattern-1 nil t) (replace-match "\2-\1-\3" nil nil) (setq mcount (+ 1 mcount))) (message (format "Replaced %d dates" mcount))) ) Erlang Language type: F - Functional or lambda-based Description: Erlang is a functional programming language with concurrency and object-oriented programming features. It was designed for application software development, especially large real-time systems. Erlang uses declarative syntax and pattern-matching rules for function application. This is similar to the approach used by Prolog, Hope, and other applicative language. Computations in Erlang are mostly sideeffect free The language is also designed to support concurrency and distributed computing, but does not support higher-order

functional constructs like currying or lazy evaluation. Expressions and functions in Erlang are generally untyped. Data types supported by the language include integers, reals, atoms (which also serve as string data), tuples, lists, and process identifiers. Tuples and lists can be heterogenous. Functions in Erlang are defined with patterns. Pattern matching is used for assignment and for function application. Functions belong to modules, which constitute separate namespaces Functions must be explicitly exported from modules to be usable from other modules. Erlang supports multiple threads per process and multiple processes. The concurrency model in Erlang is strictly message-based, there is no shared memory. The first implementation of Erlang was an interpreter written in Prolog, but all current implementations are compilers. As of late 1997 the main Erlang implementations come from Ericsson Telecommuncations Systems in Sweden. Commercial Erlang is supported on a wide variety of CPUs

and embedded operating systems. Free Erlang is available for non-commercial use and runs on Windows and some Unix platforms Documentation is available on-line, and with the distributions. Origin: J. Armstrong and R Virding, Ellemtel System Laboratories, 1990 See Also: Hope Lisp Prolog Clean ML Obliq Remarks: Erlang is widely used at Ericsson and some other telecommunications companies to write internal software (embedded systems) for telecommunications systems. To support such applications, Erlang allows interfacing and interaction with external databases and libraries written in other programming languages. The newest version of Erlang includes some advanced functional language features, including list comprehensions. Because Erlang is intended for building robust embedded systems, it has extensive error-handling features. It also permits loading of new code and replacement code during execution. Links: Erlang at Ericsson CSL High-performance Erlang at Upsala U. ACM Erlang Workshop

2002 Open Source Erlang Erlang Training and Consulting Date: Last updated 9/28/02 Sample code: A version of Quicksort in Erlang, from the book Concurrent Programming in Erlang. -module(sort). -export([sort/1]). sort([]) -> []; sort([Pivot|Rest]) -> {Smaller, Bigger} = split(Pivot, Rest), lists:append(sort(Smaller), [Pivot|sort(Bigger)]). split(Pivot, L) -> split(Pivot, L, [], []). split(Pivot, [], Smaller, Bigger) -> {Smaller, Bigger}; split(Pivot, [Hd|Tl], Smaller, Bigger) when Hd < Pivot -> split(Pivot, Tl, [Hd|Smaller], Bigger); split(Pivot, [Hd|Tl], Smaller, Bigger) when Hd >= Pivot -> split(Pivot, T, Smaller, [Hd|Bigger]). Alternative version using Erlang 4.4 features: -module(sort). -export([sort/1]). sort([Pivot|T]) -> sort([ X || X <- T, X < Pivot]) ++ [Pivot] ++ sort([ X || X <- T, X >= Pivot]); sort([]) -> []. Escher See: Goedel Language type: F - Functional or lambda-based Description: Escher is a declarative programming

language that supports both functional programming and logic programming models. It was designed mostly as a research and teaching vehicle The basic view of programming exhibited by Escher and related languages is the a program is a representation of a theory in some logic framework, and the programs execution (computation) is a deduction from the theory. The logic framework for Escher is Alonzo Churchs simple theory of types Primitive atomic data types defined for Escher include: booleans, integers, characters, and program elements (such as functions). Other data types provided by the base language are strings, sets, and lists Real numbers are apparently not supported. Like most declarative languages, Escher supports declarations of data relationships and rules, which imply various computations during program execution. Escher supports I/O through a monadic type representing the outside world. This is more-or-less conventional for modern declarative languages. One of the goals of

Eschers designers was to support meta-programming, and so the language has comprehensive support for generating and transforming programs. Origin: J.W Lloyd, University of Bristol, 1995 See Also: Haskell Sisal Prolog FP ML Remarks: Basically, Escher is still a work in progress. The initial implementation is not yet available Links: Paper about Escher Date: Last updated 2/19/98 Sample code: A simple example from J.W Lloyds 1995 paper: MODULE Lambda. CONSTRUCT Person/0. FUNCTION Jane, Mary, John: One -> Person. FUNCTION Mother : Person * Person -> Boolean. Mother(x,y) => x=Jane & y=Mary. FUNCTION Wife : Person * Person -> Boolean. Wife(x,y) => x=John & y=Jane. FUNCTION PrimitiveRel : (Person * Person -> Boolean) -> Boolean. PrimitiveRel(r) => r=Mother / r=Wife. FUNCTION Rel : (Person * Person -> Boolean) -> Boolean. Rel(r) => PrimitiveRel(r) / (SOME [r1,r2] (r = LAMBDA [u] (SOME [z] (r1(Fst(u),z) & r2(z,Snd(u)))) & PrimitiveRel(r1) &

PrimitiveRel(r2))). Esterel Language type: P - Parallel or Dataflow Description: The Esterel language is a modeling and specification language designed for the programming of synchronous reactive systems. Developed in an academic setting, it is used for studying parallel computation and also for analysis and implementation of digital hardware. Because Esterel is specialized for representing reactive, signal-driven systems, it has two fundamental kinds of objects: data elements and signals. Data elements correspond to variables in conventional structured languages, and may be declared at module or local scope. Signals and sensors are dynamic values that correspond to the interactions of the system being modeled with the outside world. Primitive data types supported by Esterel include booleans, integers, reals, and strings. Esterel supports several mechanisms of code organization: modules, procedures, functions, and tasks. Parallelism and condition handling must be explicitly

specified. Synchronization is normally provided by reacting to external signals, using the await statement or by testing for sensor values; output can be specified with the emit statement. Esterel also allows a programmer (engineer) to assert exclusion and synchronicity relationships about signals. The Esterel compiler and verification tools are available free from INRIA, France. They run on a variety of Unix systems. The current version, as of late 1998, is Version 5 Origin: G. Berry, L Cosserat, et al, CMA France, 1983 See Also: CSP Occam Lucid Reactive-C ML VHDL Remarks: The Esterel language is designed to be translated into a variety of types of host languages, depending on the intended use of the Esterel model. An Esterel program can use data types supported by the host language in addition to the Esterel primitive types. While it is a programming language, Esterel evolved in an academic environment that is essentially focused on engineering. The design of the language reflects

the priorities of engineers designing synchronous control systems and logic circuits, unlike languages such as CSP which reflect a computer science viewpoint. Links: Esterel documentation and download Esterel programming example papers Date: Last updated 11/24/98 Sample code: A module for computing a running average, from Programming a Reflex Game in Esterel V3 by R. Bernhard, G. Berry, and other authors, 1989 module AVERAGE: input INCREMENT AVERAGE(integer); output AVERAGE VALUE(integer); var TOTAL := 0, NUMBER := 0, : integer in every immediate INCREMENT AVERAGE do TOTAL := TOTAL + ? INCREMENT AVERAGE; NUMBER := NUMBER + 1; emit AVERAGE VALUE (TOTAL / NUMBER) end end. Euphoria Language type: C - Command or Scripting Description: Euphoria is an interpreted block-structured language for PCs. It is intended for general application development and game programming. The data model used by Euphoria is quite simple: all data elements are either atoms or sequences. All atoms are numeric:

chars, ints, or floats. Sequences can be any length and can contain atoms and other sequences A string is simply a sequence of characters. More complex data structures can be built up from nested sequences (as in Lisp or Scheme). Indexing and slicing are important features, as is the ability to distribute scalar operations over sequence members. Euphoria performs type checking, to the extent that it can with only two types, and also enforces sequence index bounds and function return values. Lastly, Euphoria allows a programmer to define abstract data types operationally, by declaring for each such type a boolean function that determines type membership. With its line-based syntax and simple data model, Euphoria is intended to be a very easy language to learn. Euphoria supports rather conventional sequential control features: conditionals and loops. It does not support any advanced features like threads, exceptions, or higher-order functions. The Euphoria language system and

documentation may be downloaded free from its web site (see below), with modest documentation and some demo programs included. Information is also available at other Euphoria advocacy web sites. The current implementation runs only on Windows, DOS, and OS/2 Origin: R. Craig, Rapid Deployment Software, 1993? See Also: C Perl Basic Tcl Remarks: Euphoria stands for End User Programming with Hierarchical Objects for Robust Interpreted Applications. The acronym is relevant but perhaps a bit forced, especially since the language does not include a comprehensive exception handling mechanism. The Euphoria documentation claims that it is extremely fast, due to an internal architecture that avoids data copying and performs on-the-fly storage reclamation. This is also the approach used by Perl and Tcl To allow its use for general application programming under Windows, Euphoria allows the programmer to load any Win32 dynamic link library and call functions in it. Links: Old Unofficial Euphoria web

site Beginning to Learn Euphoria Euphoria download area Euphoria Consortium home page Date: Last updated 3/25/01 Sample code: -- Prime sieve benchmark, adapted from Euphoria 2.0beta demos constant ON = 1, OFF = 0, SIZE = 5000, BATCH = 20 function sieve() sequence flags integer prime, start, count, still prime count = 0 flags = repeat(ON, SIZE) for i = 1 to SIZE do still prime = flags[i] if still prime then prime = 2 * i prime = prime + 1 start = prime + i for k = start to SIZE by prime do flags[k] = OFF end for count = count + 1 end if end for return count end function atom t, cycles, p cycles = 0 t = time() while time() < t + 30 do -- test for 30 seconds for iter = 1 to BATCH do p = sieve() end for cycles = cycles + BATCH end while t = time() - t printf(1, "%6.1f sieves per second ", cycles / t) F FLooP Language type: S - block-structured Description: FLooP was a very simple recursive block structured language invented by Douglas Hofstadter for his book Godel, Escher,

Bach. It features simple subroutine structure, very simple number and boolean handling, and recursion. Unlike its cousin BLooP, FLooP does support unbounded loops This allows it to possess the full power of a Turing machine, thus making it fair game for various undecidability theorums. The syntax of FLooP is rather verbose, but simple in structure. Origin: Hofstader, 1979 (implementation: Cowan, 1994) See Also: BLooP Remarks: Though Hofstadter doesnt mention it in GEB, FLooP is similar to early exercises in exploring the computational model of "Random Access Machines". Note the use of CELL(0) <= 2 and similar constructs Though FLooP was never intended to be more than an academic exercise, an implementation of FLooP in Perl was made. Unfortunately, I cant seem to find it Links: http://www.geocitiescom/ResearchTriangle/6100/gebhtml BLoop/FLoop Implementation Download Date: Last updated 12/6/00 Sample code: DEFINE PROCEDURE DIVIDE [DIVIDEND, DIVISOR]: BLOCK 0: BEGIN IF

DIVISOR < 1, THEN: QUIT BLOCK 0; CELL(0) <= DIVIDEND; LOOP AT MOST DIVIDEND TIMES: BLOCK 1: BEGIN IF CELL(0) < DIVISOR, THEN: QUIT BLOCK 0; CELL(0) <= MINUS[CELL(0), DIVISOR]; OUTPUT <= OUTPUT + 1; BLOCK 1: END; BLOCK0: END. DEFINE PROCEDURE PERFECT? [N]: BLOCK 0: BEGIN CELL(0) <= 0; CELL(1) <= 0; LOOP DIVIDE [N,2] TIMES: BLOCK 1 BEGIN: CELL(1) <= CELL(1) + 1; IF REMAINDER[N,CELL(1)] = 0, THEN: CELL <= CELL(0) + CELL(1); BLOCK 1 END; IF CELL(0) = N THEN: OUTPUT <= YES; BLOCK 0: END. FORMAC See: FORTRAN Language type: M - Mathematical or Simulation Description: FORMAC is a dialect of FORTRAN with an extensive set of extensions for symbolic computation and expression manipulation. It was designed and implemented in the 1960s to support scientific and engineering computing on IBM mainframes. As a kind of symbolic dialect of FORTRAN IV, the original FORMAC had syntax and overall program structure similar to FORTRAN. Data types supported included all the

FORTRAN numeric types, plus rational numbers, symbols, arrays, and expressions. FORMAC programs could include subroutines and functions, and could use other FORTRAN facilities like common areas. FORMAC was originally implemented as a preprocessor on top of FORTRAN; the formulae and symbolic function calls were transformed into calls to a symbolic manipulation library. For I/O, FORMAC could take advantage of all the usual FORTRAN facilities, and could also print its symbolic expressions. In the late 1960s, IBM researchers created a similar proprocessor for PL/I, imaginatively named PL/IFORMAC. Unlike later symbolic math systems, FORMAC supported creation of expressions but not meta-expressions (rules). This is indicative of its early status in the evolution of symbolic computation, and despite its comparative lack of features it was influential on the field on its immediate successors (e.g Reduce, Macsyma). FORMAC was used up until the early 1990s Origin: Jean Sammet et al, IBM,

1964. See Also: Mathematica Macyma APL PL/I. Remarks: FORMAC was the first general symbolic mathematics language. There had been other attempts to apply computers to symbol manipulation, but prior to FORMAC all of them were libraries of procedures and functions that had to be assembled in the context of a conventional language. Even after FORMAC and its cousin PL/I-FORMAC were dropped as official IBM products, they continued to be enhanced and used by members of IBMs SHARE user group. The name stands for FORmula MAnipulation Compiler. Date: Last updated 3/11/98 Sample code: C FORMAC program to find the symbolic roots of some C quadratic equations. By J Sammet from the HOPL-II C paper on the history of FORMAC, typos corrected. SYMARG ATOMIC X,Y,K DIMENSION CASE(3), X1(3), x2(3) LET CASE(1) = X*2 + 2X(Y+1) + (Y+1)2 LET CASE(2) = 2 * X2 - 4X LET CASE(3) = 3*X2 + K(X+X2+1) +4 N=3 DO 88 I = 1,N LET RVEXPR = EXPAND CASE(I) LET A = COEFF RVEXPR,X*2 LET B = COEFF RVEXPR,X LET C = COEFF

RVEXPR,X*0 88 LET DISCRM = EXPAND B*2 - 4AC LET X1(I) = EXPAND (-B + DISCRM*(1/2))/(2A) LET X2(I) = EXPAND (-B - DISCRM*(1/2))/(2A) CONTINUE FMCDMP STOP END Forms/3 Language type: V - Visual or graphical Description: Forms/3 is an interpreted visual programming language with an expression-oriented interface and mostly declarative semantics. It is an academic research language Elements of a Forms/3 form are called cells. Cells can hold powerful functions The syntax for cell contents is fairly simple, but includes fair support for arithmetic and general sequential programming, as well as various graphical operations. Every cell has a current value Data types supported in Forms/3 are strings, integers, reals, and booleans. Cell expressions can directly manipulate the appearance and other characteristics of graphical objects in the Forms/3 workspace. Like many other visual languages, Forms/3 embodies a notion of time; it can be compared to a visual simulation system in that respect.

Forms/3 allows time to be run both forward and backwards; it also supports semantics for reacting to asynchronous events. One interpreter for Forms/3 exists, it is written in Common Lisp and runs on Unix workstations. The system is available at no charge from the authors. Origin: Burnett and Ambler, 1991. See Also: Lisp Logo Show-and-Tell Cocoa SeeDo Remarks: Forms/3 is the successor to Forms/2 (89), also by M. Burnett and A Ambler, which was a successor to the spreadsheet-like Forms (86) language by A. Ambler Forms/3 is a research language, used to study visual programming paradigms, for comparison between visual and traditional programming methods, and for study of reversible program execution (time travel). Languages like Forms/3 differ from commercial so-called visual language like Visual Basic in the sense that in true visual languages, the actual program structure and module relationships are created graphically. Commercial visual languages are more like language-integrated

GUI builders, although some convergence with academic visual programming is beginning to occur. Links: Guided Tour of Forms/3 Date: Last updated 6/12/99 Sample code: This is an example program from the Forms/3 home page: Forth Language type: T - Threaded or stack-based Description: Forth is an interpreted stack-based language with a very simple syntax and elegant abstract exection model. Designed for efficiency and simplicity, Forth is noted for the very small size of the language system. A Forth program is a sequence of words. Each word is independent, and causes some specified action Even constants are words: the word "12" is just a command to push the number 12 onto the data stack. Sequences of words can be grouped as procedures, and employed to build up modular programs. In order for this to work, of course, operators and operands must be given in reverse polish order (operands followed by operator). All data manipulation takes place on the data stack, so Forth offers

several operations for manipulating the stack. Forth implementations vary in the range of data types they provide, but most provide a conventional set of numeric and string types, plus arrays. Forth offers regular control structures: If-Else, While-Do, and ForNext, albeit with peculiar ordering of the keywords Most dialects of Forth provides simple file handling and I/O support. Forth is also meant to be extensible at every level. Programmers can define new words, and implement them in Forth itself, in some other high-level language, or in machine code. Information about Forth is widely available on the Internet. There are several commercial and implementations, many available from here. Origin: Charles H. Moore, 1969-1971 See Also: Postscript Remarks: Forth is often employed for controlling micro-computers and embedded systems, especially at boot-up prior to loading of a more complex OS. Because Forth is small and fast, it is well-suited for embedding in ROM Forth is also used for

creating general-purpose applications, even CGI scripts. Forth is standardized as ANS-Forth; the standard is available here. There is also an IEEE standard in draft for using Forth as a standard firmware language, IEEE 1275. Forths stream-of-conciousness syntax, polymorphism, and typically terse style make reading real Forth code a challenging exercise. The first real application of what we call Forth was controlling telescopes at the NRAO at Kitt Peak, in 1971. Forth became very popular in the astronomy community, and was adopted as the standard programming language by the International Astronomical Union in 1976. Links: Forth FAQ Lists Forth Information page at Taygeta Scientific Prof. Koopmans Stack Computers and Forth pages Extensive Forth Tutorial Date: Last updated 2/28/98 Sample code: Forth implementation of Newtons method for finding roots, simplified. (c) Copyright 1994 Everett F Carter : z1 ( i -- ) ( f: -- z1 ) z F@ xn{ SWAP } F@ F; : Newton ( i -- ) ( f: e d p -- e d p )

calculate new D DUP z1 FROT F* FOVER F+ calculate new P FSWAP DUP z1 F* dif{ OVER } F@ F+ calculate new E FROT z1 FABS F* FOVER FABS F+ restore stack order FROT FROT ; : FNewt ( &xn &dif n -- ) ( f: z -- e d p) >R & dif{ &! & xn{ &! R> z F! 0.0e0 00e0 00e0 0 DO I Newton LOOP ; FORTRAN Language type: S - block-structured Description: FORTRAN (from FORmula TRANSlation) is one of the oldest programming languages. Originally developed in the late 1950s, FORTRAN has moved through many versions and is still popular even today. FORTRAN is characterized by its good support for mathematics, especially floating-point computation, its lack of modular programming structures, and implicit declarations, and odd control-flow constructs. FORTRAN is normally case-insensitive. In older versions of the language, the position of text on lines was significant; Fortran90 and later versions support free-form input. FORTRAN has had many versions over the years, some of the

most popular being: FORTRAN I, FORTRAN II, FORTRAN IV, FORTRAN 77, and Fortran90. The current standard is Fortran 95 (ISO/IEC 1539-1), and it includes many modern structured programming features in a traditional Fortran framework. Many specialized and parallel-processing versions of FORTRAN have also been created. Origin: John Backus, IBM, 1954-57 See Also: C PL/1 ACSL Remarks: FORTRAN has long been a language of choice for complex scientific calculations, engineering models, statistics, and signal processing. Its simple code structure and lack of dynamic data structures make it highly amenable to compiler optimization and targetting to special hardware (eg. vector supercomputers) Every few years, somebody predicts the imminent death of FORTRAN, and it never happens. Links: Fortran Related Links Compaq Fortran home page Fortran 90/95 Info page Fortran 90 FAQ Official home of Fortran standards Date: Last updated 7/9/01 Sample code: PROGRAM Rad ! Simple FORTRAN program REAL P,R,C IF

(.NOT (R = 00)) THEN P = 3.1415926 R = 2.5 C = P * R PRINT *, "C = ", C END IF END FP Language type: F - Functional or lambda-based Description: FP was a very early pure-functional language invented by Backus. FP was an interpreted language that attempted to break the VonNeumann-machine mould. All computations in FP were carried out by expressions and pure functions (subroutines that returned a single value and had no side effects.) Sequences and combining forms were also prominent features of FP. The language also included a fairly novel feature of an explicit no-value value called bottom. FP was succeeded by FL in 1985. Origin: John Backus, 1977. See Also: FL Haskell Clean ML Hope Erlang Remarks: FP helped to spawn the research field of functional languages, by exhibiting that a language based on very simple, clean semantics could be powerful enough to do interesting work. Also, functional programs can be reasoned about in a formal way much more easily than most

conventional language programs. Several implementations of FP existed in the late 1970s and early 80s. An FP interpreter was distributed with Berkeley UNIX 4.2BSD, a very popular UNIX implementation for DEC computers Links: Portable FP Compiler Date: Last updated 12/3/97 Sample code: # Mergesort from the Berkeley FP manual { mergeSort | merge } {merge atEnd @ mergeHelper @ [[], fixLists]} # convert atomic args into sequences {fixLists &(atom -> [id] ; id)} # Merge until one or both input seqs are empty {mergeHelper (while and @ &(not @null) @ 2 (firstIsSmaller -> takeFirst; takeSecond))} # Find seq with smaller first element {firstIsSmaller < @ [1 @ 1 @ 2, 1 @ 2 @ 2]} # Take the first element of the first seq {takeFirst [apndr @ [1,1 @ 1 @ 2], [tl @ 1 @ 2, 2 @ 2]]} # Take the first element of the second seq {takeSecond [apndr @ [1,1 @ 2 @ 2], [1 @ 2, tl @ 2 @ 2]]} # Handle remaining nonempty seq {atEnd (firstIsNull -> concat @ [1,2 @ 2]; concat @ [1,1 @ 2])}

{firstIsNull null @ 1 @ 2} # apply the function mergeSort : <0 3 -2 1 11 8 -22 -33> G Goedel Language type: L - Rule-based or logical Description: Gödel is an interpreted declarative language based on typed first-order logic. It was designed as a research vehicle, and also as a language for teaching logic programming. Data types supported by Gödel include integers, rational and real numbers, sets, strings, tuples, and symbols. The language is strongly typed, and the type mechanisms play an important role in declaring predicates. Unlike most logic-based languages, Gödel has a module system and cross-module type enforcement. Gödel is also intended for research into program generation and transformation, parallel constraint programming, and meta-programming. The only existing implementation of the language was written on top of Prolog. A substantial implementation of Gödel is available in source form, as well as binaries for various Unix systems. Some documentation and example

programs come with the distribution, but real descriptions of the language are limited to hardcopy books. Origin: P.M Hill & JW Lloyd, 1994 See Also: Escher Prolog Haskell Remarks: The developers of Gödel point out that some of the weaknesses of Prolog (lack of data typing, lack of negation safety, etc.) are remedied by this newer language It seems that development work on Gödel has slowed, in favor of work on Escher. Links: Goedel Download Area at U. of Bristol A simple Goedel example program explained Date: Last updated 2/19/98 Sample code: % This is one of the example programs % included with the V1.4 distribution MODULE EightQueens. IMPORT Lists. PREDICATE Queen : List(Integer). Queen(x) <Safe(x) & Permutation([1,2,3,4,5,6,7,8], x). PREDICATE DELAY Safe : List(Integer). Safe(x) UNTIL NONVAR(x). Safe([]). Safe([x|y]) <NoDiagonal(x,1,y) & Safe(y). PREDICATE DELAY NoDiagonal : Integer * Integer List(Integer). NoDiagonal( , ,z) UNTIL NONVAR(z).

NoDiagonal( , ,[]). NoDiagonal(x,y,[z|w]) <y ~= Abs(z - x) & NoDiagonal(x,y+1,w). GPSS Language type: M - Mathematical or Simulation Description: GPSS, the General Purpose Simulation System, is a family of mostly-declarative languages designed for discrete-event simulation and system modelling. A GPSS simulation program consists of a set of blocks, and connections between them. Block types include generators, queues, servers, selectors/routers, data collectors, timing and computational nodes, and various other types. Data types supported in simulation models varied between versions, but usually included integers, reals, strings, and records. GPSS systems always had sophisticated random sample generators to model various probability distributions that arise in modelling of real-world processes. Some versions of GPSS are still available for sale commercially, no free versions seem to be available. Documentation for the language is not easily available on-line. Origin: G. Gordon,

IBM, 1961 See Also: SLAM Simscript Remarks: There were many dialects and editions of GPSS in the period of about 1961-1991. IBM created GPSS, and sold GPSS II and III, GPSS/360, and GPSS V. Other vendors created advanced versions (GPSS/H, GPSSR/PC) and user-friendly versions (GPSS/PC), and Unix-oriented versions (GPSS/C). Versions of GPSS after about 1988 supported various extensions for more sophisticated input and output. For example, GPSS/H supports The Extended Simulation System (TESS), which allowed simulations to employ relational databases, obtain input with forms, draw graphs, etc. Some versions even supported animation of simulation execution. By the mid-1990s, GPSS had been largely superseded in industry by newer and more interactive tools, and more sophisticated languages (e.g SimscriptII) It may still be used as a teaching tool in the study of discrete-event simulation techniques. Links: GPSS/H at Meridian Marketing GPSS/PC and other products at Meridian Marketing Wolverine

Software, home of GPSS/H Date: Last updated 1/2/98 Sample code: A simple model of 20 barbers serving a stream of customers. BARBERS STORAGE 20 GENERATE RVEXPO(1,1.5) QUEUE CUSTOMS ENTER BARBERS UNLINK MIN BARBERS,BARBGO,1,(UTIL)PL LINK CUSTOMS CLEAVE AVANCE .5 TERMINATE BARBGEN GENERATE ,,,20,5,1PH,1PL 20 BARBERS ASSIGN IBARB,N(BARBGEN),,PH LINK BARBERS,FIFO BARBGO SEIZE PH(IBARB) ADVANCE RVEXPO(1,30) RELEASE PH(IBARB) LEAVE BARBERS ASSIGN BUSE,FR(PH(IBARB)),,PL UNLINK CUSTOMS,CLEAVE,1 LINK BARBERS,FIFO GENERATE TERMINATE START 60*10 1 1 H Haskell Language type: F - Functional or lambda-based Description: Haskell is a non-strict purely functional language, usually interpreted, designed by representatives of the functional programming community. The motivation for Haskell was unification of functional programming through the introduction of a standard, widespread, modern language. Haskell is a strongly typed language with a rich type system. As in all functional language,

computations are performed only by expressions; every expression has a type. Primitive data types supplied by the language include: integers, reals, characters, lists, enumerations, tuples, and various function mappings. Haskell language implementations perform static type checking prior to execution. Haskell functions are defined as mappings between parts of the type space. Of course, composition, curried functions, lambda forms, and higher-order functions are supported. Haskell uses lazy evaluation It also permits definition of operators as functions (operator overloading), a convenience feature that is unusual in functional programming systems. Modularity is explicitly supported by Haskell. Programs consist of named modules The module facility provides distinct namespaces and a means for defining encapsulated abstract data types. Haskells module features allow some degree of object oriented programming. The Haskell standard library is written using the module facility. It provides

additional numeric data types, various standard aggregate types like arrays and lists, system interface and I/O facilities, time and date handling, and random number generation. Several free academic implementations of Haskell are available, and good documentation is available at the main Haskell web site. Origin: Haskell Committee (Hughes, Wadler, Peterson et al), 1990. See Also: FP Miranda Clean ML Gofer Remarks: The language is named after Haskell B. Curry, a logician and mathematician who worked on function theory; many ideas in functional programming originated with Curry (including the notion of curried functions). Two main Haskell implementations, Glasgow Haskell Compiler (GHC) and Yale/Nottingham Hugs are based on C. GHC is a Haskell->C translator, and Hugs is an interpreter coded in C As of the end of 1997, the current version of the Haskell language definition was 1.4 A revised language definition, to be called Standard Haskell, should be finalized in 1998. Links: The

Haskell 1.4 Language Report main Haskell site in Europe Haskell download area at Chalmers Introduction to Functional Programming using Haskell Date: Last updated 12/21/97 Sample code: -- Stable quicksort in Haskell by Lennart Augustsson -module QSort(sortLe, sort) where sortLe :: (a -> a -> Bool) -> [a] -> [a] sortLe le l = qsort le l [] sort :: (Ord a) => [a] -> [a] sort l = qsort (<=) l [] -- qsort qsort le qsort le qsort le is stable and does not concatenate. [] r = r [x] r = x:r (x:xs) r = qpart le x xs [] [] r -- qpart partitions and sorts the sublists qpart le x [] rlt rge r = -- rlt and rge are in reverse order and must be sorted with an -- anti-stable sorting rqsort le rlt (x:rqsort le rge r) qpart le x (y:ys) rlt rge r = if le x y then qpart le x ys rlt (y:rge) r else qpart le x ys (y:rlt) rge r Hope Language type: F - Functional or lambda-based Description: Hope is a small, simple functional language based function composition and on the idea of

call-by-pattern. A Hope program consists of a set of modules, each of which can contain sets of recursion equations. Current implementations of Hope use full lazy evaluation. Unlike some of the original functional languages, Hope is strongly typed. There were a couple of dialects of Hope, corresponding to different groups implementations. The one that seems available today was originally called Hope . Data types supported by Hope include numbers, symbols, strings, lists, and tuples. (Constituents of a list must be all the same type, while tuples can be heterogenous.) A Hope programmer can define their own primitive and aggregate types. This ability to create true abstract data types is a novel feature in functional languages. Modern implementations of Hope use lazy evaluation A free implementation of the Hope interpreter is available for MS-DOS, Unix, and Macintosh. Origin: Burstall 1978, Perry, Kewley et al 1985. See Also: FP ML Clean Haskell Mathematica Remarks: Hope was apparently

the first functional language to employ argument/return pattern-matching as a polymorphism semantic. This kind of approach is carried on today in some symbolic programming systems, notably Mathematica, as well as many newer functional languages. The original language Hope was developed at Edinburgh U. by Burstall in the late 1970s A successor, called Hope , was developed at ICL by J. Kewley, T Thomson, and others in the mid-1980s; the first implementation used eager evaluation, but later ones switch to the more advanced lazy evaluation strategy. Links: Hope code examples Date: Last updated 1/4/2000 Sample code: A module for listing the contents of a tree by breadth-first traversal using lazy evaluation, from Ross Patersons Hope web page. use lists, functions, products; type rose tree alpha == alpha # list(rose tree alpha); dec bf list : rose tree alpha -> list alpha; --- bf list t <= [t]. iterate (concat o map snd). front with (/= []). concat. map fst; HyperTalk Language

type: C - Command or Scripting Description: HyperTalk is the scripting language for Apples information presentation system HyperCard. It has a simple and English-like syntax, a modest set of general and application-specific data types, and the usual procedural control structures. HyperTalk was designed to allow HyperCard information collections, which are called "stacks", to be more dynamic and interactive. Because Apple envisioned the users of HyperTalk to be multimedia developers and not traditional programmers, they HyperTalk interpreter was designed to be very forgiving: it allows various syntactic sugar, type conversion is automatic, and everything is case-insensitive. Most of a HyperTalk program will often consist of handers, subroutines to be called when the end-user performs some action or when a certain condition obtains. HyperTalk supports the notion of add-on external functions and commands; these are roughly analogous to library modules in a language like C.

HyperCard 2 compiles individual HyperTalk functions into intermediate codes the first time the function is called. This is done to reduce start-up time for HyperCard applications There are several versions of HyperTalk. The two main versions from Apple correspond to HyperCard releases 1 and 2. Aldus SuperCard supports a superset of HyperTalk called SuperTalk Commercial implementations of both are available for the Macintosh. At one time, SuperCard was also available for MSWindows, but that may not be true anymore Origin: Atkinson and Winkler, Apple Computer, 1986? See Also: Lingo AppleScript Remarks: HyperTalk continues to evolve along with the HyperCard product (version 3 due soon), but it is unclear whether it is still going to be a viable language. Apple is touting AppleScript as THE scripting language for all Macintosh applications, so HyperTalk may be superseded. HyperTalk was very influential on the niche area of multimedia scripting languages. For example, the scripting language

used by the current (c. 1997) market leader in multimedia authorware resembles HyperTalk in many respects. Links: Hypercard FAQ Page Hypercard Heaven Date: Last updated 12/7/97 I ICI Language type: S - block-structured Description: ICI is an interpreted structured language reminiscent of C. It is essentially a scripting language, intended for application development. ICIs syntax is similar to that of C, but it provides a high-level data model intended to reduce programmer effort and errors. Primitive data types in ICI include integers, reals, strings, files, safe pointers, and regular expressions. Aggregate data types are arrays, sets, and associative tables Sets can be heterogenous, nested, and support the usual set operations: union, intersection, etc. All data structures in ICI are dynamic, and the language environment provides memory management and garbage collection. Control structures in ICI include the usual loops and conditional statements, plus a simple error handling

construct. The language supports subroutines and nested modules. All variables are lexically scoped at the subroutine or module level, but unlike most structured languages, ICI allows the current scope to adjusted (Tcl, for example, also allows this). Although ICI is not object-based, many object programming features can be emulated in the language by using data structure inheritance feature called super-structures. To support application development, ICI has C-like file I/O and system interface support, as well as a highlevel event trigger facility. The language also has a modest standard library of built-in functions There is only one implementation of ICI; the current version is 2.02, and it runs on Unix systems, DOS, Windows, Macintosh, and some other computers. Documentation is spare and somewhat outdated, and is available for download but not on-line browsing. Origin: Tim Long, 1992 See Also: C Python Perl Remarks: ICI is pronounced icky. An overview by an ICI author places

the language mid-way between scripting languages like Perl and development languages like Java. The claim is that ICI is faster than Perl but slower than Java, a peculiar claim since Perl and Java each out-perform the other in different circumstances. Still, ICI does provide sophisticated data structures like Perl, but with a comfortable C-like syntax. The home of ICI is Canon Information Systems Research Australia, but the language is in the public domain. Links: ICI Overview page ICI Download area: sources and docs Date: Last updated 1/24/98 Sample code: /* A program to count words in input files * (from examples at the ICI web site) */ static count tokens(in) { auto count; count = 0; while (gettoken(in)) ++count; return count; } if (argc < 2) printf("%d ", count tokens(stdin)); else { auto f, fn, total; total = 0; forall (fn in interval(argv, 1)) { if (fn == "-") count = count tokens(stdin); else { auto count; count = count tokens(f = fopen(fn)); close(f); }

printf("%s %d ", fn, count); total += count; } if (argc > 2) printf("Total %d ", total); } Icon Language type: S - block-structured Description: Icon is a procedural language with high-level semantics for string and data aggregate processing. The language definition includes a large number of operators and funtions for manipulating strings and sequences, as well as novel semantics: conventional imperative control structures and goal-directed backtracking. Built-in data types in the language are integers, reals, strings (text), sets, lists, arrays, associative tables, files, and records. Icon variables are typed, but the language performs automatic type casting, so it cannot be said to support strong type checking in the sense of Ada or Modula-2. Icon also supports a very simple form of exception handling; procedures can return one or many values, or they can fail. Failures do not automatically propogate up the procedure call stack as they do in Java or C++

Icon is not object-oriented, but an object-oriented extension called Idol has been available since 1996. Icon is normally interpreted, but there is also a translator that generates compilable C code from Icon code. Icon was originally implemented for UNIX, but has been ported to VMS, MS-DOS, 32-bit MS-Windows, OS/2, and the Macintosh. Icon is distributed with a standard library; most platforms also support a GUI library. The Icon distribution also includes example programs and documentation. Icon implementations are available free from the U of Arizona ftp site. Origin: R.E Griswold, 1977 See Also: SNOBOL Perl Remarks: Icon is currently an academic project living at the University of Arizona. Research topics include OOP extensions, porting to WindowsNT, optimizing compiler improvements, and transparent Internet access. Links: Icon FAQ Icon Slow FTP Area Icon Tutorial Date: Last updated 3/19/98 Sample code: # Example from New Mexico Tech Icon # tutorial by John Shipman procedure

Quadratic Roots ( a, b, c ) # Generates the real roots of ax^2+bx+c=0. local d # Discriminant d := b ^ 2 - 4.0 * a c; # Compute the discriminant if d > 0 then { #-- Two roots suspend ( - b + sqrt ( d ) ) / ( 2.0 * a ); suspend ( - b - sqrt ( d ) ) / ( 2.0 * a ); } #-- Two roots else if d = 0 then suspend - b / ( 2.0 * a ); fail; end # No more roots procedure main () local root # Holds each root generated by the solver local count # Counts the number of roots returned count := 0; every root := Quadratic Roots ( 1, -4, 3 ) do { #-- The braces {} group the next two statements together write ( "One solution is: x = ", root ); count +:= 1; # Count the roots generated } write ( "The number of solutions was ", count ); end INTERCAL Language type: S - block-structured Description: Intercal is a compiled language deliberately designed to be convoluted, difficult to program, difficult to read, unlike all other languages, and yet still computationally complete. The

syntax of Intercal does not resemble any other computer language, but does in some respects resemble the appearance of a FORTRAN program recovered from a bad disk sector and then sent through a cheap fax. Only two primitive data types are supported: 16-bit and 32-bit unsigned integers. Intercal supports arrays, but no other data structures. Intercal provides exactly five primitive operations on data: 1. 2. 3. 4. 5. binary bit-level interleave binary bit selection with packing unary bit-wise and unary bit-wise or unary bit-wise exclusive-or Strangely enough, this set of operators can be used to build normal integer arithmetic. Data-flow constructs in Intercal are similarly conventional, that is to say, unique. One kind of Goto is provided that pushes its return address onto a fixed-size stack. Mechanisms for disabling statement, both unconditionally and with fixed probability, are also provided. Later versions of Intercal also provide the unique Come From statement. While Intercal

does not support subroutines, a similar facility can be constructed with some effort Intercal does provide I/O, after a fashion. The original edition of the language could read and write only numbers, and had the interesting disability of being totally unable to read in its own output. Later versions of Intercal provide a bit-oriented I/O facility that based on a model of the differential movement of a Turing machine tape. The Intercal reference defines a standard library for operations that are difficult to implement in the language, like addition, subtraction, multiplication, and random number generation. Intercal was originally implemented for IBM mainframes, but since about 1990 a version called C-Intercal has been available for Unix platforms. An implementation is also available for MS-DOS Information about Intercal is freely available on the web, and documentation and sample programs are included with the distribution. Origin: D.R Woods and JM Lyons, 1972 See Also: TECO Fortran

Remarks: Intercal originated as a bad joke by two computer scientists at Princeton University. However, their manual for Intercal-72, as it is now called, was so hilarious that this horrible programming language has continued to be implemented (!) and extended (!!) fitfully ever since. Here are a few highlights: o o o o o The original Intercal used overstruck characters for several operators The simplest way to store the value 65536 into a 32-bit variable in Intercal is DO :1 <= #0$#256. The shortest Intercal program known that can copy its input to its output is 23 lines. Intercal has no comment syntax, but it is possible to get the effect of a comment by beginning a line with Please Note by taking advantage of the "Not" in "Note". It has been proven that Intercal is Turing-complete. Here is one of my favorite quotes from the original Intercal manual: INTERCALs main advantage over other programming languages is its simplicity. It has few capabilities, and thus

there are few restrictions to be kept in mind. Since it is an exceedingly easy language to learn, one might expect it would be a good language for initiating novice programmers. Perhaps surprising, than [sic], is the fact that it would be more likely to initiate the novice into a search for another line of work. Links: The Pit (Intercal Resources) The Revised Intercal Reference Manual The original 1973 Intercal Manual The Retrocomputing Museum (Intercal download site) INTERCAL Resources on the Web Date: Last updated 2/18/98 Sample code: PLEASE NOTE THIS PROGRAM PRINTS A LIST PLEASE DO NOT ASSUME THAT THE NUMBERS ARE COMPOSITE PLEASE NOTE THIS PROGRAM WAS SWIPED FROM LOUIS HOWELL DO READ OUT #2 (15) (13) (16) (12) (14) (11) (23) (22) (21) (2010) (2000) (2001) (2003) (2002) (2004) (2020) (2030) (2033) (2032) (2036) DO .10 <- #1 PLEASE COME FROM (23) DO .11 <- !10$#1~#32767$#1 DO .12 <- #1 PLEASE COME FROM (16) DO .13 <- !12$#1~#32767$#1 DO .1 <- 11 DO .2

<- 13 DO (2030) NEXT DO (11) NEXT DO (13) NEXT DO .3 <- "?!4~4$#2"~#3 DO (14) NEXT PLEASE FORGET #1 DO .1 <- 12 DO (1020) NEXT DO .12 <- 1 DO .3 <- ?2$3~#0$#65535 DO .3 <- ?"&"!2~3~"??3~3$#32768"~"#0$#65535""$ ".3~3"~#1"$#2~#3 PLEASE RESUME .3 DO (12) NEXT DO FORGET #1 PLEASE READ OUT .11 DO COME FROM (15) DO .1 <- 10 DO (1020) NEXT DO .10 <- 1 DO (21) NEXT PLEASE RESUME "?!10~#32768$#2"~#3 DO (22) NEXT DO FORGET #1 PLEASE GIVE UP PLEASE ABSTAIN FROM (2004) PLEASE STASH .2 DO .2 <- #1 DO (2001) NEXT PLEASE FORGET #1 DO .1 <- ?1$2~#0$#65535 DO (2002) NEXT DO .2 <- !2$#0~#32767$#1 DO (2001) NEXT PLEASE RESUME "?!1~.2$#1"~#3 DO (2003) NEXT PLEASE RETRIEVE .2 PLEASE RESUME #2 PLEASE DO REINSTATE (2004) PLEASE RESUME ?"!1~.1~#1"$#2~#6 PLEASE STASH .2 + 3 DO (1021) NEXT DO STASH .1 + 5 DO .3 <- #0 DO .5 <- ?"!2~2~#1"$#1~#3 PLEASE DO (2031) NEXT DO .4

<- #1 PLEASE DO (2033) NEXT DO FORGET #1 DO .5 <- ?"2~#32768"$#2~#3 DO (2032) NEXT DO .2 <- !2$#0~#32767$#1 PLEASE DO .4 <- !4$#0~#32767$#1 DO (2033) NEXT DO (1001) NEXT PLEASE FORGET #1 DO .5 <- ?1$2~#0$#65535 (2034) (2035) (2031) DO .5 <- ?"&"!2~5~"??5~5$#32768"~"#0$#65535""$ ".5~5"~#1"$#2~#3 DO (2034) NEXT DO .5 <- 3 DO (1010) NEXT PLEASE DO .1 <- 3 DO .3 <- V4$5~#0$#65535 DO (2035) NEXT PLEASE DO (1001) NEXT DO FORGET #1 DO .5 <- "?4~#1$#2"~#3 DO (2031) NEXT DO .2 <- 2~#65534 DO .4 <- 4~#65534 PLEASE DO (2036) NEXT DO (1001) NEXT PLEASE DO .4 <- 1 PLEASE RETRIEVE .1 + 5 PLEASE RESUME #2 Interlisp See: Lisp Language type: F - Functional or lambda-based Description: Interlisp was a dialect of Lisp, derived from BBNLisp, that was used for research at Xerox PARC. Various implementations were made for different computers, the most popular and influential of which was

InterlispD. Origin: Teitelman and Masinter, Xerox PARC, 1965-1975 See Also: Common Lisp Date: Last updated 12/13/97 J J See: APL Language type: M - Mathematical or Simulation Description: J is a interpreted mathematical/functional programming language very closely related to APL. Basically, it is a dialect of APL with the same functionality, but employing the ASCII character set instead of APLs original unique character set. Commercial and free implementations of J are available. Excellent documentation and programming libraries are also freely available on the web. Origin: R.KW Hui et al, and J Software Inc, 1990 See Also: S Remarks: One of the primary obstacles to the use of APL is the bizarre font needed to display APLs notation. J removes that difficultly by employing 1- and 2-character mnemonics for the monadic and dyadic operators in APL. Like APL, J programming is normally conducted as an interactive session (this is not surprising when you consider that a single line of APL or

J can be the equivalent of a large subroutine in a conventional language.) Links: Links page at the ACM SIGAPL APL and J software archive at Waterloo Excellent publications page at J software Date: Last updated 2/20/98 Sample code: NB. continued fraction representation of Pi: rf=. % @ (1&|) Pi=. 1p1 [v=. < rf ^: (i10) Pi 3 7 15 1 292 1 1 1 2 1 (+%) / 5{. v 3 3.14286 314151 314159 314159 Java Language type: O - Object-oriented Description: Java is a simple, portable object-oriented language designed by research staff at Sun Microsystems. The feel of the Java language is fairly similar to that of C++, but it also borrows ideas from Modula-3, Mesa, and Objective-C. The feature set of Java is fairly broad: it has inheritance, strong type checking, modularity (packages), exception handling, polymorphism, concurrency, dynamic loading of libraries, arrays, string handling, garbage collection, and a pretty extensive standard library. The newest version of the language, Java 12 (aka

Java Platform 2), includes nested classes, persistence, and reflection as well as many additional standard libraries. The fundamental structural component of a Java program is the class. All data and methods in Java are associated with some class, there is no global data or functions as in C++. Classes can be members of packages; package and class membership help determine scope and visibility of data and methods. Java does not include features that its designers felt would compromise the similicity or safety of the language, so Java has no true pointers, no true multiple inheritance, no operator overloading, and no macro preprocessor. The lack of multiple inheritance could have been a serious shortcoming, but Java does support the definition and interitance of multiple stateless "interfaces", which serve for most areas where multiple inheritance might be desired. Java also has no facility for generic functions, but since the language imposes a rooted class hierarchy (all

object classes inherit from the root class Object), any need for generics is greatly reduced. Java 1.1 added powerful reflection and object class manipulation capabilities, and uses these to support object serialization I/O. The Java standard library packages include extensive I/O facilities, a comprehensive GUI toolkit, collection classes, date/time support, cryptographic security classes, distributed computation support, and system interfaces. Java is typically compiled to platform-independent byte-codes. These byte-codes must be interpreted by a Java Virtual Machine (JVM), which may choose to compile the byte-codes further into native machine instructions. There is a strict definition of the Java byte-code file format, the class file format, which ensures portability of compiled Java classes. In additional to normal application development, Java is used to develop embedded programs, called applets, for web browsers and other Java-enabled platforms. This capability is an important

part of Java, and the standard library packages include a security manager to restrict the capabilities of Java applets. These applet facilities were important to Javas widespread adoption and popularity. Commercial Java compilers and development environments are readily available; among the most popular are products from Symantec and Microsoft. Javasoft supports and distributes a reference Java implementation known as the JDK, it is free. Origin: Gosling et al, Sun Microsystems, 1994-95. See Also: C++ Objective-C Modula-3 Ada Eiffel Beta Remarks: According to its designers, Java was intended to be object-oriented, robust, secure, architecture neutral, portable, high-performance, threaded, and dynamic. Certainly Java succeeds at being object-oriented and threaded, it is fairly architecture-neutral and quite portable. Its performance is currently poor, but new JVM implementations that employ just-in-time compilation are helping to improve Javas speed. Java is fairly dynamic, but not as

much so as other interpreted languages like Lisp or Perl. Java security is better than many other embeddable languages, but still has significant problems to overcome, both in its security model and in various implementations. Overall, the Java language is remarkably usable and mature given its relative youth. Java information and software are widely available in bookstores and on the Web. Hundreds of add-on packages and utilities supporting Java development have been written, and many of them are free. Initiatives are underway for Java microprocessors, a Java OS, Java re-use framework (Beans), and a ISO Java standard. Links: The Java Centre JavaWorld magazine The Java Boutique Java FAQ collection Gamelan Directory for Java Date: Last updated 2/6/99 Sample code: import java.awt*; import java.util*; public class Showtime extends Frame implements Runnable { Button quitBtn; Label timeLbl; Thread tthread; public Showtime() { super("Java Showtime"); setLayout(new

FlowLayout()); quitBtn = new Button("Quit"); timeLbl = new Label((new Date()).toString()); add(quitBtn); add(timeLbl); pack(); show(); tthread = new Thread(this); tthread.run(); } public boolean action(Event evt, Object what) { if (evt.target == quitBtn) { tthread.stop(); System.exit(0); } return super.action(evt,what); } public void run() { while(true) { try { Thread.sleep(10000); } catch (Exception e) { } timeLbl.setText((new Date())toString()); } } public static void main(String [] argv) { Showtime st = new Showtime(); } } JavaScript Language type: C - Command or Scripting Description: JavaScript is a loosely typed scripting language with object-oriented and block-structuring features. Invented by Netscape Communications for adding dynamic behavior to web pages, JavaScript was originally called LiveScript. The syntax of JavaScript is similar to that of C or Java, but simpler and not as rich. Primitive data types include integers, reals, strings, and a associative

arrays. Javascript is loosely typed, any variable can contain data of any type, and conversion is mostly automatic. The language definition includes extensive facilities for controlling and manipulating parts of web pages, especially HTML forms. Each version of Netscape Navigator has brought a new version of JavaScript, and later versions also include a complicated security model for restricting the hostile capabilities of scripts embedded in web pages. Microsoft web browser also support Javascript, but under the name "JScript". Origin: Netscape Communications Corp, 1994. See Also: C Java VBScript Remarks: JavaScript is intended to complement Java, in some sense. It is interpreted where Java is bytecode-compiled, it is weakly typed where Java is strongly typed, and it is tightly bound to HTML where Java is very loosely bound. There are a great many books available about JavaScript programming; the best books explain the differences between the different versions. There are

also a large number of tutorials and introductions on the web; try this one. Javascript may be superseded by a standardized scripting language derived from it: ECMAScript. ECMA standard ECMA-262 documents this. Links: A Beginners Guide to Javascript Netscape JavaScript documentation The JavaScript Connection A JavaScript FAQ List Yahoo! JavaScript Links Date: Last updated 12/29/97 Sample code: <script language=javascript> sub chkrange(elem,minval,maxval) { if (elem.value < minval || elem.value > maxval) { alert("Value of " + elem.name + " is out of range!"); } } </script> <input type=button onclick="chkrange(myform.numitem,1,10);"> Jovial See: Algol Language type: S - block-structured Description: Jovial is a block-structured procedural language derived from early versions of Algol. It provided Algol-like data types and syntax, with structural extensions for large-scale software engineering and for real-time systems. Jovial is

standardized. The original 1973 specification was US MIL-STD-1589, and the most recent 1984 edition of the language standard is MIL-STD-1589C. At least one commercial JOVIAL is still available, and others are certainly still in use at various aerospace companies. Detailed information about the language does not seem to be available on the web Origin: Jules Schwartz et al, SDC, 1959-60. See Also: Algol CLU Ada Remarks: Jovial stands for Jules Own Version of the International Algorithmic Language (IAL). IAL was an early name for Algol, and Jules Schwartz was the initial designer. Jovial was primarility used by the US Air Force, its contractors, and some other NATO military organizations. By the mid-1980s, Jovial had been largely superseded by newer languages such as Pascal, Modula-2, CLU, and especially Ada. It still exists, though, mostly for code maintenance and porting of legacy systems. Extensive information and pointers to available compilers may be found at the Jovial Lives

page below. Links: A Jovial language system developer A USAF Overview of Jovial Jovial Lives - the USAF Jovial PMO Date: Last updated 9/26/01 L Leda Language type: O - Object-oriented Description: Leda is a modest-sized programming language designed to support several programming approaches. The current Leda implementations are interpreters, but the language can be compiled. Leda was intended mostly as a teaching and research tool, although it can be used for general application development. Multiparadigm programming is the reason for Ledas existence; the language supports four programming mindsets: 1. 2. 3. 4. Imperative (structured) - the programmer can set up subroutines, use strong type checking, and information hiding. Object-oriented - abstract data types, classes, and single inheritance are supported. Functional - functions are first-class values, and Leda can do currying and other functional operations Logical - Definition of logical rules is supported, with conventional

backtracking goal search. A fairly small language, Leda supports a modest but eclectic set of primitive data types: integers, strings, reals, functions, and relations (rules). Arrays are also available, and other aggregate data types are provided by a standard library. Leda supports the usual sequential control structures, and more novel structures can be built up using the functional and logical portions of the language. Strangely, Leda does not possess any nonlocal exception or error handling facility Ledas I/O facilities are rudimentary, although the language provides an escape mechanism out to system libraries that could be used to take advantage of more sophisticated I/O facilities on many operating systems. An implementation of Leda is available free for Unix and Windows 95/NT. Pretty good information about the language is available on the web as scholarly papers and chapters from a programming textbook. Origin: T.A Budd, Oregon State University, 1988 See Also: C++ Pascal Self

ML Prolog Scheme Mathematica Remarks: According to the introductory chapter of the Leda text, the language is meant to allow a programmer to employ multiple ways of approaching a problem. Some computational tasks are more naturally expressed in certain ways, and choice of language tends to drive a programmer toward using the paradigm best supported by that language. Leda, and a scant handful of other languages, make a broader range of choices available to the user. In its current form, Leda does not seem quite suited to mainstream application development, but it presents very interesting ideas. The current Leda implementation is written in C. Links: An information page about Leda Portions of a programming book about Leda Date: Last updated 3/1/98 Sample code: { Table data structure, adapted from an example in "Multiparadigm Data Structures in Leda" by Tim Budd, 1993 Assumes the list data structure is already defined. } class Association [X, Y : equality] of

equality[Association]; var key : X; value : Y; function equals(argValue : Association[X, Y])->boolean; begin return key = argValue.key; end; end; class Table [X, Y : equality] { of equality[Association] }; var data : List[Association[X, Y]]; function add (newKey : X, newValue : Y); begin if ~ defined(data) then data := List[Association[X, Y]](); data.add(Association[X, Y](newKey, newValue)); end; function onEach (theFun : function(X, Y)); begin if defined(data) then data.onEach(function (item : Association[X, Y]); begin theFun(item.key, itemvalue); end); end; function items (byRef key : X, byRef value : Y)->relation; var element : Association[X, Y]; begin return defined(data) & data.items(element) & unify[X](key, element.key) & unify[Y](value, element.value); end; function includesKey (key : X)->boolean; var value : Y; begin if items(key, value) then return true; return false; end; function at (key : X)->Y; var value : Y; begin if items(key, value) then return

value; return NIL; end; function atPut (key : X, value : Y); var element : Association[X, Y]; begin if defined(data) & data.items(element) & elementkey = key then element.value := value else add(key, value); end; end; LIFE Language type: L - Rule-based or logical Description: LIFE is an interpreted logic programming language, related to Prolog, with features for functional and object-oriented programming. Intended mainly as a research vehicle, LIFE integrates inheritance, functional, and constraint rule programming styles into a logic programming framework. The syntax of LIFE is similar to that of Prolog, and its logic semantics are also related to Prolog. Prolog uses indexed Herbrand terms as its primary data element, but LIFE uses extensible psi-terms. Primitive data types supported by LIFE include booleans, integers, floats, symbols, strings, and sorts (a sort is a kind of type descriptor). In addition to psi-terms, LIFE supports lists with the same syntax as Prolog As

a functional language, LIFE supports higher-order functions, currying, and similar operations. It does not support lazy evaluation. An implementation of the LIFE language is available for free download, it is written in C and works on Unix systems. A programmers manual and various scholarly papers are also available Origin: Hassan Ait-Kaci, MCC Texas, 1993. See Also: Prolog Leda ML Hope Remarks: The name LIFE is an acronym for Logic, Inheritance, Functions, and Equations. One of the most novel aspects of LIFE, as a logic programming language, is its notion of sorts. Sorts are like types, and like the types in most object-oriented languages, have inheritance relationships. Several different institutions have hosted LIFE development: MCC in Texas, DECs Paris Research Lab, and most recently Simon Frasier U in Canada. Links: LIFE page at Simon Frasier University Date: Last updated 3/17/98 Sample code: An example of the Sieve of Erastosthenes on LIFE, from the Wild LIFE Handbook.

global(sieve)? global(limit)? main :write("N=?"), read token(limit & int), next prime(2), nl. remove multiples(P,M) :cond(M < limit, (sieve.M <-multiple of(P),remove multiples(P,M+P)) ). next prime(P) :- P < limit, !, SP=sieve.P, ( SP=prime(P), !, write(P, ), remove multiples(P,2*P) ; succeed ), next prime(P+1). next prime(P). Limbo Language type: S - block-structured Description: Limbo is a block-structured, procedural language intended for application and embedded system development. It is the main programming language of the Lucent Inferno operating system The distinguishing characteristics of Limbo are its simplicity, its support for modularity, and its support for multi-threaded and distributed processing. Limbo is strongly typed, all variable and function types are explicitly declared, and type checking is performed at compile-time and module load-time. Primitive data types in the language are ints (3 sizes), reals, and strings (using Unicode). Limbo

also supports lists, arrays, tuples, channels, and definition of abstract data types. A Limbo program is comprised of separate modules, the interface and implementation of a module are separate and one interface can have several implementations. (Inheritance is not supported, though, so Limbo cannot be considered and object-oriented programming language.) The current Limbo compiler produces byte-codes that are either interpreted directly or transformed into native code on-the-fly by the Limbo run-time engine. The Limbo run-time system provides all channel and process management, as well as memory management and garbage collection. I/O and system interface facilities are provided by a set of standard library modules. Limbos run-time environment has been ported to various Unix editions, Windows, Plan9, and other operating systems, as well as directly onto various CPU architectures. The Inferno system is available free from Lucent, but requires registration. Origin: Doward, Winterbottom,

and Pike, Lucent Technologies, 1996. See Also: Pascal C Modula-2 Java Alef CSP Tcl Remarks: Limbo includes inter-process communication channels as primitive language type. These channels can be used to send any data object between Limbo processes on the same machine or across a network. The Inferno system includes full cryptographic security for the communication link. Limbo is intended to be the language for all applications under Inferno. Therefore, it must have a GUI system; the current GUI system for Limbo is a version of Tk. Limbo is occasionally referred to as "Network C," even though it really resembles several other languages as closely as it resembles C. Links: A Descent into Limbo (tutorial) A comparison of Limbo and Java Main Lucent Inferno web site Date: Last updated 1/2/98 Sample code: # A simple program to sum up some numbers # presented on the command line, from # Bob Pikes forthcoming book on Limbo. implement Sum; include "sys.m"; sys: Sys; include

"draw.m"; Sum: module { init: fn(context: ref Draw->Context, argl: list of string); }; init(context: ref Draw->Context, argl: list of string) { sys = load Sys Sys->PATH; argl = tl argl; # ignore command name if(len argl == 0){ sys->print("usage: sum numbers. "); return; } sum := 0.0; while(argl != nil){ arg := hd argl; sys->print("%s", arg); sum += real arg; argl = tl argl; if(argl != nil) sys->print(" + "); } sys->print(" = %g ", sum); } Lingo Language type: A - Application/Macro Description: Lingo is the application scripting and extension language used in Macromedia Inc. authoring and presentation products. It is a procedural, event-driven language with English-like syntax and some objectoriented programming features Lingo supports a small set of data types primitive data types: numbers, strings, and lists. Lingo also support objects; the language is defined with a large set of pre-defined object classes

that pertain to the languages application domains: multimedia, animation, and user interaction. Lingo also supports definition of new object classes, a kind of simple polymorphism, and a form of delegation. Lingo does not support persistence or multiple inheritance. In Lingo, objects store all of their data on property lists, and also can act on certain kinds of events (such as mouse clicks). The only implementation of Lingo is the commercial one supplied by Macromedia with its Director product and related products. Documentation from the vendor is modest, but several good books about the language and its use in the Director environment are available. General information about Lingo on the WWW is not widely available, but some does exist. Origin: Macromedia Inc (formerly Macromind?), 1991-96. See Also: HyperTalk AppleScript VBA Remarks: Programming in Lingo can be a little complicated, because most of the code you write it intended to be activated dynamically by timers, events in the

movie score, or user actions. An extension to the multimedia environment that can be controlled from Lingo is called an Xtra. Lots of free and commercial Xtras exist. Links: Director FAQ Lingo Users Journal Date: Last updated 12/16/97 Lisp Language type: F - Functional or lambda-based Description: Lisp is an extremely rich and powerful programming language that has enjoyed continuous use and popularity since the mid-1960s. Typically, Lisp programming systems are interpreters, but compilers are also commonly used. The Lisp language is founded on the representational power of "S-expressions", and employment of functional composition and recursion. Lisp is a weakly typed language with excellent support for reflection and on-the-fly code generation and interpreting. The languages extreme flexibility, expressive power, and its ability to treat code as data, made it the undisputed king of Artificial Intelligence research for all of the 1970s and 1980s. All Lisp implementations

since the late 1960s have offered a set of programming features tough to equal in any language, even today: macros, string handling, recursion, closures, reflection, packaging, arrays, and extensive IO facilities. Modern Lisp systems support object-oriented programming, database access, GUI construction, and all other forms of general-purpose programming. A very mature language, Lisp is extremely well-documented, and the most widespread dialect, Common Lisp, is also codified by ANSI and international standards. Origin: McCarthy et al, 1956-61 See Also: Scheme Prolog FP Common Lisp Remarks: Lisp is taught as a part of most computer science undergraduate programs. Commercial and free Lisp programming systems are available for all major computing platforms, and there is even Lisp-specific processing hardware. Of course, one thing everybody remembers who ever programmed in Lisp is the profusion of parentheses. The evolution of Lisp is a fascinating study in the growth of a specific

scion of computer science over thirty of the most active years of the field. Possibly the first really powerful interpreted computer language, Lisp has profound influence on the AI and programming language design fields since their very inception. Several good historical retrospectives on Lisp are available: short (PS) and long (Compressed PS). Links: http://www.apljhuedu/~hall/lisphtml http://www.cscmuedu/Groups/AI/html/cltl/clm/clmhtml http://www.cscmuedu/Groups/AI/html/faqs/lang/lisp/tophtml http://www.franzcom/ Date: Last updated 12/16/97 Sample code: ;; Simple factorial routine ;; (until I get a better example written) (defun fact1 (num) (cond ((not (integerp num)) nil) ((<= num 1) 1) (t (* num (fact1 (- num 1))))) ) Logo Language type: F - Functional or lambda-based Description: Logo is a functional language designed teach programming and problem-solving principles to children. It is a functional language, related to Lisp, with a simple syntax and a graphics-oriented feature

set. The Logo language provides a set of built-in procedures, a means to create new procedures, a simple data framework with symbols, numbers, and lists, and simple control structures. The language is surprisingly small, but like Lisp can be used to create very complex behavior. A central concept in Logo is the turtle. Logo was designed for use with a graphics display, and the turtle wanders around the display under the control of the Logo program, drawing lines. Some of the most fundamental statements in Logo move and rotate the turtle. By using Logos recursive nature, a programmer can cause the turtle to draw all sorts of figures. Commercial and free implementations of Logo are available for PC/Windows, Macintosh, and UNIX platforms. New releases of Logo implementations in 1993 and later have added sound, images, and multi-tasking to the basic language. Massively parallel, hardware-embedded, and object-oriented extended implementations of Logo have also been developed. Logo has been

used primarily for education, but has also been employed for AI research, robotics, and graphics creation. Origin: Papert et al, MIT, 1967. See Also: Lisp Hope ML Remarks: Logo is a simple language to learn, but amazingly functional. Many elementary schools have used Logo to teach children how to think about really controlling computers (not just point-n-click). Many of the sites listed below have links to these educational projects. Seymour Papert, the inventor of Logo and an influential early AI researcher, is still active in family computing, his latest project is on-line here. Links: Logo FTP Archive at MIT MSW Logo Terrapin Logo MicroWorlds Logo EuroLogo Date: Last updated 12/16/97 Sample code: ; Recursive procedure to line, fractalized to DrawFractalLine :level :length ifelse :level < 1 [ fd :length] [ DrawFractalLine (sum -1 :level) (quotient left 60 DrawFractalLine (sum -1 :level) (quotient right 120 DrawFractalLine (sum -1 :level) (quotient left 60 DrawFractalLine (sum

-1 :level) (quotient ] end :length 3.00) :length 3.00) :length 3.00) :length 3.00) ; procedure to clear screen and position turtle to SetupTurtle cs setpos [-160 -10] right 60 clean end ; setup turtle then draw Kochs snowflake(5) SetupTurtle setpensize [2 2] repeat 3 [DrawFractalLine 5 330 right 120] LotusScript See: Basic Language type: A - Application/Macro Description: LotusScript is a dialect of Basic used as the application extension and macro language for Lotuss line of office automation software. It has some object-oriented programming features and extensive application integration and interface facilities. Data types available in LotusScript include integers, reals, strings, arrays, records, and objects. The language supports conventional procedural constructs with simple Basic-style syntax. The language is not strongly typed, but does do some type enforcement for objects. LotusScript employs a high-level simplified event model to invoke subroutines and functions in response

to user input and application activity. LotusScript is included as part of the Lotus commercial products it serves to extend. Documentation for the language is available from Lotuss web site and elsewhere on-line. Origin: Lotus Development Corp, 1995. See Also: WordBasic VBA CorelScript Remarks: LotusScript corresponds directly to Microsoft Visual Basic for Applications and Corel CorelScript: they are all dialects of Basic that allow users to write extensions and simple applications within large software products (e.g word processors, groupware systems) LotusScript can be divided into a core language and set of classes, and application-specific objects and classes associated with the embedding product. For example, a LotusScript program running under Lotus Notes 4.5 has a different set of pre-defined classes available to it than a program running in Lotus Freelance Books and classes about the language seem to be mostly directed at Notes, because it is a popular product and because it

is an environment in which extensions and specialized features are commonly written. Compared with other dialects of Basic, LotusScript appears somewhat more verbose or sugared. This appearance is the result of the object-oriented features of the language, and the additional type information those features use. Links: "LotusScript for the Terrified" tutorial Some LotusScript product info Class reference for LotusScript in Notes Date: Last updated 1/3/98 Sample code: Find agents owned by the current user and remove them (Adapted from examples at www.lotuscom) Dim Dim Dim Dim Dim session As New NotesSession db As NotesDatabase agentArray(1 To 10) As NotesAgent count as Integer answer as string count = 0 Set db = session.CurrentDatabase Forall a In db.Agents If ( a.Owner = sessionUserName ) Then Set agentArray(count) = a count = count + 1 If (count > 10) Then Exit Forall End If End If End Forall answer = Inputbox$( "You have " & count & "

agents. Delete them?" ) If (answer = "y") Or (answer = "yes") Then Forall a in agentArray Call a.Remove End Foreall End If Lua Language type: C - Command or Scripting Description: Lua is an interpreted structured language designed for embedding into other applications. It is intended for use as an extension and scripting language, especially for applications with requirements for structured data storage. Because it is intended for use as an application extension language, Lua does not have the notion of a main program or initial entry point; instead, all code is assumed to be invoked from the host application. The syntax of Lua is somewhat similar to that of Pascal, but the data type system is quite different. Like many scripting languages, Lua is loosely typed: variables need not be declared, and may hold any kind of value. Data types supported by Lua include real numbers, strings, functions, and tables (associative arrays) Lua also has a distinguished nil

value type, and an extension data type called userdata that can store C pointers for use by the host application. Lua associative arrays subsume other data types like arrays and tuples, just as they do in Javascript. Control structures supported by Lua include various conditional and looping constructs. The language has no error handling constructs, instead errors are usually routed to pre-defined handler functions. Like Perl, Lua support multiple return values from functions and variable numbers of arguments to functions. Scope is very simple in Lua: all variables are either global, or local to a particular block. The default is global, local variables must be explicitly declared so. Function definitions are just assignments to global variables. Data values in Lua are tagged to support specialized extension by the host application. Tags can be used to define special handling for data types, or to set up inheritance or delegation relationships. There is only one implementation of Lua,

written in C. It is available free, in source form, on the web The Lua reference manual is also available. Origin: W. Celes, R Ierusalimschy, LH de Figueiredo, PUC-Rio, 1994 See Also: Tcl Perl Pascal C Javascript Elisp Remarks: Lua means "Moon" in Portuguese. The Lua manual includes extensive information on how to embed Lua in a host application, and how to expose host data and functionality to Lua scripts. Its interface for doing this appears to be a little bit simpler than the corresponding one for Tcl, and much simpler than that of Perl. However, Luas complement of data types and built-in functions is far smaller than those of Tcl or Perl. Lua has gone through several major expansions in its fairly short career so far, but new versions have maintained back-compatibility with older ones. The latest version, as of early 1998, was 30 Links: Journal article describing Lua FTP download area for Lua Canadian Lua mirror Date: Last updated 6/1/98 Sample code: -- Simple Lua

program that implements the -- bisection method for solving non-linear equations function bisect(f,a,b,fa,fb) write(n," a=",a," fa=",fa," b=",b," fb=",fb," ") local c=(a+b)/2 if abs(a-b) < delta then return c end n=n+1 local fc=f(c) if fa*fc < 0 then return bisect(f,a,c,fa,fc) else return bisect(f,c,b,fc,fb) end end -- find root of f in the inverval [a,b]. -- bisection requires that f(a)*f(b) < 0 function solve(f,a,b) delta=1e-6 -- tolerance n=0 local z=bisect(f,a,b,f(a),f(b)) write(format("after %d steps, root is %.10g ",n,z)) end -- test the bisection code with -- a function: x^3 - x - 1 function f(x) return x*xx - x - 1 end solve(f,1,2) Lucid Language type: P - Parallel or Multi-programming Description: Lucid is a dataflow programming language designed to experiment with non-VonNeumann programming models. It has fundamentally different semantics from a language like C or Lisp: in Lucid the programmer defines

filters or transformation functions that act on time-varying data streams. Lucid supported a very small set of data types: integers, reals, and symbols. The syntax of Lucid was deliberately design to be unusual and different, to prevent programmers from applying procedural-programming habits that might be inapplicable, and to sustain the illustion of data flows as infinite objects. Lucid also employed several techniques from functional programming: lack of side effects, and lazy evaluation. Lucid evolved greatly in the 1980s and 1990s. The current evolutionary step of Lucid is called GLU (Granular LUcid). It supports high-level data flow programming and embedding of legacy code GLU is available free for most UNIX platforms. Origin: Ashcroft and Wadge, 1976-77. See Also: Sisal Remarks: Lucid was a powerful advance in computer science, and spawned several additional research areas over the 1980s. Two of those areas, Multidimensional Programming and Intensional Programming, are active

research areas in computer science. Links: Lucid information at SRI Date: Last updated 12/8/97 Sample code: A Lucid program to solve Hammings Problem, from Ashcroft & Wadge, Lucid, the Dataflow Language. h where h = 1 fby merge(merge(2 * h, 3 h), 5 h); merge(x,y) = if xx <= yy then xx else yy fi where xx = x upon xx <= yy; yy = y upon yy <= xx; end; end; M M See: MUMPS Language type: D - Database or Text-processing Description: "M" is the newer name for MUMPS, a powerful high-level language mostly used for database and interactive MIS system development. M is an ISO and ANSI standard language. Date: Last updated 12/12/97 Magma Language type: M - Mathematical or Simulation Description: Magma is an environment and high-level language for number theory, algebra, and general mathematical programming. The fundamental features of Magma are its procedural syntax and statement structure, coupled with very sophisticated built-in data types and operations. In general,

Magma is dynamically typed and performs automatic conversions rather than enforcing type checking. Some of the built-in types are: unlimitedprecision integers, rational numbers, real and complex numbers, sets, atoms, arrays of various sorts, groups and fields of various sorts, and various kinds of functional types. Newer versions of Magma support closures and higher-order functions. Magma has simple I/O facilities used mainly for reading and writing mathematical objects to and from files. There is only one implementation of the Magma language. It is an interpreter written in C Magma runs on PCs and Unix systems. Magma was developed at the University of Sydney, and used to be downloadable free. Since about 1996, users have had to pay for subscriptions to Magma Documentation is available with the distributions. Origin: J. Cannon, et al, 1993 See Also: Mathematica Matlab SETL Pari Remarks: Magma evolved from an earlier system called Cayley. Both systems were intended for use by serious

mathematicians using computers to model and study mathematical concepts in detail. It borrows basic ideas from OO programming languages, particularly abstract types and type composition. In Magma, the fundamental classes based on modern notions of algebra and category theory. Links: Magma Examples at U. of Sydney Date: Last updated 1/10/98 Sample code: A Magma program to produce random selections of strings from a simple grammar, by D. Taylor produce := procedure(); seq := ["S"]; rhs := ["(", "S", ")", "S"]; i := 1; repeat if Random(1, 10) gt 7 then Insert(~seq, i, i, rhs); else Remove(~seq, i); end if; print #seq gt 0 select &*seq else "eps"; i := Position(seq, "S"); until i eq 0; print "Length:", #seq; end procedure Mathematica Language type: M - Mathematical or Simulation Description: Mathematica is a formidable commercial system for symbolic mathematics and graphics. Most of the system is

written in the Mathematica language, a powerful hybrid interpreted language for expressing mathematical formulae and procedures. The end user also employs the Mathematica language to perform describe the problems they wish Mathematica to solve to computations they want it to undertake. The language has a very broad complement of features: o o o o Rule-based semantics will pattern-matching Variety of data types: symbols, several kinds of numbers, lists, vectors, arrays, graphics objects, strings, etc. Full set of procedural control-flow constructs Facilties for reflection and on-the-fly construct of code Data elements in Mathematica are strongly typed, but the language system performs many types of automatic conversion, especially on numbers. All numbers in Mathematica are unlimited precision: integers, reals, rationals, and complex. Programmers can also define their own data types, after a fashion [Note: in a sense, Mathematica has only one non-primitive data type: the "basic

form." All aggregate data and symbolic expressions in Mathematica are internally stored as a head and a body, where the head defines the data type. Programmers can create their own head types, and do, and in that sense they are defining new data types.] For many users, the power of the Mathematica system is its immense library of pre-defined functions. These functions fall into several broad groups, some of which are: arithmetic, algebra, calculus, graphics, I/O, programming, and the GUI interface. As an interpreter, Mathematica can easily import new functions and package dynamically. Several hundred such packages have been written for the system, in academia and industry. There is only one Mathematica, now in its third major release. The system is available commercially for Windows, Macintosh, and most Unix platforms. Origin: Stephen Wolfram, 1987. See Also: Macsyma FORMAC Reduce Hope Maple Remarks: Programming with Mathematica has all the ease and pleasure of using the best

interpreters. Availability of procedural, functional, and rule-based programming models allow the user to experiment and choose the most suitable style for their background and problem domain. Of course, choice of style can have very serious implications for performance -- the mathematical core is far faster at performing some kinds of operations than others. Like Hope, Mathematica allows the programmer to set up very complex pattern matching rules to control how functions are applied during computation. This capabilities is very powerful; users have coded up significant areas of mathematical research in the language. The rivalry between Mathematica and its leading competitor Maple sometimes gets bitter. Both have their strengths, but in the area of the programming language, Mathematica is somewhat more powerful. Links: A Mathematica Tutorial MathSource archive Date: Last updated 3/11/98 Sample code: (* RandomWalk example from Maeder, 1990 ) RandomWalk::usage = "RandomWalk[n]

plots a random walk of length n" RandomWalk[n Integer] := Block[{loc = {0.0, 00}, dir, points= Table[0, {n+1}], range = N[{0, 2 Pi}]}, points[[1]] = loc; Do[ dir = Random[Real, range]; loc += {Cos[dir], Sin[dir]}; points[[i]] = loc, {i, 2, n+1}]; Show[ Graphics[{Point[{0,0}], Line[points]}], Framed -> True, AspectRation -> Automatic] ] Mawl See: C Language type: C - Command or Scripting Description: Mawl is a compiled structured scripting language designed for implementing interactive on-line services. The syntax of Mawl is similar to that of C. Primitive data types in the language include integers, reals, booleans, and strings. For data aggregates, Mawl supports vectors (homogenous) and tuples All variables in Mawl are marked as auto or static. The static variables are persistent, holding their values from session to session. Mawl also supports conventional sequential control constructs: conditionals and loops, but no goto Because it is a special-purpose language designed

for building interactive services, Mawl programs do not have traditional single-entry-point subroutine structure. Instead, a Mawl program consists of one or more invokable sessions, each of which can have multiple steps of presenting output and accepting input. A Mawl program can be executing any number of sessions simultaneously, using built-in automatic synchronization. The fundamental data type for Mawls interactive services is the form. A form is simply an interface between display and control. Mawl forms have an input type and an output type (possibly aggregates, of course) and use templates for their display. The really cool part of this is that the application programmer can treat the multi-step, event-driven sequence of delivering a form, letting the user work on it, and accepting the results all as if it were an atomic operation! Mawl includes a simple exception handling mechanism for taking care of unusual cases or error conditions. The current implementation of Mawl is

implemented as a translator, converting Mawl code into C++ code for compiling and linking with a run-time library. Mawl is available from Lucent technologies at no charge, but with licensing conditions. Origin: D.A Ladd, JC Ramming, T Ball, 1995 See Also: C++ Perl Remarks: One of the primary design goals of Mawl was to separate the control logic of a service from its presentation. To this end, Mawl uses template-driven HTML generation for web services, with so-called .mhtml files allowed to include various kinds of Mawl substitutions. Since Mawl does not have all the facilities one might wish in a general-purpose programming language, it permits inclusion of in-line C/C++ code. Mawl was created as part of Project Tardis at Bell Labs (now Lucent). Links: Planet Mawl (resource & advocacy site) Mawl Programming Tutorial Mawl system overview and links Date: Last updated 3/7/98 Sample code: /* the Voting example from the Mawl 2.1 Tutorial */ typedef { string name, int nVotes } vote;

static [ vote ] tally = [ ]; static int total = 0; session vote { auto form { [ vote ] tally, int total, string castvote } showvote; showvote.put( { tally, total, "Vote" } ); } subsession void AddVote(string name) { ++total; auto int i; for (i = 0; i < tally.length(); ++i) if (tally[i].name == name) { tally[i].nVotes++; return; } tally.append( { name, 1 } ); } session Vote { auto form void -> { string name } getName; AddVote( getName.put()name ); } Mercury Language type: L - Rule-based or logical Description: Mercury is a logic programming language with some functional language features. It was designed to give the semantic benefits of declarative programming and the speed and error-checking of procedural programming. The syntax of Mercury is similar to that of Prolog, but supports additional constructs that declare type, mode, and other constraints. Data types supported by the language include: integers, reals, strings, and a very flexible record/union type; the

standard library supports a wide variety of collection types including arrays, lists, trees, maps, etc. As a hybrid logic/functional programming language, Mercury does not support conventional procedural control flow constructs. It does support higher-order function operators like curried functions, filters, and closures Unlike most logic programming languages, Mercury is not interpreted. Instead, the compiler translates Mercury code modules into portable C. This gives Mercury additional portability and speed, but prevents it from creating and evaluating new code on the fly. Since Mercury is purely functional (side-effect-free) the I/O model depends on the notion of an "io state" value. This makes output a little tricky, but doesnt break the semantics A free implementation of Mercury for Unix and Windows platforms is available free. Mercury is distributed with some Linux systems. In order to take advantage of Mercury, however, the target system must have a good C compiler.

Origin: Mercury Project, University of Melbourne, 1993. See Also: Prolog C Remarks: Mercury is designed to fold some of the attractive features of mainstream imperative languages into a logic programming system, advantages like speed, scalability, strong type checking, and early error detection. Their approach is basically allow the programmer to convey to the language system with a good deal of additional information about types, modes, determinism, purity, and other aspects of the code. Using this information, the Mercury compiler can perform many optimizations not possible in looser languages. Also, of course, Mercury is compiled while most other logic languages are interpreted: the compiler generates C code from which a native C compiler can generate a binary executable. The C code generated by the Mercury compiler can employ various non-standard C features, such as in-line assembly and register globals, if the C compiler supports them. With all of these optimizations turned

on, Mercury is roughly an order of magnitude faster than normal Prolog, and twice as fast as the fastest commercial Prolog systems. Interestingly, the current free Mercury compiler is written in itself, having been bootstrapped from Prolog. Links: Mercury download area (code, docs) Date: Last updated 12/20/97 Sample code: % An example of finding primes using a sieve % (adapted from a logic programming benchmark in mercury) :- interface. :- import module list, int. :- implementation. :- pred primes(int, list(int)). :- mode primes(in, out) is det. :- pred integers(int, int, list(int)). :- mode integers(in, in, out) is det. :- pred sift(list(int), list(int)). :- mode sift(in, out) is det. :- pred remove(int, list(int), list(int)). :- mode remove(in, in, out) is det. primes(Limit, Ps) :- integers(2, Limit, Is), sift(Is, Ps). integers(Low, High, Result) :( Low =< High -> M is Low + 1, Result = [Low | Rest], integers(M, High, Rest) ; Result = [] ). sift([], []). sift([I | Is], [I |

Ps]) :- remove(I, Is, New), sift(New, Ps). remove( P, [], []). remove(P, [I | Is], Result) :M is I mod P, ( M = 0 -> Result = Nis, remove(P, Is, Nis) ; Result = [I | Nis], remove(P, Is, Nis) ). Miranda Language type: F - Functional or lambda-based Description: Miranda is an interpreted pure-functional language, intended both for teaching functional programming and for application development. As a pure functional language, Miranda has no conventional imperative control constructs. Instead, Miranda scripts consist of a set of equations that define various data structures and operations. Data types available in Miranda include booleans, identifiers (symbols), integers, characters, reals, strings, lists, tuples, and functions. Miranda is strongly typed, in the sense that all functions enforce type constraints Lists are extremely important in Miranda, as they are in many functional languages. Miranda provides a powerful definition syntax for lists called list comprehensions. Unlike

Lisp and the original version of ML, Miranda uses lazy evaluation for all expressions. This allows the language system to support infinite lists and indefinite parameters. Miranda supports many of the higherorder features expected of an advanced functional language: curried functions, first-class functions, sophisticated pattern matching on rule application, and definition of algebraic types. The syntax of Miranda is very terse and compact. The language has no special statement syntax, everything is an expression. The basic syntax for function application is prefix, but infix notation can also be used in most cases. The only implementation of Miranda is the commercial one, it is available for most Unix systems including Linux. Information about Miranda is fairly easy to find on the web, but the language system does not seem to be available for download anywhere. Apparently it must be purchased commercially There are several good computer science books about Miranda. Origin: David

Turner, University of Kent, 1985. See Also: FP ML Haskell Hope Remarks: Miranda began as an academic project at the University of Kent, but was later commercialized by Research Software Ltd. Typically, Miranda is used as an interactive text-based interpreter, with the programmer entering commands and expressions directly and the system evaluating or storing them. Of course, the system can also import source code files. The most recent version of the commercial Miranda seems to be 2.02, dating to 1995 Links: Miranda information and links at U. of Michigan The Miranda System Manual Topics in Miranda Programming (notes) Date: Last updated 2/25/98 Sample code: || Sorting with the comparison function as a parameter || (adapted from code example by Simon Thompson) sortG :: (* -> -> bool) -> [] -> [] sortG comp (a:x) = sortG comp smaller ++ [a] ++ sortG comp larger where smaller = [ b | b<-x ; comp b a ] larger = [ b | b<-x ; comp a b ] || Example Use CompInt :: (* ->

-> bool) CompInt m n = (m < n) SortG CompInt [3,5,0,12,8,43,7] ML Language type: F - Functional or lambda-based Description: ML is the name for a family of functional programming languages: ML, SML, SML/NJ, CAML, EML, and others. The features and usage of the different versions vary somewhat; this description is based on documentation for Standard ML. ML language systems are usually interpreters ML is a pure functional language, in the sense that there is not assignment to storage permitted. Instead, in ML the programmer declares functions and references to values; ML is a declarative rather than a procedural language. The lack of VonNeumann semantics makes functional languages like ML challenging for the programmer, but functional programs are much more amenable to formal analysis and proofs of correctness. ML supports many of the advanced capabilities expected of a good functional language: recursion, strong typing with type inference, a good variety of built-in data

types, facilities to construct aggregate and functional types, late binding, function composition, higher-order functions, and exception handling. Pure functional languages permit no side-effects of functional evaluation. These languages are usually of limited utility. ML provides file and network I/O to support writing real programs; writing data constitutes a side effect of evaluating an output function. ML also supports references to mutable storage, thus allowing the programmer some of the convenience of a VonNeumann model while preserving functional operation? All SML systems share a common library of built-in functions and modules called the SML Basis Library. The basis library provides various data manipulation, I/O, string handling, and operating system interface functions. MLs sophisticated type system gives the programmer the ability to define simple functions that automatically get applied to the right kind of data. It also supports very fine-grained polymorphism Many other

functional languages designed after ML also support a pattern-matching approach to function application. The name ML originally stood for Meta-Language. ML developed in several ways during the mid to late-1980s; a common dialect and base set of features were standardized as SML in 1990. The standard was revised in 1997, language systems that comply with the new standard are called SML97 implementations. Information on ML is easily available on the Internet. Several free implementations of ML exist for most platforms, some of the most popular are SML/NJ, CAML, and Moscow-ML. At least one commercial implementation, from Harlequin Group is also available. Origin: Standard ML, Milner and Tofte, 1990. See Also: FP Lisp Haskell Hope Remarks: SML is a very rich and usable functional language. It provides a very practical set of aggregate data types (tuples, lists, arrays), and good facilities for defining new types. Many academic functional languages do not support graphics or GUIs, some

versions of ML can present visual interfaces and output using the X Window System or MS-Windows. The French CAML system support object-oriented programming and a Tk-based GUI system. There have also been versions of ML that support lazy evaluation and concurrency. Links: An Introduction to ML The Usenet ML FAQ List Information about Standard ML Moscow ML information and ML links The CAML language (at Inria) Date: Last updated 9/23/01 Sample code: ML definitions to sort a list and compute the mean, adapted from Andrew Cummings GIML. fun sort nil = nil : int list | sort(h::t) = let fun insert(i,nil) = [i] | insert(i,h::t) = if i>h then i::h::t else h::insert(i,t) in insert(h, sort t) end; fun mean l = let fun sl(nil ,sum,len) = sum div len | sl(h::t,sum,len) = sl(t,sum+h,len+h) in sl(l,0,0) end; mean(sort [2,3,5,7,11,13] @ [6,14,28] ) Modula 3 Language type: O - Object-oriented Description: Modula-3 is a compiled procedural that supports object-oriented and block-structured

programming. It is a descendant of Modula-2 and Pascal, and is intended for application development, large-scale software engineering, and computer science education. As a descendant of Pascal, Modula-3 is strongly typed and can enforce type safety. The language supports a conventional set of data types: numbers, enumerations, strings, records, sets, and arrays. Modula-3 supports the usual control flow selection and looping constructs. It provides good support for modular programming, including subroutines and modules with explicit interfaces. Unlike Pascal, Modula-3 has full support for abstract data types and simple OOP, dynamic memory management with garbage collection, generics, exception handling, and concurrency. It is an important part of Modula-3s claim to being industrial-strength that it includes robust error handling and multi-threading as part of the language. Modula-3 does not support some OOP features that its designers believed would overcomplicate the language or

detract from productive software development: multiple inheritance, delegation, operator overloading, and reflection. Module-3s object-oriented programming model is very simple: an object is simply a record type augmented with a method suite. Superclass method overloading is supported Pascal compilers attempt to enforce type safety in every line of a program. A Modula-3 compiler allows some modules to be designated as explicitly unsafe, freeing the programmer to use tricky or machinedependent techniques to gain efficiency or access to hardware. There is a fairly wide variety of support libraries available for Modula-3, including ones for network communication, object persistence, database access, 3D rendering, and graphical user interfaces. Early implementations of Modula-3 produced C code for native compilation, but modern systems produce native machine code directly. Both commercial and free compilers for Modula-3 are available, for all major platforms include Unix, Linux, and

WindowsNT. Digital Equipment Corp, one of the originators of the language, makes a free compiler available in source form. At least one commercial implementation of Modula-3 is available as a comprehensive development environment. Information about Modula-3 is also fairly easy to find on the WWW. Origin: Luca Cardelli et al, Olivetti and DEC, 1988. See Also: Modula-2 Pascal Ada C++ Oberon Cedar Mesa Obliq Remarks: Developers that have used Modula-3 have had praise for its elegance and completeness. It has a large feature set, but not so large or complex as to be overwhelming (e.g Ada) Facilities that you need for serious system development are built-in, like concurrency and garbage collection. It is something of a mystery that Modula3 is not more widely employed (perhaps its family relationship with Pascal, regarded by many as too selflimiting for serious development, scares developers away) The direct linguistic predecessor of Modula-3 was Modula-2+, an enhancement of Modula-2

incorporating ideas from Mesa. Niklaus Wirth was consulted on the design of Modula-3, but was not the primary designer as he was for Modula-2. At this time, Modula-3 is not the subject of any formal standardization activities. Links: Modula-3 Reference and Tutorial M3 Resources at Polytechnic Montreal M3 Information and Links at DEC Critical Mass Module-3 implementation Date: Last updated 12/30/97 Sample code: An example of using the Modula-3 VBTKit GUI system. MODULE Push EXPORTS Main; IMPORT Trestle, VBT, TextVBT, RigidVBT, ButtonVBT, BorderedVBT, HVSplit, Axis; action of button when pushed PROCEDURE QuitAction (self: ButtonVBT.T; READONLY cd: VBTMouseRec) = BEGIN Trestle.Delete(main); (* NB. "main" is visible here *) END QuitAction; CONST horz = 30.0; vert = 10.0; VAR (* horizontal size "hello" window ) (* vertical size of "hello" window ) hello := RigidVBT.FromHV(TextVBTNew("Hello World"), horz, vert); quit := ButtonVBT.New(ch :=

TextVBTNew("Quit"), action := QuitAction); main := HVSplit.Cons(AxisTVer, hello, BorderedVBTNew(quit)); BEGIN Trestle.Install(main); Trestle.AwaitDelete(main); END Push. Modula-2 Language type: S - block-structured Description: Modula-2 is a procedural, block-structured language intended for application programming and computer science education. It was designed to foster good software engineering practices, and also to remedy some of the shortcomings of its predecessor, Pascal. Modula-2 has very good support for program modularity: named modules, separate compilation, and data hiding. It also featured strong type checking, a variety of conventional data types, dynamic arrays, and concurrency! Modula-2 was designed to support the construction and maintenance of real application software systems (unlike Pascal). Its support for concurrency and dynamic memory management are also better than Pascal, allowing the programmer more flexibility. The syntax of Modula-2 is also less

rigid than that of Pascal, allowing the programmer to declare variables and other items nearer to where they are used. Lastly, Modula2 support function signature type checking across module boundaries Modula-2 compilers are available, with a little searching, for most platforms: Unix systems, PCs, and VMS, and even some cross-compilers for embedded systems. Both free and commercial compilers are available, but some may be a bit old. There is at least one Modula-2 system, by XDS, that can generate C code from Modula-2 code, to improve portability. A fair number of utility, math, data handling, distributed computing, and other libraries are available for Modula-2 programmers. In its original niche, Modula-2 has been partly superseded by Modula-3, Oberon, and Ada. Origin: Niklaus Wirth, 1980. See Also: Pascal Modula-3 Oberon Ada Remarks: Modula-2 enjoyed some degree of adoption in the early 1980s, especially for software engineering education. Many commercial compilers were written for

it. Modula-2s features and semantics had substantial influence on the design of Ada. Unfortunately, while Modula-2 allows construction of abstract data types, it does not support inheritance and therefore was not able to fully support the paradigm of object-oriented programming that became popular in the late 1980s. There were several variations of Modula created in the 1980s, including a data-parallel dialect called Modula-2* designed for massively parallel computers. Links: Modula-2 resource list Formal syntax of Modula-2 Modula-2 FAQ Date: Last updated 12/30/97 Sample code: MODULE AlphaRandom; (* Randomize the alphabet, and show how to use the module Shuffle ) (* John Andrea, 1992 ) FROM InOut IMPORT WriteLn, WriteString; FROM Shuffle IMPORT Deck, Create, Next, Reset; VAR d :Deck; i, j, min, max, n :CARDINAL; BEGIN min := ORD( a ); max := ORD( z ); n := max - min + 1; Create( d, min, max ); FOR i := 1 TO 10 DO WriteString( random alphabet = ); FOR j := 1 TO n DO WriteString(

CHR( Next( d ) ) ); END; WriteLn; Reset( d ); END; END AlphaRandom. MUMPS Language type: D - Database or Text-processing Description: MUMPS (aka M) is a procedural, interpreted language with extensive features for eventdriven programming, text handling, and database manipulation. The language syntax is very simple, but quirky. A program written in M consists of commands which operate on variables These variables can be simple numbers, records, lists, or enormous databases. Persistent variables are called globals and usually live in the database. Access to globals is transparent, freeing the programmer from worrying about many database management issues. The usual sequential control structures are present in MUMPS, but in somewhat idiosyncratic forms. The usual arithmetic operators are included, but MUMPSs real strength is in its string handling. It has a flexible set of commands for pattern matching, sorting, and manipulating strings (although not as extensive as SNOBOL or Icon). M is

designed to support multi-programming and distributed computation. There are also GUI implementations available for the language, although the base language standard supports only text-based screens. Information about MUMPS products and services are easy to find on the Web, as are implementations of the language and its underlying fast database. Most MUMPS implementations are commercial, but there are also free systems around for Unix, VMS, and DOS, and Windows operating systems. Tutorials on MUMPS do not seem to be available easily on the web, but copies of the language standard are. Origin: Octo Barnett M.D et al, Mass General Hospital, 1969 See Also: DBase Icon Tcl Basic Remarks: MUMPS originally stood for Massachusetts General Hospital Utility Multi-Programming System. After the language became standardized and commercialized, people started calling it M because it was cooler and didnt evoke an unpleasant disease. Modern M systems are extensible, allowing interfacing to other

languages (like C), networking facilities, and other database systems. M was originally mostly used in medical informatics (partly as a result of NIH encouragement in the early 1970s), and it remains very popular for building clinical databases worldwide. MUMPS users groups and technical associations are active, and an international M conference is held each year. Since the advent of the WWW, MUMPS has been used to write web servers, web/database interfaces, and other CGI services. Standization efforts for M are still active, concentrating on keeping the language current and useful for its programming community. MUMPS products are sometimes touted as post-relational databases, even though the language was invented before RDBMS products became popular. However, for complex multi-dimensional data, MUMPS is regarded as superior to RDBMSs by many practitioners. Newer OODBMS products compete in MUMPSs territory. Links: M Technology Resource Center Chris Bonnicis M page M Technology

Association of North America An FTP site with MUMPS info and downloads Date: Last updated 12/16/97 Sample code: ; EXAMPLE FROM UC DAVIS LEXICON ;PROGRAM TO CREATE SORTED DICTIONARY READ !,"ENTER NEXT TERM (NULL TO QUIT): ",TERM GOTO:TERM="" LIST READ !,"ENTER ONE LINE DEFINITION: ",DEF SET ^WORD(TERM)=DEF GOTO LEXICON LIST READ !,"WOULD YOU LIKE TERMS LISTED (Y/N)?",YESNO QUIT:YESNO?1"Y".E SET X="" ;TO GO TO PRINTER ADD OPEN 1 USE 1 FOR I=1:1 SET Y=$ORDER(^WORD(X)),X=Y QUIT:X="" WRITE !,Y,?15,^WORD(Y) N NESL Language type: P - Parallel or Multi-programming Description: NESL is a data-parallel functional programming language intended to be highly portable across different parallel computer architectures, easy to use, and efficient to compile. The basic data types supported by NESL are: integers, reals, strings, and sequences (vectors). The sequences are heavily used for defining parallelism, NESL has special

operators and syntax for operating on all elements of a sequence and on each element of a vector. In addition to its parallel computation constructs, NESL also supports conventional selection (if-then-else) and iteration (for, while) control-flow constructs. The NESL function library provides a rich set of sequence operations, plus string manipulation, I/O, system interface, and windowing functions. Currently, NESL runs only on UNIX and related systems (or parallel computers attached to such systems); its windowing support is currently implemented only for X11. NESL is usually compiled; the compilation process automatically generates a mapping from the computation defined by the NESL code onto the processors of the target computer. Variables and functions in NESL are not strongly typed, but the compiler seems to perform extensive type inference at compile-time. Releases 31 and later of NESL also include a lightweight interpreter for use in training and debugging. The NESL compiler is

written in C, and the interpreter is implemented in Common Lisp. Implementations of NESL are available from CMU. The documentation and a tutorial are also available on the web. Origin: Guy Blelloch, Carnegie-Mellon, 1992-93 See Also: ML Lucid Clean Remarks: NESL is a project of SCandAL group at CMU. They are working on porting the language to a variety of parallel architectures. They also have a system for translating NESL programs into multi-threaded Java programs. NESL has special features for animating the execution of parallel algorithms, a helpful feature for presenting papers at conferences and for computer science education. Some live animations can be seen at the NESL pages at CMU. NESL has been the experimental vehicle for research in provable performance bounds in parallel algorithms, as well as parallel-processing compiler research. Links: Interactive Interface to NESL NESL distribution download site Date: Last updated 12/23/97 Sample code: % Fits a line to a set of of

points % % using a simple regression algorithm, % % return line and goodness of fit. % % (from code examples with NESL 3.1) % function line fit(x, y) = let n = float(#x); xa = sum(x)/n; ya = sum(y)/n; Stt = sum({(x - xa)^2: x}); b = sum({(x - xa)*y: x; y})/Stt; a = ya - xa*b; chi2 = sum({(y-a-b*x)^2: x; y}); siga = sqrt((1.0/n + xa^2/Stt)*chi2/n); sigb = sqrt((1.0/Stt)*chi2/n) in (a, b, siga, sigb) $ NIAL Language type: F - Functional or lambda-based Description: NIAL, the nested interactive array language, is a quasi-functional language with some procedural features. It is intended for application development. Nial offers high-level features intended to make it easy for the programmer to build complex data structures and analysis functions. The primitive data types in Nial includes integers, reals, strings, and atoms The primary aggregate data types is the rectangular array. Arrays can be heterogenous, dynamic, and built up in a variety of ways. Nial supports conventional

procedural control-flow constructs like while loops and conditional expressions. Various functional programming constructs like currying, transformers, and composition are also supported. Nial was originally designed and implemented at Queens University in Ontario, CA. It is now developed and sold by NIAL Systems Limited. The company offers free evaluation downloads Origin: M. A Jenkins et al, Queens University Ontario, 1981-86 See Also: Lisp FP S Yorick APL Mathematica Remarks: One of the design goals of Nial was to use simple laws and identities with consistent properties that always hold true. This precision, together with Nials nested control structures and powerful array operators, is supposed to make Nial programs compact and easy to explain. Like any very powerful, compact language (e.g APL) the programs can sometimes get very dense and opaque The QNial system is a portable interactive interpreter for Nial; it can be considered analogous to a Mathematica notebook or an S

session. Links: About NIAL (introduction) NIAL Free Evaluation download area Date: Last updated 1/6/98 Sample code: # A routine to look for HTML tags in a # file (from the AboutNial page at NIAL Systems) findtagtext IS OPERATION Text { Hdposns := `< findall Text; Tlposns := `> findall Text; Lengths := Tlposns - Hdposns + 1; Tags := Hdposns EACHBOTH + EACH tell Lengths EACHLEFT choose Text; Hdposns Tags } test is op fnm { findtagtext readfield fnm 0 (filelength fnm) } Posns Tags := test "intro.htm; O Oberon Language type: O - Object-oriented Description: Oberon is a procedural, block-structured language with many object-oriented features. It was designed for computer science education, but is also suitable for general-purpose application programming. Oberon has a Pascal-like syntax, but its semantics are richer than Pascals. An Oberon system consists of the Oberon language compiler along with a comprehensive operating environment. The Oberon language offers the following

features: strong type checking, separately compilable modules, type extension and type-bound functions for OOP, run-time type identification, dynamic memory management with garbage collection, regular complement of numeric, string, and array data types, and dynamic module loading. Oberon, like Pascal, enforces the rule that every thing must be declared before it is used. There are some features of other object-oriented languages that Oberon does not offer: operator overloading, multiple inheritance, abstract interfaces, and reflection. Several versions of the Oberon system and language exist. Oberon V4 (System 2) is the classic, text-based system. Oberon System 3 is the newer, GUI system with advanced OOP features like persistence and generic message passing. Oberon/F is a version of the language for embedded systems and other black-box applications. Implementations of the ETH free Oberon system are available for some Unix systems, Linux, PCs, and Macintosh. Commercial versions of

Oberon also exist Origin: Wirth and Gutknecht, ETH Zurich, 1985-88. See Also: Pascal Modula-3 Ada SELF Remarks: The Oberon language and system are designed to be compact, efficient, and highly productive. In terms of compactness, the entire Oberon distribution with compiler and libraries and operating environment fits onto 7 floppy disks. While Oberon has a community in the US, it seems to be more popular in Europe. The Juice plug-in for running web applets in Oberon is available at the Juice link below. It claims to be faster than Java. Links: Oberon Internet Resources lists StatLab Heidelberg Oberon Info The Oberon Zone Juice - Oberon for the Web Oberon FTP Site Date: Last updated 12/7/97 Sample code: (* Oberon module to read in numbers ) (* average them. *) MODULE Stats; IMPORT Texts, Oberon; TYPE Stat* = POINTER TO StatRec; StatRec *= RECORD count: LONGINT; total: REAL; END; PROCEDURE (s: Stat) Add* (REAL val); VAR this: Stat; BEGIN this := s; this.total := thistotal + val;

this.count := thiscount + 1; END Add; PROCEDURE (s: Stat) Reset*; VAR this: Stat; BEGIN this := s; this.total := 00; this.count := 0; END Reset; PROCEDURE (s: Stat) IsValid*: BOOLEAN; VAR this: Stat; BEGIN this := s; RETURN (this.count > 0); END Reset; PROCEDURE (s: Stat) Average*: REAL; VAR this: Stat; BEGIN this := s; IF this.IsValid^() THEN RETURN 0.0 ELSE RETURN (this.total / thiscount) END Average; END Stats; Objective-C See: C Language type: O - Object-oriented Description: Objective-C is an object-oriented language based on C; its object support is based on a dynamic messagepassing model. Objective-C provides a range of OOP features: inheritance, dynamic method invocation, delegation, metaclasses and dynamic object creation, a form of garbage collection, simple persistence, and a kind of polymorphism. Objective-C does not support multiple inheritance, and concurrency is not part of the language. The syntax of Objective-C is very similar to C, but with additions. Unlike

C++, Objective-C does not add OOP semantics to traditional C syntax; instead, new syntax specifically for message passing and class definition provide OOP support. Objective-C offers the same data types as C: integers and floats, arrays, structures, unions, and pointers. Objects are a new type; Objective-C uses a rooted class hierarchy: all classes inherit from a root Object class. This fact is heavily employed by the Objective-C standard class library. Brad Cox invented Objective-C in the mid-1980s as an OO extension to C, intended to bring C programmers some of the benefits offered by Smalltalk. The language was used by NeXT in the 1989-94 timeframe as the application and library programming language for the NeXTSTEP and OpenStep operating systems. Objective-C has been implemented as a C preprocessor and as a native compiler. At least one commercial and one free compiler are available. Information on Objective-C exists on the Internet but is not easy to find Origin: Brad J. Cox,

1984-85 ? See Also: Smalltalk C++ Eiffel Remarks: Objective-C is a very clean and simple OOP extension to C. It is far more dynamic than C++, allowing the easier construction of class libraries, GUI interfaces, and event-driven systems. However, a free compiler for Objective-C was not generally available until 1992, by which time C++ had begun to dominate commercial OOP. The set of Objective-C class libraries offered with the NeXT machine in 1990 was very powerful and comprehensive; a testament of Objective-Cs expressive power and convenience. Objective-C is the primary programming language for Apples new NeXT-based OS, Rhapsody. Links: Objective-C FAQ Old NeXT Objective-C Documents at Apple An Objective-C home page Stepstone Corporation The GNU Objective-C Project Date: Last updated 12/12/97 Sample code: /* still need an example here / Obliq Language type: O - Object-oriented Description: Obliq is an object-oriented interpreted scripting language that supports distributed

multi-threaded computation. The syntax of Obliq is similar to that of Modula-3, but simpler and with no support for type declarations. Obliq is basically untyped, variables and fields can hold any kind of value. Basic data types include booleans, integers, reals, characters, strings, and arrays. Obliq supports a complete set of sequential control structures including conditional, iteration, and exception handling forms, as well as special control forms for concurrency (mutexes, guarded statements). A fairly large set of standard libraries are defined for Obliq. These libraries provide support for math operations, I/O, persistence, thread control, graphics, and animation. Distributed computation in is object-based. Objects can hold state, and that state is local to a particular process. Scope of objects and other variables is purely lexical Objects can call methods of other objects, even if those objects are on another machine on the network. Obliq objects are simply collections of

named fields (like Selfs named slots), and support inheritance by delegation (like Self). The Obliq language system is an interpreter written in Modula-3, and employing Modula-3s network objects capabilities. Obliq is included free with the DEC Modula-3 distribution, and pre-compiled binaries for some platforms are also available. A manual and many journal articles about the language and its applications are available on the web. Origin: Luca Cardelli, DEC, 1993 See Also: Modula-3 Telescript Phantom Self Remarks: Obliq was designed to make distributed computation simple and easy for the programmer, while providing program safety and transparency with strict lexical scoping. The distributed computing in Obliq is based on the powerful network object facility provided by Modula-3. Unlike Modula-3, however, Obliq is interpreted and untyped, which makes it very flexible and friendly. Like most interpreters, Obliq supports evaluation of dynamically generated code. In the distributed

computation context, this means that Obliq can support mobile agents and roaming computations. Another common use for Obliq is 3D animations. The standard library provides sophisticated graphical object rendering. This feature of Obliq has been used to make some really cool animations of algorithm execution. Links: Download Obliq interpreter software Visual Obliq home page at GATech Obliq and 3D algorithm animation W3C Assemssment of Obliq Date: Last updated 12/29/97 Sample code: Since Obliq is normally used for distributed computation, this example code has two parts: Server side: (* A server for computing factorials. *) module FactServer; let fact = net export("fact","", { m => meth(s,n) if n is 0 then 1 else n * s.m(n-1) end end }); Client side: module FactClient; let fact = net import("fact",""); fact.m(13); occam Language type: P - Parallel or Multi-programming Description: Occam is a simple parallel computing language developed to

express many kinds of parallel programs easily and directly. Originally intended for the INMOS Transputer, a chip built to support fine-grain multiprocessing, Occam has been implemented for several processor and software architectures Syntactically, Occam is quite simple, structure is expressed with a few simple keywords and with indentation. Occam supports a modest set of data types: ints, reals, bytes, strings, and arrays (The original version of Occam didnt support reals.) In addition to simple data types, Occam defines some kinds of parallel computing primitives as types: channels and timers. The semantics of Occam are based on the notion of processes. A process can be any kind of computation (e.g a := b + 6) and can run in parallel with other processes The language provides structure to allow processes to execute in parallel or sequentially. Parallel processes communicate with channels; these channels must be declared, like variables, and can enforce synchronizations (something

like an Ada rendezvous, but simpler and more flexible). The language also includes advanced facilities for multiplexing channels and replicating processes. Occams model for parallel computation is based on the seminal research by C.AR Hoare and his language CSP. The current version of the Occam language definition is 2.1 Previously available only as a commercial system from INMOS, various free implementations of Occam are now available for various platforms. Check the links below for information and downloads. Some of the available compilers are really occam->C translators. Occam reference manuals and examples are available for download Origin: David May et al 1982, 1987. See Also: CSP Ada Remarks: Occam is a fascinating little language, with a very lean and spare set of features that result in a powerful whole. The language included special features for making occam programs efficient on the Transputer architecture, but theyre very cleanly integrated with the rest of the syntax.

When INMOS was acquired by SGS-Thompson, the parent company donated a lot of the occam technology to the research community, including utility libraries for the language. The occam For All project, begun in 1995, aims to provide free and architecture-neutral occam systems and tools for programming researchers and industry. Occam is considered to be a good language for learning parallel computing concepts. It is high-level enough to be usable, general enough for the knowlege to be transferable to other system, and low-level enough that you can still get into trouble. Links: Occam @ Internet Parallel Computing Archive Date: Last updated 12/8/97 Sample code: -- Pipelined parallel sort in occam --(from Pountain and May, A Tutorial -- Introduction to Occam Programming) VAL numbers IS 100 : [numbers + 1] CHAN OF INT pipe: PAR PAR i = 0 FOR numbers input IS pipe[i] : output IS pipe[i+1] : INT highest : SEQ input ? highest SEQ j = 0 FOR numbers - 1 INT next: SEQ input ? next IF next <=

highest output ! highest next > highest SEQ output ! highest highest := next SEQ i = 0 FOR numbers -- get unsorted INT unsortednumber : -- numbers SEQ input ? unsortednumber pipe[0] ! unsortednumber SEQ i = 0 FOR numbers -- dump sorted INT sortednumber : -- numbers SEQ pipe[numbers] ? sortednumber output ! sortednumber OPS5 Language type: L - Rule-based or logical Description: OPS5 is a production rule programming language for AI research and building expert systems. The OPS family of rule-based systems culminated with OPS5, which has been widely used for AI instruction and application development. An OPS5 program consists of a set of production rules. Each rule has a precedent, or set of conditions which govern application of the rule, and an antecedent which define actions to take upon triggering the rule. OPS5 supports both forward-chaining and backward-chaining control models. Data in the OPS5 model is handled as a set of global state variables and records which can be

modified by the rules. Production rules reside in "production memory", while data values reside in "working memory" Primitive data types are numbers and symbols (symbols also serve as strings). OPS5 is weakly typed, like Lisp: variables are not declared to have a particular type, but can hold any type of data placed in them. Working memory contains objects that bear attributes: these attributes can hold primitive data values, vectors, or references to other objects. OPS5 has been largely superseded by newer expert-system shells (such as CLIPS) and rule-based languages (such as OPS83). The first version of OPS5 was coded in Lisp. Later versions were written in C for speed Both commercial and free academic editions of OPS5 existed during the 1980s. Free implementations of OPS5 (C and Lisp) are supposedly available. Documentation on the language is not easily available on the net Origin: Charles Forgy et al, 1977. See Also: Lisp Prolog Remarks: The syntax and semantics

of OPS5 are highly specialized for the task of writing rule-based systems that model real-world situations. The division of the programming model into "production" and "working" memory was based on cognitive psychology frameworks of human thought processes: long-term memory is equated to domain knowledge and corresponds to production rules, and short-term memory is equated to facts about the situation at hand and corresponds to objects in working memory. In any OPS5 program, the toughest part is ensuring that the right domain-specific rule is applied to the working memory at the right moment. OPS5 supports various grouping and priority schemes to allow the programmer to guide the execution of rules; applying these facilities can be tricky. Date: Last updated 12/22/97 Sample code: ; An OPS5 program that implements a model of ; rock climbers, from exercise solutions of ; "Expert Systems Programming in OPS5" (literalize rock-climber age ; young or old style ;

timid or bold ) (p old-not-bold (rock-climber ^age old ^style <> bold) ---> (write (crlf) that is plausible)) (p bold-not-old (rock-climber ^age <> old ^style bold) ---> (write (crlf) that is quite possible)) (p error::old-and-bold (rock-climber ^age old ^style bold) ---> (write (crlf) There are no old, bold rock climbers)) (make rock-climber ^age young ^style bold) Orca Language type: P - Parallel or Multi-programming Description: Orca is a parallel-programming language based on a shared-object data model, designed to be compiled, and intended for portable application development across a variety of multiprogramming architectures. The syntax of Orca is based on that of Modula-2, and Orca supports the same sequential control constructs that Modula-2 does. Primitive data types in Orca include characters, integers, and reals Orca also supports arrays, and a high-level graph type. The programmer can define new Abstract Data Types (ADTs), with data attributes and

operations. Orca is a strongly-typed language, designed so that the compiler can catch a wide variety of semantic errors. The fundamental notion for parallelism in Orca is that running programs on different processors can share arbitrary data structures, but that operations on those structures are automatically indivisible. This is essentially a simple model for distributed objects, and provides the programmer with a good deal of flexibility in implementing the elements of a parallel system, while removing some of the low-level worries encountered with message-passing systems. An alpha distribution of Orca can be obtained from its principal developer, Dr. HE Bal at Vrije University Information about the system on-line consists mostly of journal and conference papers about Orca and its original target platform, Amoeba. Origin: Bal, Kaashoek, Tannenbaum et al, 1985-90. See Also: Modula-2 SETL Occam Remarks: Orca provides a high-level shared data model for parallel programming, in

contrast to systems that employ explicit message passing (e.g Occam) and those that use paged shared virtual memory Orca is used as a research vehicle for exploring parallel algorithms and mechanisms for efficient data handling in parallel systems. The current implementations of the Orca run-time environment are built to run on top of a service layer named Panda. The Panda virtual machine provides communication and thread support, hiding the systemdependent details of these services from running Orca programs Orca runs on a variety of parallel computers, as well as Solaris and other general-purpose Unix systems. An early version of Orca was used as the expository language in the book Programming Distributed Systems. Links: Download page for papers about Orca Date: Last updated 2/15/98 Sample code: # An example object from the paper # "Experiences with the Orca Programming Language" # by Bal and Wilson OBJECT IMPLEMENTATION buffer; CONST MAXSIZE = 10; # Maximum size of the

buffer # Local state of the object: buf:ARRAY[integer 0.MAXSIZE-1] OF integer; # the buffer itself in, out: integer; # index of next element to put/get size: integer; # current size OPERATION put(x: integer); BEGIN GUARD size ! MAXSIZE DO # blocks until there is room buf[in] := x; # store element in := (in + 1) % MAXSIZE; # bump input index size +:= 1; # increment size OD; END; OPERATION get(x: OUT integer); BEGIN GUARD size ? 0 DO # blocks while buffer is empty x := buf[out]; # retrieve element out := (out + 1) % MAXSIZE; # bump output index size -:= 1; # decrement size OD; END; END; Oz Language type: P - Parallel or Dataflow Description: Oz 2 is a declarative concurrent programming language that supports object-oriented and functional programming with constraint propagation. It was created as a research vehicle for advanced language design, AI, and concurrent system design. Primitive simple data types in Oz include integers, reals, characters, strings, booleans, atoms, threads,

objects, and functions. The language also supports a flexible set of aggregate types: records, tuples, lists, and arrays. All predefined Oz types are arranged in a type hierarchy, and inheritance relationships in the hierarchy can be used as part of the type system and constraint rules. Oz supports the usual sequential control structures, like conditionals and loops, as well as parallel versions of them. It also has exception handling constructs. The Oz object system supports encapsulation, inheritance, generics, and other OOP features Like most functional languages, Oz has full automatic memory management and garbage collection. Like most parallel programming languages, it has synchronization primitives for serializing access to objects. Thread creation in Oz 2 is always explicit. Oz uses a constraint programming system called finite domain constraint propagation. Constraint propagation runs concurrently with other program activities. Oz 2 has been implemented on Unix systems and

Windows, a distribution may be obtained from DKFI in Germany. Good documentation is available at the languages web site Origin: G. Smolka with Schulte, Henz, Muller, Wurtz et al, DFKI, 1994-97 See Also: Scheme Sisal C++ Lucid Java Simula Tcl Remarks: The current Oz language is Oz 2.0 The original Oz 1 was less capable and somewhat different than its successor, in that it had an extremely fine-grain concurrency model, and a much less capable constraint propagation system. Oz 3, which is under development, is supposed to be a lot like Oz 2 Oz 2 supports GUI programming by allowing calls to the Tk graphics toolkit. Links: Oz 2.0 Documentation area Oz 2 download area Mozart implementation of Oz 3 Date: Last updated 9/3/98 Sample code: A procedure to do a lazy check of a binary tree, from Tutorial of Oz 2 by S. Haridi local proc {AndThen BP1 BP2 ?B} case {BP1} then case {BP2} then B = true else B = false end else B = false end end in proc {BinaryTree T ?B} case T of nil then B = true []

tree(K V T1 T2) then {AndThen proc {$ B1}{BinaryTree T1 B1} end proc {$ B2}{BinaryTree T2 B2} end B} else B = false end end end P Pascal Language type: S - block-structured Description: Pascal is a simple block-structured language originally designed for computer science education. Pascal features strong type checking, simple I/O facilities, a good set of primitive data types, arrays, fixed and variant records, conventional control structures, and simple dynamic memory management. Pascal requires discipline from the programmer: all types, data, and subroutines in a Pascal program must be declared prior to use. Everything is lexically scoped, to allow for maximum compile-time type checking The language has good support for programmer-defined data types and subtypes, which are also subject to strong checking. Structure of a Pascal block is somewhat rigid, elements must appear in a certain order preceded by their identifying keyword: labels, constants, types, variables and functions,

then body code. The original Pascal language borrowed some structural ideas from Algol, but also included novel syntactic and semantic features intended to foster good structured programming technique (or at least what was considered sound structured development technique in the 1970s). The choice of features and the limited external interface facilities helped make Pascal very portable. However, the initial design was very spare, it didnt include strings, only arrays of characters, and it had a very small complement of built-in utility functions. These omissions led developers of Pascal language implementations to add extensions to help programmers accomplish real work, and unfortunately every vendors extensions were more-or-less proprietary -- the Pascal language lost some of its portability. Amazingly, while it is very strict in most ways, Pascal still supports a goto statement. Pascal does not support object-oriented programming, persistence, or multi-tasking. A 1975 variant of

Pascal called "Concurrent Pascal" had good support for multi-tasking and other advanced features. Over the 1970s and 1980s, Pascal became fairly widely used, especially in the early days of the IBM PC and the Macintosh. A great many students of computing in the 80s cut their teeth on Pascal programs Both free and commercial Pascal compilers exist. The most popular commercial compiler, and a fine language implementation, is "Turbo Pascal" from Borland. Pascal is normally compiled, either to machine code or virtual machine bytecodes of some sort. Source-level Pascal interpreters also exist, and translators from Pascal to other languages. Information on Pascal, including programming tutorials, is widely available on the WWW. Origin: Niklaus Wirth, 1968-71 See Also: Algol Modula-2 Ada Oberon Remarks: Pascal proved to be a very influential language. First described in a published report in 1971, it affected almost every block-structured language designed since (e.g Ada)

Niklaus Wirth continued to design programming languages, including the Modula family. One of the most interesting aspects of Pascal is its relative poverty of features. Compared to its rough contemporary PL/1, Pascal is a tiny language. This contrast helped frame a debate that has raged in computer science circles ever since: should languages be kept small and simple (with complex facilities provided by external libraries), or should they be made large and complex to provide all features that programmers require. Many later block-structured and object-oriented language designers would be forced to choose one of these two camps. Oberon, for example, is small and spare, depending on libraries for advanced features Perl, in contract, is complex and loads many useful features in the language itself. Recent languages like Java adopt a compromise position: keep the language simple, but standardize the supporting libraries to prevent incompatible implementations. In most programming areas,

Pascal has been superseded by newer, object-oriented languages, such C , Java, etc. Links: Turbo Pascal page at Borland SWAG Pascal archives Pascal example programs Turbo Pascal FAQ P4 free Pascal compiler Date: Last updated 12/7/97 Sample code: { Sort program adapted from "Intermediate Pascal" } { by Joe Dorward. Illustrates arrays and types } program sort array(input,output); const max = 9; type integer array = array[1.max] of integer; var I, J, K, swaps, temp : integer; test array : integer array; begin test array[1] := 4; test array[2] := 7; test array[3] := 9; test array[4] := 3; test array[5] := 15; test array[6] := 2; test array[7] := 08; test array[8] := 05; test array[9] := 12; writeln( * Initial Array ); writeln( --- --- --- --- --- --- --- --- --- ); for I := 1 to (max-1) do write(|,test array[I]:2, ); writeln(|,test array[max]:2, |); for I := 1 to max do for J := (I 1) to max do { set J to start one ahead of I } if test array[J] < test array[I] then begin

swaps := swaps 1; temp := test array[J]; test array[J] := test array[I]; test array[I] := temp; writeln; writeln(* Condition After ,swaps:1, swaps ); writeln( --- --- --- --- --- --- --- --- --- ); for K := 1 to (max-1) do write(|,test array[K]:2, ); write(|,test array[max]:2, |); end; writeln( * Sorting Complete ); end. PerfectScript See: Basic Language type: A - Application/Macro Description: PerfectScript was the macro extension language for WordPerfect, QuattroPro, and other office automation products. It is a dialect of Basic, with some additional data structure types and some C-like control structure syntax. Origin: Novell Corporation, 1995? See Also: CorelScript WordBasic LotusScript Remarks: With the release of Corel WordPerfect Suite 8 one might have expected PerfectScript to be superseded by CorelScript, but it wasnt. Links: The PerfectScript Journal Corel PerfectScript Homepage Date: Last updated 1/24/98 Perl Language type: C - Command or Scripting Description: Perl

is an interpreted scripting language with extensive facilities for data manipulation and rapid application development. Perl is basically block-structured, but also supports objectoriented programming "Perl" stands for "Practical Extraction and Reporting Language," a reference to the purpose for which the Perl interpreter was originally created: system administration and data reduction. Perl has gone through several major evolutionary phases. The current language version is Perl5, but some pockets of Perl4 use still exist. Perl5 is backward-compatible with 4 In the feature list below, features that are specific to Perl5 are marked with an asterisk. o o o o o o o o o o o o o o data types: strings, numbers, lists, associative arrays, references, globs data types: objects * conventional math and arithmetic functions subroutines, variable argument lists dynamic memory handling with garbage collection extensive file I/O facilities extensive system interface support

regular expression pattern matching and substitution very extensive data output formatting capabilities various loops and conditional constructs object definition and inheritance * separable namespaces (packages) * lexical and dynamic scope local variables * on-the-fly code evaluation and error handling The Perl language does not support the traditional notion of records or structs. Instead, associative arrays (hashes) are provided to serve all such purposes. Similarly, Perl supports object-oriented programming, but does not stipulate an object storage format. In Perl5, code is parsed and compiled into very high-level bytecodes prior to interpreted execution. This approach, and extensive optimization of the Perl interpreter and run-time engine, allow Perl scripts to achieve very high performance. Perl currently does not support multi-threading, although efforts are underway to add this important feature. Perl is very popular in the UNIX community, and gaining acceptance in the

Microsoft Windows developer community. There is only one Perl language system; written in C to be very portable, it runs on all UNIX platforms, 32-bit Windows, VMS, and many other systems. Perl is free Books, tutorials, and on-line resources for Perl are widely available, and generally of good quality. Add-on modules and pre-built scripts for Perl are also widely available, with more being written all the time. Add-ons for Perl are so numerous and in such wide demand that an organized replicated archive system for them exists: the Comprehensive Perl Archive Network (CPAN). There is no international standard for Perl syntax. The language definition is informally set forth in Programming Perl, 2nd Edition, by Wall, Christiansen, and Schwartz. Origin: Larry Wall, 1986 See Also: Awk SNOBOL Basic Icon csh Tcl Python Remarks: According to Larry Wall, "Perl is a language for getting your job done." This highly pragmatic statement is reflected in the design of Perl in many ways. Perl

is typically applied to such jobs as data reformatting, text extraction, creation of simple network servers, database access, system configuration, software testing, and much more. Perl has gained a great deal of popularity recently because it is the easiest and most effective language in which to write back-end WWW programs called CGI scripts. Perl excels at this because it has good string manipulation, file I/O, control structure, and database interfacing. (The back-end for this programming language dictionary is written in about 1100 lines of Perl, including lots of comments.) The informal symbol for Perl is the camel. Like a camel, Perl is not always beautiful, but it gets the job done Perl is fairly good at interfacing to other languages, albeit not as good as tcl. The Perl interpreter can be embedded in C or C programs, and it can be made to call C or C routines. Efforts to interface Perl with Java are also underway (circa late 1997). Perl has no native GUI toolkit, but a version

of the Tk toolkit has been intergrated with Perl. Links: CPAN (Colorado) Perl FAQs Perl for Win32 Introduction to Perl Date: Last updated 12/16/97 Sample code: #!/usr/bin/perl # Simple program to extract column 3 from a file # and total up the numbers. $total = 0; sub sumcolumn { my $col = shift; my $lin = shift; my @fields; if ($lin) { @fields = split(/:/,$lin); $total = $fields[2]; } } while (<>) { sumcolumn(3,$ ); } print "Total of column 3 is $total "; PHP Language type: C - Command or Scripting Description: PHP is an interpreted server-side scripting language for web servers. It was designed to support simple, fast server-side extension for web development. The syntax of PHP is fairly simple, and very similar to that of Perl, with some aspects of Bourne shell, Javascript, and C . Variables in PHP are weakly types, the language does not support strong typing. PHP supports the a modest complement of primitive data types: integers, floats, and strings. It also

supports heterogenous multidimensional associative arrays, with very convenient syntax PHP offers some object-oriented functionality, allowing the programmer to define classes with member variables and methods, and to use simple inheritance. The language includes an extensive set of operators and built-in functions for manipulating strings, numbers, and arrays. Control structures supported in PHP include simple conditionals, plus several kinds of bounded and unbounded loops. PHP does not support any kind of module or library structure, but it does permit simple file inclusion (similar to Cs #include directive). In addition to its basic web functionality, PHP is supported by extensive libraries that provide database interfaces and interaction with many common web data formats. There is only one implementation of series of PHP implementations, as of late 1999 the current version was 3.0, with 40 in beta PHP is free, distributed as source code, and runs on Unix, Linux, and Windows Origin:

R. Lerdorf, 1995 See Also: Javascript Mawl VBScript Perl Remarks: Designed for web usage, PHP code is normally embedded in HTML (or XML) documents. There are several embedding methods, but all of them share the same fundamental code structure. Single statements cannot span separate embeddings. Statements are normally separated with a semicolon, but the end of an embedding also implies the end of a statements. Like most web scripting languages, PHP supports control structures that span embedding blocks; this allows the web page designer to apply code conditionals and loops to parts of the page content. PHP supports the comment syntax of C, C , and Unix Shell. Documentation about PHP is easy to obtain on the WWW. The next version of PHP is being written with an embeddable scripting engine called Zend. Links: PHP Documentation Resources for PHP programmers Date: Last updated 11/13/99 Sample code: An example of printing the contents of a mySQL database table, by Yahav Boaz. <? mysql

connect("localhost","","") or die("Unable to connect to SQL server"); @mysql select db("php3") or die("Unable to select database"); $result = mysql query("select * from customerTable limit 100"); ?> <table border="1"> <tr> <? while ($field=mysql fetch field($result)) { echo "<th>"; echo "$field->name"; echo "</th>"; } echo "</tr>"; while ($row = mysql fetch row($result)) { echo "<tr>"; for ($i=0; $i<mysql num fields($result); $i ) { echo "<td>"; echo "$row[$i]"; echo "</td>"; } echo "</tr> "; } echo "</table>"; Pict Language type: P - Parallel or Dataflow Description: Pict is a research programming language designed as a practical implementation of the picalculus (a parallel computation formalism). While based on a very advanced formal

model, Pict also provides a small but usable complement of data types and constructs. The core elements of the Pict language are a simple but general static type system and concurrent processes that communicate using channels. The pi-calculus defines the semantics of the processes and channels Pict supports a small set of primitive data types: integer, character, boolean, string, and channel. It does not have enumerated or real number primitive types. The aggregate data type in Pict is the tuple, which can have named or unnamed fields. Pict supports only three sequential programming constructs: sequential composition, conditional (if-thenelse), and associative application (application of a function over several values). Oddly enough, Pict does not have any sequential looping constructs, although other forms like recursion and process composition can do the same thing. The core Pict language is extended by several derived forms and library functions that add no formal expressive power

but make programming much easier (relatively, anyway). For example, local value declarations and associative application are derived forms. Some of the library forms include bounded loops, array handling, events and exceptions, and several other additional data types. The Pict libraries also include interfaces to useful features: o o o most of the Posix-standard operating system facilities image handling X11 windows and graphics For composing larger programs, Pict has a simple import module import facility. Origin: B.C Pierce, DN Turner, 1993 See Also: ML CSP Lucid Remarks: Development of Pict seems to have stopped in 1998. The most recent version, 41, is still available from U of Indiana. The Pict compiler is written in Objective-CAML (an OO variant of ML) Pict runs on Unix systems, and requires the GNU C compiler and GNU Make. The pi-calculus formalism was defined by Milner, Parrow, and Walker in 1992. Pict is a concrete instantiation of the pi-calculus in the way that pure

Lisp is an instantiation of the lambda-calculus. Links: Pict Information Page Pict 4.1 download directory Date: Last updated 9/11/99 Sample code: The example below implements the Sieve of Erastosthenes (from the examples shipped with Pict 4.1) now (reset checks) def interval (min:Int max:Int):(List Int) = if (>> min max) then nil else (cons min (interval (inc min) max)) def sieve (max:Int):(List Int) = ( def again (l:(List Int)):(List Int) = if (null l) then nil else (val n = (car l) if (>> (* n n) max) then l else (cons n (again (list.filter #Int l (x) = (<> (mod x n) 0))))) (again (interval 2 max)) ) def prPrime (idx:Int x:Int):[] = if (== (mod idx 10) 9) then ((int.pr x); (nl)) else ((int.pr x); (pr " ")) (list.itApply (sieve 4000) prPrime); Pike See: C Language type: O - Object-oriented Description: Pike is an interpreted dialect of C with object-oriented programming features and dynamic memory management. It is intended for general programming,

especially for networking applications. The data model of Pike is similar to that of C , with the addition of a primitive string type and a mixed type that can hold any normal date value. Control structures in the language include C-like conditionals and loops, as well as a Perl-like array iteration loop. Arrays in Pike are dynamic, and the language also supports generalized associative arrays called maps. Object classes in Pike support methods with run-time resolution, multiple inheritance, and method references. Pike has extensive additional facilities, including thread support, a variety of I/O libraries, network socket support, simple image processing, and regular expression pattern matching. The current version of Pike, 0.6b, has no GUI or window system capabilities Pike is available at no charge from its developers, Idonex of Sweden. There is only one implementation, and it runs on Win32 systems as well as most Unix incarnations. Origin: Fredrik Hübinette, InformationsVävarna,

1996. See Also: C Python Scheme Perl Visual Basic Remarks: While Pike is comparable to Perl or Python in its feature set and ease of programming, its similarity to C may make it easier for some users (or more confusing, depending.) Pike has been used to write many web utilities and CGIs, as well as a web server. These uses have helped to drive development of its extensive I/O and networking libraries. Pike evolved from an interpreted C dialect called LPC, which was used for writing multi-player dungeons. Links: Pike language manual Date: Last updated 9/12/98 Sample code: // This // data inherit inherit inherit program implements a fifo that can be used to send between two threads. (From the Pike 06 manual, sec 10) Thread.Condition : r cond; Thread.Condition: w cond; Thread.Mutex: lock; mixed *buffer = allocate(128); int r ptr, w ptr; int query messages() { return w ptr - r ptr; } // This function reads one mixed value from the fifo. // If no values are available it blocks until a

write has been done. mixed read() { mixed tmp; object key=lock::lock(); while(!query messages()) r cond::wait(key); tmp=buffer[r ptr % sizeof(buffer)]; w cond::signal(); return tmp; } // This function pushes one mixed value on the fifo. // If the fifo is full it blocks until a value has been read. void write(mixed v) { object key=lock::lock(); while(query messages() == sizeof(buffer)) w cond::wait(key); buffer[w ptr % sizeof(buffer)]=v; r cond::signal(); } Pilot Language type: C - Command or Scripting Description: Pilot is a simple imperative language designed for building textual computer-aided instruction systems. The syntax of Pilot appears primitive by 1980s standards. It is highly field-oriented, each line is either a command or a label, and all commands have the same structure. A command consists of a keyword, an optional condition, and text. The core keywords are: o o o o o o o o o o TYPE - output some text ACCEPT - read an input string MATCH - compare input to a pattern JUMP

- goto another part of the program USE - call another part of the program as a subroutine COMPUTE - assign a value to a string variable END - return from a USE YES - output some text if an answer was yes. NO - output some text if an answer was no Pilot supports two data types: strings and numbers. All variables are dynamically scoped Pilot totally lacks sound control structures, data abstraction, file I/O, and error handling. An implementation of Pilot is available from the Retrocomputing Museum. No documentation about the language seems to be available. Origin: IBM, 1962. See Also: cT Lingo Hypertalk INTERCAL BASIC Remarks: Remarkably, Pilot was used for about 30 years. Despite its painfully primitive syntax and lack of graphical facilities, it had enough users in 1990 to consider standardizing it (IEEE Std. 1154-1991) Some implementations of Pilot also featured facilities for running programs in the host operating system. Links: Pilot distribution from the Retrocomputing Museum

Date: Last updated 3/8/98 Sample code: R : An example for converting a number to english *LOOP T :ENTER A NUMBER, OR ZERO TO QUIT. C :$NUM= A :#Z E(Z=0) : U :*WRITNUM T :$NUM : J :*LOOP *WRITNUM U(Z<10) :*UNITS E(Z<10) : J(Z>999):*THOU J(Z>99) :*HUND J(Z>19) :*TWENTY C(Z=10) :$NUM=$NUM C(Z=11) :$NUM=$NUM C(Z=12) :$NUM=$NUM C(Z=13) :$NUM=$NUM C(Z=14) :$NUM=$NUM C(Z=15) :$NUM=$NUM C(Z=16) :$NUM=$NUM C(Z=17) :$NUM=$NUM C(Z=18) :$NUM=$NUM C(Z=19) :$NUM=$NUM E: *UNITS C(Z=1) C(Z=2) C(Z=3) C(Z=4) C(Z=5) C(Z=6) C(Z=7) C(Z=8) C(Z=9) E: *TWENTY C:Y=Z%10 C:Z=Z-Y C(Z=20) C(Z=30) C(Z=40) C(Z=50) C(Z=60) C(Z=70) C(Z=80) TEN ELEVEN TWELVE THIRTEEN FOURTEEN FIFTEEN SIXTEEN SEVENTEEN EIGHTEEN NINETEEN :$NUM=$NUM :$NUM=$NUM :$NUM=$NUM :$NUM=$NUM :$NUM=$NUM :$NUM=$NUM :$NUM=$NUM :$NUM=$NUM :$NUM=$NUM ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE :$NUM=$NUM :$NUM=$NUM :$NUM=$NUM :$NUM=$NUM :$NUM=$NUM :$NUM=$NUM :$NUM=$NUM TWENTY THIRTY FORTY FIFTY SIXTY SEVENTY EIGHTY C(Z=90)

:$NUM=$NUM NINETY C:Z=Y E(Z=0) : J:*WRITNUM *HUND C :Y=Z%100 C :Z=(Z-Y)/100 U :*UNITS C :$NUM=$NUM HUNDRED C :Z=Y E(Z=0) : J :*WRITNUM *THOU C :X=Z%1000 C :Z=(Z-X)/1000 U :*WRITNUM C :$NUM=$NUM THOUSAND C :Z=X E(Z=0) : J :*HUND PL/C See: PL/I Language type: S - block-structured Description: PL/C was a subset of PL/I developed at Cornell University. Because the full IBM PL/I compiler was rather large and slow to be employed for student programming programming projects, PL/C was developed and used at many universities. Remarks: For a code sample, check the PL/I entry. Date: Last updated 12/4/97 PL/I Language type: S - block-structured Description: PL/I (Programming Language 1) is a large, complex block-structured language invented by IBM, and first released in 1964 in conjunction with the influential System/360 line of computers. PL/1 was intended to be THE all-around language for mainframe system and application development, and therefore it had a very large feature set. PL/1 was

widely used by the IBM community, and by the early 1980s, PL/1 included the following language facilities: o o o o o o o o o o o o functions and procedures huge complement of numeric data types array and record data types full set of control structures, including recursion charater strings and string manipulation COBOL-style picture formats stream, record, and formatted I/O facilities bit strings generics interruptions (a form of error handling) dynamic storage management multi-tasking and asynchronous events IBM spent a lot of effort developing an optimizing compiler for PL/1, and a lot of seminal research on highlevel language optimization was done in the late 1960s and early 1970s on the PL/1 optimizing compiler. Today, commercial PL/I compilers are available for IBM mainframes, PCs running WindowsNT and OS/2, and some UNIX workstations. No free PL/I compilers are currently available (although there was a subset compiler named PL/C that was free at one time). Origin: George

Radin, IBM, 1964. See Also: Fortran Algol COBOL Remarks: PL/I was an attempt to compile the best features of Algol (program structure, semantics), FORTRAN (calculations), and COBOL (data structuring, I/O) into one new, all-purpose language. The result was a very complex language, but one that did serve most programming purposes quite well. However, the complexity of the language and the resulting complexity of the compilers and their diagnostics made writing and debugging PL/I code burdensome for many users. PL/I was invented in the age of punch cards, but the language syntax is only slightly tarnished with columnspecific formatting rules. Newer versions of PL/I have entirely shed their punched-card legacy There is a great deal of legacy PL/I code in the IBM mainframe community, and skilled PL/I programmers are in demand as the year 2000 deadline approaches. Links: Why use PL/1? IBM PL/1 Family Date: Last updated 12/4/97 Sample code: FINDSTRINGS: PROCEDURE OPTIONS(MAIN) /* READ A

STRING, THEN PRINT EVERY / /* SUBSEQUENT LINE WITH A MATCH / DECLARE PAT VARYING CHARACTER(100), LINEBUF VARYING CHARACTER(100), (LINENO, NDFILE, IX) FIXED BINARY; NDFILE = 0; ON ENDFILE(SYSIN) NDFILE=1; GET EDIT(PAT) (A); LINENO = 1; DO WHILE (NDFILE=0); GET EDIT(LINEBUF) (A); IF LENGTH(LINEBUF) > 0 THEN DO; IX = INDEX(LINEBUF, PAT); IF IX > 0 THEN DO; PUT SKIP EDIT (LINENO,LINEBUF)(F(2),A) END; END; LINENO = LINENO 1; END; END FINDSTRINGS; Postscript Language type: T - Threaded or stack-based Description: PostScript is a threaded interpreted language with stack-based semantics. While usable for general-purpose computation, PostScript was specially designed to drive graphic devices, initially printers, and has a large set of operators for rendering onto a page. In terms of syntax and semantics, PostScript resembles Forth: operators use data from a stack, and place their results back on the stack. PostScript data types include floating-point numbers, strings, fonts, files,

vectors, and symbols. Defined procedures are simply code sequences stored in dictionaries. The essence of PostScript is its model of execution. In a threaded interpreted language, a program simply consists of a series of tokens. The interpreter processes each token in turn, with no look-ahead or complex parsing needed. Supporting this style requires storage for intermediate results, PostScript uses several stacks: a code stack, a data stack, and a dictionary stack. (There is also a special stack just for graphical contexts, as needed for the rendering model, making a total of four stacks.) Threaded interpreted languages can be difficult to use, but they offer the advantage that interpreters for them can be very compact and fast. As PostScript was originally designed to execute inside a printer or similar device with very little memory, compactness was an important design criterion. Several implementations of PostScript exist, but the two main ones are the commercial implementations

from Adobe Systems, and the free Ghostscript implementation from Aladdin Enterprises. The current version of PostScript language is Level 3. PostScript level 2 is also still very widely used in printers and other devices. Implementations of PostScript for GUI systems use a language dialect called "Display PostScript," that includes special operators and slightly different semantics to accomodate user interaction. Origin: John Warnock et al, Adobe Systems, 1982. See Also: Forth Logo Remarks: PostScript is a simple language, in terms of syntax and structure. The complexity, when learning it, comes from the richness of its graphics model and the large set of built-in operators. Adobe Systems, the company that owns PostScript, publishes a fine set of books on learning the language. These first editions of these books, published around 1985, were originally blue for the tutorial, red for the reference, and green for the cookbook. The current edition of the PostScript reference

manual is no longer red, but it is still sometimes referred to as "the red book." The first mass-market printer to support PostScript was the Apple LaserWriter. By 1993, most high-end laser printers and many typesetters supported the language. An interesting thing about PostScript is that most programmers who learn it dont do so because they want to write PostScript programs, they do it because they want to write programs to generate PostScript code to draw graphics. PostScript is a descendant of an older graphics language, also co-invented by John Warnock, called JaM. Links: Ghostscript and related free utilities First Guide to Postscript Postscript Speed Test Date: Last updated 12/16/97 Sample code: %!PS-Adobe-2.0 % Draw a string at an angle at a point /printat { % str x y angle => gsave 4 1 roll translate exch rotate 0 0 moveto show grestore } def % find the center of the page /pagecenter { % - => cx cy clippath pathbbox 4 1 roll exch sub 2. div 3 1 roll sub 2. div }

def % set up font and constants /Times-Bold findfont 36 scalefont setfont pagecenter /cy exch def /cx exch def /steps 9 def /basegray 0.75 def /incrgray basegray steps div def /baseangle 360 steps div def /incrangle 360 steps div def % draw a string as a rosette steps { basegray setgray (PostScript) cx cy baseangle printat /basegray basegray incrgray sub def /baseangle baseangle incrangle add def } repeat % done with this page showpage Prolog Language type: L - Rule-based or logical Description: PROLOG is a language for PROgramming in LOGic. Prolog was a progenitor of the study of logic programming, a computer science area concerned with languages and systems for logical inference, proof techniques, and very high-level programming systems. A Prolog program consists of a set of facts, and a set of rules that specify how to satisfy goals related to those facts. Prolog supports a small but rich variety of data types: numbers, strings, symbols, lists, and composite objects (analogous

to records). You never really execute a Prolog program directly, in the sense that you might run a C program; instead, you ask the Prolog system questions. By attempting to answer the questions, the Prolog system examines facts, invokes rules, and may manipulate data or perform computations. The programmer does not directly control the execution sequence of the Prolog system as it seeks to satisfy a goal, although he can exert some influence. In this sense, Prolog must be considered a declarative language and not a procedural one. Prolog was among the first computer programming systems to employ the logical formalism of unification. It also utilizes recursive goal seeking with backtracking, a common AI technique. Unfortunately, unification and backtracking can be computationally expensive, and early Prolog implementations were very slow. Newer implementation techniques, as well as language features that let the programmer guide the search to some extent, have given modern Prolog much

better performance. Prolog is usually interpreted. Free and commercial implementations of Prolog are available, for all major platforms and many specialized ones. Prolog is also undergoing ISO/EIC standardization, the draft standard is available for downloading here. Origin: D.H Warren 1977, R Kowalski 1979, Clocksin and Mellish 1980-84 See Also: Elf Mercury Remarks: A Prolog program can accomplish amazing things with a very short amount of code. The logic paradigm is a very powerful one for certain problem domains, but unsuitable for some others. Prolog gained recognition and popularity with the publishing of Programming in Prolog by Clocksin and Mellish. Prolog and logic programming in general have been proposed as the basis for 5th generation computing: a vision of massively parallel computers providing true AI. A great deal of research into parallel resolution and logic databases was performed in the US, Europe, and especially in Japan under their huge 5th Generation project. Logic

programming research continues, but grandiose visions of logic as a panacae were given up in the mid-1990s. A wide variety of research and pragmatic extensions to Prolog have been created: GUI kits, database access mechanisms, image processing kits, calling interfaces to C and Lisp, object-oriented programming methods, and expert-system shells. Links: Logic Programming WWW Resources IC Prolog II Reference Manual CMU Prolog Archive Prolog FAQs Date: Last updated 12/7/97 Sample code: % Quicksort in Prolog, by Keesey adapted from Bratko gtq(X,Y) :- X @> Y. quicksort( [],[] ). quicksort( [X | Tail], Sorted) :split( X, Tail, Small, Big), quicksort( Small, SortedSmall), quicksort( Big, SortedBig), conc( SortedSmall, [X | SortedBig], Sorted). split( , [], [], []). split( X,[Y | Tail], [Y | Small], Big) :gtq( X, Y),!, split( X, Tail, Small, Big). split( X, [Y | Tail], Small, [Y | Big] ) :split( X, Tail, Small, Big). conc([],L,L). conc( [X | L1], L2, [X | L3]) :conc( L1, L2, L3).

Python Language type: O - Object-oriented Description: Python is an interpreted, object-oriented language. It is intended to be highly effective, easy to use, and extensible. The syntax of Python is very simple and statement-oriented. Block structure is specified with indentation Python supports a good set of primitive and composite data types: integers, floats, complex numbers, strings, lists, and associative arrays (dictionaries). Data values are typed, but strong type checking is not enforced Like most scripting interpreters, Python does have the ability to execute a string as code. Python supports a conventional set of flow-control constructs: if-then, while and for loops. Python also has exceptionalhandling constructs similar to those in Modula-3 Python supports subroutines, independent modules, and object classes with Object-oriented programming features are an important part of Python, used for the standard library and for user extensibility. Classes can use single and multiple

inheritance. Python is supported by a feature-rich standard library; it includes extensive string manipulation, I/O, parsing, date handling, low-level networking services, high-level protocol and data format handling, image I/O, and a variety of operating system-specific services. Python is normally interpreted, but the Python interpreter can compile scripts and modules into portable binary form and execute this form instead. Several Unix-specific and portable graphics and GUI libraries also exist. Newer versions of Python support some functional programming features, including lambda forms. There was originally only one Python implementation, an interpreter which ran on a wide variety of Unix platforms as well as Windows and Macintosh. Later, an implementation was created that compiled Python to Java bytecodes (jPython) and there is also one that targets the Microsoft C# environment. Documentation and tutorials for Python are readily available on the web. Origin: G. van Rossum, 1991

See Also: Perl Java Tcl ABC C# Remarks: Python was originally conceived to be an extensible scripting language for the Ameoba operating system. Early in its development, the designer Guido Rossum decided to make it a portable language instead. Python is considered a good language to use for certain kinds of web programming. The standard library supports HTTP and CGI services, and a Windows-specific library support ActiveX scripting (so that you can use powerful Python for active server pages instead of the intentionally weak VBScript). Python can be extended by adding C/C libraries, and it can also be embedded in an application to serve as its extension language. Various C extensions for database access, OpenGL, numeric analysis, AI, and other Links: Python Resources at the Starship Python Python FAQ List The Python main FTP archive Python for Win32 home page jPython home page Date: Last updated 8/4/100 Sample code: # standard binary search tree from # a tree data structure package by

Dan Stubbs # class binary tree: def init (self): self.tree = None def insert (self, key): if self.tree: self. insert (selftree, key) else: self.tree = node(key) def insert (self, tree, key): if key < tree.key: if tree.left: self. insert (treeleft, key) else: tree.left = node(key) else: if tree.right: self. insert (treeright, key) else: tree.right = node(key) Q QBasic See: Basic Language type: S - block-structured Description: QBasic, or QuickBasic as it is sometimes called, is a dialect of BASIC created by Microsoft for application development under the DOS operating system. Microsoft QBasic exhibits a number of differences from traditional Basic: o o o line numbers are permitted by not required, and text labels are supported QBasic has a better set of control flow constructs than original Basic Since it was designed specifically for one platform, specialized graphics and I/O support were built into the language Later versions of QBasic featured better support for

subroutines and extending the language environment with libraries written in C and assembly. Documentation about QBasic is widely available on the web. Some versions of the language system itself are also available, although the licensing arrangements are unclear. Origin: Microsoft Crop., 1986 See Also: Basic Visual Basic VBA Remarks: QBasic was the replacement for GW-Basic on MS-DOS in the mid-1980s. The first popular version of QBasic was bundled with MS-DOS 3.3 around 1987 In the late 1980s and early 1990s, prior to the release of Visual Basic, the QBasic compiler was widely used for application development on PCs. The last version of QBasic was 45; the language is no longer supported by Microsoft. QBasic 11 is reputedly available with most Windows95 distributions Links: Tutorials on QBasic The NeoZone QBasic Site Big QBasic download site QBasic Top 20 links list Date: Last updated 2/25/98 Sample code: * -1 * Locates Find$ in sorted array Array$ () and returns element number or

* by Matt Usner. FUNCTION BinarySearch% (Array$(), Find$) BinarySearch% = -1 no matching element yet Min = LBOUND(Array$) start at first element Max = UBOUND(Array$) consider through last DO Try = (Max + Min) 2 start testing in middle IF Array$(Try) = Find$ THEN BinarySearch% = Try return matching element EXIT DO END IF IF Array$(Try) > Find$ THEN too high, cut in half Max = Try - 1 ELSE Min = Try + 1 too low, cut other way END IF LOOP WHILE Max >= Min END FUNCTION Quake-C See: C Language type: A - Application/Macro Description: Quake-C is an subset dialect of C used to define operations, semantics, and extentions for the Quake game engine, used for games like Quake and HexenII. Quake-C supplied special data objects and message-passing semantics for the multi-tasking internal environment of the game engine. Origin: John Carmack et al, id Software, 1996. Links: Quake-C archives Dissecting QuakeC Date: Last updated 12/13/97 Sample code: // code for items.qc to make a

backpack // bob in the water, by NiKoDeMoS, 1997. void() Backpackfloat = { local float pc; pc = pointcontents(self.origin); if (pc == CONTENTWATER) self.velocity z = (cvar("sv gravity") + 100) * 0.1; self.nextthink = time + 01; }; R REBOL Language type: F - Functional or lambda-based Description: REBOL is a functional scripting language with message-passing and object-oriented features. It is designed for general application and network service development. Intended to support both simple scripts and larger projects, REBOL has a fairly large complement of primitive data types: numbers, time, date, money, strings, booleans, words (atoms), and more. It also supports tuples and other primitive data aggregations, as well as application-oriented types like files, URLs, and email addresses. The primary grouping construct in REBOL is the block, it is used for both data and code aggregation (the way lists are used in Lisp and Scheme). The evaluation and code structure concepts

of REBOL resemble those of most other functional languages. As a first-class functional language, REBOL stores everything as data with a definite type; functions and objects are merely data constructed according to convention understood by the interpreter. The REBOL core language has quite a few advanced features, consult the web sites listed below for details. Some of the supported features are: automatic memory management (gc), reflection, higher-order functions, exception handling, and dialecting. There is only one existing implementation of REBOL, it is an interpreter that runs on a wide variety of operating systems. The system can be downloaded free, or purchased Origin: C. Sassenrath, 1997 See Also: Perl Java Self Python Scheme Remarks: REBOL stands for Relative Expression-based Object Language. The design of the language is purportedly based on five principles: simplicity, productivity, communications, independence, and humanity. Future versions of REBOL are planned, and may

support multi-threading, a GUI toolkit, Unicode/I18N support, and multimedia. Links: Overview: REBOL in 10 Steps Download page REBOL article at TechWeb Date: Last updated 10/17/98 Sample code: REBOL [ Title: "99 Bottles of Beer on the Wall in REBOL" Author: Neal Ziring Email: ziring@home.com Date: 17-Oct-1998 File: %99beer.r Version: #REBOL-1-0-1 Purpose: "Print the famous iterative beer song" Comment: { This is an example of a program in REBOL that prints the famous 99 bottles of beer on the wall song. For more information on REBOL go to the web site www.rebolcom This program is deliberately over-complicated to hot-dog some fancy features of REBOL. } ] song: [ Verse [ [if num > 0 [num] else ["No more"] ] " " [if num == 1 ["bottle"] else ["bottles"] ] " of beer on the wall," 1 [if num > 0 [num] else ["No more"] ] " " [if num == 1 ["bottle"] else ["bottles"] ] " of

beer!" 1 "Take one down, pass it around!" 1 [if num - 1 > 0 [num - 1] else ["No more"] ] " " [if num - 1 == 1 ["bottle"] else ["bottles"] ] " of beer on the wall." 2 ] Finale [ "Time to buy more beer!" 1 ] ] processItem: func [item num] [ if integer? item [loop item [prin newline] ] if string? item if block? item exit [prin item] [ftmp: func [num] item prin ftmp num ] ] dosong: func [start] [ bottlesleft: start until [ foreach item song/Verse [processItem item bottlesleft] bottlesleft: bottlesleft - 1 (bottlesleft == 0) ] foreach item song/Finale [processItem item 0] return none ] dosong 99 Reduce Language type: M - Mathematical or Simulation Description: Reduce is a system for computer algebra and symbolic mathematics, featuring a language named Reduce in which users can define new functions and symbolic computation rules. The expression syntax of Reduce is similar to that of FORTRAN, but with a

variety of extensions for symbolic operations. The following data types are supported: integers, reals, rationals, and complex numbers, all infinite-precision, strings, matrices, arrays, and patterns. Reduce supports definition of procedures and functions, but has no support for object-oriented programming or package structure. Reduce is written in Lisp, and the source code for the kernel is normally supplied with the distribution. There is a low-level extension language under Reduce , but above Lisp, called RLisp. RLisp is used in some versions of Reduce for code efficiency or to build complicated data structures. Reduce is available as a commercial product for most computer platforms. Free demo versions are also available. Origin: Anthony Hearn, RAND Corp, 1963. See Also: Algol Mathematica Maple Macsyma Lisp Remarks: Reduce was one of the earliest portable symbolic computation systems. Implemented in a dialect of Lisp called Portable Standard Lisp, Reduce was widely used in industry

and academia. While Reduce is not as large or sophisticated as some more recent symbolic math systems (e.g Maple, Mathematica), its long history and stability have earned it a loyal following. Also, a great many libraries for specialized scientific and engineering calculations have been developed for it. While the syntax of Reduce resembles that of Fortran in some respects, it was originally based on Algol and actually resembles Algol60 more than it does Fortran. Formerly, Reduce had been available to academic institutions for free. The current version of Reduce is 36 Links: Overview of Reduce Reduce file area at RAND Codemist Reduce information Reduce 3.5 documentation Date: Last updated 9/28/98 Sample code: A polynomial GCD routine from REDUCE - Software for Algebraic Computation by G. Rayna PROCEDURE EUCLID(A,B,X); BEGIN SCALAR R,Q,AA,BB,SA,SB,SR,D; CLEAR FIRST,SECOND; AA := A; BB := B; SA := FIRST; SB := SECOND; WHILE (R := POLYREM(AA,BB,X)) NEQ 0 DO <<ON GCD; Q := (AA -

R) / BB; OFF GCD; SR := SA - Q * SB; D := DEN Q; SA := SB * D; SB := SR D; AA := BB * D; BB := R D>>; RETURN SB END; Rexx Language type: C - Command or Scripting Description: Rexx is an block-sturctured procedural language commonly used for application development, integration, and extension. Designed primarily for ease of use, the Rexx language is weakly typed and has a very plain, uncomplicated syntax. Rexx supports strings, numbers, and associative arrays as its data structure The numbers can be unlimited-precision. The language includes conventional control structures: if-then-else, counted and free loops, and a case statement form. It supports recursive functions, and also supports evaluation of run-time code (like Lisp, Perl, and many other interpreted languages.) Some commercial implementations of Rexx support the creation of GUIs and interaction with database management systems. An ANSI standard for Rexx is available, the standard was created by the X3J18 committee and

is designated X3.274-1996 A pre-pub draft is available on-line from here Various superset dialects of Rexx exist, providing a variety of extensions: ObjectRexx supports object-oriented programming, and NetRexx provides a variety of network interface and I/O facilities. Both free and commercial implementation of Rexx are available. Most are interpreters only, but a few Rexx compilers also exist. Information about the language is freely available from IBM, various academic institutions, and the Rexx Language Association. Origin: M. Cowlishaw, IBM, 1979 - 1985 See Also: Perl Tcl Basic csh Remarks: Rexx was originally invented as a sophisticated command language for IBM mainframe environments (MVS, CMS). It has gained some popularity as a programming language with expressive power and convenience. In the Windows environment it competes with Visual Basic, Java, Perl, and Tcl In the UNIX environment is competes with Perl, Tcl, Java, and various shells. On IBM OS/2 Rexx is probably the most

popular scripting language. Links: Rexx Info (with a good tutorial) Rexx FAQ List Waterloo Rexx FTP archive The Rexx Language Associate home page Date: Last updated 12/16/97 Sample code: /* Subroutine example from Ian Colliers tutorial, / /* stand-in until I get a more extensive example. */ /* Calculate factorial x, that is, 123 . *x parse pull x . say x"!="factorial(x) exit */ factorial: /* calculate the factorial of the argument / procedure parse arg p if p<3 then return p else return factorial(p-1) * p RPG Language type: D - Database or Text-processing Description: RPG, Report Program Generator, is a high-level database access and text generation language invented for mainframe MIS environments. The RPG language is designed around the programmers presumed goal: generating informative large-scale reports from mainframe databases. To this end, RPG supports input forms definition, database access, and very extensive output formatting facilities. Because it is mainly

intended for formatting and presenting data, RPG does not have very extensive computational support, but most versions have at least a minimal set of sequential control-flow operators, support for subroutines, etc. Data types in RPG include integers, fixedformat numbers, reals, strings, and records Often, data types and records are declared as having a particular print format (like in COBOL) and the compiler takes care of choosing a suitable internal representation. The lexical structure of RPG is column/card oriented. Programs consist of four distinct sections: file description, input formats, calculation, and output formats. RPG-IV (1994) added another section: the subprocedures section. RPG programs are typically compiled. They must be supported by an extensive run-time environment that provides I/O and data management services. Commercial implementations of RPG are available from IBM, Lattice, and other companies. There are no free implementations Books are RPG programming are

widely available from commercial publishers. Origin: IBM, 1965. See Also: COBOL Remarks: There were several dialects or versions of RPG over the years: IBM created RPG for the System/360 (1964), RPG-II for the System/3 (1965), RPG-III, RPG/400 for the AS/400, RPG-IV, and Visual Age for RPG. Other companies produced versions of RPG-II and RPG/400 for MS-DOS and Windows operating systems. RPGs support for different kinds and formats of textual output is very broad. RPG/400 has at least 20 different output field types. IBMs newest RPG products allow the developer to create graphical user interfaces for forms input and output presentation. Links: Visual Age for RPG add-ons download area Lattice RPG/400 for DOS system overview Getting Started with Visual Age for RPG (tutorial) RPG/400 Programmers Manual Date: Last updated 3/28/100 Sample code: * A simple RPG subprocedure to determine * an amount to pay a worker. From IBM * book SC09-2074-01 "RPG/400 Programmers Guide" P CalcPay D

CalcPay D Rate D Hours D Bonus D Overtime B PI S 8P 5P 10U 5P 2 2 VALUE 0 VALUE 2 VALUE 5P 2 INZ(0) C C C C * Determine any overtime hours to be paid. IF Hours > 40 EVAL Overtime = (Hours - 40) * Rate 1.5 EVAL Hours = 40 ENDIF C * Calculate the total pay and return it to the caller RETURN Rate * Hours Bonus Overtime P CalcPay E Ruby Language type: O - Object-oriented Description: Ruby is an interpreted scripting language, fully object-oriented and designed for easy extensibility. The syntax of Ruby is simple but bears a strong resemblance to Perl. All data types in Ruby are object classes, like in Smalltalk. Pre-defined data types include integer and float numeric types, strings, arrays and hash tables, and structures. Control constructs in Ruby include a wide variety of conditionals and several kinds of loops, along with several controls structure variations like break and continue. Ruby does not have declarations; variables are weakly typed, and their scope is

denoted by prefixes. Ruby supports many important OO features, including classes with inheritance, class methods, and even closures. Ruby also supports exceptions with functionality similar to that of Java Ruby supports a variety of kinds of introspection, including Java-style reflection and Lisp-style enumeration of active objects. The syntax of Rubys reflection support is simpler than that of Java. Ruby does support threading There is only one implementation of Ruby; it is free open-source. Documentation for Ruby is available on the WWW, and there are also several published books about the language. Origin: Y. Matsumoto and others, 1993-95 See Also: Perl Python Tcl Smalltalk Self Remarks: The current version of Ruby is 1.65, as of Sep 2001; it is available for Linux and other Unix systems, Windows, and some other platforms. Ruby is normally distributed as source code, but pre-compiled binaries are available for many of the supported platforms. While Ruby resembles Perl in many

respects, it differs substantially in its representation of data. Perl treats numeric data, strings, lists, and hashes as built-in types, while Ruby implements everything as objects. Another interesting aspect of Ruby is its notion of Modules. A class can implement any number of modules; they are similar to Java interfaces and to Flavors Lisp mix-ins. There are many extension libraries and toolkits available for Ruby, including database, network, GUI, IO libraries. The Ruby OOP language is at least the 3rd programming language to bear that name. The first was a teaching language Ruby from the late 1960s, it was based on Markov processes. The second was a hardware specification language based on higher-order functions, from the mid-1980s. Links: Main Ruby Download area Some Ruby libraries Invitation to Ruby The Ruby Garden Ruby Central Date: Last updated 12/13/01 Sample code: A sample from the Ruby distribution, a simple sieve. # sieve of Eratosthenes max = Integer(ARGV.shift || 100)

sieve = [] for i in 2 . max sieve[i] = i end for i in 2 . Mathsqrt(max) next unless sieve[i] (i*i).step(max, i) do |j| sieve[j] = nil end end puts sieve.compactjoin ", " S S Language type: M - Mathematical or Simulation Description: S is an interpreted, high-level procedural language designed and used for statistics, numerical modeling, data analysis, and simulation. The structure of an S program is quite simple: it consists of statements. Some of the statements might define functions, which allows the S programmer to build up complicated modular programs. The expression syntax of S is very sophisticated and rich. Array and sequence handling are supported with a set of compact primitives that allow complicated data manipulation to be built fairly easily. Like many interpreters, S permits evaluation of code constructed on the fly. It also has some limited facilities for reflection and expression manipulation. By default, all global variables in S are persistent. They get

saved at each assignment to one of several data areas Function definitions are also persistent, saved in the same fashion. The newest version of S, Version 4, supports object-oriented programming and event-driven programming. S is sold commmercially as S-Plus by MathSoft, Inc. It is available for all Unix and PC platforms Some documentation can be found on-line, but available textbooks and reference documents distributed with the commercial implementation are better. Origin: R.A Becker et al, 1977-84 See Also: Mathematica APL Fortran C NIAL Remarks: The initial goal of S, according to its primary inventor, was to provide powerful interactive statistics and data analysis. The desire to create an interactive system arose from the desire of the statistics researchers at Bell Laboratories to be able to explore data and analyze it in various and sundry ways without the overhead and difficulty of writing FORTRAN programs. The initial implementation of S was in Fortran, later implementations

and current ones are in C. S and S-Plus both offer a huge library of statistics, graphics, data-handling, and other functions. Textbooks and on-line technical reports and archives provide additional resources and specialized functionality. Links: S-Plus pages at MathSoft Statistics Center Technical documents (some about S) S resources at CMU StatLib Date: Last updated 1/6/98 Sample code: # Some S code to plot concentric convex hulls # around some data, from the documentation for # the chull function. drawhull <- function(xvec, yvec, ltype) { polygon(xvec, yvec, density=0, lty=ltype) } p <- chull(corn.rain, cornyield, peel=T) which <- rep(seq(p$count), p$count) s <- split(p$hull, which) plot(corn.rain, cornyield, pch="X") for(i in seq(s)) { j <- s[[i]] if (length(j) > 2) drawhull(corn.rain[j], cornyield[j], i) } Sather Language type: O - Object-oriented Description: Sather is an object-oriented language, strongly typed, that supports many modern OO software

engineering features. The syntax of Sather is somewhat similar to Eiffel or Ada. However, in Sather all types belong to object classes. Primitive types include integers, floats, strings, booleans, and the distinguished value void Arrays are supported, too, but as a parameterized class rather than a built-in data type. The only ways to define new types are class definition and class parameterization. All memory management is automatic for Sather programmers, all Sather implementations include garbage collection. Some advanced features of Sather are listed below. o o o o o o o o Exception handling Closures and iterators Multiple inheritance (subtyping) Supertyping Operator overloading Immutable classes Abstract and partial classes Assertions, preconditions and postconditions The Sather standard library provides an assortment of container types, I/O facilities, system interfaces, and more. Implementations of Sather and the source code for them are available free. Documentation is

available online and is also included with most distributions Origin: S.M Omohundro, C-C Lim, et al, UC Berkeley, 1990 See Also: Eiffel C Objective-C Oberon Cecil Smalltalk Self Remarks: Sather was originally built as a version of Eiffel, and it was named after the Sather tower at UC Berkeley. The language evolved a great deal in the early 1990s, and can no longer be considered a close relative of Eiffel (except that they are both modern, robust OO languages.) Sather is implemented as a translator on top of C, and has therefore been ported to a wide variety of Unix and other platforms. The current Sather manuals are fairly good with respect to documenting the language itself, but there is not enough documentation on the standard library. Links: The Sather Documentation Page Sather-K Home Page at U. of Karlsruhe Sather FTP download area The pSather home page Date: Last updated 12/31/97 Sample code: -- Still working on a good code example here. -- A simple class from the Sather Essential

manual class POINT is attr x,y:INT; create(x,y:INT):POINT is res:POINT := new; res.x := x; end; res.y := y; add(xval,yval:INT):POINT is xsum:INT := x xval; ysum:INT := y yval; res:POINT := #POINT(xsum, ysum); return res; end; offset by(val:INT):POINT is return add(val,val); end; end; Scheme return res; Language type: F - Functional or lambda-based Description: Scheme is a dialect of Lisp with functional and procedural language aspects. Unlike original Lisp, Scheme is lexically scoped, but like Lisp it is dynamically typed. Scheme provides a wide set of data types: symbols, various numeric types, characters and strings, lists, vectors, bit strings, records, association lists and hash tables, and various functional/lambda types (curried procedures, closures, promises, etc). Scheme has comprehensive I/O facilities based on an abstraction called "Ports." As a Lisp dialect, Scheme naturally supports lambda expressions. It also has a full set of sequential controlflow

constructs: a variety of selection, iteration, and block special forms Scheme also has a comprehensive error handling mechanism. Scheme has gone through four major revisions since the first "Report on the Algorithmic Language Scheme" was issued in 1978. The current version of MIT Scheme, as of last 1997, is 74 Various other academic implementations also exist. Scheme is used to teach computer science principles, as well as for writing various compilers, AI systems, and many other kinds of programs. Information about Scheme is widely available on academic sites on the Internet. Several free implementations are available for all major platforms: MIT Scheme,DrScheme, Gambit-C, MzScheme, PcScheme, SCM, VSCM, and others. There have also been many extended scheme dialects created Origin: Gerald Sussman & Guy Steele, 1975. See Also: Lisp Remarks: Scheme was developed at the Massachusetts Institute of Technology, and has been used to test many innovations in language

implementation. Some Scheme systems are interpreters, some are native compilers, and some are Scheme->C translators. There is even a Scheme compiler that produces Java bytecodes (Kawa). The GNU project has selected Scheme as a universal extension/macro language for GNU products. Their idea is to implement a powerful Scheme dialect, and then support other languages by translating them into Scheme. Links: Indiana University Scheme Repository Scheme FAQ List Princeton University VCSM Portable Scheme Date: Last updated 12/16/97 Sample code: ;;; takes two sorted lists merges them (define (merge! a b less?) (define (loop r a b) (if (less? (car b) (car a)) (begin (set-cdr! r b) (if (null? (cdr b)) (set-cdr! b a) (loop b a (cdr b)) )) ;; (car a) <= (car b) (begin (set-cdr! r a) (if (null? (cdr a)) (set-cdr! a b) (loop a (cdr a) b)) )) ) (cond ((null? a) b) ((null? b) a) ((less? (car b) (car a)) (if (null? (cdr b)) (set-cdr! b a) (loop b a (cdr b))) b) (else ; (car a) <= (car b) (if

(null? (cdr a)) (set-cdr! a b) (loop a (cdr a) b)) a))) Self Language type: O - Object-oriented Description: Self is a dynamic object-oriented language and programming environment based on an object prototypes a general message-passing model. It was designed to be small, very flexible, and easy to use An object, in Self, consists of several named slots. Each slot can be a data slot or a method slot, there is no fundamental distinction between them. Slots can hold integers, reals, strings, methods, code blocks, and references to other objects. Aggregate data types of all kinds are provided by prototype objects in the Self standard library. The library also provides a great many prototypes for graphics, windowing, I/O, networking, and other services. Self supports the usual selection and iteration control flow constructs for use inside methods and blocks. Their syntax is a little peculiar because they are built as methods of the object prototype Block. Self is very unusual, among

OOP languages, because it allows an object to change its slots and its methods dynamically; this is equivalent to allowing run-time class definition. There is no strict inheritance in Self; the parent class of an object is simply a reference stored in a parent slot, messages that cannot be handled by an object get delegated to its parent (effectively, its superclass). Self also fully supports reflection, allowing objects to inspect each others configuration during execution. The Sun implementation of Self is written in C with some assembly code. It is basically an on-the-fly translator with compiled code caching. Since re-compilation is transparent, Self appears to the user as if it were interpreted. The current (and last) release of Sun Labs Self is 4.0 It is available for SunOS and Solaris UNIX from several FTP sites. The Merlin project is implementing a version of Self for Linux Documentation about Self, including conference papers and a reference manual, are available on the web.

Origin: David Ungar & Randall Smith, 1986. See Also: Smalltalk Java Objective-C Cedar C Remarks: Computer science researchers at Sun Microsystems Labs and Stanford University worked on the Self programming environment from about 1991 to 1995. It served as a vehicle for studying user interfaces, OOP compiler and interpreter technology, and general OO language concepts. Self is an elegant and charming OOP system, but the very limited support and platform availability that Sun Labs could offer helped to deter widespread adoption. Selfs highly dynamic and flexible object model could be used to emulate the object models of other language. For example, the Sun team wrote a Smalltalk environment entirely in Self Links: Self FTP download area Description of tinySelf at the Merlin Project TinySelf for Linux home page Date: Last updated 9/3/98 Sample code: SETL Language type: S - block-structured Description: SETL is a high-level procedural language designed to bring the power of set theory

to programmers. SETL programs are typically compiled. The fundamental data types in SETL are: integers (unlimited precision), reals (machine precision), strings, booleans, and the explicit non-value, omega ("om" for short). The main data structures are sets and tuples: sets are unordered but unique, while tuples are ordered but can contain duplicates. A special case of the set type very often employed in programming is the map, a set of 2-tuples. The language includes a rich set of constructs and functions for creating and manipulating sets and tuples. SETL is a highly dynamic language; sets and tuples can be heterogeneous, and can be nested to arbitrary depth. In general, variables are typed by the value they hold; some type checking for operators is enforced Sets and tuples can be created on the fly, garbage collection is automatic (presumably by reference counting, since there are no pointers in the language). Because it supports generalized notions of sets and tuples,

SETL provides loop constructs based on them. It also provides conventional while-do loops, if-then-else selection, and a case statement. SETL supports definition of functions and definition of new operators. There are no procedures in SETL, but any function can return omega. Most dialects of SETL support a sub-language that allows the programmer to define how data structures are to be stored internally by the compiler; this allows the user to give guidance to the compiler, possibly improving performance. SETL supports module and library features for large-scale programming. Newer editions of the language also support named packages (like Ada), and there are also dialects that support classes and object-oriented programming. Several implementations of SETL are available, mostly for DOS and UNIX platforms, but there is also a Macintosh version. Information on the language, including tutorials and references, is available but mostly in downloadable print formats rather than web pages.

Origin: Jacob T. Schwartz, 1969; Courant Institute, 1970 See Also: Algol Perl APL Ada Remarks: SETL is reputed to be very good for writing compilers, translators, and other transformational programs; its set and map data types allow the programmer to take a very high-level view of the problem and its solution. The first Ada language system was implemented with SETL. Several dialects or variations on SETL have been created since the language became widely available in the 1970s. ISETL is a dialect with more formal mathmatics operations, intended for mathematicians PSETL is a dialect with data structure time-history. SETL-S was a subset of the language for small PCs running DOS Modern implementations of SETL correspond to a language definition from the 1980s called SETL2. Links: A description of SETL, with grammar The On-Line SETL server SLIM, a variation of SETL A SETL FTP download area Date: Last updated 12/22/97 Sample code: $ A SETL program to do the sieve of $ Erastothenes (probably

badly, but its my first $ SETL program) program sieve; read(mx); primes := {}; (for x in [3.mx] | odd x) primes with:= x; end; (for x in [3.ceil(mx / 2)] | odd x) primes := sieve1(x, primes); end; print(primes); proc sieve1(rd n, rd pset); (for x in pset | n < x and x mod n = 0) pset less:= x; end; return pset; end proc sieve1; end program sieve; sh Language type: C - Command or Scripting Description: The Bourne shell scripting language was one of the original command languages for the Unix operating system. It is a simple interpreted language, but widely used for automating complex tasks and assembling multi-step functionality from individual Unix tools. The syntax of sh is line-oriented. Sh has very limited data typing and scoping features Variables are usually called parameters. The only data type for parameters is string Parameters are global and dynamically scoped. The shell language supports a modest but complete set of control-flow constructs: bounded and free loops,

if-then-else, and a powerful case statement. Sh also supports a rudimentary error handling facility for catching asynchronous interrupts. Modern versions of sh support named functions, which may not be nested Function parameters are the only non-global variables. Strangely, sh has no support for computation, all computations must be carried out by calling Unix utilities like test and expr. The basic boolean construct in sh programming is the success or failure of program execution. The shell language offers extensive special syntax and features for running programs and handling their I/O. One of the most influential of these constructs was the "pipe", a simple syntax for connecting the output of one program to the input of another. The Bourne shell is included on all Unix and Linux systems, and more-or-less complete versions are available for many other systems. Documentation is included, and good books are also available Origin: Steve Bourne, 1971 See Also: csh tcl perl

Remarks: The ability to write complex programs in sh language used to be considered a core skill for Unix users, and it still is for Unix system administrators. For more sophisticated tasks, sh has been superseded by Perl Since the early days of Unix, many different shells have been created: C shell, Tenex C shell, Korn shell, Bourne-Again Shell, and many others. Unix shell languages are interpreted, as a rule. A variety of shell compilers have been written over the years, these typically translate a shell script into a C program with extensive reliance on a support library. Links: AIX Bourne Shell documentation An Introduction to Bourne Shell Introduction to Bourne shell programming Date: Last updated 2/6/98 Sample code: #!/bin/sh # Simple shell script to count files of size # greater than 1k if [ -z "$1" ] then pat="*" else pat="$1" fi cnt=0 for fname in $pat do if [ -r $fname -a ! -d $fname ] then size=`cat $fname | wc -c` if [ $size -gt 1024 ] then

echo $fname $size cnt=`expr $cnt 1` fi fi done echo "${pat}: Files bigger than 1K: $cnt" exit Simscript Language type: M - Mathematical or Simulation Description: Simscript is a simulation language with both declarative and procedural features, designed for discrete-event and hybrid discrete/continuous modelling. It has been in continuous use and development since its invention in 1962. The syntax and semantics of Simscript II are designed to make simulation programs easy to write and understand. The language syntax is "English-like" and fairly high-level Like many simulation systems, items in the system under study are represented in the language as attributed objects. The user defines what attributes each class of objects possess. Basic data types for attributes and procedural code variables include integers, reals, strings, and pointers. Composite data types include arrays, sets, and lists All data elements in a Simscript program are dynamic - memory

allocation is fully automatic. Procedural code can use simple conditional and iteration constructs, subroutines, and functions. Scoping is simple: each entity and variable belongs to global scope, or is local to some routine. Like Simula, Simscript uses a concurrent process model for discrete-event simulation. Nodes of a system are represented by instances of a particular process class, and can invoked on a time basis or in response to simulation events. The language also includes facilities for data gathering, statistics, random-number generation, various kinds of I/O, and process synchronization. Early versions of Simscript produced Fortran code output. Simscript II5 produces C code In both cases, the generated code would be compiled and linked with a run-time library. Simscript II.5 is a commercial product sold by CACI Products Company Documentation is available from the company web site, and trial versions of the software can be downloaded from there, too. Origin: H. Markowitz et

al, Rand Corporation, 1962 See Also: GPSS SLAM Simula Matlab Remarks: There have been many front-end and extension products for Simscript over the years: Quikscript, EPSS, Simgraphics, and others. Basically, Simscripts popularity created a market for specialized extensions, and its complexity created a need for user-friendly interfaces, especially for teaching purposes. The current version of Simscript II.5 is distributed with a graphical front-end called SIMDRAW, a debugger, a statistics package, and other utilities and libraries. Links: Simscript II.5 Information at CACI FTP site for Simscript and related products Date: Last updated 1/3/98 Sample code: Preamble A simple telephone system model - CACI Products Company files: TELPHN1.SRC Normally mode is integer Processes include GENERATOR Every INCOMING.CALL has a CALL.ID Define NUMBER.BUSY and LOST.CALLS as integer variables End Preamble Main Activate a GENERATOR now Start simulation Print 1 line with LOST.CALLS thus 15 phone calls

were made and * were lost due to busy lines End Main Process GENERATOR For I = 1 to 15 do Activate a INCOMING.CALL now Let CALL.ID(INCOMINGCALL) = I Wait uniform.f (20, 60, 1) minutes Loop End GENERATOR Process INCOMING.CALL If NUMBER.BUSY < 2 Add 1 to NUMBER.BUSY Wait uniform.f(60, 100, 2) minutes Subtract 1 from NUMBER.BUSY Else Add 1 to LOST.CALLS Endif End INCOMING.CALL SIMULA Language type: O - Object-oriented Description: Simula67 is a block-structured procedural language with some object-oriented programming features. It was the first language to supply abstract data type and class support, and is therefore recognized as one of the founding elements of object-oriented computing. Simula syntax is similar to that of Algol, but with special features and keywords for record classes and type support. Other features of Simula include: basic numeric data types, strings, strong type checking, basic control structures, data encapsulation, simple inheritance, simple I/O support,

some polymorphism, and special semantics for discrete-event simulation. The execution of a Simula program consists of one or more processes, each of which is an instance of some class. Objects can interact with eachother somewhat independently; Simula supported a primitive form of concurrency (coroutines). Simula I was designed in 1962 and first implemented in 1964; it was an extension of Algol 60 for discreteevent simulation. In 1967, the more general-purpose Simula67 was introduced, with a wider set of data types and object support. Simula was standardized in 1977 Today, the language is controlled by a small independent standarization body, the SSG, dedicated to ensuring compliance by all Simula language compilers with the official language definition. Simula is available free for just about every general-purpose computing platform. Some of the Simula implementations are native compilers, and some are Simula-to-C translators. Many free add-on libraries and packages exist, and are

available free for Simula programmers. Information about Simula, including programming tutorials and source examples, is surprisingly widely available on the WWW. Origin: Ole Dahl and Kristen Nygaard, NCC Olso, 1964-67. See Also: Algol Smalltalk Ada C Eiffel Remarks: Simula was invented in Norway, and has always enjoyed the largest following in Scandinavia. It was never really widely adopted for general-purpose programming, but was and still is used in educational settings. The Simula language has the distinction of having been stable and useful with almost no changes for 30 years (as compared to Fortran or Lisp, for example!) Simula may not have been widely adopted, but its influence can be seen in almost every object-oriented language invented since, especially block-structured ones like Eiffel, C , and even Java. Links: U. of Montreal SIMULA home page Association of SIMULA Users SIMULA download area Simula Unix CIM FTP Site Date: Last updated 12/10/97 Sample code: Simula Line class,

taken from Kathleen Fishers "Introduction to Simula" Class Line(a,b,c); real a,b,c; begin boolean procedure parallelto(l); ref(Line) l; if l =/= none then parallelto := abs(a*l.b - b* l.a) < 000001; ref(Point) procedure meets(l); ref(Line) l; begin real t; if l =/= none and ~parallelto(l) then begin t := 1/(l.a * b - l.b * a); * complicated expressions omitted below meets :- new Point(., ); end; end; *meets real d; d := sqrt(a*2 b*2); if d = 0.0 then error else begin d := 1/d; a := a * d; b := b d; c := c d; end; end * Line Sina Language type: O - Object-oriented Description: Sina is an academic object-oriented language designed around the Composition Filters Object Model. As an OO language, Sina supplies the usual features like inheritance, encapsulation, and abstract data types. The structure of a Sina program is simply a collection of classes. Each class may be separated into an interface and an implementation. Each interface and implementation can contain

external and internal state, invariant conditions, methods, and filters. Individual methods (and filters) contain sequential code; the control structures supported by Sina are: if-then-else, while loops, and a numerically-oriented for loop. Primitive data types supported by Sina include: strings, numbers, booleans, and object references. Arrays are not primitives, but are provided by a built-in class. The only implementation of Sina, called Sina/st, is an interpreter written in Smalltalk. The implementation is available free, but requires a copy of a commercial Smalltalk system. The current version as of late 1996 was Sina/st 3.1 Origin: A. Tripathi et al, 1989 See Also: Smalltalk Eiffel Leda Self Objective-C Remarks: Sina was implemented specifically for VisualWorks(tm) Smalltalk, and currently runs only in that environment. It does give the Sina programmer access to the extensive facilities of the Smalltalk system The Compositional Filters Object Model is a layering abstraction for

defining objects and their interactions. It can be employed to define mechanisms for inheritance, delegation, reflection, persistence, and other advanced OOP concepts in a uniform and general way. Early papers about Sina seem to imply concurrency support, but the current documentation does not mention it. It seems that development of Sina stopped after version 3.1 Links: Introduction to the Sina Language Sina download page Date: Last updated 6/19/98 Sample code: // an example from the Sina/st 3.1 distribution main comment Bring a salute to our globe; temps hello: HelloWorld; begin hello.show end // main #Category Sina-Hello world; class HelloWorld interface methods show returns nil; inputfilters disp: Dispatch = {inner.*}; end; // interface HelloWorld class HelloWorld implementation methods show begin self.printLine(Hello, world!); return end; // show end; // implementation HelloWorld SISAL Language type: F - Functional or lambda-based Description: SISAL is a functional

programming language designed for parallel processing. The name SISAL stands for Streams and Iteration in a Single Assignment Language. It is intended for use programming scientific application on multi-processor supercomputers, and for educational use in teaching parallel programming. The lexical structure of SISAL is similar to that of Pascal. The syntax is simple and uniform, with special keywords for controlling arrays and iteration. Data types in SISAL include integers, reals, strings, multidimensional arrays, and records Control structures in SISAL look deceptively familiar, but have functional rather than procedural semantics. The semantics of the for loop are particularly rich, although somewhat complicated. SISAL is strongly typed, and no implicit conversions are supported; all data type casting must be explicitly specified by the programmer. Other programming features of SISAL include multi-arity functions, user-defined data types, sophisticated array handling, a large

library of built-in math functions, and streams-oriented I/O. The mathematical foundations of SISAL are similar to that of other functional languages: all computations produce results, and computations do not produce side-effects. Further, SISAL programs are guaranteed to be deadlock-free and determinate, even in parallel environments. The main SISAL implementation is an optimizing compiler with back-ends targetted for different parallel architectures. There are also subset SISAL interpreters for beginner use All SISAL language implementations are free. It runs one a fair variety of platforms, including many UNIX systems, PC, Macintosh, and Cray and Intel supercomputers. Documentation for the language and its compilers is easily available on the WWW. Origin: John Feo et al, Lawrence Livermore National Laboratory, 1990. See Also: Lucid Clean ML Pascal Remarks: SISAL was designed to allow the compiler to make fine-grained decisions about parallelism. The LLNL optimizing SISAL compiler

uses dataflow graphs to identify dependencies and order computations. In performance tests, parallelized SISAL programs were faster than comparable parallelized FORTRAN programs on several supercomputer platforms. As in many other functional languages, I/O in SISAL is somewhat rigid and still problematic. SISAL does support, partially, an I/O data format called Fibre; this facility is still under development as of late 1997. SISAL is suitable for use on a large class of mathematical problems, but its adoption outside of LLNL seems to be spotty. Links: A Tutorial Introduction to SISAL SISAL Main FTP download area Sisal90 Users Manual Date: Last updated 11/7/99 Sample code: % A simple example of using SISAL arrays, % adapted from various sample exercises in the % SISAL tutorial by John Feo. define main type Matrix = array [ array [ real ] ] % generate a square matrix where element [n,m] % is set to n m function gensquare(siz : integer returns Matrix ) for i in 1,siz cross j in 1,siz

returns array of real(i) real(j) end for end function % perform one step of a relaxation, average each % element with its eight nearest neighbors function relax ( a : Matrix returns Matrix ) for row in a at i cross elt in row at j avg := (elt a[i, j-1] a[i, j 1] a[i 1, j-1] a[i 1, j] a[i 1, j 1] a[i-1, j-1] a[i-1, j] a[i-1, j 1]) / 9.0 returns array of avg end for end function % test the generator and relax function function main(returns Matrix) let a1 := gensquare(5) end let in a1 end function SLAM Language type: M - Mathematical or Simulation Description: SLAM was a discrete system modelling language, mainly oriented toward discrete event simulation of service scheduling, manufacturing, military logistics, computer architectures, and other interconnected concurrent systems. SLAM is a proprietary language owned by Pritsker & Associates (now Pritsker Corporation). SLAM went through many versions, the last being 4.2 The language had a Fortran-like syntax, with special operators

for defining discrete event networks. The language offered a wide variety of network components, probability distributions, and reporting options. SLAM is implemented as a Fortran preprocessor. Editions are available for most Unix systems, mainframes, and Windows PCs. Some versions had slightly different names, like "Slamsystem" SLAM has been superseded by newer products, but is still used in academic settings to teach queuing system simulation and related topics. Information on SLAM is not easily available on the web Origin: A.AB Pritsker et al, 1976-77 See Also: GPSS Simula Simscript Fortran Remarks: SLAM offered a very useful paradigm for network simulation, because the constructs of the language mapped directly to the elements of the network model at an appropriate semantic level (not too high, not too low). Also, an ambitious programmer could create new network elements by coding them in Fortran SLAM was a successor to an older Fortran-based discrete simulation

language named GASP. Links: Pritsker Corporation page Date: Last updated 1/2/98 Sample code: An example in rather old-fashioned SLAM from the Pritsker & Pegden textbook, 1978. GEN, PEGDEN, SERIAL WORK AREAS QUEUE MODEL, 7/14/77, 1; LIMITS,2,1,50; NETWORK; CREATE, EXPON(.4), , 1; QUEUE(1), 0, 4, BALK(SUB); ACT/1,EXPON(0.25); QUEUE(2), 0, 2, BLOCK; ACT/2,EXPON(0.50); COLCT, INT(1), TIME IN SYSTEM, 20/0/.25 TERM; SUB COLCT,BET,TIME BETWEEN BALKS; TERM; INIT,0,300; FIN; Smalltalk Language type: O - Object-oriented Description: Smalltalk is a dynamic object-oriented language originally designed in the 1970s. It was originally designed as an experiment, but evolved into a powerful application development language. Smalltalk is a pure object-oriented language: all data are encapsulated as objects, and all operations and functions are performed by sending messages to objects. All objects inherit from an Smalltalks programming model is very rich and mature, supporting inheritance,

abstract data types, polymorphism, automatic memory management with garbage collected, delegation, reflection, and persistence. Unlike some newer OOP languages, Smalltalk is not strongly typed. The language typically does not enforce type constraints, and method declarations usually do not include type declarations. Fundamental data types supported by the language include integers, reals, strings, booleans, and arrays. The standard class library distributed with every Smalltalk system includes a wide variety of collection classes (such as vectors, trees, hash tables, etc.), stream-oriented I/O facilities, object persistence support, and graphical user interface classes. Early Smalltalk implementation were interpreted, but most modern implementations employ translation to abstract machine intermediate codes and/or dynamic native compilation (so-called "Just-in-time" code generation). As of late 1997, an ANSI standard for Smalltalk was in draft form under the J20 committee. The

final standard is expected in late 1998. Several commercial and free Smalltalk implementations exist, for all sorts of platforms. On of the more popular free implementations, for Unix systems, is GNU Smalltalk. IBM and ObjectShare are the primary commercial Smalltalk vendors. Good information and documentation about the language, as well as free class libraries of all sorts, can be found on the web. Origin: Alan Kay and Xerox Software Concepts Group, 1972. See Also: Simula Eiffel Lisp Objective-C Java C Remarks: Smalltalk is used for application development, but it has also been used to teach OOP principles. Unlike C or Java, Smalltalk represents everything as an object, making the language much more consistent in its treatment of data aggregations. While the Smalltalk language and its object model were very influential, its run-time environment was even more so. Smalltalk was the first language to support a multi-window graphical user interface Later windowing systems, like the

Xerox Star, the Apple Lisa and Macintosh, the X Window System, and Microsoft Windows all took ideas (and sometimes even personnel) from the Smalltalk development efforts. The Smalltalk GUI uses a very powerful conceptual framework: the Model-View-Controller (MVC) paradigm. In this framework, every GUI element has a model that holds its data, a view that draws its display, and a controller that responds to activities and causes the object to react. By keeping these three aspects of GUI elements separate, Smalltalk allows the programmer great flexibility. (The MVC framework was also employed in the NeXTStep GUI, which was written in Objective-C.) There have been many dialects of Smalltalk, some of them influential enough to be called de-facto standards: Smalltalk-80, Smalltalk/V, and others. The upcoming ANSI standard should help alleviate the problems caused by differing implementations. A free academic edition of Smalltalk, ObjectShare Smalltalk Express, can be obtained here. Links:

The Smalltalk Developers Site The UIUC Smalltalk Archive An On-line textbook about Smalltalk More Smalltalk resource links SQUEAK Smalltalk web site Date: Last updated 6/19/98 Sample code: Smalltalk class to constraint a 2D point to a fixed grid (from Horan & Hopkins, Smalltalk: An Introduction.) Point subclass: #GriddedPoint instanceVariableNames: classVariableNames: poolDictionaries: category: Exercise11.5! !GriddedPoint methodsFor: accessing! x: xInteger "Set the x coordinate gridded to 10 (using rounding, alternatively I could use truncating)." super x: (xInteger roundTo: 10)! y: yInteger "Set the y coordinate gridded to 10 (using rounding, alternatively I could use truncating)." super y: (yInteger roundTo: 10)! ! !GriddedPoint methodsFor: private! setX: xPoint setY: yPoint "Initialize the instance variables rounding to 10." super setX: (xPoint roundTo: 10) setY: (yPoint roundTo: 10)! ! SML See: ML Language type: F - Functional or

lambda-based Description: SML is the standardized definition for the powerful functional language ML. See the ML entry for more information. Date: Last updated 12/13/97 SNOBOL Language type: D - Database or Text-processing Description: SNOBOL is a very powerful but eccentric programming language primarily oriented towards string data handling. Developed as a research project at Bell Labs 1960-1962, it gained a small but loyal following and has enjoyed modest popularity ever since. There were various versions of SNOBOL, but the main one was and is SNOBOL4. While SNOBOL offers the usualy arithmetic and variable assignments of conventional languages, its essence is string pattern matching. The language syntax supports extremely powerful string recognition and manipulation constructs that allow many types of data manipulation to be expressed in SNOBOL very concisely. Control flow in SNOBOL is mostly done on the basis of string matches or lack thereof, but modularity in the form of

subroutines is also part of the language. Data types offered in the language include strings, reals, integers, and homogeneous arrays. SNOBOL4 is wonderfully documented in the 1971 book The SNOBOL4 Programming Language, 2nd Edition. Origin: Griswold and Faber, Bell Labs, 1962. See Also: awk Icon Perl Remarks: Despite its rather punch-card oriented syntax, SNOBOL4 was one of the coolest languages of all time. Heres why: o o o Super-powerful pattern-matching Rich pattern composition semantics Interpretive environment (in 1961!) The expressiveness of SNOBOL, and its ability to compose simple functions in powerful utilities, had a profound effect on the evolution of the UNIX programming environment in the early 1970s, as well as on tools that originated in that environment, like sed, awk, and Perl. Several free UNIX implementations of SNOBOL dialects (e.g SPITBOL) exist, as well as a free version of SNOBOL4 for DOS named Vanilla. The leading commercial implementation is by Catspaw, Inc

Of course, the power of the language and its rather idiomatic control flow features make SNOBOL4 code almost impossible to read and understand after writing it. Links: http://www.dsuedu/~johnsone/snobookhtml http://www.idiomcom/free-compilers/LANG/Snobol4-1html ftp://ftp.csarizonaedu/snobol/ http://www.snobol4com/ Sample code: * Find biggest words and numbers in a test string * (from Griswold,Poage,& Polonsky, 1971) BIGP = (*P $ TRY GT(SIZE(TRY,SIZE(BIG))) $ BIG FAIL STR = IN 1964 NFL ATTENDANCE JUMPED TO 4,807884; AN INCREASE OF 401,810. P = SPAN(0123456789,) BIG = STR BIGP OUTPUT = LONGEST NUMBER IS BIG P = SPAN(ABCDEFGHIJKLMNOPQRSTUVWXYZ) BIG = STR BIGP OUTPUT = LONGEST WORD IS BIG END SPARCL Language type: V - Visual or graphical Description: Created as an attempt to combine visual, logic, and set-based programming disciplines, SPARCL is an academic programming system developed to aid exploratory programming. As a logic programming language, SPARCL supports definition

of facts and relationships between them. The system has three kinds of clauses: facts, rules, and questions, although any rule can be queried as a question if the user wishes. Data types supported by the language seem to be numbers and atoms Execution in SPARCL, as in Prolog, occurs in response to a question. The language system performs a unification of the facts and rules presented by the visual diagrams. Backtracking is the unification strategy employed by the current implementation. There is only one implementation of SPARCL, for the Mac, available free from the languages web site. Origin: L. Spratt, U of Kansas, 1993 See Also: SETL Forms/3 Prolog CUBE Remarks: SPARCL runs in the highly visual environment provided by MacOS on Macintosh hardware. It can also generate 3-D models of its programs for rendering with the POV-Ray raytracer. However, it is not clear from the documentation whether the 3-D aspects of some SPARCL programs are algorithmically necessary, or merely cosmetic. Use

of the 3-D rendering as a tool for improving view comprehension of diagrams of algorithms was examined in a 1994 paper about SPARCL. Links: SPARCL Tutorial Date: Last updated 8/8/98 Sample code: Here is a SPARCL program that computes the sum of the values of a term. SPITBOL See: SNOBOL Language type: D - Database or Text-processing Description: SPITBOL was a compiled variant of SNOBOL, available for DEC computers and some other systems. Later marketed for UNIX workstations by Catspaw, Inc. Origin: Dewar et al, 1971. Remarks: SPITBOL stands for SPeedy ImplemenTation of snoBOL. T T See: Scheme Language type: F - Functional or lambda-based Description: T was an implementation of Scheme originally developed at Yale University. Date: Last updated 12/19/97 Tcl Language type: C - Command or Scripting Description: Tcl (pronounced tickle) is a block-structured interpreted scripting language intended for portable application development and extension. The name originally stood for Tool

Command Language The language and its interpreter were designed to be easy to use for development projects, and also easy to bind to other programs and libraries written in C or C . Tcl is frequently mentioned along with its associated graphical toolkit, Tk. The package, Tcl/Tk, is a complete system for writing portable GUI applications. Tcl and Tk are built to allow a programmer to extend them with additional code written in C/C , or to embed them into a larger C/C application to serve as that applications scripting language. The syntax of Tcl is fairly simple, but uses the command language paradigm of verb-noun rather than the more common expression-statement paradigm used by scripting languages like Perl and JavaScript. This approach makes the language somewhat unforgiving in terms of coding style. Tcl was originally heavily oriented towards creating, evaluating, and processing strings. Tcls syntax includes several subtly distinguished quoting mechanisms. Like many interpreters, Tcl

has the ability to create and then execute code on the fly. Tcl offers a small set of very flexible data types: numbers, strings, lists, and associative arrays. In practice, lists and associative arrays get used for just about everything. Tcl includes a conventional complement of control structures: if-then-else, loop, switch, and exception handling structures are all provided (but with some quirks driven by the command language verb-noun structure.) Tcl has extensive I/O capabilities, as well as good features for invoking and controlling local utility programs. Tcl also provides network I/O support, and mechanisms for asynchronous (event-driven) scripting Tcl does not support a general concurrency or threading model. Tk is a comprehensive GUI toolkit offering the usual buttons, menus, labels, and scrollbars. It also offers higher-level facilties like lists, a vector-graphic canvas, a sophisticated text display/editor, color and clipboard management, and more. Tcl was originally

designed to be a common scripting language to be embedded in Unix graphical tools (the inventor of Tcl/Tk, John Ousterhout, is also famous for his contributions to the VLSI tool community). Tcl evolved greatly in the early 1990s, becoming a powerful scripting language suitable for crafting whole applications. In the mid-1990s, it was first ported to a platform other than Unix, and has since been ported to over a dozen operating systems. Tk works under the X Window System, MS-Windows, and the Macintosh Versions of Tcl prior to 8.0 were strictly interpreted, and suffered from a variety of performance problems related to the interpretation process and the interpreters data storage mechanisms. These problems were fixed in version 8.0, and the language now employs an on-the-fly bytecode compiler, and the data storage management has been re-designed and improved. Other new features in version 80 include reflection, separate namespaces, and various system-dependent enhancements for

MS-Windows. Information about Tcl/Tk is widely available on the web, and there are also a few good books about Tcl programming. Extensions and add-ons for Tcl are common and popular, especially extensions that support object-oriented programming. A very wide variety of such add-ons are available free from Tcl download archives. Various development tools are also available, some free and some commercial Tcl/Tk 80 is available free from Sun Microsystems for Unix, Windows, Macintosh, and other platforms. Origin: John Ousterhout et al, UC Berkeley, 1990. See Also: Perl csh Python Icon Remarks: Tcls syntax takes a little getting used to, but it basically provides the same functionality as a structured language like Pascal. Unlike Pascal, Tcl is not strongly typed Numbers, strings, and lists can be freely interconverted. Tcl associative arrays are implemented as hash tables, and provide the only heterogenous aggregation facility in the language. The real strengths of Tcl are its

portability and its extensibility. It is very easy to embed a Tcl interpreter into an application program (compared with embedding Perl, for example, which is feasible but difficult). It is also very easy to add new commands to Tcl by linking in C or C libraries. This friendliness has helped drive Tcls acceptance in some sectors of the computing community. In 1996 Tcl was also ported to the web browser environment. The SafeTcl plug-in allows any Netscapecompliant browser to run specialized Tcl/Tk applications (called Tclets) inside the browser window As this facilities is not yet offered directly by the browser vendors, though, its acceptance has been limited. As of December 1997, most Tcl/Tk books available were still stuck at version 7. Be careful to check the version coverage of any Tcl/Tk book before buying it. Links: Tcl WWW Resources Official Tcl/Tk Contributions Archive Virtual Library Tcl/Tk Entry Tcl/Tk FAQ Lists A Tcl/Tk Tutorial Date: Last updated 11/7/99 Sample code: #

Small Tcl sorting program, after Welch, 1997. proc NameCompare {a, b} { set $asurname = [lindex $a end] set $bsurname = [lindex $b end] set ret [string compare $asurname $bsurname] if { $ret == 0 } { $ret = [string compare $a $b] } return $ret } set namelist {} set line {} while { [gets stdin line] != 0 } { lappend namelist $line } set namelist [lsort -command NameCompare $namelist] set lineno 1 foreach line $namelist { puts stdout "$lineno $line" set lineno [expr $lineno 1] } TECO Language type: D - Database or Text-processing Description: Teco was an editor and interpreted text editing language characterized by extremely terse syntax. Teco offers extensive facilities for text manipulations, keyboard handling, and screen drawing. Built-in data types include integers, strings, buffers, dispatch tables. Some versions had additional data types Control structures supported included simple loop and conditional constructs, as well as means for defining new functions (macros) and

binding them to user input in various ways. Teco is an interpreted language. Original interpreters were written in platform assembly language, later ones were written in C or other languages. Implementations of Teco are available for some Unix systems, VMS, MS-DOS, and for many obsolete DEC operating systems. Manuals are often included with distributions Origin: Digital Equipment Corp, 1980? See Also: Elisp Remarks: Teco stands for Text Editor and COrrector (originally, it is reputed to have stood for Tape Editor.) The syntax of TECO is extremely cryptic and compact. Most constructs and commands in the language are only one or two bytes (not necessarily printable characters either) and many of the commands had complicated semantics. TECO was commonly employed on DEC computers, such as the PDP-11, DEC-10, DEC-20, and VAX, to write editors and editor extensions, as well as text processing programs. Emacs was originally written in Teco. Links: FTP Archive of TECO software and notes

Date: Last updated 1/10/98 Sample code: ! DISPLAY CURRENT LINES ASCII CODES, 20 PER DISPLAY-LINE.! ! D F KOENIG, 1989-11-24. ! @^U.L[^[^A Line length = ^A^[ MN0U.0^[QN<Q0A:=^[^A ^A^[((%0/10)*10)-Q.0"E^[((Q0/20)*20)-Q.0"E^[^A ^A^[ ^[|^[^A ^A^[ ^[^[^[>^[^A ^A^[[ Telescript Language type: O - Object-oriented Description: Telescript is an object-oriented language and run-time support system designed for creating portable GUIs, messaging applications, software agents, remote application scripts, and other kinds of distributed computation systems. The run-time system that supports Telescript programs is called Magic Cap It provides GUI, messaging, network, I/O and other services. As a procedural OOP language, Telescript supports the usual sequential control constructs, as well as simple data types like fixed- and floating-point numbers, and strings. Telescript supports simple interheritance and a form of multiple inheritance using a mix-in set-up like some dialects of Lisp.

All object classes inherit directly or indirectly from the Object class; method arguments may also subject to a simple form of typepredicate constraints. It also supports simple error handling using a try/catch syntax Telescript also includes notions of authority and ownership to provide security restrictions for software agents. Classes in Telescript can belong to class families, which are a form of generic class factory. Telescript programs are compiled into native code for a target platform, or into portable bytecodes for the Telescript engine (a virtual machine). As of the end of 1997, Telescript development tools are restricted to the Macintosh platform, although the engine is more portable (Windows, some Unix). The only implementation of Telescript is General Magics Magic Cap product, the compiler and development environment are sold by Metrowerks. Information on the language is available on the web, but not easy to find. A great deal of information is available under General

Magics web site Origin: General Magic, Inc, 1995 See Also: Java Remarks: Magic Cap is a run-time system and GUI environment for palmtops and personal communicators. Telescript programs run in Magic Cap, and they may also run as agents in host software to which the personal communicator connects. The Telescript language object model provides extensive support for object mobility and security. A modest variety of add-on packages and extensions for the Magic Cap environment can be found at General Magics web site and elsewere. Links: Technical Documentation for Telescript & Magic Cap Telescript Language Reference manual Magic Cap freeware site Date: Last updated 12/19/97 Terse Language type: S - block-structured Description: Invented to simplify low-level programming on the Intel x86 line of microprocessors, Terse is a small blockstructured language with a set of operators tightly bound to the x86s capabilities. The basic syntax of Terse is statement-oriented, with an extensive

(and unusual) set of operators. The data types available in Terse are the data types supported in the instruction set of the target x86-series processor: integers, reals, byte strings, and various kinds of pointers. As a venier over assembly, Terse does not support complex data abstractions; it does support arrays. Terse supports a modest set of control-flow structures based on the branch instructions available on the x86 operators. It has conditional and looping structures, and supports jump tables and other low-level control structures. Terse supports subroutines and functions, plus x86 interrupt handlers There is only one implementation of Terse, a commercial system for DOS and Windows operating systems. Origin: Jim Neil, 1987. See Also: C Remarks: Intel x86 assembly language is complex; Terse was designed to ease the inconveniences and hassles of assembly programming while preserving the degree of control. The syntax and data model of Terse are almost totally bound to the x86

architecture; programming in Terse requires understanding the x86 data types, registers, interrupts, and instruction set capabilities. However, Terse does free the programmer from many of the syntatic and lexical constraints of assembly, and it is more concise. Terse is an example of a specialized kind of language, the structured assembler. There have been a several structured assemblers developed over the years, but the popularity of such languages declined with the rise in popularity of C. The main uses for Terse are writing modules and programs that require the low-level control of assembly language: drivers, embedded control systems, data acquisition, and I/O sub-systems. Links: Terse home site Date: Last updated 11/7/99 Sample code: An implementation of the Sieve in Terse, by the Jim Neil. code Segment; define code Segment. Org 0100h; all .COM programs start at 0100h. data Segment; First2 =1, =13, =10, text. =2, =13, =10, =24h; Primes =" primes.", crlf =13, =10,

=24h; DOS. EOP Label Byte; data EndS; code. define data Segment. Initial 2 primes message followed by a $ for DOS. declare message text. followed by CR, LF and $ for define End Of Program. close data segment, goes after Computes and displays all of the primes between 0 and 65536 using the Eratosthenes Sieve method. Note that the first 2 primes (1 and 2) are handled as a special case. dx = O(First2); ah = 9; !21h; * print first 2 primes using sp = O(EOP set up 256 word stack at end of DOS. 512); prog. bx = sp 15 > 4; bx = number of paragraphs we use. es = ds = ax = cs bx; setup ds,es to free space past stack. cx = 32768; ax = (-1); &di; offset. cx = number, ax = value, di = ; <> * =; auto-inc, clear full 64K flags array. bx = 2; &si; &ch; count = 2 (for 1 & 2), i = 0, { ch = 0. cl = [si]; ?<> { dx = si si 3; <<1; do. if flags[i] is non-zero. then. prime = i * 2 3, break if done. ax ax ax di = = = =

dx; =.PrintNum; H(14) L(13); !10h; H(14) L(10); !10h; si dx; >> * print prime using PrintNum. * print CR using BIOS. * print LF using BIOS. k = i prime, if & while k << limit, { [di] = ch; di bx ; dx; }>>; }; si ; }.; do flags[k] = 0, k = k prime. count = count 1; endif flags[i] is non-zero. i = i 1. loop forever-- break gets us es = ds = ax = cs; ax = bx; =.PrintNum; dx = O(Primes); ah = 9; !21h; !20h; restore ds and es. print ax in decimal to screen. print " primes." using DOS return to DOS. out. TeX Language type: A - Application/Macro Description: TeX is a descriptive, interpreted language used to process, format, and typeset documents. TeX also has many of the facilities of a block-structured language, and is used to extend the text formatting system of which it is a part. TeX statements (macro calls) are normally embedded and interspersed through text to be formatted. Most TeX programming is confined to macro and extension

packages written to allow TeX users to create new, improved, or specialized kinds of documents. For doing this kind of programming, TeX offers string and numeric data types, very simple control flow constructs, and the ability to define macros (analogous to subroutines). TeX is implemented as an interpreted macro processor for the control of a general engine for producing typeset documents. The engine provides very simple but general-purpose formatting commands (called Plain TeX), and facilities for building up more sophisticated commands in the TeX language. While TeX is powerful enough to express (at least) all primitive recursive predicates, its syntax makes it illsuited for general-purpose computation. Several commercial and free implementations of TeX exist. Free versions of TeX for Unix, Mac, Linux, Windows, and other systems can be downloaded from sites on the Comprehensive TeX Archive Network. Origin: Donald Knuth, 1978, 1982. See Also: troff Remarks: TeX, and the various

extension packages for it, are very heavily used in academic to format books, dissertations, and scholarly papers. TeX is especially popular in the mathematics and physics communities because it has superlative support for typesetting mathematical formulae. Using TeX as a programming language, document authors can create new formatting techniques and procedures to meet their specific requirements. For example, many people employ TeX packages to collect and format index and bibliography data for their documents. Many good books about TeX exist, check the web sites linked here for more information. Links: Comprehensive TeX Archive Network Main TeX FAQ List Date: Last updated 12/20/97 Sample code: % Code to test whether a given year is % a leap-year. From % S. Bechtolsheims "TeX in Practice" volume 3 InputD{imodn.tip} ewifif@LeapYear defLeapYearConditional #1{% TTfi {% count0 = #1 elax IModN{count0}{4}{count1}% ifnumcount1 = 0 global@LeapYeartrue IModN{count0}{100}{count2}%

IModN{count0}{400}{count3}% ifnumcount2 = 0 global@LeapYearfalse fi ifnumcount3 = 0 global@LeapYeartrue fi else global@LeapYearfalse fi }% if@LeapYear } Theta Language type: O - Object-oriented Description: Theta is an object-oriented language with a sophisticated and flexible type system, developed by the MIT Programming Methodology Group. Theta supports a fairly conventional set of built-in data types and control structures. Integers, reals, characters, strings, booleans, and subroutine references are all primitive types. Composite types are parameterized (generic), and include arrays, sequences, vectors, records, and structs. Control structures include conditional and loop constructs, and simple exception handling. The parameterized type system of Theta is very powerful, and allows a programmer to cleanly define new abstract type templates with desired properties. Object classes in Theta are associated with user-defined types: a type is implemented by one or more classes. Theta

supports single inheritance for classes; the programmer can restrict how a class may be subclassed (like Java but more flexibly). Theta uses a rooted type hierarchy: all types are subtypes of "any" (even built-ins like "int"). Routine types are also part of the hierarchy, and the type rules are used to enforce method call type conformance. Types are decoupled from classes. Theta supports separately compiled modules, optionally supplying multiple implementations for a particular type interface. Memory management in Theta is dynamic and automatic. Unreferenced objects are reclaimed by a garbage collector. The Thor database provides object persistence for Theta objects As of early 1998, the MIT Theta implementation was not available for download, possibly because Theta is bound to Thor? The Theta reference manual is available (link below). Origin: Barbara Liskov et al, MIT, 1994. See Also: CLU Modula-3 C Remarks: Theta was developed to be the programming language for

Thor, a distributed transactional OO database system. One of the goals of the overall Thor project was to study distributed object systems, and the Theta language embodies features derived from that research. Links: Theta language reference manual Date: Last updated 1/8/98 Turing Language type: S - block-structured Description: Turing is a structured programming language designed for teaching computing principles and for simple graphics. Used mainly in high schools, Turing is meant to be simple and usable while supporting good programming practices. The syntax of Turing is similar to that of Pascal, but much more forgiving. Data types include numbers, characters, and strings, plus arrays and records. Like Pascal, Turing also supports variant records and references. Looping and conditional constructs are available in the language, and seem a little more comprehensive than those in Pascal. Subroutines and functions are used to modularize Turing programs, and recursion is also

supported. In addition to commonplace structured programming statements, Turing also supports specification of invariants and assertions, like Eiffel, to help encourage sound algorithm construction. Recent versions of Turing have gained libraries for supporting graphics and GUIs, animation, and other multi-media operations. A variant of Turing called "Turing Plus" was designed for system programming; it featured type casting and multi-processing, plus unsigned numeric types and other system programming conveniences. This dialect seems to be no longer available but many of the features in it seem to have been rolled into Object-Oriented Turing (OOT). Turing is available for Windows, Mac, and Unix operating systems, but only as a commercial product. There is no free downloadable version or documentation. Schools can get free trial licences Origin: R.C Holt et al, Univ of Toronto, 1987 See Also: Pascal Eiffel Remarks: Turing seems to be more popular in Canada than in other parts

of the world. Originally, Turing was conceived as a kind of "super-Pascal", a language with Pascals ease-of-use and expressiveness, but without some of Pascals recognized problems. The operation of programs written in Turing was defined formally using axiomatic semantics, very unusual for a language meant for teaching beginners. It was developed by the Holt Group (under Prof RC Holt) at U of Toronto in the late 1980s and early 90s, and since about 1994 has been a commericial product targeted mainly at teachers. An extended version of Turing, called Object-Oriented Turing, features inheritance, encapsulation, concurrency, delegation, and other OOP mechanisms, but with syntax very similar to that of original Turing. (Relationship seems to be like that of C and C .) Unfortunately, very little detailed information about OOT seems to be available on the WWW. Links: Turings old home at U. of Toronto Technical Info on Turing, Holt Software Programming in Turing Lecture notes

introducing Turing Date: Last updated 11/21/98 Sample code: Placeholder until I get a better example. % Roll a die until you get 6. (This is a comment) var die : int loop randint (die, 1, 6) exit when die = 6 put "This roll is ", die end loop put "Stopping with roll of 6" U UFO Language type: O - Object-oriented Description: Unified Functions and Objects (UFO) is an object-oriented functional language designed for implicit parallelism. The syntax of UFO is fairly simple and expression-based; some lexical aspects are reminiscent of Algol. All UFO functions are side-effect-free, but the bodies of functions allow local variables. Fundamental data types supported by the language include integers, floats, chars and strings, and booleans. Arrays are also supported, with list expressions for generating numeric and other sequences. Control flow constructs include conditional expressions and loops; the loop constructs can generate arrays automatically. UFO supports

class definition with single inheritance, virtual classes, and stateless classes (similar to Java interfaces). Generic, or parameterized, functions and classes are also supported In its role as a functional language, UFO allows the programmer to define higher-order functions and build up Scheme-like functional mechanisms. UFO has a modest library of built-in classes, collections, and I/O facilities. UFO is available free from the authors, it is currently at version 1.0 Origin: J. Sargeant et al, 1996 See Also: Haskell Leda Sather Java Self Remarks: UFO is essentially an academic project, meant to show how functional and OO features can be combined in a language that allows automatic identification and exploitation of concurrency. The current (10) implementation compiles UFO down to the dataflow intermediate language UFlow. Unlike a pure functional language, UFO does support stateful classes with procedures, but they are not the usual way of programming. Links: UFO Project Overview

Date: Last updated 5/29/98 Sample code: * An example numerical integration program * from the UFO1.0 Tutorial by J Sargeant polyf (x : Float) : Float is 2*xx + 6x + 1 trap(f: Float -> Float; a,b,approx : Float; n : Int) : Float is { h = (b - a) / n; return approx/2 + h* initially s = 0.0; for i in [1 to n step 2] do x = a + i * h ; new s = s + f(x) ; return s od } integrate(f : Float -> Float; a, b: Float) : Float is initially done = false; n = 1 ; integral = (f(a) + f(b)) * (b - a) / 2; while not done do next integral = trap(f, a, b, integral, 2 * n) ; new n = 2 * n ; new done = abs(next integral - integral) < 1.0e-4 new integral = next integral return next integral od main : String is "Integral is " ++ print(integrate(Float|polyf, 1.0, 60) ++ " " Until See: Forth Language type: T - Threaded or stack-based Description: Until is an interpreted dialect of Forth designed for portability and for use as an embedded extension language. Unlike most Forth

implementations, Until is designed to provide easy access to underlying operating system services, and to be easily integrated with C programs. Source code for the Until implementation is supposedly available, targetted mainly at MS-DOS but supposedly portable to Unix as well. Origin: N.E Smith, 1991 See Also: Postscript Remarks: Development of Until seemed to stop sometime in the mid-1990s. Links: Until 2.5 available via FTP Date: Last updated 2/19/98 V VBScript See: Basic Language type: A - Application/Macro Description: Visual Basic Scripting Edition is a subset dialect of Visual Basic; it is an interpreted, procedural language intended for creating application extension scripts and for adding interactivity to web pages. VBScripts syntax resembles that of Visual Basic: statements are bounded by end-of-line, and normal Basic keywords are used for control structures and code modularity. VBScript supports a modest set of data types: various numeric types, strings, dates, booleans,

arrays, and object references. Variables in VBScript are typed, but the interpreter does not do strong type enforcement. VBScript supports subroutines and functions, and can interact with objects provided by its environment (usually a scriptable application). VBScript does not support the definition of new object classes, nor does it support overloading or polymorphism. The language has fairly good support for handling time, dates, and strings. The newest version of VBScript also supports a dictionary object, an associative array for storing string data. VBScript is most commonly employed in web browsers and web servers from Microsoft. Under the 32-bit Windows environment, any application can employ VBScript if it is installed; Microsoft intends VBScript to be the baseline or typical scripting language for simple OLE applications. The first release of VBScript was part of Microsofts Internet Explorer 3.0 product; in 1997 they released VBScript 20 Good information about VBScript,

including a hyperlinked reference manual, in available from Microsofts web site. Many good books about it are also available Origin: Microsoft Corporation, 1995 ? See Also: VBA Visual Basic JavaScript Remarks: In the web browser niche, VBScript and JavaScript are the two main competitors. They are comparable in terms of functionality, although in most respects JavaScript is a more powerful programming language. In web browsers, VBScript is often employed to validate HTML form data and to make forms more responsive. It can also be used, in web browsers and elsewhere, to configure and manipulate ActiveX controls. VBScript has not language-defined I/O facilities; any I/O that it supports must be provided by object classes supplied from the controlling application environment. In a web browser client, these objects are not available, but in a web server environment they are. Links: VBScript Writers Resources Date: Last updated 12/23/97 Sample code: An example of using VBScript to check

form data. Function isSSN(ssns) isSSN = False If (len(ssns) = 9 or len(ssns) = 11) Then isSSN = True End If End Function Sub submit OnClick dim namestr, ssnstr, psw, req set form = document.form1 namestr = Trim(form.NameStrFieldValue) ssnstr = Trim(form.SSNStrFieldValue) If (len(namestr) = 0) Then msgbox "Name is empty, please type in your name" Exit Sub ElseIf (not isSSN(ssnstr)) Then msgbox "SSN field is not the right length, please fix it" Exit Sub Else psw = InputBox("Enter your password:","Form Password","") End If req = "http://test.org/cgi/startcgi?ssn=" & ssnstr & "&passwd=" psw loc.href = req End Sub VHDL Language type: M - Mathematical or Simulation Description: VHDL is a modeling and simulation language intended for study and design of digital integrated circuits. The name is an acronym for VHSIC Hardware Description Language. The syntax and general appearance of VHDL are similar to that of

Ada, but the semantic structure is quite different. A VHDL model consists of a hierarchy of entities, these entities usually directly correspond to the parts of the digital system under study. Entities operate in parallel during simulation; the simulations use a kind of timed dataflow model that is adjustable by the user (so as to accurately represent a real circuit or chip). The operation of the various entities can be very simple, like a small expression, or very complex. VHDL supports subroutines and functions as well as conventional sequential control structures. Data types in VHDL include bits, enumerated sets, integers, reals, time, arrays, and records. The support for enumerated types and their use is very good. (Because most simulations of digital circuits model the state of a digital signal with more than just a bit.) VHDL has good support for modularity and for separation of interface and implementation of entities. First, it support generics for entities; and second, the

interface to an entity is always separate from the description of its operation. This allows simulations structure to be built up once, but simulated for several different hardware technologies. A variety of VHDL implementations are available from commercial CAD vendors. At least one free implementation is available for Unix systems as part of the ALLIANCE educational VLSI package. Origin: M.R Shahdad et al, 1985; IEEE Standard 1076, 1987 See Also: Verilog Ada Remarks: VHDL is a remarkable complete procedural block-structured language, considering that it was not intended for application programming. VHDL was originally standardized in 1987 as IEEE 1076, and revised six years later as IEEE 1076-1993; there is also an analog modeling extension which is IEEE 1076.1 Unfortunately, there does not seem to be a copy of the standard available as HTML. Links: VHDL Archive site (FTP) VDHL FAQ Lists VHDL resources at SCRA More VHDL Resources, at Ohio U Date: Last updated 12/14/97 Sample

code: -- Behavioral model of a D flip-flop, from -- the US Army FCIM VHDL Tutorial. USE WORK.std logic 1164ALL ENTITY mydff IS GENERIC(q out, qb out PORT(preset, clear, din, clock: q, qb : END mydff :time); :IN std logic; :OUT std logic); ARCHITECTURE behavioral OF mydff IS BEGIN mydff proc : PROCESS(preset, clear, clock) VARIABLE int q :std logic; BEGIN IF preset = 0 AND clear = 0 THEN IF(clockEVENT) AND (clock = 1) THEN int q := din; END IF; ELSEIF preset = 1 AND clear =0 THEN int q := 1; ELSEIF clear = 1 AND preset = 0 THEN int q := 0; ELSE int q := X; ENDIF; q <= int q AFTER q out; int q := NOT(int q); qb <= int q AFTER qb out; END PROCESS mydff proc; END behavioral; Visual Basic See: Basic Language type: S - block-structured Description: Visual Basic is an advanced structured dialect of Basic developed by Microsoft, and intended for application development. The syntax of Visual Basic is similar to that of other modern Basic dialects, but with many additional features. The

following primitive data types are supported: integers, reals, strings, booleans, currency, dates, and object references. Variables may be declared, but need not be. Type checking can be performed, but is enforced only for declared variables and parameters. Composite data types include arrays and user-defined records Control structures include various conditional and iteration constructs, and rudimentary error handling mechanisms. Memory management in Basic is automatic. Visual Basic is nominally an interpreted language, but newer implementations include native code compilers. During execution, Visual Basic programs are normally supported by a run-time library. Visual Basic is a commercial product. A subset edition is available free, the full development environment must be purchased. Visual Basic runs on Microsoft Windows platforms Information about the language and other resources for developers are widely available on the Internet and in print media. Origin: Microsoft Corp,

1990. See Also: VBA WordBasic VBScript Remarks: As a language, Visual Basic has evolved enormously since its commercial introduction in 1990. Version 5, 1997, supports object oriented programming, a wide variety of data types and type checking, function pointers, and assertions. The "Visual" in the name Visual Basic does not really refer to the language, but to the development environment. The VB integrated development environment that Microsoft distributes has extensive facilities for on-screen design of graphical user interfaces: dialog boxes, window interfaces, menus, etc. It also provides a rich but complicated interface for code management and debugging. GUI programs are easy to write in Visual Basic, and the development environment provides copious support for coding the necessary event handling subroutines. The popularity of Visual Basic is derived partly from its extensibility. New components, especially GUI elements, can be added to the language run-time system and

transparently used by application developers. There is a large community of programmers who design and distribute "Visual Basic Controls" (VBXs) and "ActiveX Controls" for use in Visual Basic. Links: Microsoft technical materials on VB Visual Basic starting point (resources, searching) Visual Basic Info Booth (FAQs, resources) The Visual Basic Palace On-line catalog for VB developers Date: Last updated 1/8/98 Sample code: Simple program to compute factorials (placeholder until I write a better example) Function factorial(n as Long) If (n <= 0) Then factorial = 1 Else factorial = n * factorial(n - 1) End If End Function Dim fx(12) as Long For i = 1 to 12 fx(i) = factorial(i) Next W WordBasic See: Basic Language type: A - Application/Macro Description: Dialect of Basic used as the extension language for the popular Microsoft Word program, versions 2 through 7. Superseded by VBA Origin: Microsoft, 1992? See Also: VBScript VBA Remarks: WordBasic became a popular

language for writing computer viruses when the hacker community discovered that macros can be used to add macros to word processor files. Links: WordBasic Workbook Date: Last updated 12/6/97 X xlisp See: Lisp Language type: F - Functional or lambda-based Description: Xlisp is a dialect of Lisp; it is basically a free edition of Common Lisp with object-oriented extensions. XLisp is somewhat fragmented, there are several major implementations available. They are all free, however, and run on major platforms including Unix, Windows, and Macintosh. Origin: David Betz, 1985. See Also: Elisp Common Lisp Scheme Remarks: The name XLisp is short for "eXperimental Lisp". One of the most popular systems based on XLisp is XLISP-STAT, a version of Lisp with extensive statistical functions built-in, and an interpreted stats language. Links: XLisp (XScheme) 3.0 FTP Area XLISP-PLUS 3.01 FTP Area XLISP-STAT home page Date: Last updated 12/29/97 Y Yorick Language type: M - Mathematical

or Simulation Description: Yorick is an interpreted block-structured language intended for data analysis and data graphics. It is designed to be easy to use, but scalable to very large datasets and very complex computations. The syntax of Yorick is very simple, and the language looks somewhat like a simplified C. Variables need not be declared. Data types supported include integers, floating-point numbers, vectors of numbers, and file handles. The language does support definition of procedures and functions, along with a simple set of conditional and loop control structures. Yorick can also be extended with C code and libraries Yorick includes extensive facilities for creating and manipulating numeric vectors and datasets. Some versions can read and write a variety of scientific data formats. Yorick has a broad set of data display and graphing facilities. One of the languages main purposes is filtering and graphing scientific data obtained from huge experiments and numeric simulations.

There is only one implementation of Yorick, available free from LLNL. It runs on Unix and Linux systems, Macintoshes, and 32-bit Windows. Origin: Lawrence Livermore National Laboratory, 1994? See Also: S Pari Matlab Remarks: Yorick is not well known, but it is a very high-performance computation language used on supercomputers and Unix workstations at LLNL. It is fairly low level for a mathematical analysis language, but many higherlevel facilities are available as extensions Links: Yorick FAQ List Yorick FTP Distribution Archive Date: Last updated 12/19/97 Sample code: Plot function for a complex scalar function by Georg Michel. func cmplxplot(z, u) /* DOCUMENT cmplxplot, z, u * plots a scalar complex function of a complex variable. */ { resx=100; resy=100; s=[[sqrt(2./3),0,1/sqrt(3)],[-1/sqrt(2*3.0),1/sqrt(2),1/sqrt(3)], [-1/sqrt(2*3.0),-1/sqrt(2),1/sqrt(3)]]; phi=span(-pi,pi,256); vec=array(double,3,256); vec(1,)=cos(phi); vec(2,)=sin(phi); vec(3,)=1/sqrt(2)(-); f=s(+,)*vec(+,);

palette,bytscl(f(2,),top=255),bytscl(f(1,),top=255),bytscl(f(3,),top=255); xmin=min(u.re); xmax=max(u.re); ymin=min(u.im); ymax=max(u.im); zi=array(complex,resx,resy); zi.re=interp2(span(ymin,ymax,resy)(-:1:resx,),span(xmin,xmax,resx)(,:1:resy), z.re,uim,ure); zi.im=interp2(span(ymin,ymax,resy)(-:1:resx,),span(xmin,xmax,resx)(,:1:resy), z.im,uim,ure); // Caution: on some platforms atan(0,0) crashes ! arr=bytscl(atan(zi.im,zire+1e-200),cmin=-pi,cmax=pi); pli,arr, xmin,ymin,xmax,ymax; plc,abs(z),u.im,ure,marks=0; } Z ZPL Language type: P - Parallel or Dataflow Description: ZPL is an array programming language designed for efficient parallel implementation. It is used for scientific computations. Basic data types in ZPL include a wide variety of integer and real numeric types, strings, and booleans. It also supports both record aggregate types (like C structs) and two kinds of arrays: parallel and non-parallel. ZPL supports a wide variety of compound statement types and implicitly

parallel operators. Its statement syntax is vaguely similar to that of Pascal or Ada. Of course, being a parallel language, ZPL imposes some restrictions on use of conditional flow control. Procedures can be defined, and may be declared as parallel The program structure facilities of ZPL are very primitive: all code must reside in a single source file. The current ZPL implementation is a translator: the ZPL code is converted to ANSI C, which is then compiled with a platform-specific library. Origin: Snyder et al, University of Washington, 1993. See Also: APL Yorick J Matlab Fortran C Remarks: The basic point of ZPL is to express computations on vectors and higher-dimensional arrays in way that supports parallelism. Tests in scholarly articles indicate that ZPL programs can equal hand-tuned parallel C programs. Super-computing platforms on which ZPL will run include: Intel Paragon, Cray T3E, SGI Origin, IBM SP2, and others. One of the most novel aspects of ZPL is its facility for

defining regions of arrays for parallel operations, and directions of array offsets. Associated with this facility are some array structuring features including wrapping, reflecting, and flooding of array dimensions. Links: ZPL Installation & Download pages Language reference manual in HTML Date: Last updated 9/12/98 Sample code: A program to apply a Jacobi averaging operation to an array, from the ZPL example set. program jacobi; config var n delta : integer = 5; : float = 0.0001; region R = [1.n, 1n]; direction north east = [-1, 0]; south = [ 1, 0]; = [ 0, 1]; west = [ 0,-1]; procedure jacobi(); var A, Temp : [R] float; err : float; [R] [north [east [west [south of of of of R] R] R] R] begin A A A A A [R] := := := := := [R] -- Entry point 0.0; 0.0; 0.0; 0.0; 1.0; repeat Temp := err := A := until err < -- Declarations -- Initialization -- Main body (A@north+A@east+A@west+A@south) / 4.0; max<< abs(A-Temp); Temp; delta; writeln(A); -- Output

result end; 145 entries retrieved. Information about the dictionary: • • • • Dictionary working master list Questions and Answers about this project How entries get added to the dictionary Perl source code for CGI back-end Here are some other sites that have surveys or dictionaries of programming languages. NCSA Computing Languages List Pretty broad list, with short descriptions and links for most entries. Also includes some data-description and formatting languages. [Large flat HTML file with links] Tunes Review of Programming Languages As part of the TUNES project, F. Rideau is examining all existing languages, operating systems, virtual machines, and UI systems. This language list is pretty broad, contains both subjective and objective critique of the various languages, and the related reviews under the main reviews page are also pretty cool. [Large flat HTML file, some links] More Programming Language Resource Links. Some more resource links with descriptions. WWW

Virtual Library: Computing, Programming Languages A nice list, not exceptionally broad, but with links for every topic. [Large flat HTML file, many links] THE Language List The largest and most comprehensive list on the net, and a fine job by the CUI group at University of Geneva and Bill Kinnersley. This list has a very good search capability, and many of the entries have links to FTP sites for compilers and tools. Unfortunately, some of the links on the list are a little out of date, but its source attribution and journal references are great. search [Very large searchable database] Descriptions in this dictionary are 1997-99 Neal Ziring. Some examples copyright of their respective authors Some technologies and languages are trademarked Permission to copy descriptions is granted as long as authorship credit is preserved. Comments on this dictionary, corrections and suggestions, are all welcome. Please use email, the address is ziring@homecom [Ziring MicroWeb Home] [Dictionary

Start] [Sign Guestbook] Dictionary and script maintained by Neal Ziring, last major modifications 3/18/98. Most recent additions to dictionary and master list, 1/00