A is for ...

ABC

ABC is an interactive programming language and environment for personal computing, originally intended as a good replacement for BASIC. It was designed by first doing a task analysis of the programming task.

ABC is easy to learn (an hour or so for someone who has already programmed), and yet easy to use. Originally intended as a language for beginners, it has evolved into a powerful tool for beginnersand experts alike.

Here is an example function words to collect the set of all words in a document:

   HOW TO RETURN words document:
      PUT {} IN collection
      FOR line IN document:
         FOR word IN split line:
            IF word not.in collection:
               INSERT word IN collection
      RETURN collection

Some features of the language:

• a powerful collection of only 5 data types that can easily be combined
• strong typing, yet without declarations
• no limitations (such as max int), apart from sheer exhaustion of memory
• refinements to support top-down programming
• nesting by indentation
• programs typically one fourth or one fifth the size of the equivalent Pascal or C.

Some features of the environment:

• no need for files: procedures and functions and global variables remain after logging out
• one consistent face is shown to the user at all times, whetherexecuting commands, editing, or entering input to a program
• generalized undo mechanism.

ABCL

The tenet of our ABCL research project is to exploit both parallelism and object orientation. Parallelism is ubiquitous in our problem domains; parallelism is not only the source of computational power, but also promotes structural simplicity/naturalness in design and algorithm. Object-orientation accompanying parallelism, enhances system modularity, flexibility, and safety. Such an approach, called object-oriented concurrency, is summarized as follows:
* the software or algorithm to be designed/constructed is represented as a collection of concurrently executable (concurrent) objects, and
* the interaction among the system components is represented solely as message transmissions among such objects.
A concurrent object models the functions and properties of an entity appearing in a problem domain. It is an encapsulated (program) module which contain data and the associated procedures to operate on the data, and also perform message passing. Upon receiving a message, it becomes active and executes a procedure specified by the message. Message transmission may take place concurrently among objects, thus enabling objects to be active in parallel. The basic mode of message passing in our approach is asynchronous in the sense that an object can send a message whenever it wants to, irrespective of the mode of the receiver of the message. This expands the degree of parallelism allowed in a system. We also assume that an object is able to create new objects dynamically. The capability of dynamic object creation is indispensable in modeling and representing complex, open systems naturally. We believe that the asynchrony and this dynamicity are fundamental in our approach. We developed a parallel computation model ABCM/1 (An object-Based Concurrent computation Model 1) and its associated description language ABCL/1 (An object-Based Concurrent Language 1). ABCM/1 is based on our notion of "objects", while ABCL/1 serves as a programming language in which systems and algorithms are written based on objects defined in ABCM/1. From ABCM/1 and ABCL/1, our research project has stemmed mainly towards three directions: theory, implementation/environment, and application. In each direction, there are a number of research topics that have been identified and investigated.

ACC

(pronounced by naming the letters A, C and C) is a near-C compiler for the IBMPC line of computers for MSDOS programs. The compiler and compiled programs will run on any 386 or above PC running MSDOS. Included with the compiler are a 386 assembler and a linker for combining multiple object files. There are also two libraries, which are a protected mode dos extender (Based on Thomas Pytel's (aka Tran's) PMODE30B + PMODE307 dos extenders), and a library of useful functions callable by C programs. Pointers are 4 bytes, and can access all available memory. You can allocate blocks as large as you want (megabytes) as long as there is memory available.
The compiler, assembler and linker are all very small and fast. The code generated is adequate for most programming needs, but time critical stuff should be written in assembler. The compiler supports easy inline asm with the #asm, #endasm directives. The assembler syntax is very similiar to TASM's.

AKL

(AGENTS Kernel Language) is a concurrent constraint programming language developed at the Swedish Institute of Computer Science (SICS). In AKL, computation is performed by agents interacting through stores of constraints. This notion accomodates multiple programming paradigms; in appropriate contexts, AKL agents may be thought of as processes, objects, functions, relations, or constraints.
AGENTS is a system for programming in AKL. It provides a complete implementation of AKL with records, finite domain constraints (over integers), and port-based communication, a novelty of AKL. It also provides assorted built-in agents, libraries, and other support.

ALF

is a language which combines functional and logic programming techniques. The foundation of ALF is Horn clause logic with equality which consists of predicates and Horn clauses for logic programming, and functions and equations for functional programming. Since ALF is a genuine integration of both programming paradigms, any functional expression can be used in a goal literal and arbitrary predicates can occur in conditions of equations. The operational semantics of ALF is based on the resolution rule to solve literals and narrowing to evaluate functional expressions. In order to reduce the number of possible narrowing steps, a leftmost-innermost basic narrowing strategy is used which can be efficiently implemented. Furthermore, terms are simplified by rewriting before a narrowing step is applied and also equations are rejected if the two sides have different constructors at the top. Rewriting and rejection can result in a large reduction of the search tree. Therefore this operational semantics is more efficient than Prolog's resolution strategy.

AMC

AMC is a a language translator that gets its translation rules from aprogramming language called CGL (code generation language). AMC generatesoutput by running a back end program (usually a C compiler or assembler) ona text file that it creates during parsing of the source code.
In addition, AMC also adds a module structure and build facility that is quite simple to understand yet works well for large projects.
AMC was developed on an HP 710 running HP-UX using the GCC compiler.However, the majority of the code for AMC conforms to the ANSI C89 standard.There is a small portion of code that interfaces with the operating systemand is non-portable, but this code is easily replaced to adapt AMC to a newoperating system.

APLX

APL is a unique, general-purpose high level programming language used in application areas such as financial planning, market research, statistics, management information and for all types of scientific and engineering work. APLX is an advanced, second generation implementation of the APL language, closely based on IBM's APL2, but with a number of important enhancements (see the APLX Language Specification).

ATOM

Atom is a programmable, register based virtual machine for Win32 computers. The program is a text-base console application. The VM can be programmed using a neo-assembler language called Atom Assembler. This document discusses the VM and explains each opcode in Atom Assembler.

Agora

is a reflective prototype-based object-oriented programming language that is entirely (and solely!) based on message passing. Message passing is considered as one of the fundamental characteristics of object-oriented programming languages. It lies at the heart of late-binding polymorphism which is the key feature that makes incremental modification of programs possible. However, prototype-based languages often go beyond message passing. Deep down in their implementation, many things such as delegation, encapsulation, cloning and object concatenation can be found as explicit operations on objects. By making such languages reflective, these implementation operators also become visible to the programmer. As such, the programmer can easily bypass the message passing paradigm just by 'going meta'. Also, very often, these operators are an explicit feature in the language, even when reflection is not a language feature. We claim that these explicit operators on objects is the source of encapsulation problems, over-flexibility and the reason why it is so difficult to make abstractions in (reflective) prototype-based languages. We therefore designed Agora as a prototype-based object-oriented programming language whose only operation on objects is message passing. Agora shows that even within these limits, it is possible to build a full-fledged object-oriented language that features inheritance, cloning and reflective operators. The idea is that an object is fully encapsulated and can only be subject to message passing. But seen from the inside of the object, the object knows all about it's own structures. It is therefore perfectly capable of cloning and extending itself. This is accomplished by special methods we call cloning methods and mixin-methods.

Alambik

is based on MCNL, a breakthrough language which is to interactive audiovisual publishing what HTML is to interactive press publishing.

Similar in use to HTML, MCNL combines a complete set of text-based programming instructions with text-based audiovisual commands (video, audio, 2D, 3D, vectorial, etc.). These two conceptual worlds, once distinct, are united synergistically under Alambik within a simple, uniform programming environment, for scripting real-time audiovisual creations.

Alambik is fully complementary to HTML. Its audiovisual, interactive multicontent rounds out HTML content, enhancing the overall end-user experience in much the same way that radio and television round out - without replacing - the traditional press.

Afnix

is a multi-threaded functional programming language with dynamic symbol bindings that support the object oriented paradigm. Afnix features a state of the art runtime engine that supports both 32 and 64 bits platforms. Afnix comes with a rich set of libraries that are designed to be platform independent. Afnix is a free software. A flexible license has been designed for both individuals and corporations. Everybody is encouraged to use, distribute and/or modify the Afnix engine for any purpose.

Afnix is an interpreted language. When used interactively, commands are entered on the command line and executed when a complete and valid syntactic object has been constructed. Alternatively, the interpreter can execute a source file. Afnix does not have a garbage collector. Afnix operates with a lazy, scope based, object destruction mechanism. Each time an object is no longer visible, it is destroyed automatically.

Algol68G

Algol 68 Genie - is a fairly fully featured Algol 68 implementation. Algol68G's front-end parses an entire Algol 68 source program. If parsing is successful, the syntax tree (that serves as an intermediate program representation) is interpreted by Algol68G's back-end.

Alma

ALMA-Towards an Imperative Constraint Programming Language
Alma project aims at a realization of a strongly typed constraint programming language that combines the advantages of logic and imperative programming.
At this stage the first layer, Alma-0, is available. Alma-0 extends a subset of Modula-2 by features that facilitate writing programs that involve search.

Alvyn

is an Open Source free software multiplatform BASIC interpreter written entirely in C++ , developed with aim to be 100% compatible with AMOS Professional (Amiga), to allow game developing on Unix system. Alvyn uses SDL library (see www.libsdl.org) for music and graphic framework

AutoIt v3

is an opensource BASIC-like scripting language designed for automating the Windows GUI. It uses a combination of simulated keystrokes, mouse movement and window/control manipulation in order to automate tasks in a way not possible or reliable with other languages (e.g. VBScript and SendKeys).

AutoIt was initially designed for PC "roll out" situations to configure thousands of PCs, but with the arrival of v3 it is also well suited to performing home automation and the scripting of repetitive tasks.