i all the A langs

Conf/lang.yaml

@@ -1,13 +1,67 @@
 0815:
 360 Assembly:
 4D:
+4DOS Batch:
+6502 Assembly:
+6800 Assembly:
+8 1/2:
+80386 Assembly:
+8080 Assembly:
+8086 Assembly:
 A+:
 ABAP:
 ACL2:
 ActionScript:
   ext: as
 Ada:
+Agda:
+Agda2:
+Agena:
+Aikido:
+Aime:
+Algae:
+ALGOL:
+  ext: alg
+ALGOL 60:
+  ext: alg
+ALGOL 68:
+  ext: alg
+ALGOL W:
+  ext: alg
+Alice ML:
+Alore:
+AmbientTalk:
+  ext: ambient
+AmigaE:
+  ext: amiga
+AMPL:
+ANT:
+ANTLR:
+APL:
+AppleScript:
+Applesoft BASIC:
+  ext: bas
+Application Master:
+  ext:
+Arbre:
+Argile:
+ARM Assembly:
+ASP:
+ASP.Net:
+  ext: asp
+AspectC++:
+  ext: acpp
+AspectJ:
+Assembly:
+  ext: .as
+Asymptote:
+ATS:
+AutoHotkey:
+  ext: ahk
+AutoIt:
 AWK:
+Axiom:
+Axum:
 B:
 Babel:
   ext: pb

Lang/4DOS-Batch/0DESCRIPTION

@@ -0,0 +1,10 @@
+{{stub|exec=no|gc=no|parampass=no|safety=no|strength=no|compat=no|express=no|checking=no|untyped=no|tags=no|LCT=no}}
+{{language
+|site=http://www.jpsoft.com/
+}}
+
+'''4DOS''' is a command line interpreter by [http://jpsoft.com/ JP Software], designed to replace the default command interpreter in [[DOS]] and [[Windows]]. '''Take Command''' is a [[GUI]] version for Windows (which includes '''Take Command Console''', formerly called '''4NT'''), and '''4OS2''' is an [[OS/2]] version.
+
+== See Also ==
+* [[wp:4DOS|4DOS on Wikipedia]]
+* [[wp:Take Command (command line interpreter)|Take Command on Wikipedia]]

Lang/6502-Assembly/0DESCRIPTION

@@ -0,0 +1,18 @@
+[[Category:Assembly]]
+{{stub}}
+{{language|6502 Assembly
+|site=http://www.6502.org/
+}}{{assembler language}}
+
+The MOS Technology 6502 is an 8-bit microprocessor that was designed by Chuck Peddle and Bill Mensch for MOS Technology in 1975. When it was introduced, it was the least expensive full-featured microprocessor on the market by a considerable margin, costing less than one-sixth the price of competing designs from larger companies such as Motorola and Intel. It was nevertheless fully comparable with them, and, along with the Zilog Z80, sparked a series of computer projects that would eventually result in the home computer revolution of the 1980s. The 6502 design, with about 4,000 transistors, was originally second-sourced by Rockwell and Synertek and later licensed to a number of companies. It is still made for embedded systems.
+
+One of the first "public" uses for the design was the Apple I computer, introduced in 1976. The 6502 was next used in the Commodore PET and the Apple II. It was later used in the Atari home computers, the BBC Micro family, the Commodore VIC-20 and a large number of other designs both for home computers and business, such as Ohio Scientific and Oric.
+
+
+==Citations==
+#[[wp:MOS_Technology_6502|Wikipedia: MOS Technology 6502]]
+
+==See Also==
+*[http://en.wikibooks.org/wiki/6502_Assembly 6502 Assembly From Wikibooks]
+*[http://www.6502asm.com/ 6502 compatible assembler and emulator in javascript]
+*[http://e-tradition.net/bytes/6502/ 6502 assembler and debugger in JavaScript]

Lang/6502-Assembly/99-Bottles-of-Beer

@@ -0,0 +1 @@
+../../Task/99-Bottles-of-Beer/6502-Assembly

Lang/6502-Assembly/Comments

@@ -0,0 +1 @@
+../../Task/Comments/6502-Assembly

Lang/6502-Assembly/FizzBuzz

@@ -0,0 +1 @@
+../../Task/FizzBuzz/6502-Assembly

Lang/6502-Assembly/Forest-fire

@@ -0,0 +1 @@
+../../Task/Forest-fire/6502-Assembly

Lang/6800-Assembly/0DESCRIPTION

@@ -0,0 +1,11 @@
+{{language}}{{assembler language}}
+The 6800 was the central processing unit of a family of integrated circuits and development boards designed by Motorola in the early 1970s, and marketed heavily beginning in 1975.  Like its contemporary, the Intel 8080, it was a microprocessor with an 8-bit data bus and a 16-bit address bus, offered in a 40-pin DIP.
+
+It has been stated that the design team loosely based the assembly language of the 6800 on the DEC PDP-11, although cost concerns necessitated that it be a subset of the much larger and more expensive DEC design.
+
+From a programmer's standpoint, the 6800 possessed two 8-bit accumulators (A and B), two 16-bit pointer registers (X and S), a 16-bit instruction pointer, and an 8-bit flag register (P).  Although the 8080 had more registers and a faster base clock, real-world performance and machine-code density were quite similar, due to the more flexible addressing modes and lower clock-per-instruction ratio of the 6800.  PC-relative branching instructions (with signed 8-bit displacements) and 8-bit (direct-page) addressing options also helped the 6800 in this regard.  The hobbyists of the day had a tendency to fall into two different groups (the 8xxx and 6xxx 'camps'), and countless contests and debates ensued, with each group claiming that their 'family' was superior.  It was quite rare to see a small-computer enthusiast in the late 1970s who didn't have a strong preference for one over the other.
+
+The 6800 spawned many offshoots and offspring, like the MOS Technology 65xx family, the "upward-compatible" Motorola 6809, and numerous micro-controllers.  68xx-based systems were prevalent in the late 1970s and early 1980s, in household, business, and automotive applications.  The 6800's popularity in home computers, however, was easily eclipsed by the 65xx family of microprocessors, largely due to the lower hardware cost and comparable performance of the 65xx family.  The 8080 suffered a similar fate, at the hands of the Zilog Z-80 (due mostly to the Z-80's richer and more versatile instruction set).
+
+The Motorola 68000, designed in the late 1970s, was the popular and much more capable successor to the 6800, and although their assembly languages both share a similarity to the DEC PDP-11 (a model of elegance and orthogonality), they are all mutually incompatible.
+{{stub}}

Lang/6800-Assembly/99-Bottles-of-Beer

@@ -0,0 +1 @@
+../../Task/99-Bottles-of-Beer/6800-Assembly

Lang/8-1-2/0DESCRIPTION

@@ -0,0 +1,15 @@
+{{stub|exec=no|gc=no|parampass=no|safety=no|strength=no|compat=no|express=no|checking=no|untyped=no|tags=no|LCT=no}}
+{{language
+|site=http://www.spatial-computing.org/~giavitto/HomePageOtto/
+}}
+
+8 1/2, pronounced  otto e mezzo, is a high-level data-parallel language based on a new data structure: the fabric (initially called web). This fundamental data structure represents a field over a (discrete) piece of space-time. It is used in the simulation of dynamical systems. A fabric unify the concept of stream and collection and can be viewed either as a ``stream of collections'' or as a ``collection of streams''. The name come from the title of a Fellini movie.
+
+The main features of the 8 1/2 programming language are:
+
+* 8 1/2 is a declarative language, i.e. a programme is a set of definitions (functional equations) specifying fabrics. 
+* The 8 1/2 streams are sequential, synchronous, memory-bounded streams.
+* 8 1/2 collections are handled as a whole.
+* 8 1/2 programmes are hierachized through the concept of system.
+* The 8 1/2 language is naturally a data flow, data parallel language.
+* A static 8 1/2 programme (i.e. a programme involving only fabric with static shape) is detected by the interpreter and can be compiled (in sequential C or towards a SIMD abstract machine).

Lang/80386-Assembly/0DESCRIPTION

@@ -0,0 +1 @@
+{{language}}{{assembler language}}{{stub}}

Lang/8080-Assembly/0DESCRIPTION

@@ -0,0 +1 @@
+{{language}}{{Stub}}{{assembler language}}[[Category:Assembly]]

Lang/8086-Assembly/0DESCRIPTION

@@ -0,0 +1 @@
+{{Stub}}{{language}}{{assembler language}}[[Category:Assembly]]8086 Assembly is the assembly language used by the Intel 8086 processor. This processor was used for the first time in the IBM PC, and in its various clones. The 8086 gave birth, starting with the 80186 processor, to the X86 family, that nowadays is the most used processor family in desktop computers. All the 32 and 64 bit processors from this family are able to operate in a 8086 compatibility mode, for backward compatibility with legacy software and running very low-level code (like the BIOS). For the evolution of this assembly implementation to 32 bits, see [[X86 assembly]].

Lang/8086-Assembly/Comments

@@ -0,0 +1 @@
+../../Task/Comments/8086-Assembly

Lang/8086-Assembly/FizzBuzz

@@ -0,0 +1 @@
+../../Task/FizzBuzz/8086-Assembly

Lang/ALGOL-60/0DESCRIPTION

@@ -0,0 +1,4 @@
+{{stub}}{{language|bnf=http://www.masswerk.at/algol60/syntax.txt}}
+==See also==
+*[[wp:ALGOL|ALGOL 60 on Wikipedia]]
+*[[ALGOL 68]]

Lang/ALGOL-68/0DESCRIPTION

@@ -0,0 +1,165 @@
+[[File:Algol68.png|64px|left|alt=Language|link=http://sourceforge.net/projects/algol68]]
+{{language|ALGOL 68
+|parampass=both
+|strength=soft, weak, meek, firm and strong - depending on context.
+|safety=safe
+|express=explicit
+|compat=structural
+|checking=both
+|LCT=yes}}
+ALGOL 68 (short for ALGOrithmic Language 1968) is an [[imperative programming|imperative]] computer programming language that was conceived as a successor to the ALGOL 60 programming language, designed with the goal of a much wider scope of application and more rigorously defined syntax and semantics.
+
+The main aims and principles of design of ALGOL 68:
+#Completeness and clarity of design,
+#Orthogonal design,
+#Security,
+#Efficiency: 
+#* Static mode checking,
+#* Mode-independent parsing,
+#* Independent compilation,
+#* Loop optimization,
+#* Representations - in minimal & larger character sets.
+
+==Execute an ALGOL 68 program online==
+* http://www.compileonline.com/execute_algol_online.php
+==Grammar==
+The grammar for ALGOL 68 is officially in the two level, [[wp:Van Wijngaarden grammar|Van Wijngaarden grammar]] but a subset has been done in the one level [[wp:Backus–Naur Form|Backus–Naur Form]]:
+* [[wp:Van Wijngaarden grammar|Van Wijngaarden grammar]]: [http://www.fh-jena.de/~kleine/history/languages/Algol68-ReportAttachement.pdf]
+* [[wp:Backus–Naur Form|Backus–Naur Form]]/[[wp:Yacc|Yacc]]: [http://wwwmathlabo.univ-poitiers.fr/~maavl/algol68/syntax68]
+* [http://www.softwarepreservation.org/projects/ALGOL/book/Lindsey_van_der_Meulen-IItA68-Revised-SyntaxOnly.pdf/view Syntax Chart (Size 516.6 kB - File type application/pdf)]
+
+==Resources==
+* ALGOL BULLETIN - March 1959 to August 1988, in 52 issues[http://archive.computerhistory.org/resources/text/algol/algol_bulletin/]
+* Algol68 mailinglist - December 2008 - algol68-user AT lists.sourceforge.net[https://lists.sourceforge.net/lists/listinfo/algol68-user]
+
+FYI: There are two online manual pages:
+* [https://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/a68g-doc.pdf/download Algol 68G Manual - By Marcel van der Veer]
+* [http://www.poenikatu.co.uk/algol68/ Programming Algol 68 Made Easy - Sian Mountbatten]
+
+Or - if you prefer a hardcopy - you can try and pick up a hard cover manual like "''Informal Introduction to Algol 68''" - by C. H. Lindsey & S. V. Vander Meulen.  Be sure to get the 1977 edition:
+* [http://www.amazon.com/gp/offer-listing/0720405041/ref=dp_olp_used?ie=UTF8&condition=used www.amazon.com] - Aboout $119
+* [http://search.barnesandnoble.com/Informal-Introduction-to-ALGOL-68/C-H-Lindsey/e/9780720407266/?itm=3&USRI=Informal+Introduction+to+Algol+68 barnesandnoble.com] - about $40
+IItA68 is a beautiful book, and makes great "bedtime" reading... Highly recommended!
+
+Editor modes:
+* [http://www.jemarch.net/a68-mode Emacs mode] for Algol 68  supporting syntax highlighting and context-sensitive indentation.
+* [http://www.vim.org/scripts/script.php?script_id=1927 Vim script] providing support for syntax colouring.
+
+==Status==
+* 20th December 1968 - '''ALGOL 68's''' Final Report was ratified by [http://en.wikipedia.org/wiki/UNESCO UNESCO's] [http://en.wikipedia.org/wiki/IFIP IFIP] working group 2.1 in Munich.
+* 20th December 2008 - [[Zig_Zag#ALGOL 68|Zig Zag]] - the 100th '''ALGOL 68''' code contribution on rosettacode.org! 
+** Happy 40th Birthday '''ALGOL 68''', 
+** AND 50th Birthday '''ALGOL 58'''.
+* 23rd August 2009 - [http://sourceforge.net/projects/algol68/files/ algol68g-1.18.0-9h] released
+* 20th December 2009 - Happy 51st/41st Birthdays with [[Hamming_numbers#ALGOL_68|Hamming numbers]] - the 200th '''ALGOL 68''' code contribution on rosettacode.org!  
+** This time code was by [[User:Algol68g|Marcel van der Veer]], author of [http://www.xs4all.nl/~jmvdveer/algol.html Algol 68 Genie]
+* 25th October 2011 - [[User:Jejones3141|Jejones3141]] added [[Soundex#ALGOL_68|Soundex]] - the 300th '''ALGOL 68''' code specimen.
+
+== Revisions ==
+*Mar. 1968: Draft Report on the Algorithmic Language ALGOL 68 - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck and C.H.A. Koster.  
+*Oct. 1968: Penultimate Draft Report on the Algorithmic Language ALGOL 68 - Chapters 1-9 - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck and C.H.A. Koster.
+*Dec. 1968: Report on the Algorithmic Language ALGOL 68 - Offprint from Numerische Mathematik, 14, 79-218 (1969); Springer-Verlag. - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck and C.H.A. Koster.  
+*Sep 1973: Revised Report on the Algorithmic Language Algol 68 - Springer-Verlag 1976 - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck, C.H.A. Koster, M. Sintzoff, C.H. Lindsey, L.G.L.T. Meertens and R.G. Fisker.
+==Code samples==
+Most of the code samples provided here have a leading <code>main:(</code> and a matching <code>)</code> at the end. These are not actually required in the language, but are included so as to highlight that the code sample is complete, and works with (at least) [[ALGOL 68G]] unmodified.
+
+On some compilers, it may be necessary to include appropriate "job cards" 
+or precludes in order for the programs to compile successfully. Hopefully 
+not too much else is required. Examples:
+{|border="1" style="border-collapse: collapse; border: 5px double grey;"  align="center" 
+|| Brief Algol68
+|| Algol68 as in rosettacode
+|| Actual ELLA Algol 68RS code
+|-
+||
+ print(("Hello, world!",new line))
+||
+ main:(
+   print(("Hello, world!",new line))
+ )
+||
+ PROGRAM helloworld CONTEXT VOID
+ USE standard
+ BEGIN
+   print(("Hello, world!", new line))
+ END
+ FINISH
+|}
+===Example of different program representations===
+At the time when ALGOL 68 was defined some predominant computers had 
+36 bit words, and 6 bit character sets.  Hence it was desirable that
+ALGOL 68 should be able to run on machines with only uppercase.  Hence 
+the official spec provided for different representations of the same 
+program.  Example:
+{|border="1" style="border-collapse: collapse; border: 5px double grey;"  align="center" 
+|| Algol68 as typically published
+ ¢ bold/underline typeface ¢
+ '''mode''' '''xint''' = '''int''';
+ '''xint''' sum sq:=0;
+ '''for''' i '''while'''
+   sum sq≠70&times;70
+ '''do'''
+   sum sq+:=i↑2
+ '''od''' 
+|| quote stropping (similar to wiki)
+ 'pr' quote 'pr' 
+ 'mode' 'xint' = 'int';
+ 'xint' sum sq:=0;
+ 'for' i 'while'
+   sum sq≠70&times;70
+ 'do'
+   sum sq+:=i↑2
+ 'od' 
+|| Code for a 7-bit/ascii compiler
+ .PR UPPER .PR
+ MODE XINT = INT;
+ XINT sum sq:=0;
+ FOR i WHILE
+   sum sq/=70*70
+ DO
+   sum sq+:=i**2
+ OD 
+|| Code for a 6-bits/byte compiler
+ .PR POINT .PR
+ .MODE .XINT = .INT;
+ .XINT SUM SQ:=0;
+ .FOR I .WHILE
+   SUM SQ .NE 70*70
+ .DO
+   SUM SQ .PLUSAB I .UP 2
+ .OD
+|| Algol68 using RES stropping
+ .PR RES .PR
+ mode .xint = int;
+ .xint sum sq:=0;
+ for i while
+   sum sq≠70&times;70
+ do
+   sum sq+:=i↑2
+ od 
+|}
+
+== Coercion (casting) ==
+ALGOL 68 has a hierarchy of contexts which determine which kind of 
+coercions are available at a particular point in the program. These contexts are:
+* soft - deproceduring
+* weak - dereferencing or deproceduring, yielding a name
+* meek - dereferencing or deproceduring
+* firm - meek, followed by uniting
+* strong - firm, followed by widening, rowing or voiding
+
+Depending on the context a MODE (type) will be coerced (widened) to another type if there is no loss
+of precision. For example: An INT will be coerced to a REAL, and a REAL will be
+coerced to a LONG REAL.  But not vice-versa.  Examples:
+* INT to REAL
+* REAL to COMPL
+* BITS to []BOOL
+* BYTES to STRING
+A variable can also be coerced (rowed) to an array of length 1.  For example:
+* INT to [1]INT 
+* REAL to [1]REAL etc
+Pointers are followed (dereferenced), For example:
+* REF REF REAL to REAL
+== Code Specimen ==
+{{language programming paradigm|Concurrent}}
+{{language programming paradigm|Imperative}}

Lang/ALGOL-68/99-Bottles-of-Beer

@@ -0,0 +1 @@
+../../Task/99-Bottles-of-Beer/ALGOL-68

Lang/ALGOL-68/Ackermann-function

@@ -0,0 +1 @@
+../../Task/Ackermann-function/ALGOL-68

Lang/ALGOL-68/Arrays

@@ -0,0 +1 @@
+../../Task/Arrays/ALGOL-68

Lang/ALGOL-68/Assertions

@@ -0,0 +1 @@
+../../Task/Assertions/ALGOL-68

Lang/ALGOL-68/Binary-search

@@ -0,0 +1 @@
+../../Task/Binary-search/ALGOL-68

Lang/ALGOL-68/Binary-strings

@@ -0,0 +1 @@
+../../Task/Binary-strings/ALGOL-68

Lang/ALGOL-68/Bulls-and-cows

@@ -0,0 +1 @@
+../../Task/Bulls-and-cows/ALGOL-68

Lang/ALGOL-68/Caesar-cipher

@@ -0,0 +1 @@
+../../Task/Caesar-cipher/ALGOL-68

Lang/ALGOL-68/Calendar

@@ -0,0 +1 @@
+../../Task/Calendar/ALGOL-68

Lang/ALGOL-68/Classes

@@ -0,0 +1 @@
+../../Task/Classes/ALGOL-68

Lang/ALGOL-68/Define-a-primitive-data-type

@@ -0,0 +1 @@
+../../Task/Define-a-primitive-data-type/ALGOL-68

Lang/ALGOL-68/Delete-a-file

@@ -0,0 +1 @@
+../../Task/Delete-a-file/ALGOL-68

Lang/ALGOL-68/Detect-division-by-zero

@@ -0,0 +1 @@
+../../Task/Detect-division-by-zero/ALGOL-68

Lang/ALGOL-68/Determine-if-a-string-is-numeric

@@ -0,0 +1 @@
+../../Task/Determine-if-a-string-is-numeric/ALGOL-68

Lang/ALGOL-68/FizzBuzz

@@ -0,0 +1 @@
+../../Task/FizzBuzz/ALGOL-68

Lang/ALGOL-68/Forest-fire

@@ -0,0 +1 @@
+../../Task/Forest-fire/ALGOL-68

Lang/ALGOL-68/Infinity

@@ -0,0 +1 @@
+../../Task/Infinity/ALGOL-68

Lang/ALGOL-68/Knuth-shuffle

@@ -0,0 +1 @@
+../../Task/Knuth-shuffle/ALGOL-68

Lang/ALGOL-68/Narcissist

@@ -0,0 +1 @@
+../../Task/Narcissist/ALGOL-68

Lang/ALGOL-68/Pi

@@ -0,0 +1 @@
+../../Task/Pi/ALGOL-68

Lang/ALGOL-68/Quine

@@ -0,0 +1 @@
+../../Task/Quine/ALGOL-68

Lang/ALGOL-68/Search-a-list

@@ -0,0 +1 @@
+../../Task/Search-a-list/ALGOL-68

Lang/ALGOL-W/0DESCRIPTION

@@ -0,0 +1,32 @@
+{{language|ALGOL W
+|parampass=both
+|strength=strong
+|safety=safe
+|express=explicit
+|compat=structural
+|checking=both
+|LCT=yes}}
+Algol W is a successor to [[wp:Algol 60|Algol 60]] closely based on A
+Contribution to the Development of ALGOL by [[wp:Niklaus Wirth|Niklaus Wirth]] 
+and [[wp:C.A.R. Hoare|C. A. R. Hoare]]. It includes dynamically
+allocated records, string handling, complex numbers and a standard I/O
+system. A copy of the Algol W Language Description can be found on Karl
+Kleine's [http://www.fh-jena.de/~kleine/history/history.html Historic Documents in Computer Science] 
+page. [http://everything2.com/title/Algol%2520W Dabcanboulet's Algol W @ Everything2] 
+page contains an excellent
+history and tutorial.
+
+[http://www.jampan.co.nz/~glyn/ aw2c] is a new compiler for the Algol W
+language. It is a complete implementation of the language described in
+the Algol W Language Description, June 1972. aw2c should be able to
+compile code intended for the [[wp:OS/360|OS/360]] Algol W compilers
+with little or no modification. See the aw2c manual for more details.
+
+aw2c correctly compiles Tony Marsland's computer [[wp:chess|chess]] player
+[http://webdocs.cs.ualberta.ca/~tony/Public/Awit-Wita-ComputerChess/ Awit] 
+and Hendrik Boom's [http://mtn-host.prjek.net/projects/a68h/ A68H]
+[[Algol 68]] compiler.
+
+== Code Specimen ==
+{{language programming paradigm|Concurrent}}
+{{stub}}

Lang/ALGOL/0DESCRIPTION

@@ -0,0 +1 @@
+{{language}}{{stub}}

Lang/AMPL/0DESCRIPTION

@@ -0,0 +1,5 @@
+{{stub}}
+{{language
+|site=http://www.ampl.com/
+}}
+AMPL is a comprehensive and powerful algebraic modeling language for linear and nonlinear optimization problems, in discrete or continuous variables. One particular advantage of AMPL is the similarity of its syntax to the mathematical notation of optimization problems.

Lang/ANT/0DESCRIPTION

@@ -0,0 +1,12 @@
+{{stub}}
+{{language
+|site=http://ant.berlios.de/
+}}
+ANT (ant is not TeX) is a typesetting system inspired by [[TeX]]. In addition to all major features of TeX, ANT provides:
+* an improved macro language
+* a builtin high-level scripting language
+* UNICODE support
+* support for various font formats including Type1, TrueType, and OpenType
+* partial support for advanced OpenType features
+* support for colour and graphics
+* simple page layout specifications

Lang/ANTLR/0DESCRIPTION

@@ -0,0 +1,5 @@
+{{language}}
+
+ANother Tool for Language Recognition, is a language tool that provides a framework for constructing recognizers, interpreters, compilers, and translators from grammatical descriptions containing actions in a variety of target languages. ANTLR provides excellent support for tree construction, tree walking, translation, error recovery, and error reporting.
+
+See: http://www.antlr.org/

Lang/ANTLR/Balanced-brackets

@@ -0,0 +1 @@
+../../Task/Balanced-brackets/ANTLR

Lang/ANTLR/JSON

@@ -0,0 +1 @@
+../../Task/JSON/ANTLR

Lang/APL/0DESCRIPTION

@@ -0,0 +1,4 @@
+{{stub}}{{language|APL
+|checking=dynamic}}{{language programming paradigm|functional}}
+
+APL is an array oriented interactive programming language and integrated development environment.

Lang/APL/Ackermann-function

@@ -0,0 +1 @@
+../../Task/Ackermann-function/APL

Lang/APL/Determine-if-a-string-is-numeric

@@ -0,0 +1 @@
+../../Task/Determine-if-a-string-is-numeric/APL

Lang/APL/FizzBuzz

@@ -0,0 +1 @@
+../../Task/FizzBuzz/APL

Lang/ARM-Assembly/0DESCRIPTION

@@ -0,0 +1,3 @@
+{{stub}}{{language}}{{assembler language}}
+
+[[Category:Assembly]]

Lang/ASP.Net/0DESCRIPTION

@@ -0,0 +1 @@
+{{language|site=http://www.asp.net/}}{{stub}}

Lang/ASP/0DESCRIPTION

@@ -0,0 +1,5 @@
+{{language|site=http://msdn.microsoft.com/en-us/library/aa286483.aspx}}
+{{implementation|VBScript}}{{implementation|JavaScript}}
+'''Active Server Pages''', usually abbreviated as '''ASP''', is a scripting engine for web servers. Although developed by [[Microsoft]], and used almost exclusively under [[wp:Internet Information Services|IIS]], there are a few third-party implementations, most notably [http://www.apache-asp.org/ Apache::ASP] (and, before the Oracle buyout, Sun's Chilisoft ASP).
+
+By default, the Microsoft implementation of ASP includes [[:Category:VBScript|VBScript]] and [[:Category:JavaScript|JavaScript]], but can be extended to use other languages, such as [[wp:PerlScript|PerlScript]] (derived from [[:Category:Perl|Perl]]).

Lang/ATS/0DESCRIPTION

@@ -0,0 +1,36 @@
+{{language
+|exec=machine
+|gc=allowed
+|safety=safe
+|parampass=both
+|checking=static
+|strength=strong
+|express=explicit
+|tags=ATS
+|bnf=http://www.ats-lang.org/DOCUMENTATION/GRAMMAR/ats_grammar_desc.html
+|site=http://www.ats-lang.org/
+|hopl=no
+}}
+{{language programming paradigm|Declarative}}
+{{language programming paradigm|Functional}}
+{{language programming paradigm|Imperative}}
+{{language programming paradigm|Concurrent}}
+{{language programming paradigm|Modular}}
+'''ATS''' is a [[Type checking|statically typed]] programming language that unifies implementation with formal specification. It is equipped with a highly expressive [[type system]] rooted in the framework Applied Type System, which gives the language its name. In particular, both dependent types and linear types are available in ATS.
+
+
+
+* [[Functional programming]]. The core of ATS is a functional language based on eager (aka. call-by-value) evaluation, which can also accommodate lazy (aka. call-by-need) evaluation. The availability of linear types in ATS often makes functional programs written in it run not only with surprisingly high efficiency (when compared to [[C]]) but also with surprisingly small (memory) footprint (when compared to [[C]] as well).
+
+* [[Imperative programming]]. The novel and unique approach to imperative programming in ATS is firmly rooted in the paradigm of programming with theorem-proving. The type system of ATS allows many features considered dangerous in other languages (e.g., explicit pointer arithmetic and explicit memory allocation/deallocation) to be safely supported in ATS, making ATS a viable programming langauge for low-level systems programming.
+
+* [[Concurrent programming]]. ATS, equipped with a multicore-safe implementation of [[garbage collection]], can support multithreaded programming through the use of pthreads. The availability of linear types for tracking and safely manipulating resources provides a effective means to constructing reliable programs that can take advantage of multicore architectures.
+
+* [[Modular programming]]. The module system of ATS is largely infuenced by that of [[Modula-3]], which is both simple and general as well as effective in supporting large scale programming.
+
+
+
+In addition, ATS contains a subsystem ATS/LF that supports a form of (interactive) theorem-proving, where proofs are constructed as total functions. With this component, ATS advocates a programmer-centric approach to program verification that combines programming with theorem-proving in a syntactically intertwined manner. Furthermore, this component can serve as a logical framework for encoding deduction systems and their (meta-)properties. 
+
+==Citations==
+* [[wp:ATS_%28programming_language%29|Wikipedia:ATS (programming language)]]

Lang/ATS/99-Bottles-of-Beer

@@ -0,0 +1 @@
+../../Task/99-Bottles-of-Beer/ATS

Lang/ATS/Ackermann-function

@@ -0,0 +1 @@
+../../Task/Ackermann-function/ATS

Lang/Agda/0DESCRIPTION

@@ -0,0 +1,3 @@
+{{language|Agda
+|site=http://wiki.portal.chalmers.se/agda/pmwiki.php}}{{implementation|Agda}}{{stub}}
+Agda is a dependently typed functional programming language.

Lang/Agda2/0DESCRIPTION

@@ -0,0 +1 @@
+{{language|Agda2}}{{implementation|Agda2}}{{stub}}

Lang/Agena/0DESCRIPTION

@@ -0,0 +1,21 @@
+{{language
+|site=http://agena.sourceforge.net/
+|express=implicit}}
+{{language programming paradigm|procedural}}
+== What is Agena ? ==
+Agena is an easy-to-learn procedural programming language designed to be used in scientific, educational, linguistic, and many other applications. 
+
+== What can you do with Agena ? == 
+Agena provides all the means to implement ideas quickly: fast real and complex arithmetics, efficient text processing, graphics, flexible data structures, intelligent procedures, simple package management, plus various configuration facilities in multi-user environments.
+
+Besides providing basic operations, it has advanced programming features such as high-speed processing of data structures,
+extended conditionals, abridged and extended syntax for loops, efficient recursion techniques, an arbitrary precision mathematical library, easy-to-use package handling, and much more.
+
+== Which operating systems are supported ? == 
+Installers are available for [[Solaris]], [[Windows]], [[Linux]], [[Mac OS X]], [[OS/2]] & eComStation, and DOS.
+
+== How does it look like ? ==
+The syntax looks like very simplified [[ALGOL 68]] with elements taken from [[Lua]] and [[SQL]]. 
+
+== How has it been implemented ? ==
+Agena is based on the [[ANSI]] [[C]] source code of [[Lua]], a popular and widely used Open Source programming language.

Lang/Aikido/0DESCRIPTION

@@ -0,0 +1,15 @@
+{{Wikipedia|Aikido (programming language)}}
+{{language
+|site=http://aikido.sourceforge.net/
+|compat=duck
+|strength=weak}}
+{{language programming paradigm|object-oriented}}
+{{language programming paradigm|imperative}}
+{{language programming paradigm|concurrent}}
+'''Aikido''' is an interpreted language that can be used for rapid scripting, prototyping and general programming tasks.
+
+It was developed at [[Sun Microsystems|Sun Microsystems Laboratories]] by David Allison and released as open source in September 2003, with the most recent release dated June 2007. It is a dynamically typed, object oriented language with built-in multithreading.
+
+In some respects it is similar in functionality to [[Python]], [[Perl]], [[JavaScript]] and [[Java]]. Syntactically it is very similar to [[C++]] and Java.
+
+Aikido is available for Linux, Mac OS X and Solaris.  The interpreter can be obtained from http://sourceforge.net/projects/aikido.  Documentation (in PDF) is at http://downloads.sourceforge.net/aikido/aikido_prm.pdf

Lang/Aikido/Arrays

@@ -0,0 +1 @@
+../../Task/Arrays/Aikido

Lang/Aikido/Check-that-file-exists

@@ -0,0 +1 @@
+../../Task/Check-that-file-exists/Aikido

Lang/Aikido/Classes

@@ -0,0 +1 @@
+../../Task/Classes/Aikido

Lang/Aikido/Delegates

@@ -0,0 +1 @@
+../../Task/Delegates/Aikido

Lang/Aikido/Delete-a-file

@@ -0,0 +1 @@
+../../Task/Delete-a-file/Aikido

Lang/Aime/0DESCRIPTION

@@ -0,0 +1,4 @@
+{{language|aime
+|site=http://sourceforge.net/projects/aime-embedded/
+}}{{language programming paradigm|Imperative}}[[derived from::C| ]]
+''aime'' is a simple, [[C|C]]-like, [[procedural programming|procedural]], [[imperative programming|imperative]] computer programming language.  It is designed as a lightweight language targeted towards application extension [http://en.wikipedia.org/wiki/List_of_programming_languages_by_category#Extension_languages].  As such, the aime interpreter is easily embeddable in other applications.  For the same reasons, the language stresses application integrity and accessibility.

Lang/Aime/99-Bottles-of-Beer

@@ -0,0 +1 @@
+../../Task/99-Bottles-of-Beer/Aime

Lang/Algae/0DESCRIPTION

@@ -0,0 +1,6 @@
+{{stub}}
+{{language
+|site=http://algae.sourceforge.net/
+}}
+
+Algae is an interpreted language for numerical analysis.

Lang/Alice-ML/0DESCRIPTION

@@ -0,0 +1,8 @@
+{{language|Alice ML
+|site=http://www.ps.uni-saarland.de/alice/
+}}
+
+Alice ML is a functional programming language based on [[Standard ML]], With ideas from [[Oz]]. It has rich support for concurrent, distributed, and constraint programming. Alice ML extends [[Standard ML]] with laziness, light-weight concurrency with implicit data-flow synchronisation, higher-order functors and abstract signatures, Packages, Pickling, type-safe cross-platform remote functions and network mobility & Constraints. It also has a lot of similarities to [[Erlang]].
+
+==See Also==
+* [[wp:Alice_(programming_language)|Wikipedia: Alice ML]]

Lang/Alore/0DESCRIPTION

@@ -0,0 +1,9 @@
+{{stub}}{{language
+|exec=bytecode
+|strength=strong
+|checking=both
+|gc=yes
+|site=http://www.alorelang.org/}}
+{{language programming paradigm|Object-oriented}}
+
+Alore is an [[object-oriented programming]] language with a clean syntax that resembles [[Python]] and [[Lua]]. Alore is optionally-typed like Google Dart: it is both a dynamic scripting language and a general-purpose language with static typing. It is aimed at diverse programming tasks, from short scripts to complex applications. Alore also allows you to freely mix static and dynamic typing within a program.

Lang/AmbientTalk/0DESCRIPTION

@@ -0,0 +1,31 @@
+{{language|AmbientTalk
+|strength=strong
+|safety=safe
+|express=explicit
+|compat=duck
+|checking=dynamic
+|parampass=value
+|gc=yes
+|LCT=yes}}
+AmbientTalk is a concurrent, distributed programming language designed specifically for mobile ad hoc networks. It's concurrency model is inspired by actors, and more specifically the event loop concurrency model of the [[E]] language. AmbientTalk has built-in support for distributed service discovery and (asynchronous) messaging.
+
+The language was designed at the Software Languages Lab of the Vrije Universiteit Brussel, primarily as a research framework for exploring new concurrent and distributed language features for highly dynamic, decentralized networks, such as wireless, mobile ad hoc networks.
+
+The default implementation of AmbientTalk is a Java interpreter, which features full interoperability with the JVM, enabling AmbientTalk code to use existing Java libraries, and enabling Java code to use AmbientTalk as a distributed scripting language. Recent version of AmbientTalk also run on the Android OS, making AmbientTalk portable across a wide range of mobile phones.
+
+==Trying AmbientTalk==
+
+[http://ambienttalk.googlecode.com The open source AmbientTalk interpreter]
+
+To run an AmbientTalk program:
+
+ <lang sh>$ iat program.at</lang>
+
+To get a [[REPL]] (aka prompt, shell, interactive interpreter):
+
+ <lang sh>$ iat</lang>
+
+==See Also==
+
+* [http://ambienttalk.googlecode.com Open source google code project]
+* [http://soft.vub.ac.be/amop AmbientTalk home page] at the Software Languages Lab of the Vrije Universiteit Brussel.

Lang/AmigaE/0DESCRIPTION

@@ -0,0 +1,12 @@
+{{stub}}{{language|AmigaE
+|site=http://strlen.com/e/}}
+{{language programming paradigm|object-oriented}}
+{{language programming paradigm|procedural}}
+<cite>E is an object-oriented/procedural/unpure functional/whatever language with quite a popular implementation on the amiga. It's mainly influenced by languages such as C++, Ada, Lisp etc.</cite> (from the official site)
+
+Do not confuse [[E]] with AmigaE. Amiga E was born in 1993, E in 1997. Unluckily, they share the same name, and since Amiga E is the most popular (as far as I know, unique...!) implementation of E, and since Amiga E has some features that bind it to ''Amiga family'', the name AmigaE seems reasonable, even though HOPL reports it as E.
+
+The language was designed by Wouter von Oortmerssen, also the perpetrator of [[FALSE]].
+
+==See Also==
+* [[wp:Amiga E|Wikipedia: AmigaE]]

Lang/AmigaE/99-Bottles-of-Beer

@@ -0,0 +1 @@
+../../Task/99-Bottles-of-Beer/AmigaE

Lang/AmigaE/Classes

@@ -0,0 +1 @@
+../../Task/Classes/AmigaE

Lang/AmigaE/Comments

@@ -0,0 +1 @@
+../../Task/Comments/AmigaE

Lang/AppleScript/0DESCRIPTION

@@ -0,0 +1,6 @@
+{{language|AppleScript}}
+
+This is a scripting language created by [[Apple, Inc]]. It provides a [[Mac]] user the ability to easily transfer data between applications and process the data to their needs.
+
+AppleScript is a trademark of Apple, Inc.
+* [https://duckduckgo.com/?q=AppleScript Duck AppleScript]

Lang/AppleScript/FizzBuzz

@@ -0,0 +1 @@
+../../Task/FizzBuzz/AppleScript

Lang/AppleScript/Knuth-shuffle

@@ -0,0 +1 @@
+../../Task/Knuth-shuffle/AppleScript

Lang/Applesoft-BASIC/0DESCRIPTION

@@ -0,0 +1,9 @@
+{{stub}}{{language|Applesoft BASIC
+|exec=interpreted}}
+{{implementation|BASIC}}
+
+'''Applesoft BASIC''' was a dialect of [[BASIC]] supplied with the [[wp:Apple II|Apple II]] series of computers. It superseded [[Integer BASIC]] and was the [[BASIC]] in ROM in all [[wp:Apple II|Apple II]] series computers after the original Apple II model.
+
+==See Also==
+* [[wp:Applesoft BASIC|Wikipedia: Applesoft BASIC]]
+* [http://www.landsnail.com/a2ref.htm Apple II Programmer's Reference] from ][ In a Mac, via [http://www.landsnail.com/ Landsnail.com]

Lang/Applesoft-BASIC/99-Bottles-of-Beer

@@ -0,0 +1 @@
+../../Task/99-Bottles-of-Beer/Applesoft-BASIC

Lang/Applesoft-BASIC/Color-of-a-screen-pixel

@@ -0,0 +1 @@
+../../Task/Color-of-a-screen-pixel/Applesoft-BASIC

Lang/Applesoft-BASIC/Detect-division-by-zero

@@ -0,0 +1 @@
+../../Task/Detect-division-by-zero/Applesoft-BASIC

Lang/Application-Master/0DESCRIPTION

@@ -0,0 +1 @@
+{{stub}}{{language}}

Lang/Arbre/0DESCRIPTION

@@ -0,0 +1,11 @@
+{{language|Arbre
+|gc=yes
+|untyped=yes
+|tags=arbre
+|site=http://code.google.com/p/arbrelang
+}}
+
+Arbre is a tree-oriented parallel programming language.
+
+==Citations==
+* [http://code.google.com/p/arbrelang/source/browse/#svn%2Ftrunk%2Fjs Source]

Lang/Arbre/99-Bottles-of-Beer

@@ -0,0 +1 @@
+../../Task/99-Bottles-of-Beer/Arbre

Lang/Arbre/FizzBuzz

@@ -0,0 +1 @@
+../../Task/FizzBuzz/Arbre

Lang/Argile/0DESCRIPTION

@@ -0,0 +1,20 @@
+{{language
+|site=http://www.nongnu.org/argile/}}
+Argile is an experimental, [[C]]-based, compiled programming language, that produces C code. It is not intended for beginners, but for experienced programmers with a good knowledge of C.
+Its main features are:
+* Variable syntax
+* Polymorphism-oriented
+* Call guessing
+* Keyword-less
+* [[UTF-8]] based
+* Access to low level programming
+* Extensible through a module system
+* Parametered types
+* [[Object-oriented]] classes available
+* Implicit type casters can be defined
+* Definitions can be made after they are used
+* Subfunctions and anonymous functions
+* Both indentation-style and braces-style can be used
+
+==See also==
+* [https://savannah.nongnu.org/projects/argile/ Argile project page on Savannah]

Lang/Argile/99-Bottles-of-Beer

@@ -0,0 +1 @@
+../../Task/99-Bottles-of-Beer/Argile

Lang/Argile/Ackermann-function

@@ -0,0 +1 @@
+../../Task/Ackermann-function/Argile

Lang/Argile/Arrays

@@ -0,0 +1 @@
+../../Task/Arrays/Argile

Lang/Argile/Infinity

@@ -0,0 +1 @@
+../../Task/Infinity/Argile

Lang/AspectC++/0DESCRIPTION

@@ -0,0 +1,9 @@
+{{stub}}{{language|AspectC++
+|site=http://www.aspectc.org/
+}}
+
+AspectC++ is an aspect-oriented extension of [[C]] and [[C++]] languages. It is based on source-to-source translation, translating AspectC++ source code to 
+[[C++]]. 
+
+==See Also==
+*[[wp:AspectC++|Wikipedia AspectC++]]

Lang/AspectJ/0DESCRIPTION

@@ -0,0 +1,7 @@
+{{language|AspectJ
+|site=http://www.eclipse.org/aspectj/
+}}[[runs on vm::java virtual machine| ]]
+AspectJ is an aspect-oriented extension of [[derived from::Java]]. AspectJ has become the de-facto standard for [[Aspect Oriented Programming]] (AOP).
+
+==See Also==
+* [[wp:AspectJ| Wikipedia: AspectJ]]

Lang/Assembly/0DESCRIPTION

@@ -0,0 +1,9 @@
+{{language}}{{assembler language}}
+[[Category:Encyclopedia]]'''Assembly language''' (or just '''assembly'''; often abbreviated '''asm'''; sometimes called '''assembler''', although that more properly refers to the program that translates the assembly source into machine code) is a term used for a language which is as close to raw machine code as a language can get.
+
+Usually assembly languages use textual "[[wp:mnemonic|mnemonic]]" instructions that correspond directly to binary machine code instructions (merely hiding details of bit-wise encoding), except for ''macros'' which expand to multiple instructions, and often give direct control over the overall layout of the assembled program on disk and in memory. Available instructions and codes are specific to the architecture being programmed on (although there are assemblers which provide an abstracted, non-architecture-specific language; the most notable one is the [[wp:GNU Assembler|GNU Assembler]]). Assembly programs are typically loaded directly into a computer's memory and run from there.
+
+==See also==
+*[[wp:Assembly language|Assembly language]] on Wikipedia (includes an in-depth discussion of assembly)
+*[[wp:High-level assembler|High-level assembler]] (a.k.a. ''macro assembler'') on Wikipedia
+*Compare with [[wp:Microcode|Microcode]].

Lang/Asymptote/0DESCRIPTION

@@ -0,0 +1 @@
+{{stub}}{{language}}

Lang/AutoHotkey/0DESCRIPTION

@@ -0,0 +1,15 @@
+{{language|AutoHotkey
+|gc=no
+|parampass=both
+|untyped=yes
+|tags=ahk, autohotkey
+|site=http://www.autohotkey.com/
+|LCT=yes}}'''[[wp:AutoHotkey|AutoHotkey]]''' is an [[open source]] programming language for Microsoft [[Windows]].
+==Citations==
+* [http://autohotkey.com/docs Documentation]
+* [http://autohotkey.net/ AutoHotkey.net] - user projects and [http://www.autohotkey.net/#archives archives]
+* [http://www.autohotkey.com/docs/scripts/ Script Showcase], [http://www.autohotkey.com/wiki/index.php?title=Script_Listing scripts: wiki]
+* [http://www.autohotkey.com/forum/ Community forum]
+* [[wp:AutoHotkey|AutoHotkey on Wikipedia]]
+* [irc://irc.freenode.net/ahk #ahk] on [[Help:IRC|freenode]] ([http://webchat.freenode.net/?channels=%23ahk Web interface])
+* [[:Category:AutoHotkey_Originated]]

Lang/AutoHotkey/99-Bottles-of-Beer

@@ -0,0 +1 @@
+../../Task/99-Bottles-of-Beer/AutoHotkey

Lang/AutoHotkey/Ackermann-function

@@ -0,0 +1 @@
+../../Task/Ackermann-function/AutoHotkey

Lang/AutoHotkey/Anagrams

@@ -0,0 +1 @@
+../../Task/Anagrams/AutoHotkey