VC知识库BLOG-七猫的藏经阁-计算机语言列表，看看你知道哪些，下次可以在简历上加些你“精通”的种类

HyperNews Home
Using HyperNews (Instructions)

HYPERNEWS COMPUTER LANGUAGE LIST v1.4 These definitions have been culled from existing programming language sources, the language designer's web pages, books, articles and language critiques. They are by no means meant to be the definitive language definitions, but rather quick and painless definitions and links to available language web sites and newsgroups. My sources are listed in Parts 3 & 5. Special Thanks to Dr John Stockton. Corrections, omissions, and any feedback is encouraged and appreciated. Please support Open Source. Eric Lebherz March 26, 2002 EricLebherz@yahoo.com CONTENTS Part 1 - Definitions of Computer Language Families Part 2 - Definitions of Computer Languages Part 3 - Links to Essential Computer Language Web Sites Part 4 - Links to Computer Language Software Part 5 - Sammet's 26 Most Significant Programming Languages, By Year Part 6 - Bibliography Part 7 - Abbreviations PART 1 DEFINITIONS OF COMPUTER LANGUAGE FAMILIES APPLICATIVE LANGUAGES- operates by application of functions to values. A functional language in the broad sense. ASSEMBLY LANGUAGES- a symbolic representation of the machine language of a specific computer. CONCURRENT LANGUAGES- describes programs that may be executed in parallel. this may be either: multiprogramming, sharing one processor, multiprocessing- separate processors sharing one memory distributed. CONSTRAINT LANGUAGES- languages in which a problem is specified and solved by a series of constraining relationships. DATAFLOW LANGUAGE- language suitable for use on a dataflow architecture. Necessary properties include freedom from side effects, and the equivalence of scheduling constraints with data dependencies. Examples: Val, Id, SISAL, Lucid. DECLARATIVE LANGUAGES- operates by making desriptive statements about data and relations between data. The algorithm is hidden in the semantics of the language. This category encompasses both Applicative and Logic languages. Examples of declarative features are set comprehensions and pattern-matching statements. DEFINITIONAL LANGUAGES- an applicative language containing assignments interpreted as definitions. FUNCTIONAL LANGUAGES- in the narrow sense, operates on higher-order functions, building operators that manipulate functions directly without ever appearing to manipulate the data. IMPERATIVE LANGUAGES- operates by a sequence of commands that change the value of data elements. Typified by assignments and iteration. INTERMEDIATE LANGUAGE- a language used as an intermediate stage of compilation. May be text or binary. LOGIC LANGUAGES- deals with predicates or relationships. Logic languages try alternatives for each goal in succession, backtracking in a search for a common solution. METALANGUAGE-a language used for the formal description of another language. PROCEDURAL LANGUAGES- which states how to compute the result of a given problem.Each statement in the language tells the computer to do something.A procedural program is "a list of instructions". Encompasses both imperative and functional languages. QUERY LANGUAGES- an interface to a database. SINGLE ASSIGNMENT LANGUAGE- an applicative language using assignments with the convention that the variable may appear on the left side of an assignment only once within the portion of the program in which it is active. SPECIFICATION LANGUAGES- a formalism for expressing a hardware or software design. PART 2 DEFINITIONS OF COMPUTER LANGUAGES A#- OO and functional, a separate component of Version 2 of the Axiom computer algebra system. Both types and functions are first class values. Designed for compilation to efficient machine code. ABC-for personal computing, originally intended as a replacement for BASIC.ABC is easy to learn (an hour or so for someone who has programmed before) and is easy to use. Originally intended as a language for beginners, it has evolved into a powerful tool for beginners and expert alike. http://www.cni.nl/~steven/abc ABEL- (Advanced Boolean Equation Language) allows you to enter behavior-like desriptions of a logic circuit. Developed by Data I/O Corp. for programmable logic devices. Other hardware desription languages include: VHDL and VERLOG, but ABEL is simpler. ABEL can be used to describe the behavior of a system in a variety of forms including logic equations, truth tables, and state diagrams using C-like statements. The ABEL compiler allows designs to be simulated and implemented into PLD's such as PAL's, CPLD's, and FPGA's. http://www.ee.upenn.edu/ra/software/abel/abel.primer.h ABCL- a family of languages developed by Akinori Yonezauwa and his lab, for OO concurrent programming. These languages are based on LISP or SCHEME core with primitives for OO concurrency. The language was further extended to use computational reflection to manage distributed computing and other language extensions in a way that is as seamless as possible to the user. ACCENT- a very high-level interpreted language from Caseware, Inc with strings and tables. It is strongly typed and has remote function calls.Interpreter ACTOR- OOL for MS Windows. PASCAL-like syntax. Uses a token-threaded interpreter. Early binding is an option. Written by Charles Duff of the Whitewater Group. ca 1986. ACTOR- OOL for MS Windows. PASCAL/C-like syntax. Uses a token-threaded interpreter. Early binding is an option. Written by Charles Duff of the Whitegroup, 1986. ADA- powerful, general-purpose language with built-in conccurrency, exception handling, generic templates, distributed execution, standard and de facto interfaces to other languages and libraries. ADA compiles to just about any OS out there. Strongly influenced by PASCAL, and at one time mandatory for Dept. of Defense software projects at the Pentagon. ADA is a large, complex block-structured language aimed primarily at embedded computer applications. It has facilities for real-time response, concurrency, hardware access, and reliable run-time handling. So much for the pros. Now the cons: it was designed by committee, its crockish, difficult to use, and overall a disastrous, multi-billion dollar boondoggle. Hackers find ADA's exception handling and interprocess communications features particularly hilarious. The kindest thing that can be said, is that there is probably a good small language screaming to get out of it's elephantine bulk. http://home.hiway.net/~crispen/ada comp.lang.ADA ADL-(Assertion Definition Language) is a formal grammar for descibing the behavior of interfaces. This very general concept can be applied to any interface for which the behavior can be described. ADL is a very large C++ compilation, and as such, requires a robust C++ compilation system in order to be built. ADL's development team has had great success with GNU's GCC compiler. Developed by X/Open company Ltd and the Suntest Division of Sun Microsystems Laboratories working closely with MIT's Information Technology Promotion Agency in the research area of Automated Test Technology. http://adl.opengroup.org AGORA- is a prototype-based language solely based on message passing, developed at the Programming Tech Lab of Brussels Free University, Dept. of Computer Science. It incorporates features like method based inheritance, reflection and encapsulated inheritance of objects, and has a clean formal foundation. AKL- (Agents Kernel Language) concurrent, constraint programming language. Computation is performed by agents interacting through stores of constraints. This notation accommodates multiple programming paradigms; in appropriate contexts, AKL agents may be thought of as processes, objects, functions, relations, and constraints. Developed at the Swedish Institute of Computer Science. ALEF- concurrent language for systems programming. It has a C-like syntax, but a different type system. Exception handling, process management and sychronization primitives, both shared variables and message passing. A windows system, user interface, OS network, newsreader, and a mailer. ALEPH- combines the functional programming technology with the OO paradigm, designed to be compatable with C++ run-time operations. Implementation is a multi-threaded interpreter with an automatic protection engine for shared objects. ALEPH is a powerful engine associated with a rich library. The interpreter is completely written in state-of-the-art C++. It has a rich set of features providing run-time compatability with C++. The engines runs on both 32 bit and 64 bit platforms. It is designed to be portable across platforms. http://www.aleph-lang.org ALF- a language which combines functional and logic programming techniques. The foundation of ALF is Horn logic with equality which consists of predicates and Horn clauses for logic programming, and functions and equations for functional programming. The operational semantics of ALF is based on the resolution rule to solve literals and narrowing to evaluate functional expressions. The ALF system is an efficient implementation of the combination of resolution, narrowing, rewriting, and rejection. Similar to PROLOG, ALF uses a backtracking strategy corresponding to a depth-first search in the derivination tree. Therefore this operational semantics is more efficient than PROLOG's resolution strategy. ALGOL- the youngest, and probably most influential of the three big, classic languages, the other two being LISP and FORTRAN. The language is suitable for expressing a large class of numerical processor in a form sufficiently concise for direct automatic translation into the language of programmed automatic computers. The algorithmic language has three different kinds of representations- reference, hardware, and publication, and the development described is in terms of the language are represented by a given set of symbols and it is only in the choice of symbols that the other two representations may differ. Structure and content must be the same for all representations. http://www.masswerk.at/algol60/report.htm ALGOL 60- a portable language for scientific computations. ALGOL 60 is small and elegant. It is block-structured, nested, recursive, and free-form. It was also the first language to be described in BNF (Backus-Naur Form). There are three lexical representations: hardware, reference, and publication. The only structured data types are arrays, but they are permitted to have lower bounds and could be dynamic. It also has conditional expressions, it introduced =, if, then, else ; very general "for' loops, switch declaration. Parameters are call-by-name and call-by-value. It has static local "own" variables. It lacks user-defined types, character manipulation and standard I/O. Other ALGOL's are: ALGOL 68, ALGOL 68C, ALGOL 68R, ALGOL c, ALGOL W, ALGOL X, ALGOL Y, ALGOL 58, ABC ALGOL. ALLOY- is a higher-level programming language appropriate for programming massively parallel computing systems. It is based on a combination of ideas from functional, OO, and logic languages. AMBER- a functional language which adds CSP (Communicating Sequential Processes) like concurrency, multiple inheritance and pesistence to ML and generalizes it's type system. It is similar to Galileo. Programs must be written in two type faces, roman and italics. It has both static types and dynamic types. AMIGA E- is a powerful and flexible OO/procedural/unpure functional higher language, mainly influenced by languages such as C++, LISP, ADA. E is a very fast compiler with speeds of >20,000 lines a minute on a 7 mhz Amiga. It has a inline assembler and linker integrated into compiler, a large set of integrated functions, great module concept with includes as modules, flexible type system, quoted expressions, immediate and typed lists, parametric and inclusion polymorphism, exception handling, inheritance, data-hiding, methods, multiple return values, default arguments, register allocation, fast memory management, unification, LISP-cells, GUI-toolkit, (macro) preprocessor, very intuitive and powerful source-level debugger, and easy library linking. AML- (Anil's Machine Language) implements a simple, virtual register machine in C++, to make a portable, powerful, efficient way to solve math problems. Its use is not strictly limited to math, but that is its main use so far. Syntax is far easier than normal machine languages as the instruction set is easy to learn and understand. http://www.cris.com/~adhawan Ampere-"Pascal-like, but the typing was extended to confer dimensions (mass, length, time, current) on variables, to check that the operands of addition-type operators, and the sides of assignments, matched, and the procedure parameters were dimensionally correct", Dr John Stockton. http://www.merlyn.demon.co.uk/othrlang.htm AMPL- a comprehensive and powerful algebraic modeling language for linear and non-linear optimization problems, in discrete or continuous variables. Developed at Bell Labs, AMPL lets you use common notation and familiar concepts to formulate optimization models and examine solutions, while the computer manages communication with an appropriate solver. It's flexibility and convenience render it ideal for rapid prototyping and model development while it's speed and control options make it especially efficient choice for repeated production runs. appall (Array Processing Language) language best known for it's use of non-exact symbols, including a few Greek letters. All operations are either dyadic infix or monadic prefix. It's a general purpose language distinguished by it's simple and consistent rule, a large set of built-in capabilities, powerful facilities for defining new operations, and a general and systemic treatment of arrays. http://www.acm.org/sigapl/white.htm comp.lang.APL AVAIL- multi-polymorphic modular language with highly flexible syntax. Unique inheritance model allows multiple inheritance, multiple polymorphism, constrained genericity, and covariant attributes via immutability. due to identityless nature of types, a type can have an infinite number of supertypes and subtypes. Developed by Mark van Gulik, in cooperation with Ghoulsoft Incorporated. Currently in early experimental stage and intended for mission-critical use. Currently provided as Open Source (all source code available). AWK- named after it's three inventors: Alfred V. Aho, Brian W. Kernighan, and Peter J. Weinberger. Designed to search, match patterns, and to perform action on files. Scans lines one at a time for matches and patterns specified. Thus, an AWK program consists of a number of patterns and associated actions. http://www.crossmyt/hc/htmlchek/awk-perl.html comp.lang.AWK B- language intended for recursive, primarily non-numeric applications, typified by system programming. A systems language written for UNIX on the PDP-11. Derived from BCPL, and very similar except for syntax. B was the predecessor of C. Used as the systems language on Honeywells GCOS-3 BABEL- 1) a functional logic language whose operational semantics is based on lazy narrowing and provides some higher order features. 2) a subset of ALGOL 60 with many ALGOL W extensions. 3) higher-order functional plus first-order logic language. BASIC- language originally designed for Dartmouth's experimental timesharing system in the early 1960's. A novice can write short BASIC programs (10-12 lines) very easily, writing anything longer a) is very painful, and b) encourages bad habits that will make it harder to use more powerful languages well. Dijkstra observed in "selected Writings on Computing", "It is practically impossible to teach good programming style to students that have had prior exposure to BASIC: as potential programmers they are mentally mutilated beyond all hope of regeneration". And whereas every programming language has flaws, BASIC's are deep and many. And as another great programmer once said,"This is what happens when a language designed as an educational toy is taken to seriously". http://fn2.frrenet.edmonton.ab.ca/~voxel/ comp.lang.BASIC BAWK- GNU implementation of a superset of POSIX AWK, a pattern scanning and data manipulation language. BeBOP- combines sequential and parallel logic programming, OO, and meta-levels. Both "don't know" non-determinism and stream parallelism. PROLOG theories are first-order entities and may be updated or passed as messages. Implemented by translation to NU-PROLOG and PNU-PROLOG. BEFUNGE- was created in 1993 by Chris Pressey for the purpose of being original, entertaining, and hard to compile. In most languages, control flow is restricted to one direction and one dimension only; any instruction which does not perform an explicit jump actually performs an implicit jump to the next instruction. BEFUNGE however, allows execution to proceed in less restricted fashion; the program is stored in a two-dimensional grid and control can flow left or right, or up and down. this multi-dimensional nature makes programming in BEFUNGE an extremely "visual" (or maybe spatial) activity. http://www.catseye.mb.ca/esoteric/befunge/index.html BETA- a modern OOL with comprehensive facilities for procedural and functional programming. BETA has powerful abstraction mechanisms that provide excellent support for design and implementation, including data definition for persistent data. The abstraction mechanisms include support for identification of objects, classification, and composition. Abstract mechanisms include class, procedure, function, co-routine, process, exception, and many more, all unified into the ultimate abstraction mechanism: the pattern. In addition to the pattern, BETA has sub-pattern, virtual pattern, and pattern variable. BETA does not only allow for passive objects as in SMALLTALK, C++, and EIFFEL. BETA objects may also act as co-routines, making it possible to model alternating sequential processes and quasi-parallel processes. BETA coroutines may also be executed concurrently with supported facilities for synchonization and communication, including monitors and rendezvous communication. Originates from the Scandanavian School of OOL, where the first OOL- SIMULA was developed by the Norwegian Computing Center, Oslo, in the 1960's. Simula was invented for writing simulation programs and later was used as a basis for defining a general-purpose language. Beta development process started in 1975, with the aim to develop concepts, constructs, and tools for programming. The team consisted of Bent B. Kristensen, Birger Molle-Pederson, Ole Lehrman Madsen, and Kristen Nygaard. http://www.daimi.au.dk/~beta comp.lang.BETA BEGL (Back-End generator Language) A code generator description language. The input language for the back-end generator BEG. ftp://iraun1.ira.uka.de/pub/programming/cocktail BERTRAND -named after British mathematician Bertrand Russell (1872-1970). rule-based specification language based on augmented term rewriting. Used to implement constraint languages. The user must explicitly specify the tree-search and the constraint propagation. http://nexus.yorku.ca/pub/scheme/scm/bevan.shar BIGWIG- is a high-level language for developing interactive web services. Complete specifications are compiled into a conglomerate of low-level technologies such as HTML, CGI scripts, Javascripts, HTTP authentication, and JAVA scripts. http://www.brics.dk/bigwig BISTRO- new programming language that intergrates the best features of SMALLTALK and JAVA. BISTRO is a variation of SMALLTALK that runs on the JAVA Virtual Machine that conforms to Sun's JAVA Specifications. BISTRO perserves much of the simplicity, expressivness and readability of SMALLTALK. Apart from a few minor differences in puncuation, the method syntax of BISTRO is almost identical to that of SMALLTALK. Like SMALLTALK, BISTRO offers software developers the ability to build software models with a syntax that approaches the expressiveness and readability of natural language. http://bistro.sourceforge.net BLISS (Basic language for Implemention of System Software) an expression language. It is block-structured and typeless with exception handling facilities, co-routines, a macro system, and a highly optimizing compiler. It was one of the first non-assembly languages for OS implementation. It gained fame for it's lack of a goto and also lacks implicit de-referencing; all symbols stand for addresses, not values. CMU BLISS 10 for the PDP10, CMU B LISS 11 and DEC BLISS 32 for the VAX/VMS. BLUE-OOPL aimed at first year students and beginners. The system addresses the problem of dealing with the complexity of the concepts associated with OOL's. Blue is a programming environment and language. It is very clean, small, and simple OOL. Blue provides error-checking and reporting that is better than that provided by other systems. It's environment allows the interactive manipulation of classes and their relationship to each other graphically or textually. Objects of any class in the project can be created interactively. In addition, users can interactively call any method of any object. The class design of the current project is visible on the screen. It encourages student's to consciously think about design, urging students to introduce classes and their relationships before small-scale code is written. The environment includes an integrated edition, a compiler, debugger, class browser, and an online help system. BLUE is designed so that the concepts are directly transferable to other OOL, such as C++, JAVA, EIFFEL, SMALLTALK. BLUE cannot be a goal in itself. It is not, and never should be, used in real-world industrial projects. http://www.cs.ut.ee/~igorko/pl_blue.html BRIAN-Open Source, high-level, pure OOL, prototype based, scripting language; SMALLTALK like syntax; some features borrowed from SCHEME, SELF, and JAVASCRIPT. http://brain.sourceforge.net BRILLIANT- one of the five pedagogical languages based on Markov algorithms, used in " Non-Pariel, a Machine Level Machine Independent Language for the Study of Semantics", B. Higman, U. of London, 1968. BSL- (Backtracking Specification Language) a logic programming language fundamentally different from PROLOG. A non-deterministic ALGOL-like language where variables cannot be assigned more than once except in controlled contexts. Each BSL program corresponds to an assertion in first order logic and, and executing the program amounts to proving the assertion. Used to write an expert system CHORAL for harmonization of Bach-style chorales. C- created by Brian W.Kernighan and Dennis Ritchie during the 1970's, and immediately used to re-implement UNIX on the PDP-11. Briefly named NB. Influenced by BCPL. Often described with a mixture of fondness and disdain,"A language that combines all the elegance and power of assembly language with all the readability and maintainability of assembly language", The New Hackers Dictionary. 90 % or more of errors made by experienced programmers are memory management faults. http://www.prineas.com/links/C/index.html http://prineas.com/Links/C/index.html comp.lang.C C++ - OOL. Derivative of C, "with classes".Inheritance, polymorphism, encapsulation, data hiding, reusability, etc, are all aspects of C++ and OOL. Very powerful and fast, but considered hard to learn. Developed by Bjarne Stroustrup, who desribes C++ as "a general-purpose programming language with a bias towards system programming that is better than C; supports data abstraction, OOP, and generic programming". He also said,"within C++, there is a smaller cleaner language struggling to get out". "Main problem with C/C++ is that the programmer is required to do their own memory management (to declare variables, explicitly manage pointer-chained lists, dimension buffers and detect or prevent buffer overruns, to allocate and deallocate dynamic storage" Eric S. Raymond. Great for software development with support by Borland Builder (and their free compiler 5.5, and debugger), Microsoft SDK Visual C++, and the free ,amazing DJGPP system. http://www.reality.sgi.com/austern-mti/std-c++/faq.html comp.lang.C++ C#(sharp)- web-enabled language from microsoft. OO, programmer friendly capabilities make it vastly easier to learn and use than older languages like C/C++, especially for developing web applications. Developed by Anders Hejlsberg who desribed C# as,"a simple, modern, OO, and type-safe language derived from C and C++ http://www.c-sharpcorner.com C*- superset of C; OO, data-parallel with synchronous semantics, for the connection machine. Adds a data type, the "domain" and a selection statement for parallel execution in domains. C(GNU-C)- many extensions: compound statements within an expression, pointers to labels, local labels, nested functions, typeof operator, compound and conditional expressions and casts allowed as values, long integers, arrays of variable length, macros with variable number of arguments, nonconstant initializers, constructor expressions, labeled elements in initializers, case ranges. "Using and Porting GNU CC", R.M. Stallman, DEC. 1992 CECIL- combines multi-methods with a simple classless object model, a kind of dynamic inheritance, modules, and optional static type checking. An OOL intended to support rapid construction of high-quality, extensible software. Instance variables are accessed solely through messages, allowing instance variables to be replaced or overridden by methods and vice-versa. CECIL's predicate object mechanism allows an object to be classified automatically based on it's run-time(mutable) state. It's static type system distinguishes between sub-typing and code inheritance, but CECIL enables these two to be described with a single set of declarations, streamlining the common case where the two graphs are parallel. The design goal is to maximize the programmers ability to develop software quickly and to re-use and modify existing software quickly. So, all data are objects and objects are manipulated solely by passing messages. A pure object model ensures that the power of OOP is uniformly available for all data and all parts of a program. The CECIL/Vortex system is very slow with a massive resource hunger. 128K of code compiled from scratch requires approx. 96-128mb of main memory and several hours of CPU time. A small program takes "only" 20mb of main memory, and 1-2 min of CPU time. http://www.cs.washington.edu/research/projects/cecilHome.html CHARITY- is functional in style, that is, programmers familiar with declarative paradigms should find CHARITY easy to grasp. It is based on the theory of strong categorical datatypes. These are divided into two subclasses: the inductive datatypes (built by constructors in the familiar way) and the coinductive datatypes (broken down by destructors).Programs over these datatypes are expressed by folds (catamorphism) and by unfolds (anamorphism), respectively. http://www.cpsc.ucalgary.ca/projects/charity/home.html CHEETAH- "one of the easiest and fastest programming languages ever". You can make awesome programs in two lines of code. you can make video games, webpages, etc. http://www.wattsware.com CHiLL- (CCiTT High-Level Language) is a general procedural language which is mainly used in the field of communications. As a general programming language it is by no means limited to that field. There is also an OO CHiLL with class extensions, methods, inheritance, and polymorphism. http://www.informatik.uni-jena.de/languages/chill/chill.htm CILK- is a language for multi-threading parallel programs based on ANSI C. Cilk is designed for general-purpose programming, but it is especially effective for exploiting dynamic highly asynchronous parallelism, which can be difficult to write in data-parallel or message-passing style. http://supertech.lcs.mit.edu/cilk/ CLAIRE- is a high-level functional and OOL with advanced rule processing capabilities. It is intended to allow the programmer to express complex algorithms with fewer lines and in an elegant readable form. Parametric classes and methods, OO logic with set extensions, dynamic versioning that supports easy exploration of search spaces, very rich type system including type intervals and second-order types (with dual static/dynamic typing). Set-based with an intuitive syntax, simple OOP, truly polymorphic and parametric programming, powerful yet readable extensions of DATALOG to express logic conditions. Has a complete system with compiler, interpreter, tools- tracer, debugger, and object inspector. CLARITY- functional schematic language and provides an environment that allows a programmer to draw a program as a set of directed graphs. CLEAN- pure and lazy functional language based on the concept of mathematical functions. A CLEAN function is referential transparent: the result of the function only depends on the value of the function arguments and on nothing else. This has important consequences: once a function is working, it will always work. A function will always react in the same way, regardless when and in which context the function is used. One can reason about CLEAN functions and the program as a whole by using traditional mathematical reasoning, uniform substitution and mathematical induction. Has a modular, sophisticated I/oh library. Although CLEAN does not have assignment, objects can be updated destructivily. It's the only functional language in the world which has it's own type system, uniqueness typing: enabling updating of functional arguments destructively! Although lazy by default, it can easyieasilyly turn into a strict language to obtain optimal time/space behavior. Software Technology Research Group introduced (among other things) term graph writing, lazy copying, abstract reduction and uniqueness typing. http://www.cs.kun.nl/~clean CONCURRENT CLEAN- version for loosely coupled parallel architectures. Lazy, purely functional, strongly typed, modules, functional I/O library. CLIPS- (C Language Integrated Production System) a language for developing expert systems, with the inferencing and representation capabilities of OPS5, and support for three paradigms: forward chain rule-based, OO, and procedural LISP-like syntax. Available for MS-DOS, comes with source code in C. CLOS- (Common Lisp Object System) is ideal for projects that are complex or need rapid prototyping and delivery. OO extension to COMMON LISP, based on generic functions, multiple inheritance, declarative method combination and a meta-object protocol. A descendant of COMMON LOOPS and based on Symbolics FLAVORS and Xerox LOOPS among others. CLU- OOL in the PASCAL family and designed data abstraction, similar to ALPHARD. Introduced the iterator: a co-routine yielding the elements of a data object to be used as a sequence of values in a 'for' loop. A CLU program consists of separately compilable procedures, clusters and iterators, no nesting. A cluster is a module naming an abstract type and it's operation, it's internal representation and implementation. Clusters and iterators may be generic. http://www.pmg.lcs.mit.edu/CLU.html comp.lang.CLU COBOL- (Common Business Oriented Language) a weak, verbose, and flabby language used to do boring mindless things on dinosaur mainframes. It's name is seldom uttered without expressions of disgust or horror. Dijkstra observed, "the use of COBOL cripples the mind; it's teaching therefore should be regarded as a criminal offense". No self-respecting hacker would ever admit to knowing this language. http://www.infogoal.com/cbd/cdbhome.htm comp.lang,cobol OO COBOL- includes the following abilities: to define classes comprising object definitions and object functions, to define data encapsulation inside class objects, to define methods for class objects, to use inheritance and define subclasses, to define data items able to hold references to objects, to invoke methods on objects, to create and manage objects as required, and to use objects as a normal part of COBOL programming in developing new programs and maintaining existing programs. The concept of conformance in OO COBOL resembles that in EMERALD language. COLD FUSION- programming environment that uses a tag-based server scripting language: CFML (Cold Fusion Markup Language), which clearly integrates HTML with XML. Applications that you develop can be run on any end-user platform. The application will have scalable deployment, ensuring high performance on even the most demanding websites. Remote administration tools make management of websites straightforward. Also includes advanced database connectivity, including support for ODBC, OLE, DB, and native database drivers for Oracle and Sybase. A full array of internet protocols, ranging from e-mail to ftp, are tightly integrated into the programming environment, making them easy to incorporate in applications you develop. Also includes thorough security features for all phases of software development and implementation. COMAL- (Common Algorithmic Language) originally intended as a language for beginners. It is similar to BASIC, with PASCAL-like structures. COMMON LISP- huge language. Because of LISP's flexible class system and dynamic typing, configuring robust systems are easy. If new data types are added, classes and methods already compiled usually don't have to be reconciled in order to interact properly. Ideal for large systems that evolve over time. According to Kennersley,"it is in most respects, the most powerful and well-thoughtout OOL today". Excels at dealing with partially specified problems whose essential nature is not fully known at the outset. It has been supporting the world's most complex applications since 1958, and it has grown alot since then. The White House Electronic Publication System is written in LISP, and so is Yahoo's web browser editor. It is also used in applications involving financial and investment analysis, tracking stock market trends, airline scheduling, space exploration, process planning and scheduling, robotics, chemistry, medicine, and physics. Some companies consider LISP technology so valuable that they keep their use of it under wraps. http://www.alu.org/table/contents.htm COOL-1) (Concurrent Object Oriented Language) an extension of C++ with task level parallelism for shared-memory multi-processors. 2)CLIPS Object oriented Language. COMPONENT PASCAL- (OBERON 2) OBERON is the name of a language and an operating environment created by the Institute for Computing Systems, Zurich. Originally designed for computer science education by it's implementers Professor Nikalaus Wirth and J Gutknecht in 1986. COMPONENT PASCAL is a superset of OBERON 2. Compared to OBERON 2, it provides several classifications and improvements. The language revision was driven by the experience with the Black Box Component Framework, and their desire to further improve support for the specification, documentation, development, maintenance, and refactoring of component framework. http://www.plasrc.qut.edu.au/Componentpascal CORAL- 1) Class Oriented Ring Associated Language. Graphical display and systems programming on the TX-2. Used rings (circular lists) from the sketchpad. 2) University of Wisconsin at Madison, for deductive database. PROLOG-like syntax with SQL-like extensions. Many evaluation techniques are supported. Implemented in C++. 3) Royal Signals and Radar Establishment, Malvern, U.K.,real-time system programming language, a derivative of JOVIAL and ALGOL 60. Strongly associated with MASCOT, a design technique for real-time systems. Adopted as the British military standard from 1970 until the arrival of ADA versions. COQ- a higher-order proof system based on the Curny-Howard isomorphism between propositions and types, proofs and terms in a pure functional language. By restraining to constructive logic (i.e. no built-in choice axiom) it allows to extract actual programs from proofs. But, it is not reflective, and there's no way to meta-translate expressions. CORBA- (Common Object Request Broker Architecture), an architecture that enables pieces of programs, called objects, to communicate with one another regardless of what programming language they were written in or what OS they are running on. Developed by an industry consortium known as the Object management Group (OMG). There are several implementations of CORBA, the most widely used being IBM's SOM (System Object Model) and DSOM (Distributed System Object Model). CORBA has been (among many other implementations) been embraced by Netscape as part of it's Netscape One (Open Network Environment) platform. COSY- COSY Infinity is an arbitrary order beam dynamic simulation and analysis code. It allows the study of lattices, spectographs, beamlines, electron microscopes, and many other devices. It can determine high-order maps of combinations of particle-optical elements of arbitrary field configurations. The elements can either be based on a large library of existing elements with realistic field configurations including fringe fields, or described in detail by measured data. Two methods of obtaining information on how to use COSY: the COSY manual, and the lecture. The lecture is audio, and is downloaded as such, with lecture notes. The COSY Infinity Reference Manual was written by M.Berz in 1998, Michigan State U. CWEB- an ANSI C implementation of the Web Literate programming language. version 3.1 by Levy, Knuth, and Marc van Leeuwen is written in and outputs ANSI C and C++. ftp://ftp.cwi.nl/pub/cweb DAD- (Declarative ADA Dialect) to aid rapid prototyping of ADA programs. Adds many features including manipulation of first-order functions, lazy evaluation, and streams. Implemented as a preprocessor to ADA. DARK BASIC- is a language that allows you to write games with the speed and power of Direct X + Direct 3D. Friendly interface provides beginners with the best opportunity to learn to program. http://www.darkbasic.co.uk DELPHI- combines visual, component-based design with an optimizing native code compiler and scalable database access. Grandson of PASCAL and both were developed by Professor Nikalaus Wirth. Lots of support. Borland compiler, debugger http://www.borland.com/delphi DEMETER- adaptive OOP is viewed as a major advance in software technology based on using well known finite automata and formal language theory to express succinctly and process efficiently paths sets in architectural graphs (e.g. UML class diagrams). It allows you to make your software both simpler and more reusable by exploiting regularities which exist in most OO programs. It reduces software development and maintenance costs significantly. The more collaborating objects you use in a project, the larger the reduction. http://www.ccs.neu.edu/demeter/book/book-dow DIALECT- procedural language inspired by BASIC; supports pre-compilation of code, exceptions, regular expressions. Cross platform code, capacity to pre-compile code for rapid execution, IDE with debugger works on desktops and handheld PC's. Support for sockets, files, GUI elements, printing. Exception handling mechanisms, regular expressions. http://www.aristar.com/DeveloperTools.html DRAGOON- a distributed, concurrent, OO ADA-based language developed in the Esprit DRAGOON Project by Colin Atkinson at the Imperial College in 1989. DRAGOON supports OOP for embeddable systems and is presently implemented as an ADA preprocessor. DYLAN- (Dynamic Languages) general-purpose, high-level programming language. includes garbage collection, type-safety, error recovery, a module system, and a programmers control of run-time extensibility of programs. Invented by Apple Computer. Uses one construct for simple purposes through multi-method dispatch. DYLAN is dynamic, anything that is not flagged constant can be changed at run-time. It's common for a DYLAN class to start off using generic (weak) types, and to later refine the types to be specialized (strong). Functions can have both positional and keyword arguments. Compiles like C++, compiler optimizes out much of the object-dispatch and dynamic overhead that plagued SMALLTALK. DYLAN classes are simple compared to JAVA or C++. Each class contains some number of slots, which hold objects. DYLAN's objects are alot like SMALLTALK's: both have languages with "objects all the way down", even a simple number is an instance of a class. Doesn't enforce information hiding by class like JAVA or C++, it enforces it by module. Modules can import, export, and re-export names, and imported names can be mapped to different names to avoid names clashes. Supports multiple inheritance without redundantacy, to encourage a mix-in style programming. Can descend from a base class more than once through multiple inheritance, but will still only contain one copy of the base class. In DYLAN, methods don't belong to classes, they are basically functions, organized into generic functions. Proponents claim that this makes adding functionality much easier than having to modify classes or create subclasses to add new methods. http://www.double.co.nz/dylan comp.lang.Dylan DYNACE- OO extension to C. DYNACE is a preprocessor, includes files and a library which extends the C and C++ languages with automatic garbage collection and multiple threads. It is designed to solve many problems associated with C++ while being easier to learn and containing more flexible OO facilities. DYNACE is able to add facilities previously available in languages such as SMALLTALK and CLOS without all the overhead normally associated with these environments. E - developed by Mark S. Miller. Began as end-user language and has now morphed into a secure language. Runs on top of JAVA. Very SCHEME-like under the hood. Because of this, its lost a bit of ease of use. It does illustrate some valuable concepts for distributed programming and security. E defines and implements a pure object model of secure distributed persistent computation. It has two parts: 1) Elib- defines the stuff that goes on between objects. Written in pure JAVA and is currently being used commercially from JAVA. In this form, it simply makes the E object model available to JAVA programmers. 2) E language- can be used to express what happens within as object. Is very simple. Object granularity security. http://www.erights.org ECLIPSE- combines SEPIA's extended PROLOG technology with MEGALOG's persistent knowledge base functionality; a substantial subset of CHIP's constraints handling facilities, several new constraints libraries, and soon or-parallelism as featured in ElipseSys. Eiffel- a sophisticated language striving for OO purity. It is an advanced OOL that emphasizes the design and construction of high-quality and reusable software. Classes with multiple and repeated inheritance, deferred classes, and clusters of classes. Objects can have both static and dynamic types. The dynamic type must be a descendant of the static (declared) type. Dynamic binding resolves clashes from the multiple inheritance. Best for assertions. Has built in support for Design by Contract. Developed by Bertrand Meyer. http://www.elj.com http://www.eiffel.com comp.lang.Eiffel EGG- an interpreter for an anonymous computer language in, "A Discipline of Computer Programming", by Edsger Dijkstra. The interpreter is written by Andrew Cooke. ELF- is a constraint language based on the LF Logical framework. It is a uniform Meta-language for specifing, implementing and providing properties of programming languages and logics. http://www.cs.cmu.edu/~fp//elf.html ELASTIC C- is a portable, high-level OO language interpreted with a C-like syntax. Dynamic typing, automatic real,very fast garbage collection; OO with meta-programming support (a la SMALLTALK). Functional programming support (SCHEME-like closures with lexical scoping; heirarchial namespaces, many useful basic types (dynamic arrays, dictionaries, symbols). Extensible with C (you can add functions, types, classes, methods, packages); embeddable in C. Small footprint makes it ideal in embeddable systems. ELASTIC C has been strongly influenced by C, SMALLTALK, SCHEME, and PYTHON and tries to merge the best characteristics of all these languages, while maintaining it's own unique personality. http://www.elasticworld.org ELLIE- OOL with fine-grained parallelism for distributed computing. Based on BETA, SMALLTALK, and others. Parallelism by unbounded RPC and 'future' objects. Synchronization by 'dynamic' interfaces. Classes, methods, blocks and objects all modeled by first-class 'Ellie objects'. Genericity, polymorphism, delegation, and inheritance. EMERALD- language and programming system providing both process and object mobility on a network of workstations. Objectives- develop and distribute an OOL and system incorporating lightweight object migration, and investigate the issues in using such languages for distributed application development, particularly the areas of reliability and availability. Developed by Norm Hutchinson. EMERALD is implemented in style similar to JAVA (and PASCAL, and SIMULA, and..). The EMERALD compiler, which is written in EMERALD, generates byte codes which are then interpreted by a relatively portable interpreter. The interpreter takes care of finding remote objects, performing remote invocations, moving objects, and doing both local and distributed garbage collection. http://www.cs.ubc.ca/nest/dsg/emerald.html ENIAC- claimed to be the first computer language. The other contestant for "first" is PLANKALKUL. Designed by J. Prosper Eckert and John Mauchly between 1943-45. EOL-1) Expression Oriented language- a low level language for strings ERLANG- a programming language specifically designed to build fault-tolerant, distributed systems which can contain large numbers of current processes. Concurrent functional language for large industrial real-time systems. Dynamically typed, pattern matching syntax, recursive equations, explicit concurrency, and asynchronous message passing. Relatively free from side effects. Transparent cross-platform distribution. Primitives for detecting run-time errors. Real-time GC modules. Dynamic code replacement (change code in running real-time systems without stopping systems). Foreign language interface. http://www.erlang.org ESCHER- declarative, general-purpose language which integrates the best features of both functional and logic programming languages. It has types and modules, higher-practicalorder and meta-programming facilities, and declarative input/output. It also has a collection of system modules, providing numerous operations on standard data types such as integers, lists, characters, strings, sets, and programs. The main design aim is to combine in a practical and comprehensive way the best ideas of existing functional and logic languages, such as G諨EL, HASKELL, and LLAMBDA PROLOG. Indeed, it goes well beyond G諨EL in it's ability to allow function definitions, it's higher-order facilities, it's improved handling definitions, it's improved handling of sets, and it's declarative I/O. It goes well beyond HASKELL in it's ability to run partly-instantiated predicate calls, a familiar feature of logic languages which provides a form of non-deterimism, and it's more flexible handling of equality. The language also has clean semantics. http://www.cs.bris.ac.uk/Tools/Reports/Abstracts/1995-ll0y EuLISP- is a modern OO dialect of LISP whose design was less minimalistic than that of SCHEME but less constrained by compatability reasons than that of COMMON LISP. In particular, it has a single namespace for variables and functions (like SCHEME, and unlike COMMON LISP) and it's type system is perfectly integrated with the object system. Futhermore, the language makes use of the module system, so that every program may import only those parts it needs. EUPHORIA- ( End User Programming Hierarchial Objects for Robust Interpreted Applications) a simple, powerful, flexible language that is easy to learn. It is not a true OOL but achieves many of the benefits in a much simpler way. Dynamic storage location. Objects of any size can be assigned to an element of a Euphoria sequence (array). A high-performance, state-of-the-art interpreter that's at least 10-30 times faster than PERL or PYTHON. Lightening fast pre-compilation. Program is checked for syntax and converted into an efficient internal form at over 35,000 lines per second (wow!) on a Pentium-150. Not subject to 64k or 640k memory limitations. You can create multi-megabyte memory of your computer, and a swap file is automatically used when a program needs more memory than exists on your computer. EUPHORIA was released after 3 years of Research and Development and 6 months of Beta testing. Many of the ideas behind EUPHORIA came from Robert Craig's Masters Thesis in Computer Science at University of Toronto. That thesis was strongly influenced by the work of John Backus on functional programming languages. Complete,royalty-free rights to distribute any programs that you develop; you can make a single, stand-alone, .exe file from your program (Euphoria is sold in two versions, a free version where you are limited to 300 lines, and the unlimited version which is $39.00. http://rapideuphoria.com FRANZ LISP- a MACLISP dialect of LISP. Developed primarily for work in symbolic algebra. Written by C.R. Fateman et al, ca 1980. FMPL- 1) (Frobozz Magic Programming Language)is a prototype based on OOL with functional features. Event driven. 2) (Formula Calculator-Interactive), for PDP-5,8's a descendant of AID/JOSS 3) (Forty-One Calculator Language)- language of the HP-41 calculator line. FORMS/3- general-purpose, declarative, form-based VPL (Visual Programming Language). It's goal is to provide computational and expressive power in a language featuring a simple, concrete programming style with immediate feedback. It follows the spreadsheet paradigm: the programmer uses direct manipulation to place cells on forms, and then defines a formula for each cell. Such a formula may include constants, references to the cells own value at a previous moment in time. Cells are referenced by clicking on them. A programs calculations are determined by these formulas. http://www.cs.orst.edu/~burnett/Forms3/forms3.html FORTH- An extensible language and an interactive development methodology. It's primary uses have been: scientific and industrial applications such as instrumentation, robotics, process control, graphics and image processing, AI, and business. Principal advantages include rapid, interactive software development and efficient use of computer hardware. Often spoken of as a language because that is it's most visible aspect. But in fact, FORTH is both more and less than a conventional language; more- all the capabilities normally associated with a large portfolio of separate programs (compilers, editors, etc.) are included within it's range and less in that it lacks (deliberately) the complex syntax characteristic of most high-level languages. http://dec.bournemouth.ac.uk/forth http://www.ultratechnology.com comp.lang.forth FORTRAN (FORmula TRANslator)- particularly good language for processing numerical data, but it does not lend itself very well to organizing large programs, the first and still most widely used. FORTRAN 1- John Backus, for IBM 704. Design begun in 1954, compiler released April 1957. FORTRAN ll- added subroutines, 1958. FORTRAN III- this was only distributed to 20 sites. FORTRAN IV- IBM 1962, this went well beyond the original definition. For the IBM 7090/94 Fortran V- preliminary work on adding character handling facilities by IBM, 1962. Name was never really used. http://www.nsc.liu.se/~boein/fortran.html http://fortran.com/fortran/F77_std/rjcnf0001.html comp.lang.forth comp.lang.forth.mac G- 1) combines functional, OO, relational, imperative, and logic programming, their motto literally is, "you name it, we got it", Oregon State, 1988. " The Multiparadigm Language G", J. Placer, Computer Languages, 1991. 2) Functional Language with Generic Abstract Data Types, P.A.G. Bailes, 1987. GEL- scripting language used in the object-oriented development environment GainMomentum. 1989. GENTLE- language for compiler writers. It supports language recognition, definition of abstract syntax trees, construction of tree walkers based on pattern matching, smart traversal, simple unparsing for source-to-source translation, and optimal code selection for microprocessors. GENTLE provides a uniform framework for all these tasks. http://www.first.grnd.de/gentle GNU E- is a persistent, OOL developed as part of the Exodus Project. It extends C++ with the notion of persistent data, program level data objects that can be transparently used across multiple executions of a program, or multiple programs, without explicit input and output operations. G諨EL- a declarative, general-purpose language in the family of logic languages. It is a strongly typed language, the type system being based on man-sorted logic with parametric polymorphism. It has a module system. It supports infinite precision integers, infinite precision rationals, and also floating-point numbers. It can solve constraints over finite domains of integers and also linear rational constraints. It supports processing of finite sets. Considerable emphasis is placed on G諨EL's meta-logical facilities which provide significant support for analysis, transformation, compilation, debugging, and verification. http://www.cs.bris.ac.uk/~bowers/g鰀el.html GREEN- is a very new language, it's official birthday was 11/98. It separates subtyping from subclassing, supports and requires garbage collection, makes classes first-class objects, has a nice introspective reflection library, and an efficient kind of meta-objects called shells. Parameterized classes (the C++ templates) and the module system are being designed. The result will be a very coherent programming language in which all parts fit nicely together with no ad-hoc patches to make a newly introduced feature work with the rest of the language. GUILE- and GOOPS (The Guile Object-Oriented Programming System) very close in spirit to CLOS, but it is adapted from the SCHEME language. GUILE is the interpreter for the SCHEME language nicely packaged as a library you can link to your programs. Your program has full access to the interpreter's data structures, so you can extend GUILE with your own primitives, datatypes, and syntax. The result is a scripting language tailored to your applications. The GOOPS extension gives the user a full OO system with multiple inheritance and generic functions with multi-method dispatch. The implementation relies on a true meta-object protocol, in the spirit of the one defined for CLOS. HASKELL- purely functional programming language. Computation proceeds by replacing expressions with their values. While all languages incorporate functions to some degree, HASKELL programs are composed solely of functions. It's based on Lambda calculus, hence the L used as a logo. The language is named for logician Haskell B. Curry, whose work provided much of the logical basis for the language. Yale has been an integral part of the development and implementation of the HASKELL language since it's inception, Yale has helped write the HASKELL Report, Wrote a tutorial, and most recently Paul Hudak has published a textbook on using HASKELL, "The Haskell School of Expression". Today, the focus of the Yale group is on putting HASKELL to work in the real world by : using HASKELL to construct a variety of DSL's (Domain-Specific Embedded Languages). The challenges include 1) the semantic underpinnings of DSL's, 2) building blocks for DSL construction, 3) Domain-specific analysis and transformation, 4)compiling DSL's,5) deploying DSL technology. http://haskell.cs.yale.edu /yale http://haskell.org HOPE- a small polymorphically-typed functional language. First language to use call-by-pattern. HOPE was originally strict, but there are versions with lazy lists, or with lazy constructors but strict functions. HPCODE- stack-based intermediate language used by Hewlett-Packard in many of it's compilers for RISC and stack-based architectures. Supports FORTRAN, ADA, PASCAL, COBOL, and C++. Descended from Stanford's U-code. HUGO- is a text adventure compiler and run-time engine written by Kent Tessman. ICI- is a language with dynamic, object-based data model with the flow control constructs and operators of C. It is designed for use in many environments, including embedded systems, as an adjunct to other programs and as a text-based interface to compiled libraries. http://www.zeta.org.au/~atm/ici/default.html ICON- is a high-level general-purpose language with a large repertoire of features for processing data structures and character strings. ICON is an imperative, procedural language with syntax reminiscent of C and PASCAL, but with semantics at a much higher level. The OO extension is Idol. The ICON system is user-friendly and a pleasure to work with, which facilitates code production. http://www.cs.arizona.edu/icon/index.html comp.lang.icon INFER- a statically-typed dialect of SCHEME. Infer combined many (but not all) of the best features of SCHEME and ML. Compared with latently-typed languages such as SCHEME, statically-typed language such as ML and Infer, sacrifice some expressive power in exchange for the ability to catch many errors at compile-time, the possibility of more efficient execution, and some system-verified program verification. By supporting all of the forms and primitives procedures of Scheme, with a Scheme-like syntax, it is hoped Infer will prove accessible to Scheme programmers. Efficient compilation of Infer into Scheme is possible, thereby providing compatibility with Scheme programming environments. ISWIM- (If You See What I Mean) is a purely functional, sugaring of Lambda calculus, and the ancestor of most applicative languages. An ISWIM program is a single expression qualified by "where" clauses (auxiliary definitions including equations among variables), conditional expressions and functional definitions. ISWIM was the first language to use lazy-evaluation and introduced the off-side rule for indentation. J- is a very high-level general-purpose language, with strong emphasis on functional programming and array processing. J was designed and developed by Ken Iverson and Roger Hui, and implemented by Iverson Software Inc.(ICI). J is distinguished by it's simple and consistent rules, a large set of built-in functions, powerful facilities for defining new operations, and a general and systematic treatment of arrays. It is ideal for complex analytical work, modeling, and RAD ( Rapid Application Development). JADE- is a rich OO software development technology purpose built for transaction-based enterprise programming, particularly the development of high volume web applications. Developed by Aoraki Corp. of Australasia. JAVA- originally called OAK. Developed by James Gosling (Sun Microsystems) who described it as,"a general purpose, concurrent, class-based OOL". Modular and fully object-oriented. From a programmer's standpoint, it is faster and easier and more elegant than other Web tongues. Stronger and cleaner than C++ and has been embraced by the hacker communities (well, part of the community anyhow). Uneven support on different Web browser platforms, performance issues, and some deficiencies of some standard toolkits (AWT in particular), are annoying disadvantages. Microsoft's determined attempts to corrupt the language (which it rightly sees as a threat) have not helped. Still, irregardless of MS, JAVA is extremely portable by way of it's VM (Virtual Machine), although relatively slow, (MS's VM is faster), which interprets the bytecode in a JAVA program and translates it for use on most any given Operating System. This "write once, run anywhere" philosophy is understandably attractive to many software developers. The VM also insulates JAVA programs from the host environments (and vice-versa) providing a secure implementation which is not available with Microsoft's Active X technology. It has taken on a quasi-religious enthusiasm in some circles, as have many computer languages- The Powerhouse Java Church of the Almighty Bytecode of the Holy Boast. (90% wink). http://java.sun.com http://javalobby.org comp.lang.java comp.lang.java.advocacy JAVA BEANS- provides portability, ease-of-use, and functionality, making it an ideal vehicle for adding interactivity to Internet and Intranet applications. Software components are designed and built so that they can be accessed and used in a variety of different development and run-time scenarios. JAVA BEANS component software technology is based on JAVA and provides a means of creating and using JAVA classes as software components. Abilities include: property management, introspection, event handling, persistence, and Application Builder support. comp.lang.java.beans JAVASCRIPT- a scripting language developed by Netscape to enable Web authors to design interactive sites. Although it shares many of the features and structures of the full JAVA language, it was developed separately. JAVASCRIPT can interact with HTML source code, enabling Web authors to spice their sites with dynamic content. JAVASCRIPT is endorsed by a number of software companies, and it is an Open Source product that anyone can use without purchasing a license. It is supported by recent browsers from Netscape and MS; although IE supports a subset, which MS calls JSCRIPT. "Within HTML, JAVASCRIPT reigns supreme and is the default script. It has C++ and JAVA like structures and can port some of the C/C++ and JAVA code. JAVASCRIPT basically extends the HTML language, but it's scope seems confined to the browser". http://javascript.com http://javascript.internet.com JoCAML- is an experimental extension of the OBJECTIVE CAML language with the distributed join-calculus programming model. This model includes high-level communication and synchronizing channels, mobile agents, failure detection and automatic management. JOY- is a purely functional language. Whereas all other functional languages are based on the application of functions to arguments, JOY is based on the composition of functions. All such functions take stack as arguments and produce a stack as value. Consequently, much of JOY looks like ordinary pastfix notation. JUICE- is a new technology for distributing executable content across the web. It differs from JAVA in several important aspects that allow it to out-perform JAVA in many "downloadable Applets" applications. Juice is meant to be a complement to JAVA, giving users a choice of either. K- a concise language with powerful primitives and math notations, a high-performance engine, GUI, built-in memory management, interprocess communications, web-server capabilities, and connectivity features. KALEIDOSCOPE-mixes OOL which mixes imperative and constraint-oriented features. Similar to Siri. Vaguely related to Prase 2. KEVO- Proto-type based object-oriented system built around a threaded code interpreter. Semantically resembles SELF and OMEGA. Syntactically resembles FORTH. LAGOONA- Peter Frohlich http://www.ics.edu./%7Efranz/publications/J9703%20ProgLanguageLagoona.pdf LAMINA- Concurrent object-oriented language. Stanford U. 1988 LAURE- A language for knowledge representation combining object orientation and logic programming. Set operations, object-oriented exception handling and a polymorphic type system. LEDA- Multi-paradigm programming- to provide a framework in which programmers can work a variety of styles, freely intermixing constructs from different paradigms.Techniques supported by LEDA include imperative programming, OO approach, logic and functional programming. http://www.cs.orst.edu/~budd/leda.html LENS- Compact language which is an orthogonal combination of three fundamental OO concepts: late binding (through message passing), (multiple) inheritance, and encapsulation. LIANA- is a C-like, interpretive, OOL; class library, and an IDE. Aimed at Windows applications. No pointers, and no multiple inheritance. Garbage collection. "The Liana Programming Language", R. Valdes, 1993. LIFE- (Logic, Inheritance, Functions, and Equations) is an experimental language proposing to integrate three orthogonal programming paradigms proven useful for symbolic computation. From a beginners standpoint, it maybe perceived as a language taking after logic, functional,and OOPing. From a formal perspective, it maybe seen as an instance or rather, a composition of three instances) of a Constraint Logic Programming SCHEME due to Hoehfeld and Smolka refining that of Jaffer and Lassez. LIMBO- is strongly typed, provides automatic garbage collection, supports only very restricted pointers, and compiles into machine-independent byte code for execution on a virtual machine. The language is intended for applications running distributed systems on small computers. It supports modular programming, strong type checking at compile and run-time, interprocess communications over typed channels, automatic garbage collection, and simple abstract data types. It is designed for safe execution even on small machines without hardware memory protection. http://casl.csa.iisc.ernet.in/OperatingSystems/inferno/Limbo_Ref20/ comp.lang.limbo LINDA- explores a variety of research topics in parallel and distributed programming languages, groupware and information systems. Much of the work centers around the Linda programming language or ideas that have been spawned from work on the Linda system. The Linda Group, Dept. of Computer Science, Yale University. LIS- (Language Implementation System) a predecessor of ADA, influenced by Pascal data structures and SUE's control structures, A type declaration may have a low-level implementation specification. LISP- AI's mother tongue, a language based on the ideas of a) variable-length lists and trees as fundamental data types, and b) the interpretation of code as data and vice-versa. Invented by John McCarthy at MIT in the late 1950's; it is older than any other HLL still in use except Fortran. Accordingly, it has undergone considerable adaption. Modern variants are quite different in detail from the original LISP 1.5. http://www.xanalys.com/software_tools/reference/HyperSpec http://www.alu.org/table/contents.htm comp.lang.lispx LISP 2- Lisp 1.5 with an Algol 60-like surface syntax. Also optional type declarations, new data types including integer-indexed arrays and character strings, partial-word extraction/insertion operators and macros. A pattern-matching facility similar to Comit was proposed. LISP 70- a descendant of MLISP and MLISP2. Also known as PLISP and VEL. Useful for parsing. Only the pattern-matching system was published and fully implemented. According to Alan Kay, Lisp 70 had an influence on Smalltalk 72. LISP languages have always been at the forefront because they stressed better semantics over fancy syntax. LML- 1)lazy, functional, variant of ML2. Implemented on the G-machine, and used to implement the Haskell B compiler. Developed at Chalmers U. Tech, Gothenburg, Sweden. 2)logical ML that adds to Lazy ML a data type of "theories" whose objects represent logic problems. P. Denansart et al,LNCS 456,1990. LOGO- a language specifically designed for children, to teach them the concepts of computer programming in a fun and intuitive way. One of the ideas guiding it's creation was the principle "low floor, high ceiling". This means that it should be easy for the novice programmer to get started (the "low floor") writing programs and getting satisfaction doing so, but that the language should be powerful and extensive in a "sky is the limit" sort of a way (the "high ceiling). http://www.media.mit.edu/groups/logo-foundation comp.lang.logo LOOEE- a language designed for laboratories, but it can be used to program any simple calculation. If you can break an expression into simple steps involving single operators, you can program LOOEE. Developed by Scott Warner LOOKS- 1) Knowledge-Representation System for Designing Expert System in a Logical Programming Framework. 2) Language for Object-Oriented Kinematics Specifications-imperative, object-oriented language for specifying motion. LORE- 1) Object-oriented language for knowledge representation. 2)CGE, Marcousis, Frame-set-based language. LPC- interpreted, OOPL for flexible and yet efficient application development and prototyping. LUA- is a powerful, lightweight programming language designed for extending applications. Also frequently used as a general-purpose stand-alone language. LUA is a language engine that you can embed in your application. this means that, besides syntax and semantics, LUA has an API that allows the application to exchange data with Lua programs and also extend Lua with C functions. Lua is implemented as a small library of C functions, written in ANSI C, and compiles unmodified in all known platforms. The implementation goals are simplicity, efficiency, portability, and low embedding cost. The result is a fast language engine with a small footprint, making it ideal in embedded systems. Lua was designed and implemented at TeCGAF, the Computer Graphics Tech Group of PUC-Rio, Pontifical Catholic University of Rio de Janario in Brazil. http://www.tecgraf.puc-rio.br/lua/manual LUCID- developed by Bill Wadge and Ed Ashcroft, 1995. The language is very much like BASIC, Pascal, or even LISP. "The Home Wurld of Intensional Programming" http://lucy.uvic.ca LUSTRE- real-time dataflow language for synchronous systems, especially automatic control and signal processing. A Lucid subset with timing operators and user-defined clocks. "Outline of a Real-Time Dataflow Language", J.L. Bergerand, 1985. M4- is a powerful macro-expansion program designed as a preprocessor to stubborn languages. Its ugly, but its fairly standard, and available on most platforms, including a GNU version. The semantics are bad: it uses back-door evaluation in a dynamically-bound global environment as the only way to program, without anyway to safely quote text. MAGENTA- designed to be the most redundant language in existence. It has over 80 reserved words, a needlessly convoluted exception system, a threading system that looks entirely too much like a really weird function syntax, a function call syntax that happens to be a curse. In short, a perfect design-by-committee language. Developed at Boston College, March, 1995. MAGMA- is a radically new system designed to solve computationally hard problems in algebra, number theory, geometry, and combinatorics. It provides a mathematically rigorous environment for computing with algerbriac, number-theoretic, combination and geometric objects. http://www.maths.usyd.edu.au:8000/comp/magma/overview MATCHMAKER- a language for specifying and automating the generation of multilingual interprocess communication interfaces. MIG is an implementation of a subset of Matchmaker that generates C and C++ remote procedure call interfaces for interprocess communication between Mach tasks. MATLAB- is an intuitive language and a technical computing environment. It provides core math and advanced graphic tools for data, analysis, visualization, and algorithm and application development. http://www.engin.umich.edu/group/ctm http://members.nbci.com/gregersonweb/matlab MCPL- is a simple typeless language which is based on BCPL. It makes extensive use of pattern matching, somewhat related to that used in ML and Prolog, and some other features found in C. MELD- concurrent, OO, dataflow, modular and fault-tolerant. Comparable to SR. MELD C- a C based concurrent OO coordination language built on a reflective architecture. A redesign of MELD. Version 2.0 for Sun 4's and DEC stations. MENTAT- OO distributed language, an extension of C++, portable to a variety of MIMD architectures. Fundamentals are : 1) provide easy-to-use parallelism, 2) achieve high-performance via parallelism execution, 3) facilitate the executions of applications across a wide-range of platforms. The MENTAT approach exploits the OO paradigm to provide high-level abstractions that mask the complex aspects of parallel programming. Also: Real-time MENTAT- an extension of C++. MERCURY- is a new logic/functional language which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic systems, and close to conventional programming systems. http://www.cs.mu.oz.au/research/mercury MEROON- OOL written in Scheme. All objects of Scheme can be seen as Meroon objects without restrictions on inheritance. Very fast. CLOS-like generic functions. Self-description features: classes are Meroon objects and can be inspected. Portable. Named after the developer's son's Teddy Bear. MIRANDA- the aim of the Miranda system is to provide a modern functional language, embedded in an "industrial quality" environment. it is now being used at a growing number of sites for teaching functional programming and as a vehicle for the rapid prototyping of software. http://www.cs.ukc.ac.uk/pubs/1995/59 MISA- it's goal is to design a language that includes those paradigm in current languages that have been proven, and new ones that add support and, hopefully, future technologies. ML- (Meta-language) is a family of advanced languages with (usually) functional control structures, strict semantics, a strict polymorphic type system and parameterized modules. The family includes; Standard ML, Lazy ML, Caml, Caml Light, and various research languages. Implementations are available on many platforms, including PC's, mainframes, most models of workstations, multiprocessors, and supercomputers. ML has many users, is taught at many Universities (it's the first language taught at some of these). http://www.faqs.org/faqs/meta-lang-faq 2) Manipulator Language- IBM language used in handling robots. MODULA 2- is a programming notation that corrects some of the deficiencies of Pascal. It is suitable for learning programming, for large projects written and maintained in the fashion of professional software engineers, and for real-time embedded systems. http://www.arjay.bc.ca/Modula-2/m2faq.html comp.lang.Modula2 MODULA 3- is a systems programming language that descends from Mesa, Modula 2, Cedar. It resembles it's cousins: Object Pascal, Oberon, and Euclid. The goal is to be simple and safe as it can be while meeting the needs of modern system programmers. Modula 3 retains one of Modula 2's most successful features, the provision for explicit interfaces between modules. It adds objects and classes, exception handling, garbage collection, lightweight processes (or threads), and the isolation of unsafe features. Used in industrial and research projects, and for teaching. It encourages good programming practices and comes with excellent libraries for distributed programming and GUI's. Supports 25 different OS platforms. http://www.research.digital.com/SRC/modula-3/html comp.lang.modula3 MOPS- Michael Hore's robust and powerful public-domain development system for the Macintosh. With Forth and Smalltalk parentage, MOPS has extensive OOP capabilities, including multiple inheritance, and a class library supporting the Macintosh interface. MOZART- is a major platform (development) for open fault-tolerated distributed applications, constraint applications, and logic applications. It includes a full-fledged development environment with many tools and extensive documentation including tutorials. Applications developed include configuration tools, collaborative graphic editor, browser, and an extended version of ICQ. Provides state-of-the-art support in two areas: open distributed computing and constraint-based inference. Ideal platform for both general purpose distributed applications as well as for hard problems requiring sophisticated organization and inference abilities. An ideal system for self-study. Full source code available. See OZ. The successor of DFKI OZ is Mozart. Mozart improves on DFKI by offering supported for distributed programming, more constraint systems, more tools (including debugger and profiler), much better documentation, a powerful Internet-based module system based on dynamic linking. Uses Emacs as programming environment. http://www.mozart-oz.org MUMPS- (M) a pretty simple command oriented, general purpose, procedural language with a fairly powerful string handling and multi-dimensional associative arrays and a very powerful built-in database. Also used for managing data and communicating information between widely disparate units within an organization. http://www.geocities.com/SiliconValley/7041 comp.lang.mumps NAPIER 88- is a persistent programming system named after John Napier, that provides the following facilities: 1) orthogonal persistent-models of data independent of longevity, 2) type completness- no restrictions on constructing types, 3) higher-order procedures are data types, 4) parametric polymorphism- generic forms which may be specialized for use, 5) abstract (existential) data types - for sophisticated protection and viewing, 6) collections of bindings, 7) a strongly typed stable store, 8) graphic data types, 9) concurrent execution and data access using threads, semaphores, and transactions, 10) support for reflective programming- for system evolution. The Napier 88 system consists of the language and it's persistent environment. The persistent store is populated and, indeed, the system uses objects within the persistent store to support itself. http://www-ppg/dcs.st-and.ac.uk/languages/Napier88 NAWK- (New Awk) pattern scanning and processing language. An enhanced version of Awk, with dynamic regular expressions, additional built-ins and operators, and user-defined functions. NEON- an OO extension of Forth for the Mac. Inheritance, floating point, system classes and objects for Mac interfacing, overlays. Developed by Charles Duff, now sold by Kriya Systems, modified, and renamed Yerk. NESL- is a parallel language developed at Carnegie Mellon by the SCandAL Project. It integrates various ideas from the theory community (parallel algorithms), the languages community (functional) and the systems community (many of the implementations techniques). The most important new ideas are: nested data parallelism- concise code that is east to understand and debug, while being well-suited for irregular algorithms. A language based performance model- this gives a formal way to calculate the work and depth of a program. NET REXX- is a "human-oriented" language designed as an effective and simple alternative to the Java language. With NetRexx, you can create programs and applets for the Java environment faster and more easily than with Java. Using Java classes is especially easy in Netrexx, as different types of numbers and strings that Java expects are handled automatically by the language. Inspired by two very different languages, Rexx and Java, NetRexx blends the easy to learn syntax of Rexx with the robustness and portability of Java. The result is a language which is tuned for both scripting and application development, and is truly general-purpose. NEWTON- general-purpose expression language, syntatically Algol-like, with OO and functional features and a rich set of primitives for concurrency. Used for undergraduate teaching at Lausanne, Swiss Federal Institute of Technology NIAL- (Nested Interactive Array Language) a multi-paradigm language that combines aspects of both functional and procedural languages. Q'Nial is an interactive programming environment for the Nial interpreter that can be used for application development and production computing. The Nial Data Engine is an embeddable interpreter available for Windows platforms. Nial is a hybrid language combining a functional array language based on Trenchard More's mathematical treatment of nested arrays, with a procedural language with a familiar control structures. It has a rich set of language primitives that make it easy to rapidly develop loop-free data-driven algorithms. Nial and it's implementations were designed by Mike Jenkins at Queens University in Canada. O'Nial is being used for application in decision support, knowledge based systems, scientific computing and data analysis. O2- OO database language used in the Altair Project. Implemented as an interpreter."Advances in OO Database Systems", K.R. Dittrich, 1988. OAKLISP- a portable OO Scheme, syntactically a Scheme superset. Based on generic operations rather than functions. Anonymous classes. 1986. OBERON- invented by Professor Niklaus Wirth and J. Gutknecht, Professor Wirth also invented or assisted in Pascal, Modula, Delphi, and now Oberon! A modern, integrated software environment for single-user workstations. The language is, unsurprisingly, in the Pascal/Modula tradition and a highly effective and compact OS. Oberon is the successor of Pascal and Modula 2 and was designed for systems programming. It was later extended with OO features resulting in Oberon 2. Component Pascal is a superset of Oberon 2. The desire for additional support for development, documentation, and refactoring of component frameworks. Type extensions and text abstract data types. Fast compilation. Optional GUI component framework called Gadgets available with integrated WWW support. According to Oberon Microsystems,"the language revision was driven by the experience with the Black Box Component Framework, and the desire to further improve support for the specification, documentation, development, maintenance, and refactoring of component framework". http://www.oberon.ethz.ch http://ping.de/sites/edge/VisualOberon.html OBJ- a family of declarative "ultra high-level" languages. Abstract types, generic modules, subsorts (subtypes with multiple inheritance), pattern-matching modulo equations, E-strategies (user control over laziness), module expressions (for combining modules), theories and views (for describing module interface). For the massively parallel RRM (Rewrite Rule Machine). OBJECTIVE C- was designed by Brad Cox, whose primary purpose was to add the main features on Smalltalk 80 to the C language. His work led to an OOL with a complete programming environment. No operator overloading, no multiple inheritance, no class variables. Does have run-time binding. http://www.tatters.org/computers/objc OBJECTIVE CAML- developed and distributed by INRIA (Institut de National de Recherche en Infornatique et Automatique) the main French research institute for computer science. Caml is a safe language. The compiler performs many sanity checks on programs before compilation. That's why many programming errors cannot happen in Caml: data type confusion, erroneous access into compound values become impossible. In effect, all these points are carefully verified by the compiler, so that data accesses can be delegated to the compiler code generator, to ensure that data manipulated by programs may never be corrupted: the perfect integrity of data manipulated by programs is granted for free in Caml. Caml is statically type-checked, but there is no need to add type information in programs (as in Ada, Pascal, or C): type annotations are fully automatic and handled by the compiler. Predefined data types include: basic types-booleans, floating-point numbers, characters, strings. And more sophisticated data types: tuples, arrays,sets, lists, queues, stacks, hash tables, and data streams. Comes in two flavors: Caml light and Objective Caml. Caml Light is merely a subset of Objective Caml, designed for teaching and learning the art of programming. In addition to Caml Light core language, objective Caml features a powerful module system, full support to OO paradigm, and an optimizing compiler. Available for PC, Unix, and Mac. http://caml.inria.fr/ocaml/ OBJECT-ORIENTED FORTRAN 90- is a modern language that introduces many inportant new features for scientific programming. While the array-syntax notation has received the most attention, we have found that many modern software development techniques can be supported by this language, including OO concepts. While Fortran is not a full OOL, it can directly support many of the important concepts of such a language including abstract data types, encapsulation, function overloading, and classes. Other concepts such as inheritance and dynamic dispatching are not supported directly, but can be emulated. Since Fortran 90 is backwards compatable with Fortran 77, new concepts can be introduced into existing programs in a controlled manner. OBLIQ- is a lexically-scoped untyped interpreted language that supports distributed OO computation. An Obliq computation may involve multiple threads of control within an address space, multiple address spaces on a machine, heterogenous machines over a local network, and multiple networks over the internet. Obliq objects have state and are local to a site. Obliq computations can roam over the network, while maintaining network connections. Luca Cardelli, 1993. http://www.luca.demon.co.uk/obliq/Obliq.html OCCAM- a language which facilitates writing parallel programs, allowing the programmer to specify whether processes are to be executed sequentially or in parallel. Based on CSP, it was originally developed for the Transputer. Developed at the Oxford University Computing Laboratory. http://wotug.ukc.ac.uk/parallel/occam OCTAVE- GNU Octave is a high-level language, primarily intended for numerical computations. It provides a convenient command line interface for solving linear and non-linear problems numerically, and for performing other numerical experiments using a language that is mostly compatible with Matlab. Also may be used as a batch language. OLABL- extends Objective Caml with open sum types, named and operational functional arguments. OMEGA- prototype-based OOL. Developed by Gunther Blascek at the Instit fur Praktische Informatik Gruppe Software, Universitat Linz, Austria. "Type-Safe OOP with Prototypes- The Concept of Omega". ONTIC- OOL for an inference system. LISP-like appearance, but based on set theory. "Ontic: A Knowledge Representation System for Mathematics", D.A. McAllster, MIT Press, 1989. OPAL- 1) Technical University of Berlin, strongly typed, higher-order, strict application language, with Algerbriac specification. Uses parameterized structures rather than polymorphism. 2) language for compiler testing said to be used internally by DEC. 3) simulation language with provision for stochastic variables. An extension of AutoStart. 4) previous name for Smalltalk DB. 5) DSP language. http://uebb.cs.tu-berlin.de/~opal ORCA- is a language for parallel programming on distributed systems, based on the shared data-object model. This model is a simple and portable form of object-based distributed shared memory. Developed by Henri E. Bal, Free University of Amsterdam. OSCAR- 1) (Oregon State Controverial Aid to Research) interactive numerical calculations, vectors, matrices, complex arithmetic string operations, for CDC 3300. "Oscar: A User's Manual With Examples", J.A. Baughman. 2) OOL used in the COMANDOS Project, 1988 OSQL- (Object-Oriented Structured Query Language) functional language, a superset of SQL, used in Hewlett-Packard's Open ODB Database System. OZ- high-level language, combining constraint inference with concurrency. Dynamically typed and has first-class procedures, classes, objects, exceptions, and sequential threads synchronizing over a constraint store. Supports finite domain and feature constraints and has powerful primitives for programming constraint inference engines at a high level. Typical application areas of OZ include: optimization problems like scheduling, time tabling, placement and configuration, reasoning and knowledge representation, processing of natural language, simulation, multi-agent systems, and sophisticated GUIs. The successor of DFKI OZ 2.0 is Mozart. DFKI OZ 2.0 is an interactive implementation featuring incremental compiler, support for stand alone applications, an OO interface to Tcl/Tk, and unique graphic tools for constraint programming. It provides an extensive library of constraint propagators, distributors,and search engines, including special support for scheduling. Users can add their own constraint propagators through a C++ interface. It is a high-level PL that is designed for modern, advanced, concurrent, intelligent, networked, soft real-time, parallel, interactive and pro-active application. Oz provides the salient features of OOP, including state, abstract data types, objects, classes, and inheritance. It also features the salient features of functional programming including compositional syntax, first-class procedures/functions, and lexical scoping, and also provides the salient features of logic and constraint programming including logic, variables, constraints, disjunction constructs, and programmable search mechanisms. Performance is competitive with the best Prolog and Lisp. http://www.mozart-oz.org PAL- 1) Paradox Application Language is the language for Paradox, Borland's relational database. 2)Pedagogic Algorithmic Language is a language for teaching programming, A.Evans Jr., 1968. 3) PDP Assembly Language for the PDP-8 and the PDP-11. 4) OO Prolog-like language, K.Akama, Springer 1986. 5) for the AVANCE distributed persistent OS. PARASOL- (Parallel Systems Objects Language) OO, supports network and parallel computing. Modules and exceptions. ftp://ftp.uu.net/languages/parasol PARLOG++- object-oriented plus parallel logic, built on top of MacParlog. Developed by Andrew Davison, Imperial College. parlog@doc.ic.ac.uk PASCAL- father of Delphi. Developed by Professor Niklaus Wirth. Originally developed primarily as a teaching language, but it has more often been recommended as a serious language. But, according to Brian W. Kernighan the creator of C, it is not suitable for serious programming,"It is suitable only for small, self-contained programs which have only trivial interactions with their environment and that make no use of any software written by anyone else". Pascal is very good for writing well-structured and readable programs, but it is not as flexible as C. http://www.pascal.about.com http

七猫的藏经阁

公告

留言簿(3)

随笔分类

随笔档案

文章分类

文章档案

相册

收藏夹

好友

搜索

最新评论

阅读排行榜

评论排行榜