title
stringlengths 1
251
| section
stringlengths 0
6.12k
| text
stringlengths 0
716k
|
|---|---|---|
APL (programming language) | Short description | APL (named after the book A Programming Language) is a programming language developed in the 1960s by Kenneth E. Iverson. Its central datatype is the multidimensional array. It uses a large range of special graphic symbols to represent most functions and operators, leading to very concise code. It has been an important influence on the development of concept modeling, spreadsheets, functional programming, and computer math packages. It has also inspired several other programming languages. |
APL (programming language) | History | History |
APL (programming language) | Mathematical notation | Mathematical notation
A mathematical notation for manipulating arrays was developed by Kenneth E. Iverson, starting in 1957 at Harvard University. In 1960, he began work for IBM where he developed this notation with Adin Falkoff and published it in his book A Programming Language in 1962. The preface states its premise:
This notation was used inside IBM for short research reports on computer systems, such as the Burroughs B5000 and its stack mechanism when stack machines versus register machines were being evaluated by IBM for upcoming computers.
Iverson also used his notation in a draft of the chapter A Programming Language, written for a book he was writing with Fred Brooks, Automatic Data Processing, which would be published in 1963.Iverson, Kenneth E., "Automatic Data Processing: Chapter 6: A programming language" , 1960, Draft copy for Brooks and Iverson 1963 book, Automatic Data Processing.Brooks, Fred; Iverson, Kenneth, (1963), Automatic Data Processing, John Wiley & Sons Inc.
In 1979, Iverson received the Turing Award for his work on APL. |
APL (programming language) | Development into a computer programming language | Development into a computer programming language
As early as 1962, the first attempt to use the notation to describe a complete computer system happened after Falkoff discussed with William C. Carter his work to standardize the instruction set for the machines that later became the IBM System/360 family.
In 1963, Herbert Hellerman, working at the IBM Systems Research Institute, implemented a part of the notation on an IBM 1620 computer, and it was used by students in a special high school course on calculating transcendental functions by series summation. Students tested their code in Hellerman's lab. This implementation of a part of the notation was called Personalized Array Translator (PAT).
In 1963, Falkoff, Iverson, and Edward H. Sussenguth Jr., all working at IBM, used the notation for a formal description of the IBM System/360 series machine architecture and functionality, which resulted in a paper published in IBM Systems Journal in 1964. After this was published, the team turned their attention to an implementation of the notation on a computer system. One of the motivations for this focus of implementation was the interest of John L. Lawrence who had new duties with Science Research Associates, an educational company bought by IBM in 1964. Lawrence asked Iverson and his group to help use the language as a tool to develop and use computers in education.
After Lawrence M. Breed and Philip S. Abrams of Stanford University joined the team at IBM Research, they continued their prior work on an implementation programmed in FORTRAN IV for a part of the notation which had been done for the IBM 7090 computer running on the IBSYS operating system. This work was finished in late 1965 and later named IVSYS (for Iverson system). The basis of this implementation was described in detail by Abrams in a Stanford University Technical Report, "An Interpreter for Iverson Notation" in 1966. The academic aspect of this was formally supervised by Niklaus Wirth.Abrams, Philip S., An interpreter for "Iverson notation", Technical Report: CS-TR-66-47, Department of Computer Science, Stanford University, August 1966; Like Hellerman's PAT system earlier, this implementation omitted the APL character set, but used special English reserved words for functions and operators. The system was later adapted for a time-sharing system and, by November 1966, it had been reprogrammed for the IBM System/360 Model 50 computer running in a time-sharing mode and was used internally at IBM. |
APL (programming language) | Hardware | Hardware
thumb|IBM typeballs and typewheel containing APL Greek characters
thumb|A programmer's view of the IBM 2741 keyboard layout with the APL typing element print head inserted
A key development in the ability to use APL effectively, before the wide use of cathode-ray tube (CRT) terminals, was the development of a special IBM Selectric typewriter interchangeable typing element with all the special APL characters on it. This was used on paper printing terminal workstations using the Selectric typewriter and typing element mechanism, such as the IBM 1050 and IBM 2741 terminal. Keycaps could be placed over the normal keys to show which APL characters would be entered and typed when that key was struck. For the first time, a programmer could type in and see proper APL characters as used in Iverson's notation and not be forced to use awkward English keyword representations of them. Falkoff and Iverson had the special APL Selectric typing elements, 987 and 988, designed in late 1964, although no APL computer system was available to use them.Breed, Larry, "The First APL Terminal Session", APL Quote Quad, Association for Computing Machinery, Volume 22, Number 1, September 1991, p. 2–4. Iverson cited Falkoff as the inspiration for the idea of using an IBM Selectric typing element for the APL character set.19, 2009 Adin Falkoff – Computer History Museum. "Iverson credited him for choosing the name APL and the introduction of the IBM golf-ball typewriter with the replacement typehead, which provided the famous character set to represent programs."
Many APL symbols, even with the APL characters on the Selectric typing element, still had to be typed in by over-striking two extant element characters. An example is the grade up character, which had to be made from a delta (shift-H) and a Sheffer stroke (shift-M). This was necessary because the APL character set was much larger than the 88 characters allowed on the typing element, even when letters were restricted to upper-case (capitals). |
APL (programming language) | Commercial availability | Commercial availability
The first APL interactive login and creation of an APL workspace was in 1966 by Larry Breed using an IBM 1050 terminal at the IBM Mohansic Labs near Thomas J. Watson Research Center, the home of APL, in Yorktown Heights, New York.
IBM was chiefly responsible for introducing APL to the marketplace. The first publicly available version of APL was released in 1968 for the IBM 1130. IBM provided APL\1130 for free but without liability or support.APL\1130 Manual , May 1969 It would run in as little as 8k 16-bit words of memory, and used a dedicated 1 megabyte hard disk.
APL gained its foothold on mainframe timesharing systems from the late 1960s through the early 1980s, in part because it would support multiple users on lower-specification systems that had no dynamic address translation hardware. Additional improvements in performance for selected IBM System/370 mainframe systems included the APL Assist Microcode in which some support for APL execution was included in the processor's firmware, as distinct from being implemented entirely by higher-level software. Somewhat later, as suitably performing hardware was finally growing available in the mid- to late-1980s, many users migrated their applications to the personal computer environment.
Early IBM APL interpreters for IBM 360 and IBM 370 hardware implemented their own multi-user management instead of relying on the host services, thus they were their own timesharing systems. First introduced for use at IBM in 1966, the APL\360Falkoff, Adin; Iverson, Kenneth E., "APL\360 Users Guide" , IBM Research, Thomas J. Watson Research Center, Yorktown Heights, NY, August 1968."APL\360 Terminal System" , IBM Research, Thomas J. Watson Research Center, March 1967. system was a multi-user interpreter. The ability to programmatically communicate with the operating system for information and setting interpreter system variables was done through special privileged "I-beam" functions, using both monadic and dyadic operations.Falkoff, Adin D.; Iverson, Kenneth E.,The Design of APL, IBM Journal of Research and Development, Volume 17, Number 4, July 1973. "These environmental defined functions were based on the use of still another class of functions—called "I-beams" because of the shape of the symbol used for them—which provide a more general facility for communication between APL programs and the less abstract parts of the system. The I-beam functions were first introduced by the system programmers to allow them to execute System/360 instructions from within APL programs, and thus use APL as a direct aid in their programming activity. The obvious convenience of functions of this kind, which appeared to be part of the language, led to the introduction of the monadic I-beam function for direct use by anyone. Various arguments to this function yielded information about the environment such as available space and time of day."
In 1973, IBM released APL.SV, which was a continuation of the same product, but which offered shared variables as a means to access facilities outside of the APL system, such as operating system files. In the mid-1970s, the IBM mainframe interpreter was even adapted for use on the IBM 5100 desktop computer, which had a small CRT and an APL keyboard, when most other small computers of the time only offered BASIC. In the 1980s, the VSAPL program product enjoyed wide use with Conversational Monitor System (CMS), Time Sharing Option (TSO), VSPC, MUSIC/SP, and CICS users.
In 1973–1974, Patrick E. Hagerty directed the implementation of the University of Maryland APL interpreter for the 1100 line of the Sperry UNIVAC 1100/2200 series mainframe computers. In 1974, student Alan Stebbens was assigned the task of implementing an internal function. Xerox APL was available from June 1975 for Xerox 560 and Sigma 6, 7, and 9 mainframes running CP-V and for Honeywell CP-6.
In the 1960s and 1970s, several timesharing firms arose that sold APL services using modified versions of the IBM APL\360 interpreter. In North America, the better-known ones were IP Sharp Associates, Scientific Time Sharing Corporation (STSC), Time Sharing Resources (TSR), and The Computer Company (TCC). CompuServe also entered the market in 1978 with an APL Interpreter based on a modified version of Digital Equipment Corp and Carnegie Mellon's, which ran on DEC's KI and KL 36-bit machines. CompuServe's APL was available both to its commercial market and the consumer information service. With the advent first of less expensive mainframes such as the IBM 4300, and later the personal computer, by the mid-1980s, the timesharing industry was all but gone.
Sharp APL was available from IP Sharp Associates, first as a timesharing service in the 1960s, and later as a program product starting around 1979. Sharp APL was an advanced APL implementation with many language extensions, such as packages (the ability to put one or more objects into a single variable), a file system, nested arrays, and shared variables.
APL interpreters were available from other mainframe and mini-computer manufacturers also, notably Burroughs, Control Data Corporation (CDC), Data General, Digital Equipment Corporation (DEC), Harris, Hewlett-Packard (HP), Siemens, Xerox and others.
Garth Foster of Syracuse University sponsored regular meetings of the APL implementers' community at Syracuse's Minnowbrook Conference Center in Blue Mountain Lake, New York. In later years, Eugene McDonnell organized similar meetings at the Asilomar Conference Grounds near Monterey, California, and at Pajaro Dunes near Watsonville, California. The SIGAPL special interest group of the Association for Computing Machinery continues to support the APL community. |
APL (programming language) | Microcomputers | Microcomputers
On microcomputers, which became available from the mid-1970s onwards, BASIC became the dominant programming language. Nevertheless, some microcomputers provided APL instead – the first being the Intel 8008-based MCM/70 which was released in 1974 and which was primarily used in education. Another machine of this time was the VideoBrain Family Computer, released in 1977, which was supplied with its dialect of APL called APL/S."VideoBrain Family Computer", Popular Science, November 1978, advertisement.
The Commodore SuperPET, introduced in 1981, included an APL interpreter developed by the University of Waterloo.
In 1976, Bill Gates claimed in his Open Letter to Hobbyists that Microsoft Corporation was implementing APL for the Intel 8080 and Motorola 6800 but had "very little incentive to make [it] available to hobbyists" because of software piracy. It was never released. |
APL (programming language) | APL2 | APL2
Starting in the early 1980s, IBM APL development, under the leadership of Jim Brown, implemented a new version of the APL language that contained as its primary enhancement the concept of nested arrays, where an array can contain other arrays, and new language features which facilitated integrating nested arrays into program workflow. Ken Iverson, no longer in control of the development of the APL language, left IBM and joined I. P. Sharp Associates, where one of his major contributions was directing the evolution of Sharp APL to be more in accord with his vision. APL2 was first released for CMS and TSO in 1984. The APL2 Workstation edition (Windows, OS/2, AIX, Linux, and Solaris) followed later.
As other vendors were busy developing APL interpreters for new hardware, notably Unix-based microcomputers, APL2 was almost always the standard chosen for new APL interpreter developments. Even today, most APL vendors or their users cite APL2 compatibility as a selling point for those products. IBM cites its use for problem solving, system design, prototyping, engineering and scientific computations, expert systems, for teaching mathematics and other subjects, visualization and database access. |
APL (programming language) | Modern implementations | Modern implementations
Various implementations of APL by APLX, Dyalog, et al., include extensions for object-oriented programming, support for .NET, XML-array conversion primitives, graphing, operating system interfaces, and lambda calculus expressions. Freeware versions include GNU APL for Linux and NARS2000 for Windows (which also runs on Linux under Wine). Both of these are fairly complete versions of APL2 with various language extensions. |
APL (programming language) | Derivative languages | Derivative languages
APL has formed the basis of, or influenced, the following languages:
A and A+, an alternative APL, the latter with graphical extensions.
FP, a functional programming language.
Ivy, an interpreter for an APL-like language developed by Rob Pike, and which uses ASCII as input.
J, which was also designed by Iverson, and which uses ASCII with digraphs instead of special symbols.
K, a proprietary variant of APL developed by Arthur Whitney.
MATLAB, a numerical computation tool.
Nial, a high-level array programming language with a functional programming notation.
Polymorphic Programming Language, an interactive, extensible language with a similar base language.
S, a statistical programming language (usually now seen in the open-source version known as R).
Snap!, a low-code block-based programming language, born as an extended reimplementation of Scratch
Speakeasy, a numerical computing interactive environment.
Wolfram Language, the programming language of Mathematica. |
APL (programming language) | Language characteristics | Language characteristics |
APL (programming language) | Character set | Character set
APL has been criticized and praised for its choice of a unique character set. In the 1960s and 1970s, few terminal devices or even displays could reproduce the APL character set. The most popular ones employed the IBM Selectric print mechanism used with a special APL type element. One of the early APL line terminals (line-mode operation only, not full screen) was the Texas Instruments TI Model 745 () with the full APL character set which featured half and full duplex telecommunications modes, for interacting with an APL time-sharing service or remote mainframe to run a remote computer job, remote job entry (RJE).
Over time, with the universal use of high-quality graphic displays, printing devices and Unicode support, the APL character font problem has largely been eliminated. However, entering APL characters requires the use of input method editors, keyboard mappings, virtual/on-screen APL symbol sets, or easy-reference printed keyboard cards which can frustrate beginners accustomed to other programming languages. With beginners who have no prior experience with other programming languages, a study involving high school students found that typing and using APL characters did not hinder the students in any measurable way.
In defense of APL, it requires fewer characters to type, and keyboard mappings become memorized over time. Special APL keyboards are also made and in use today, as are freely downloadable fonts for operating systems such as Microsoft Windows. The reported productivity gains assume that one spends enough time working in the language to make it worthwhile to memorize the symbols, their semantics, keyboard mappings, and many idioms for common tasks. |
APL (programming language) | Design | Design
Unlike traditionally structured programming languages, APL code is typically structured as chains of monadic or dyadic functions, and operators acting on arrays. APL has many nonstandard primitives (functions and operators) that are indicated by a single symbol or a combination of a few symbols. All primitives are defined to have the same precedence, and always associate to the right. Thus, APL is read or best understood from right-to-left.
Early APL implementations ( or so) had no programming loop control flow structures, such as do or while loops, and if-then-else constructs. Instead, they used array operations, and use of structured programming constructs was often unneeded, since an operation could be performed on a full array in one statement. For example, the iota function (ι) can replace for-loop iteration: ιN when applied to a scalar positive integer yields a one-dimensional array (vector), 1 2 3 ... N. Later APL implementations generally include comprehensive control structures, so that data structure and program control flow can be clearly and cleanly separated.
The APL environment is called a workspace. In a workspace the user can define programs and data, i.e., the data values exist also outside the programs, and the user can also manipulate the data without having to define a program. In the examples below, the APL interpreter first types six spaces before awaiting the user's input. Its own output starts in column one.
n ← 4 5 6 7 Assigns vector of values, {4 5 6 7}, to variable n, an array create operation. An equivalent yet more concise APL expression would be n ← 3 + ⍳4. Multiple values are stored in array n, the operation performed without formal loops or control flow language. n
4 5 6 7 Display the contents of n, currently an array or vector. n+4
8 9 10 11 4 is now added to all elements of vector n, creating a 4-element vector {8 9 10 11}. As above, APL's interpreter displays the result because the expression's value was not assigned to a variable (with a ←). +/n
22 APL displays the sum of components of the vector n, i.e., 22 (= 4 + 5 + 6 + 7) using a very compact notation: read +/ as "plus, over..." and a slight change would be "multiply, over..." m ← +/3+⍳4
m
22 These operations can be combined into one statement, remembering that APL evaluates expressions right to left: first ⍳4 creates an array, [1,2,3,4], then 3 is added to each component, which are summed together and the result stored in variable m, finally displayed. In normal mathematical notation, it is equivalent to: . Recall that mathematical expressions are not read or evaluated from right-to-left.
The user can save the workspace with all values, programs, and execution status.
APL uses a set of non-ASCII symbols, which are an extension of traditional arithmetic and algebraic notation. Having single character names for single instruction, multiple data (SIMD) vector functions is one way that APL enables compact formulation of algorithms for data transformation such as computing Conway's Game of Life in one line of code. In nearly all versions of APL, it is theoretically possible to express any computable function in one expression, that is, in one line of code.
Due to the unusual character set, many programmers use special keyboards with APL keytops to write APL code. Although there are various ways to write APL code using only ASCII characters, in practice it is almost never done. (This may be thought to support Iverson's thesis about notation as a tool of thought.) Most if not all modern implementations use standard keyboard layouts, with special mappings or input method editors to access non-ASCII characters. Historically, the APL font has been distinctive, with uppercase italic alphabetic characters and upright numerals and symbols. Most vendors continue to display the APL character set in a custom font.
Advocates of APL claim that the examples of so-called write-only code (badly written and almost incomprehensible code) are almost invariably examples of poor programming practice or novice mistakes, which can occur in any language. Advocates also claim that they are far more productive with APL than with more conventional computer languages, and that working software can be implemented in far less time and with far fewer programmers than using other technology.
They also may claim that because it is compact and terse, APL lends itself well to larger-scale software development and complexity, because the number of lines of code can be reduced greatly. Many APL advocates and practitioners also view standard programming languages such as COBOL and Java as being comparatively tedious. APL is often found where time-to-market is important, such as with trading systems. |
APL (programming language) | Terminology | Terminology
APL makes a clear distinction between functions and operators. Functions take arrays (variables or constants or expressions) as arguments, and return arrays as results. Operators (similar to higher-order functions) take functions or arrays as arguments, and derive related functions. For example, the sum function is derived by applying the reduction operator to the addition function. Applying the same reduction operator to the maximum function (which returns the larger of two numbers) derives a function which returns the largest of a group (vector) of numbers. In the J language, Iverson substituted the terms verb for function and adverb or conjunction for operator.
APL also identifies those features built into the language, and represented by a symbol, or a fixed combination of symbols, as primitives. Most primitives are either functions or operators. Coding APL is largely a process of writing non-primitive functions and (in some versions of APL) operators. However a few primitives are considered to be neither functions nor operators, most noticeably assignment.
Some words used in APL literature have meanings that differ from those in both mathematics and the generality of computer science.
+Terminology of APL operators Term Description function operation or mapping that takes zero, one (right) or two (left & right) arguments which may be scalars, arrays, or more complicated structures, and may return a similarly complex result. A function may be:
Primitive: built-in and represented by a single glyph;
Defined: as a named and ordered collection of program statements;
Derived: as a combination of an operator with its arguments. array data valued object of zero or more orthogonal dimensions in row-major order in which each item is a primitive scalar datum or another array. niladic not taking or requiring any arguments, nullary"Programmera i APL", Bohman, Fröberg, Studentlitteratur, monadic requiring only one argument; on the right for a function, on the left for an operator, unary dyadic requiring both a left and a right argument, binary ambivalentor monadic capable of use in a monadic or dyadic context, permitting its left argument to be elided operator operation or mapping that takes one (left) or two (left & right) function or array valued arguments (operands) and derives a function. An operator may be:
Primitive: built-in and represented by a single glyph;
Defined: as a named and ordered collection of program statements. |
APL (programming language) | Syntax | Syntax
APL has explicit representations of functions, operators, and syntax, thus providing a basis for the clear and explicit statement of extended facilities in the language, and tools to experiment on them. |
APL (programming language) | Examples | Examples |
APL (programming language) | Hello, world | Hello, world
This displays "Hello, world":
'Hello, world'
A design theme in APL is to define default actions in some cases that would produce syntax errors in most other programming languages.
The 'Hello, world' string constant above displays, because display is the default action on any expression for which no action is specified explicitly (e.g. assignment, function parameter). |
APL (programming language) | Exponentiation | Exponentiation
Another example of this theme is that exponentiation in APL is written as , which indicates raising 2 to the power 3 (this would be written as or in some languages, or relegated to a function call such as in others). Many languages use to signify multiplication, as in , but APL chooses to use . However, if no base is specified (as with the statement in APL, or in other languages), most programming languages one would see this as a syntax error. APL, however, assumes the missing base to be the natural logarithm constant e, and interprets as . |
APL (programming language) | Simple statistics | Simple statistics
Suppose that is an array of numbers. Then gives its average. Reading right-to-left, gives the number of elements in X, and since is a dyadic operator, the term to its left is required as well. It is surrounded by parentheses since otherwise X would be taken (so that the summation would be of —each element of X divided by the number of elements in X), and gives the sum of the elements of X. Building on this, the following expression computes standard deviation:
Naturally, one would define this expression as a function for repeated use rather than rewriting it each time. Further, since assignment is an operator, it can appear within an expression, so the following would place suitable values into T, AV and SD: |
APL (programming language) | ''Pick 6'' lottery numbers | Pick 6 lottery numbers
This following immediate-mode expression generates a typical set of Pick 6 lottery numbers: six pseudo-random integers ranging from 1 to 40, guaranteed non-repeating, and displays them sorted in ascending order:
x[⍋x←6?40]
The above does a lot, concisely, although it may seem complex to a new APLer. It combines the following APL functions (also called primitives and glyphs):
The first to be executed (APL executes from rightmost to leftmost) is dyadic function ? (named deal when dyadic) that returns a vector consisting of a select number (left argument: 6 in this case) of random integers ranging from 1 to a specified maximum (right argument: 40 in this case), which, if said maximum ≥ vector length, is guaranteed to be non-repeating; thus, generate/create 6 random integers ranging from 1 to 40.
This vector is then assigned (←) to the variable x, because it is needed later.
This vector is then sorted in ascending order by a monadic ⍋ function, which has as its right argument everything to the right of it up to the next unbalanced close-bracket or close-parenthesis. The result of ⍋ is the indices that will put its argument into ascending order.
Then the output of ⍋ is used to index the variable x, which we saved earlier for this purpose, thereby selecting its items in ascending sequence.
Since there is no function to the left of the left-most x to tell APL what to do with the result, it simply outputs it to the display (on a single line, separated by spaces) without needing any explicit instruction to do that.
? also has a monadic equivalent called roll, which simply returns one random integer between 1 and its sole operand [to the right of it], inclusive. Thus, a role-playing game program might use the expression ?20 to roll a twenty-sided die. |
APL (programming language) | Prime numbers | Prime numbers
The following expression finds all prime numbers from 1 to R. In both time and space, the calculation complexity is (in Big O notation).
(~R∊R∘.×R)/R←1↓⍳R
Executed from right to left, this means:
Iota ⍳ creates a vector containing integers from 1 to R (if R= 6 at the start of the program, ⍳R is 1 2 3 4 5 6)
Drop first element of this vector (↓ function), i.e., 1. So 1↓⍳R is 2 3 4 5 6
Set R to the new vector (←, assignment primitive), i.e., 2 3 4 5 6
The / replicate operator is dyadic (binary) and the interpreter first evaluates its left argument (fully in parentheses):
Generate outer product of R multiplied by R, i.e., a matrix that is the multiplication table of R by R (°.× operator), i.e.,
4 6 8 10 12 6 9 12 15 18 8 12 16 20 24 10 15 20 25 30 12 18 24 30 36
Build a vector the same length as R with 1 in each place where the corresponding number in R is in the outer product matrix (∈, set inclusion or element of or Epsilon operator), i.e., 0 0 1 0 1
Logically negate (not) values in the vector (change zeros to ones and ones to zeros) (∼, logical not or Tilde operator), i.e., 1 1 0 1 0
Select the items in R for which the corresponding element is 1 (/ replicate operator), i.e., 2 3 5
(This assumes the APL origin is 1, i.e., indices start with 1. APL can be set to use 0 as the origin, so that ι6 is 0 1 2 3 4 5, which is convenient for some calculations.) |
APL (programming language) | Sorting | Sorting
The following expression sorts a word list stored in matrix X according to word length:
X[⍋X+.≠' ';] |
APL (programming language) | Game of Life | Game of Life
The following function "life", written in Dyalog APL,Further technical details in APL Wiki's article "Conway's Game of Life". Retrieved November 20, 2021. takes a Boolean matrix and calculates the new generation according to Conway's Game of Life. It demonstrates the power of APL to implement a complex algorithm in very little code, but understanding it requires some advanced knowledge of APL (as the same program would in many languages).
life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +⌿ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵} |
APL (programming language) | HTML tags removal | HTML tags removal
In the following example, also Dyalog, the first line assigns some HTML code to a variable txt and then uses an APL expression to remove all the HTML tags:
txt←'<html><body><p>This is <em>emphasized</em> text.</p></body></html>'
{⍵ /⍨ ~{⍵∨≠\⍵}⍵∊'<>'} txt
This is emphasized text. |
APL (programming language) | Naming | Naming
APL derives its name from the initials of Iverson's book A Programming Language, even though the book describes Iverson's mathematical notation, rather than the implemented programming language described in this article. The name is used only for actual implementations, starting with APL\360.
Adin Falkoff coined the name in 1966 during the implementation of APL\360 at IBM:
APL is occasionally re-interpreted as Array Programming Language or Array Processing Language,Acharya, R; Pereira, (904567457)
N.E. APL Programming Language . Paper for CS5314 (Concepts of Programming Languages) at Virginia Tech. thereby making APL into a backronym. |
APL (programming language) | Logo | Logo
thumb|British APL Association (BAPLA) conference laptop bag
There has always been cooperation between APL vendors, and joint conferences were held on a regular basis from 1969 until 2010.APL Wiki. APL Conference. Retrieved 13 Oct 2021. At such conferences, APL merchandise was often handed out, featuring APL motifs or collection of vendor logos. Common were apples (as a pun on the similarity in pronunciation of apple and APL) and the code snippet which are the symbols produced by the classic APL keyboard layout when holding the APL modifier key and typing "APL".
Despite all these community efforts, no universal vendor-agnostic logo for the programming language emerged. As popular programming languages increasingly have established recognisable logos, Fortran getting one in 2020,Jacob Williams. Degenerate Conic: New Blood. Retrieved 13 Oct 2021. British APL Association launched a campaign in the second half of 2021, to establish such a logo for APL, and after a community election and multiple rounds of feedback, a logo was chosen in May 2022.APL Wiki. APL logo. Retrieved 20 May 2022. |
APL (programming language) | Use | Use
APL is used for many purposes including financial and insurance applications, artificial intelligence,
neural networks
and robotics. It has been argued that APL is a calculation tool and not a programming language; its symbolic nature and array capabilities have made it popular with domain experts and data scientists who do not have or require the skills of a computer programmer.
APL is well suited to image manipulation and computer animation, where graphic transformations can be encoded as matrix multiplications. One of the first commercial computer graphics houses, Digital Effects, produced an APL graphics product named Visions, which was used to create television commercials and animation for the 1982 film Tron. Latterly, the Stormwind boating simulator uses APL to implement its core logic, its interfacing to the rendering pipeline middleware and a major part of its physics engine.
Today, APL remains in use in a wide range of commercial and scientific applications, for example
investment management,
asset management,
health care,
and DNA profiling. |
APL (programming language) | Notable implementations | Notable implementations |
APL (programming language) | APL\360 | APL\360
The first implementation of APL using recognizable APL symbols was APL\360 which ran on the IBM System/360, and was completed in November 1966 though at that time remained in use only within IBM. In 1973 its implementors, Larry Breed, Dick Lathwell and Roger Moore, were awarded the Grace Murray Hopper Award from the Association for Computing Machinery (ACM). It was given "for their work in the design and implementation of APL\360, setting new standards in simplicity, efficiency, reliability and response time for interactive systems."
In 1975, the IBM 5100 microcomputer offered APL\360 as one of two built-in ROM-based interpreted languages for the computer, complete with a keyboard and display that supported all the special symbols used in the language.
Significant developments to APL\360 included CMS/APL, which made use of the virtual storage capabilities of CMS and APLSV, which introduced shared variables, system variables and system functions. It was subsequently ported to the IBM System/370 and VSPC platforms until its final release in 1983, after which it was replaced by APL2. |
APL (programming language) | APL\1130 | APL\1130
In 1968, APL\1130 became the first publicly available APL system, created by IBM for the IBM 1130. It became the most popular IBM Type-III Library software that IBM released. |
APL (programming language) | APL*Plus and Sharp APL | APL*Plus and Sharp APL
APL*Plus and Sharp APL are versions of APL\360 with added business-oriented extensions such as data formatting and facilities to store APL arrays in external files. They were jointly developed by two companies, employing various members of the original IBM APL\360 development team.
The two companies were I. P. Sharp Associates (IPSA), an APL\360 services company formed in 1964 by Ian Sharp, Roger Moore and others, and STSC, a time-sharing and consulting service company formed in 1969 by Lawrence Breed and others. Together the two developed APL*Plus and thereafter continued to work together but develop APL separately as APL*Plus and Sharp APL. STSC ported APL*Plus to many platforms with versions being made for the VAX 11, PC and UNIX, whereas IPSA took a different approach to the arrival of the personal computer and made Sharp APL available on this platform using additional PC-XT/360 hardware. In 1993, Soliton Incorporated was formed to support Sharp APL and it developed Sharp APL into SAX (Sharp APL for Unix). , APL*Plus continues as APL2000 APL+Win.
In 1985, Ian Sharp, and Dan Dyer of STSC, jointly received the Kenneth E. Iverson Award for Outstanding Contribution to APL. |
APL (programming language) | APL2 | APL2
APL2 was a significant re-implementation of APL by IBM which was developed from 1971 and first released in 1984. It provides many additions to the language, of which the most notable is nested (non-rectangular) array support. The entire APL2 Products and Services Team was awarded the Iverson Award in 2007.
In 2021, IBM sold APL2 to Log-On Software, who develop and sell the product as Log-On APL2. |
APL (programming language) | APLGOL | APLGOL
In 1972, APLGOL was released as an experimental version of APL that added structured programming language constructs to the language framework. New statements were added for interstatement control, conditional statement execution, and statement structuring, as well as statements to clarify the intent of the algorithm. It was implemented for Hewlett-Packard in 1977. |
APL (programming language) | Dyalog APL | Dyalog APL
Dyalog APL was first released by British company Dyalog Ltd. in 1983 and, , is available for AIX, Linux (including on the Raspberry Pi), macOS and Microsoft Windows platforms. It is based on APL2, with extensions to support object-oriented programming, functional programming, and tacit programming. Licences are free for personal/non-commercial use.
In 1995, two of the development team – John Scholes and Peter Donnelly – were awarded the Iverson Award for their work on the interpreter. Gitte Christensen and Morten Kromberg were joint recipients of the Iverson Award in 2016. |
APL (programming language) | NARS2000 | NARS2000
NARS2000 is an open-source APL interpreter written by Bob Smith, a prominent APL developer and implementor from STSC in the 1970s and 1980s. NARS2000 contains advanced features and new datatypes and runs natively on Microsoft Windows, and other platforms under Wine. It is named after a development tool from the 1980s, NARS (Nested Arrays Research System). |
APL (programming language) | APLX | APLX
APLX is a cross-platform dialect of APL, based on APL2 and with several extensions, which was first released by British company MicroAPL in 2002. Although no longer in development or on commercial sale it is now available free of charge from Dyalog. |
APL (programming language) | York APL | York APL
York APL was developed at the York University, Ontario around 1968, running on IBM 360 mainframes. One notable difference between it and APL\360 was that it defined the "shape" (ρ) of a scalar as 1 whereas APL\360 defined it as the more mathematically correct 0 — this made it easier to write functions that acted the same with scalars and vectors. |
APL (programming language) | GNU APL | GNU APL
GNU APL is a free implementation of Extended APL as specified in ISO/IEC 13751:2001 and is thus an implementation of APL2. It runs on Linux, macOS, several BSD dialects, and on Windows (either using Cygwin for full support of all its system functions or as a native 64-bit Windows binary with some of its system functions missing). GNU APL uses Unicode internally and can be scripted. It was written by Jürgen Sauermann.
Richard Stallman, founder of the GNU Project, was an early adopter of APL, using it to write a text editor as a high school student in the summer of 1969. |
APL (programming language) | Interpretation and compilation of APL | Interpretation and compilation of APL
APL is traditionally an interpreted language, having language characteristics such as weak variable typing not well suited to compilation. However, with arrays as its core data structure it provides opportunities for performance gains through parallelism, parallel computing, massively parallel applications, and very-large-scale integration (VLSI), and from the outset APL has been regarded as a high-performance language – for example, it was noted for the speed with which it could perform complicated matrix operations "because it operates on arrays and performs operations like matrix inversion internally".
Nevertheless, APL is rarely purely interpreted and compilation or partial compilation techniques that are, or have been, used include the following: |
APL (programming language) | Idiom recognition | Idiom recognition
Most APL interpreters support idiom recognition and evaluate common idioms as single operations. For example, by evaluating the idiom BV/⍳⍴A as a single operation (where BV is a Boolean vector and A is an array), the creation of two intermediate arrays is avoided. |
APL (programming language) | Optimised bytecode | Optimised bytecode
Weak typing in APL means that a name may reference an array (of any datatype), a function or an operator. In general, the interpreter cannot know in advance which form it will be and must therefore perform analysis, syntax checking etc. at run-time. However, in certain circumstances, it is possible to deduce in advance what type a name is expected to reference and then generate bytecode which can be executed with reduced run-time overhead. This bytecode can also be optimised using compilation techniques such as constant folding or common subexpression elimination. The interpreter will execute the bytecode when present and when any assumptions which have been made are met. Dyalog APL includes support for optimised bytecode. |
APL (programming language) | Compilation | Compilation
Compilation of APL has been the subject of research and experiment since the language first became available; the first compiler is considered to be the Burroughs APL-700 which was released around 1971. In order to be able to compile APL, language limitations have to be imposed. APEX is a research APL compiler which was written by Robert Bernecky and is available under the GNU General Public License.
The STSC APL Compiler is a hybrid of a bytecode optimiser and a compiler – it enables compilation of functions to machine code provided that its sub-functions and globals are declared, but the interpreter is still used as a runtime library and to execute functions which do not meet the compilation requirements. |
APL (programming language) | Standards | Standards
APL has been standardized by the American National Standards Institute (ANSI) working group X3J10 and International Organization for Standardization (ISO) and International Electrotechnical Commission (IEC), ISO/IEC Joint Technical Committee 1 Subcommittee 22 Working Group 3. The Core APL language is specified in ISO 8485:1989, and the Extended APL language is specified in ISO/IEC 13751:2001. |
APL (programming language) | References | References |
APL (programming language) | Further reading | Further reading
An APL Machine (1970 Stanford doctoral dissertation by Philip Abrams)
A Personal History Of APL (1982 article by Michael S. Montalbano)
A Programming Language by Kenneth E. Iverson
APL in Exposition by Kenneth E. Iverson
Brooks, Frederick P.; Kenneth Iverson (1965). Automatic Data Processing, System/360 Edition. .
|
APL (programming language) | Video | Video
– a 1974 talk show style interview with the original developers of APL.
– a 1975 live demonstration of APL by Professor Bob Spence, Imperial College London.
– a 2009 tutorial by John Scholes of Dyalog Ltd. which implements Conway's Game of Life in a single line of APL.
– a 2009 introduction to APL by Graeme Robertson. |
APL (programming language) | External links | External links |
APL (programming language) | Online resources | Online resources
TryAPL.org, an online APL primer
APL2C, a source of links to APL compilers
Category:.NET programming languages
Category:Array programming languages
Category:Command shells
Category:Dynamic programming languages
Category:Dynamically typed programming languages
Category:Functional languages
Category:IBM software
Category:Programming languages created in 1964
Category:Programming languages with an ISO standard
Category:Programming languages
Category:Homoiconic programming languages
Category:Articles with example code |
APL (programming language) | Table of Content | Short description, History, Mathematical notation, Development into a computer programming language, Hardware, Commercial availability, Microcomputers, APL2, Modern implementations, Derivative languages, Language characteristics, Character set, Design, Terminology, Syntax, Examples, Hello, world, Exponentiation, Simple statistics, ''Pick 6'' lottery numbers, Prime numbers, Sorting, Game of Life, HTML tags removal, Naming, Logo, Use, Notable implementations, APL\360, APL\1130, APL*Plus and Sharp APL, APL2, APLGOL, Dyalog APL, NARS2000, APLX, York APL, GNU APL, Interpretation and compilation of APL, Idiom recognition, Optimised bytecode, Compilation, Standards, References, Further reading, Video, External links, Online resources |
ALGOL | Short description | ALGOL (; short for "Algorithmic Language")The name of this language family is sometimes given in mixed case (Algol 60 ), and sometimes in all uppercase (ALGOL68 ). For simplicity this article uses ALGOL. is a family of imperative computer programming languages originally developed in 1958. ALGOL heavily influenced many other languages and was the standard method for algorithm description used by the Association for Computing Machinery (ACM) in textbooks and academic sources for more than thirty years.Collected Algorithms of the ACM Compressed archives of the algorithms. ACM.
In the sense that the syntax of most modern languages is "Algol-like", it was arguably more influential than three other high-level programming languages among which it was roughly contemporary: FORTRAN, Lisp, and COBOL."The ALGOL Programming Language" , University of Michigan-Dearborn It was designed to avoid some of the perceived problems with FORTRAN and eventually gave rise to many other programming languages, including PL/I, Simula, BCPL, B, Pascal, Ada, and C.
ALGOL introduced code blocks and the begin...end pairs for delimiting them. It was also the first language implementing nested function definitions with lexical scope. Moreover, it was the first programming language which gave detailed attention to formal language definition and through the Algol 60 Report introduced Backus–Naur form, a principal formal grammar notation for language design.
There were three major specifications, named after the years they were first published:
ALGOL 58 – originally proposed to be called IAL, for International Algebraic Language.
ALGOL 60 – first implemented as X1 ALGOL 60 in 1961. Revised 1963.
ALGOL 68 – introduced new elements including flexible arrays, slices, parallelism, operator identification. Revised 1973.
ALGOL 68 is substantially different from ALGOL 60 and was not well received, so reference to "Algol" is generally understood to mean ALGOL 60 and its dialects. |
ALGOL | History | History
ALGOL was developed jointly by a committee of European and American computer scientists in a meeting in 1958 at the Swiss Federal Institute of Technology in Zurich (cf. ALGOL 58). It specified three different syntaxes: a reference syntax, a publication syntax, and an implementation syntax, syntaxes that permitted it to use different keyword names and conventions for decimal points (commas vs periods) for different languages.
ALGOL was used mostly by research computer scientists in the United States and in Europe; commercial applications were hindered by the absence of standard input/output facilities in its description, and the lack of interest in the language by large computer vendors (other than Burroughs Corporation). ALGOL 60 did however become the standard for the publication of algorithms and had a profound effect on future language development.
thumb|alt=caption|Family tree of the Algol, Fortran and COBOL programming language dynasty
John Backus developed the Backus normal form method of describing programming languages specifically for ALGOL 58. It was revised and expanded by Peter Naur for ALGOL 60, and at Donald Knuth's suggestion renamed Backus–Naur form.
Peter Naur: "As editor of the ALGOL Bulletin I was drawn into the international discussions of the language and was selected to be member of the European language design group in November 1959. In this capacity I was the editor of the ALGOL 60 report, produced as the result of the ALGOL 60 meeting in Paris in January 1960."ACM Award Citation: Peter Naur , 2005
The following people attended the meeting in Paris (from 11 to 16 January):
Friedrich Ludwig Bauer, Peter Naur, Heinz Rutishauser, Klaus Samelson, Bernard Vauquois, Adriaan van Wijngaarden, and Michael Woodger (from Europe)
John Warner Backus, Julien Green, Charles Katz, John McCarthy, Alan Jay Perlis, and Joseph Henry Wegstein (from the US).
Alan Perlis gave a vivid description of the meeting: "The meetings were exhausting, interminable, and exhilarating. One became aggravated when one's good ideas were discarded along with the bad ones of others. Nevertheless, diligence persisted during the entire period. The chemistry of the 13 was excellent." |
ALGOL | Legacy | Legacy
A significant contribution of the ALGOL 58 Report was to provide standard terms for programming concepts: statement, declaration, type, label, primary, block, and others.
ALGOL 60 inspired many languages that followed it. Tony Hoare remarked: "Here is a language so far ahead of its time that it was not only an improvement on its predecessors but also on nearly all its successors.""Hints on Programming Language Design" , C.A.R. Hoare, December 1973. Page 27. (This statement is sometimes erroneously attributed to Edsger W. Dijkstra, also involved in implementing the first ALGOL 60 compiler.) The Scheme programming language, a variant of Lisp that adopted the block structure and lexical scope of ALGOL, also adopted the wording "Revised Report on the Algorithmic Language Scheme" for its standards documents in homage to ALGOL. |
ALGOL | Properties | Properties
ALGOL 60 as officially defined had no I/O facilities; implementations defined their own in ways that were rarely compatible with each other. In contrast, ALGOL 68 offered an extensive library of transput (input/output) facilities.
ALGOL 60 allowed for two evaluation strategies for parameter passing: the common call-by-value, and call-by-name. Call-by-name has certain effects in contrast to call-by-reference. For example, without specifying the parameters as value or reference, it is impossible to develop a procedure that will swap the values of two parameters if the actual parameters that are passed in are an integer variable and an array that is indexed by that same integer variable., Section 7.5, and references therein Think of passing a pointer to swap(i, A[i]) in to a function. Now that every time swap is referenced, it is reevaluated. Say i := 1 and A[i] := 2, so every time swap is referenced it will return the other combination of the values ([1,2], [2,1], [1,2] and so on). A similar situation occurs with a random function passed as actual argument.
Call-by-name is known by many compiler designers for the interesting "thunks" that are used to implement it. Donald Knuth devised the "man or boy test" to separate compilers that correctly implemented "recursion and non-local references." This test contains an example of call-by-name.
ALGOL 68 was defined using a two-level grammar formalism invented by Adriaan van Wijngaarden and which bears his name. Van Wijngaarden grammars use a context-free grammar to generate an infinite set of productions that will recognize a particular ALGOL 68 program; notably, they are able to express the kind of requirements that in many other programming language standards are labelled "semantics" and have to be expressed in ambiguity-prone natural language prose, and then implemented in compilers as ad hoc code attached to the formal language parser. |
ALGOL | Examples and portability | Examples and portability |
ALGOL | Code sample comparisons | Code sample comparisons |
ALGOL | ALGOL 60 | ALGOL 60
(The way the bold text has to be written depends on the implementation, e.g. 'INTEGER'—quotation marks included—for integer. This is known as stropping.)
procedure Absmax(a) Size:(n, m) Result:(y) Subscripts:(i, k);
value n, m; array a; integer n, m, i, k; real y;
comment The absolute greatest element of the matrix a, of size n by m,
is copied to y, and the subscripts of this element to i and k;
begin
integer p, q;
y := 0; i := k := 1;
for p := 1 step 1 until n do
for q := 1 step 1 until m do
if abs(a[p, q]) > y then
begin y := abs(a[p, q]);
i := p; k := q
end
end Absmax
Here is an example of how to produce a table using Elliott 803 ALGOL."803 ALGOL" , the manual for Elliott 803 ALGOL
FLOATING POINT ALGOL TEST'
BEGIN REAL A,B,C,D'
READ D'
FOR A:= 0.0 STEP D UNTIL 6.3 DO
BEGIN
PRINT ,££L??'
B := SIN(A)'
C := COS(A)'
PRINT PUNCH(3),,,A,B,C'
END
END' |
ALGOL | ALGOL 68 | ALGOL 68
The following code samples are ALGOL 68 versions of the above ALGOL 60 code samples.
ALGOL 68 implementations used ALGOL 60's approaches to stropping. In ALGOL 68's case tokens with the bold typeface are reserved words, types (modes) or operators.
proc abs max = ([,]real a, ref real y, ref int i, k)real:
comment The absolute greatest element of the matrix a, of size ⌈a by 2⌈a
is transferred to y, and the subscripts of this element to i and k; comment
begin
real y := 0; i := ⌊a; k := 2⌊a;
for p from ⌊a to ⌈a do
for q from 2⌊a to 2⌈a do
if abs a[p, q] > y then
y := abs a[p, q];
i := p; k := q
fi
od
od;
y
end # abs max #
Note: lower (⌊) and upper (⌈) bounds of an array, and array slicing, are directly available to the programmer.
floating point algol68 test:
(
real a,b,c,d;
# printf – sends output to the file stand out. #
# printf($p$); – selects a new page #
printf(($pg$,"Enter d:"));
read(d);
for step from 0 while a:=step*d; a <= 2*pi do
printf($l$); # $l$ - selects a new line. #
b := sin(a);
c := cos(a);
printf(($z-d.6d$,a,b,c)) # formats output with 1 digit before and 6 after the decimal point. #
od
) |
ALGOL | Timeline: Hello world | Timeline: Hello world
The variations and lack of portability of the programs from one implementation to another is easily demonstrated by the classic hello world program. |
ALGOL | ALGOL 58 (IAL) | ALGOL 58 (IAL)
ALGOL 58 had no I/O facilities. |
ALGOL | ALGOL 60 family | ALGOL 60 family
Since ALGOL 60 had no I/O facilities, there is no portable hello world program in ALGOL.
The next three examples are in Burroughs Extended Algol. The first two direct output at the interactive terminal they are run on. The first uses a character array, similar to C. The language allows the array identifier to be used as a pointer to the array, and hence in a REPLACE statement.
A simpler program using an inline format:
An even simpler program using the Display statement. Note that its output would end up at the system console ('SPO'):
An alternative example, using Elliott Algol I/O is as follows. Elliott Algol used different characters for "open-string-quote" and "close-string-quote", represented here by and .
Below is a version from Elliott 803 Algol (A104). The standard Elliott 803 used five-hole paper tape and thus only had upper case. The code lacked any quote characters so £ (UK Pound Sign) was used for open quote and ? (Question Mark) for close quote. Special sequences were placed in double quotes (e.g£. £L?? produced a new line on the teleprinter).
HIFOLKS'
BEGIN
PRINT £HELLO WORLD£L??'
END'
The ICT 1900 series Algol I/O version allowed input from paper tape or punched card. Paper tape 'full' mode allowed lower case. Output was to a line printer. The open and close quote characters were represented using '(' and ')' and spaces by %.
'BEGIN'
WRITE TEXT('('HELLO%WORLD')');
'END' |
ALGOL | ALGOL 68 | ALGOL 68
ALGOL 68 code was published with reserved words typically in lowercase, but bolded or underlined.
begin
printf(($gl$,"Hello, world!"))
end
In the language of the "Algol 68 Report" the input/output facilities were collectively called the "Transput". |
ALGOL | Timeline of ALGOL special characters | Timeline of ALGOL special characters
The ALGOLs were conceived at a time when character sets were diverse and evolving rapidly; also, the ALGOLs were defined so that only uppercase letters were required.
1960: IFIP – The Algol 60 language and report included several mathematical symbols which are available on modern computers and operating systems, but, unfortunately, were unsupported on most computing systems at the time. For instance: ×, ÷, ≤, ≥, ≠, ¬, ∨, ∧, ⊂, ≡, ␣ and ⏨.
1961 September: ASCII – The ASCII character set, then in an early stage of development, had the \ (Back slash) character added to it in order to support ALGOL's Boolean operators /\ and \/.How ASCII Got Its Backslash , Bob Bemer
1962: ALCOR – This character set included the unusual "᛭" runic crossiron/runic cross character for multiplication and the "⏨" Decimal Exponent SymbolDecimal Exponent Symbol for floating point notation.
1964: GOST – The 1964 Soviet standard GOST 10859 allowed the encoding of 4-bit, 5-bit, 6-bit and 7-bit characters in ALGOL.
1968: The "Algol 68 Report" – used extant ALGOL characters, and further adopted →, ↓, ↑, □, ⌊, ⌈, ⎩, ⎧, ○, ⊥, and ¢ characters which can be found on the IBM 2741 keyboard with typeball (or golf ball) print heads inserted (such as the APL golf ball). These became available in the mid-1960s while ALGOL 68 was being drafted. The report was translated into Russian, German, French, and Bulgarian, and allowed programming in languages with larger character sets, e.g., Cyrillic alphabet of the Soviet BESM-4. All ALGOL's characters are also part of the Unicode standard and most of them are available in several popular fonts.
2009 October: Unicode – The ⏨ (Decimal Exponent Symbol) for floating point notation was added to Unicode 5.2 for backward compatibility with historic Buran programme ALGOL software. |
ALGOL | ALGOL implementations | ALGOL implementations
To date there have been at least 70 augmentations, extensions, derivations and sublanguages of Algol 60.
NameYearAuthorCountryDescriptionTarget CPU ZMMD-implementation 1958 Friedrich L. Bauer, Heinz Rutishauser, Klaus Samelson, Hermann Bottenbruch implementation of ALGOL 58 Z22 (later Zuse's Z23 was delivered with an Algol 60 compiler)Computer Museum History , Historical Zuse-Computer Z23, restored by the Konrad Zuse Schule in Hünfeld, for the Computer Museum History Center in Mountain View (California) USX1 ALGOL 60 1960 August Edsger W. Dijkstra and Jaap A. Zonneveld First implementation of ALGOL 60 Electrologica X1Elliott ALGOL 1960s C. A. R. Hoare Subject of the 1980 Turing Award Lecture Elliott 803, Elliott 503, Elliott 4100 seriesJOVIAL 1960 Jules Schwartz A DOD HOL prior to Ada Various (see article)Burroughs Algol (Several variants) 1961 Burroughs Corporation (with participation by Hoare, Dijkstra, and others) Basis of the Burroughs (and now Unisys MCP based) computers Burroughs Large Systems and their midrange also.Case ALGOL 1961 Case Institute of Technology Simula was originally contracted as a simulation extension of the Case ALGOL UNIVAC 1107GOGOL 1961 William M. McKeeman For ODIN time-sharing system PDP-1RegneCentralen ALGOL 1961 Peter Naur, Jørn Jensen Implementation of full Algol 60 DASK at RegnecentralenDartmouth ALGOL 30 1962 Thomas Eugene Kurtz et al. LGP-30USS 90 Algol 1962 L. Petrone ALGOL 601962Bernard Vauquois, Louis Bolliet Institut d'Informatique et Mathématiques Appliquées de Grenoble (IMAG) and Compagnie des Machines BullBull Gamma 60 Algol Translator 1962 G. van der Mey and W.L. van der Poel Staatsbedrijf der Posterijen, Telegrafie en Telefonie ZEBRAKidsgrove Algol 1963 F. G. Duncan English Electric Company KDF9VALGOL 1963 Val Schorre A test of the META II compiler compilerWhetstone 1964 Brian Randell and L. J. Russell Atomic Power Division of English Electric Company. Precursor to Ferranti Pegasus, National Physical Laboratories ACE and English Electric DEUCE implementations. English Electric Company KDF9NU ALGOL 1965 UNIVACALGEK 1965 АЛГЭК, based on ALGOL-60 and COBOL support, for economical tasks Minsk-22ALGOL W 1966 Niklaus Wirth Proposed successor to ALGOL 60 IBM System/360MALGOL 1966 publ. A. Viil, M Kotli & M. Rakhendi, Minsk-22ALGAMS 1967 GAMS group (ГАМС, группа автоматизации программирования для машин среднего класса), cooperation of Comecon Academies of Science Comecon Minsk-22, later ES EVM, BESMALGOL/ZAM 1967 Polish ZAM computerSimula 67 1967 Ole-Johan Dahl and Kristen Nygaard Algol 60 with classes UNIVAC 1107Triplex-ALGOL Karlsruhe 1967/1968 Karlsruhe, ALGOL 60 (1963) with triplex numbers for interval arithmetic Chinese Algol 1972 Chinese characters, expressed via the Symbol systemDG/L 1972 DG Eclipse family of ComputersS-algol 1979 Ron Morrison Addition of orthogonal datatypes with intended use as a teaching language PDP-11 with a subsequent implementation on the Java VM
The Burroughs dialects included special Bootstrapping dialects such as ESPOL and NEWP. The latter is still used for Unisys MCP system software. |
ALGOL | See also | See also |
ALGOL | References | References |
ALGOL | Further reading | Further reading
. On the design of the Whetstone Compiler, and one of the early published descriptions of implementing a compiler.
|
ALGOL | External links | External links
Revised Report on the Algorithmic Language Algol 60 by Peter Naur, et al.
The European Side of the Last Phase of the Development of ALGOL 60, by Peter Naur
A History of ALGOL from the Computer History Museum
Category:ALGOL 60 dialect
Category:Articles with example ALGOL 60 code
Category:Computer-related introductions in 1958
Category:Procedural programming languages
Category:Programming languages created in 1958
Category:Structured programming languages
Category:Systems programming languages |
ALGOL | Table of Content | Short description, History, Legacy, Properties, Examples and portability, Code sample comparisons, ALGOL 60, ALGOL 68, Timeline: Hello world, ALGOL 58 (IAL), ALGOL 60 family, ALGOL 68, Timeline of ALGOL special characters, ALGOL implementations, See also, References, Further reading, External links |
AWK | Short description | AWK () is a domain-specific language designed for text processing and typically used as a data extraction and reporting tool. Like sed and grep, it is a filter, and it is a standard feature of most Unix-like operating systems.
The AWK language is a data-driven scripting language consisting of a set of actions to be taken against streams of textual data – either run directly on files or used as part of a pipeline – for purposes of extracting or transforming text, such as producing formatted reports. The language extensively uses the string datatype, associative arrays (that is, arrays indexed by key strings), and regular expressions. While AWK has a limited intended application domain and was especially designed to support one-liner programs, the language is Turing-complete, and even the early Bell Labs users of AWK often wrote well-structured large AWK programs.
AWK was created at Bell Labs in the 1970s, and its name is derived from the surnames of its authors: Alfred Aho (author of egrep), Peter Weinberger (who worked on tiny relational databases), and Brian Kernighan. The acronym is pronounced the same as the name of the bird species auk, which is illustrated on the cover of The AWK Programming Language. When written in all lowercase letters, as awk, it refers to the Unix or Plan 9 program that runs scripts written in the AWK programming language. |
AWK | History | History
According to Brian Kernighan, one of the goals of AWK was to have a tool that would easily manipulate both numbers and strings. AWK was also inspired by Marc Rochkind's programming language that was used to search for patterns in input data, and was implemented using yacc.
As one of the early tools to appear in Version 7 Unix, AWK added computational features to a Unix pipeline besides the Bourne shell, the only scripting language available in a standard Unix environment. It is one of the mandatory utilities of the Single UNIX Specification, and is required by the Linux Standard Base specification.
In 1983, AWK was one of several UNIX tools available for Charles River Data Systems' UNOS operating system under Bell Laboratories license.
AWK was significantly revised and expanded in 1985–88, resulting in the GNU AWK implementation written by Paul Rubin, Jay Fenlason, and Richard Stallman, released in 1988. GNU AWK may be the most widely deployed version because it is included with GNU-based Linux packages. GNU AWK has been maintained solely by Arnold Robbins since 1994. Brian Kernighan's nawk (New AWK) source was first released in 1993 unpublicized, and publicly since the late 1990s; many BSD systems use it to avoid the GPL license.
AWK was preceded by sed (1974). Both were designed for text processing. They share the line-oriented, data-driven paradigm, and are particularly suited to writing one-liner programs, due to the implicit main loop and current line variables. The power and terseness of early AWK programs – notably the powerful regular expression handling and conciseness due to implicit variables, which facilitate one-liners – together with the limitations of AWK at the time, were important inspirations for the Perl language (1987). In the 1990s, Perl became very popular, competing with AWK in the niche of Unix text-processing languages. |
AWK | Structure of AWK programs | Structure of AWK programs
thumb
An AWK program is a series of pattern action pairs, written as:
condition { action }
condition { action }
...
where condition is typically an expression and action is a series of commands. The input is split into records, where by default records are separated by newline characters so that the input is split into lines. The program tests each record against each of the conditions in turn, and executes the action for each expression that is true. Either the condition or the action may be omitted. The condition defaults to matching every record. The default action is to print the record. This is the same pattern-action structure as sed.
In addition to a simple AWK expression, such as foo == 1 or /^foo/, the condition can be BEGIN or END causing the action to be executed before or after all records have been read, or pattern1, pattern2 which matches the range of records starting with a record that matches pattern1 up to and including the record that matches pattern2 before again trying to match against pattern1 on subsequent lines.
In addition to normal arithmetic and logical operators, AWK expressions include the tilde operator, ~, which matches a regular expression against a string. As handy syntactic sugar, /regexp/ without using the tilde operator matches against the current record; this syntax derives from sed, which in turn inherited it from the ed editor, where / is used for searching. This syntax of using slashes as delimiters for regular expressions was subsequently adopted by Perl and ECMAScript, and is now common. The tilde operator was also adopted by Perl. |
AWK | Commands | Commands
AWK commands are the statements that are substituted for action in the examples above. AWK commands can include function calls, variable assignments, calculations, or any combination thereof. AWK contains built-in support for many functions; many more are provided by the various flavors of AWK. Also, some flavors support the inclusion of dynamically linked libraries, which can also provide more functions. |
AWK | The ''print'' command | The print command
The print command is used to output text. The output text is always terminated with a predefined string called the output record separator (ORS) whose default value is a newline. The simplest form of this command is:
print
This displays the contents of the current record. In AWK, records are broken down into fields, and these can be displayed separately:
print $1
Displays the first field of the current record
print $1, $3
Displays the first and third fields of the current record, separated by a predefined string called the output field separator (OFS) whose default value is a single space character
Although these fields ($X) may bear resemblance to variables (the $ symbol indicates variables in the usual Unix shells and in Perl), they actually refer to the fields of the current record. A special case, $0, refers to the entire record. In fact, the commands "print" and "print $0" are identical in functionality.
The print command can also display the results of calculations and/or function calls:
/regex_pattern/ {
# Actions to perform in the event the record (line) matches the above regex_pattern
print 3+2
print foobar(3)
print foobar(variable)
print sin(3-2)
}
Output may be sent to a file:
/regex_pattern/ {
# Actions to perform in the event the record (line) matches the above regex_pattern
print "expression" > "file name"
}
or through a pipe:
/regex_pattern/ {
# Actions to perform in the event the record (line) matches the above regex_pattern
print "expression" | "command"
} |
AWK | Built-in variables | Built-in variables
AWK's built-in variables include the field variables: $1, $2, $3, and so on ($0 represents the entire record). They hold the text or values in the individual text-fields in a record.
Other variables include:
NR: Number of Records. Keeps a current count of the number of input records read so far from all data files. It starts at zero, but is never automatically reset to zero.
FNR: File Number of Records. Keeps a current count of the number of input records read so far in the current file. This variable is automatically reset to zero each time a new file is started.
NF: Number of Fields. Contains the number of fields in the current input record. The last field in the input record can be designated by $NF, the 2nd-to-last field by $(NF-1), the 3rd-to-last field by $(NF-2), etc.
FILENAME: Contains the name of the current input-file.
FS: Field Separator. Contains the "field separator" used to divide fields in the input record. The default, "white space", allows any sequence of space and tab characters. FS can be reassigned with another character or character sequence to change the field separator.
RS: Record Separator. Stores the current "record separator" character. Since, by default, an input line is the input record, the default record separator character is a "newline".
OFS: Output Field Separator. Stores the "output field separator", which separates the fields when awk prints them. The default is a "space" character.
ORS: Output Record Separator. Stores the "output record separator", which separates the output records when awk prints them. The default is a "newline" character.
OFMT: Output Format. Stores the format for numeric output. The default format is "%.6g". |
AWK | Variables and syntax | Variables and syntax
Variable names can use any of the characters [A-Za-z0-9_], with the exception of language keywords, and cannot begin with a numeric digit. The operators + - * / represent addition, subtraction, multiplication, and division, respectively. For string concatenation, simply place two variables (or string constants) next to each other. It is optional to use a space in between if string constants are involved, but two variable names placed adjacent to each other require a space in between. Double quotes delimit string constants. Statements need not end with semicolons. Finally, comments can be added to programs by using # as the first character on a line, or behind a command or sequence of commands. |
AWK | User-defined functions | User-defined functions
In a format similar to C, function definitions consist of the keyword function, the function name, argument names and the function body. Here is an example of a function.
function add_three(number) {
return number + 3
}
This statement can be invoked as follows:
(pattern) {
print add_three(36) # Outputs '''39'''
}
Functions can have variables that are in the local scope. The names of these are added to the end of the argument list, though values for these should be omitted when calling the function. It is convention to add some whitespace in the argument list before the local variables, to indicate where the parameters end and the local variables begin. |
AWK | Examples | Examples |
AWK | Hello, World! | Hello, World!
Here is the customary "Hello, World!" program written in AWK:
BEGIN {
print "Hello, world!"
exit
} |
AWK | Print lines longer than 80 characters | Print lines longer than 80 characters
Print all lines longer than 80 characters. The default action is to print the current line.
length($0) > 80 |
AWK | Count words | Count words
Count words in the input and print the number of lines, words, and characters (like wc):
{
words += NF
chars += length + 1 # add one to account for the newline character at the end of each record (line)
}
END { print NR, words, chars }
As there is no pattern for the first line of the program, every line of input matches by default, so the increment actions are executed for every line. words += NF is shorthand for words = words + NF. |
AWK | Sum last word | Sum last word
{ s += $NF }
END { print s + 0 }
s is incremented by the numeric value of $NF, which is the last word on the line as defined by AWK's field separator (by default, white-space). NF is the number of fields in the current line, e.g. 4. Since $4 is the value of the fourth field, $NF is the value of the last field in the line regardless of how many fields this line has, or whether it has more or fewer fields than surrounding lines. $ is actually a unary operator with the highest operator precedence. (If the line has no fields, then NF is 0, $0 is the whole line, which in this case is empty apart from possible white-space, and so has the numeric value 0.)
At the end of the input, the END pattern matches, so s is printed. However, since there may have been no lines of input at all, in which case no value has ever been assigned to s, s will be an empty string by default. Adding zero to a variable is an AWK idiom for coercing it from a string to a numeric value. This results from AWK's arithmetic operators, like addition, implicitly casting their operands to numbers before computation as required. (Similarly, concatenating a variable with an empty string coerces from a number to a string, e.g., s "". Note, there is no operator to concatenate strings, they are just placed adjacently.) On an empty input, the coercion in { print s + 0 } causes the program to print 0, whereas with just the action { print s }, an empty line would be printed. |
AWK | Match a range of input lines | Match a range of input lines
NR % 4 == 1, NR % 4 == 3 { printf "%6d %s\n", NR, $0 }
The action statement prints each line numbered. The printf function emulates the standard C printf and works similarly to the print command described above. The pattern to match, however, works as follows: NR is the number of records, typically lines of input, AWK has so far read, i.e. the current line number, starting at 1 for the first line of input. % is the modulo operator. NR % 4 == 1 is true for the 1st, 5th, 9th, etc., lines of input. Likewise, NR % 4 == 3 is true for the 3rd, 7th, 11th, etc., lines of input. The range pattern is false until the first part matches, on line 1, and then remains true up to and including when the second part matches, on line 3. It then stays false until the first part matches again on line 5.
Thus, the program prints lines 1,2,3, skips line 4, and then 5,6,7, and so on. For each line, it prints the line number (on a 6 character-wide field) and then the line contents. For example, when executed on this input:
Rome
Florence
Milan
Naples
Turin
Venice
The previous program prints:
1 Rome
2 Florence
3 Milan
5 Turin
6 Venice |
AWK | Printing the initial or the final part of a file | Printing the initial or the final part of a file
As a special case, when the first part of a range pattern is constantly true, e.g. 1, the range will start at the beginning of the input. Similarly, if the second part is constantly false, e.g. 0, the range will continue until the end of input. For example,
/^--cut here--$/, 0
prints lines of input from the first line matching the regular expression ^--cut here--$, that is, a line containing only the phrase "--cut here--", to the end. |
AWK | Calculate word frequencies | Calculate word frequencies
Word frequency using associative arrays:
BEGIN {
FS="[^a-zA-Z]+"
}
{
for (i=1; i<=NF; i++)
words[tolower($i)]++
}
END {
for (i in words)
print i, words[i]
}
The BEGIN block sets the field separator to any sequence of non-alphabetic characters. Separators can be regular expressions. After that, we get to a bare action, which performs the action on every input line. In this case, for every field on the line, we add one to the number of times that word, first converted to lowercase, appears. Finally, in the END block, we print the words with their frequencies. The line
for (i in words)
creates a loop that goes through the array words, setting i to each subscript of the array. This is different from most languages, where such a loop goes through each value in the array. The loop thus prints out each word followed by its frequency count. tolower was an addition to the One True awk (see below) made after the book was published. |
AWK | Match pattern from command line | Match pattern from command line
This program can be represented in several ways. The first one uses the Bourne shell to make a shell script that does everything. It is the shortest of these methods:
#!/bin/sh
pattern="$1"
shift
awk '/'"$pattern"'/ { print FILENAME ":" $0 }' "$@"
The $pattern in the awk command is not protected by single quotes so that the shell does expand the variable but it needs to be put in double quotes to properly handle patterns containing spaces. A pattern by itself in the usual way checks to see if the whole line ($0) matches. FILENAME contains the current filename. awk has no explicit concatenation operator; two adjacent strings concatenate them. $0 expands to the original unchanged input line.
There are alternate ways of writing this. This shell script accesses the environment directly from within awk:
#!/bin/sh
export pattern="$1"
shift
awk '$0 ~ ENVIRON["pattern"] { print FILENAME ":" $0 }' "$@"
This is a shell script that uses ENVIRON, an array introduced in a newer version of the One True awk after the book was published. The subscript of ENVIRON is the name of an environment variable; its result is the variable's value. This is like the getenv function in various standard libraries and POSIX. The shell script makes an environment variable pattern containing the first argument, then drops that argument and has awk look for the pattern in each file.
~ checks to see if its left operand matches its right operand; !~ is its inverse. A regular expression is just a string and can be stored in variables.
The next way uses command-line variable assignment, in which an argument to awk can be seen as an assignment to a variable:
#!/bin/sh
pattern="$1"
shift
awk '$0 ~ pattern { print FILENAME ":" $0 }' pattern="$pattern" "$@"
Or You can use the -v var=value command line option (e.g. awk -v pattern="$pattern" ...).
Finally, this is written in pure awk, without help from a shell or without the need to know too much about the implementation of the awk script (as the variable assignment on command line one does), but is a bit lengthy:
BEGIN {
pattern = ARGV[1]
for (i = 1; i < ARGC; i++) # remove first argument
ARGV[i] = ARGV[i + 1]
ARGC--
if (ARGC == 1) { # the pattern was the only thing, so force read from standard input (used by book)
ARGC = 2
ARGV[1] = "-"
}
}
$0 ~ pattern { print FILENAME ":" $0 }
The BEGIN is necessary not only to extract the first argument, but also to prevent it from being interpreted as a filename after the BEGIN block ends. ARGC, the number of arguments, is always guaranteed to be ≥1, as ARGV[0] is the name of the command that executed the script, most often the string "awk". ARGV[ARGC] is the empty string, "". # initiates a comment that expands to the end of the line.
Note the if block. awk only checks to see if it should read from standard input before it runs the command. This means that
awk 'prog'
only works because the fact that there are no filenames is only checked before prog is run! If you explicitly set ARGC to 1 so that there are no arguments, awk will simply quit because it feels there are no more input files. Therefore, you need to explicitly say to read from standard input with the special filename -. |
AWK | Self-contained AWK scripts | Self-contained AWK scripts
On Unix-like operating systems self-contained AWK scripts can be constructed using the shebang syntax.
For example, a script that sends the content of a given file to standard output may be built by creating a file named print.awk with the following content:
#!/usr/bin/awk -f
{ print $0 }
It can be invoked with: ./print.awk <filename>
The -f tells awk that the argument that follows is the file to read the AWK program from, which is the same flag that is used in sed. Since they are often used for one-liners, both these programs default to executing a program given as a command-line argument, rather than a separate file. |
AWK | Versions and implementations | Versions and implementations
AWK was originally written in 1977 and distributed with Version 7 Unix.
In 1985 its authors started expanding the language, most significantly by adding user-defined functions. The language is described in the book The AWK Programming Language, published 1988, and its implementation was made available in releases of UNIX System V. To avoid confusion with the incompatible older version, this version was sometimes called "new awk" or nawk. This implementation was released under a free software license in 1996 and is still maintained by Brian Kernighan (see external links below).
Old versions of Unix, such as UNIX/32V, included awkcc, which converted AWK to C. Kernighan wrote a program to turn awk into ; its state is not known.
BWK awk, also known as nawk, refers to the version by Brian Kernighan. It has been dubbed the "One True AWK" because of the use of the term in association with the book that originally described the language and the fact that Kernighan was one of the original authors of AWK. FreeBSD refers to this version as one-true-awk. This version also has features not in the book, such as tolower and ENVIRON that are explained above; see the FIXES file in the source archive for details. This version is used by, for example, Android, FreeBSD, NetBSD, OpenBSD, macOS, and illumos. Brian Kernighan and Arnold Robbins are the main contributors to a source repository for nawk: .
gawk (GNU awk) is another free-software implementation and the only implementation that makes serious progress implementing internationalization and localization and TCP/IP networking. It was written before the original implementation became freely available. It includes its own debugger, and its profiler enables the user to make measured performance enhancements to a script. It also enables the user to extend functionality with shared libraries. Some Linux distributions include gawk as their default AWK implementation. As of version 5.2 (September 2022) gawk includes a persistent memory feature that can remember script-defined variables and functions from one invocation of a script to the next and pass data between unrelated scripts, as described in the Persistent-Memory gawk User Manual: .
gawk-csv. The CSV extension of gawk provides facilities for inputting and outputting CSV formatted data.
mawk is a very fast AWK implementation by Mike Brennan based on a bytecode interpreter.
libmawk is a fork of mawk, allowing applications to embed multiple parallel instances of awk interpreters.
awka (whose front end is written atop the mawk program) is another translator of AWK scripts into C code. When compiled, statically including the author's libawka.a, the resulting executables are considerably sped up and, according to the author's tests, compare very well with other versions of AWK, Perl, or Tcl. Small scripts will turn into programs of 160–170 kB.
tawk (Thompson AWK) is an AWK compiler for Solaris, DOS, OS/2, and Windows, previously sold by Thompson Automation Software (which has ceased its activities).
Jawk is a project to implement AWK in Java, hosted on SourceForge. Extensions to the language are added to provide access to Java features within AWK scripts (i.e., Java threads, sockets, collections, etc.).
xgawk is a fork of gawk that extends gawk with dynamically loadable libraries. The XMLgawk extension was integrated into the official GNU Awk release 4.1.0.
QSEAWK is an embedded AWK interpreter implementation included in the QSE library that provides embedding application programming interface (API) for C and C++.
libfawk is a very small, function-only, reentrant, embeddable interpreter written in C
BusyBox includes an AWK implementation written by Dmitry Zakharov. This is a very small implementation suitable for embedded systems.
CLAWK by Michael Parker provides an AWK implementation in Common Lisp, based upon the regular expression library of the same author.
goawk is an AWK implementation in Go with a few convenience extensions by Ben Hoyt, hosted on Github.
The gawk manual has a list of more AWK implementations. |
AWK | Books | Books
|
AWK | See also | See also
Data transformation
Event-driven programming
List of Unix commands
sed |
AWK | References | References |
AWK | Further reading | Further reading
– Interview with Alfred V. Aho on AWK
AWK – Become an expert in 60 minutes
|
AWK | External links | External links
The Amazing Awk Assembler by Henry Spencer.
awklang.org The site for things related to the awk language
Category:1977 software
Category:Cross-platform software
Category:Domain-specific programming languages
Category:Free and open source interpreters
Category:Pattern matching programming languages
Category:Plan 9 commands
Category:Programming languages created in 1977
Category:Scripting languages
Category:Standard Unix programs
Category:Text-oriented programming languages
Category:Unix SUS2008 utilities
Category:Unix text processing utilities |
AWK | Table of Content | Short description, History, Structure of AWK programs, Commands, The ''print'' command, Built-in variables, Variables and syntax, User-defined functions, Examples, Hello, World!, Print lines longer than 80 characters, Count words, Sum last word, Match a range of input lines, Printing the initial or the final part of a file, Calculate word frequencies, Match pattern from command line, Self-contained AWK scripts, Versions and implementations, Books, See also, References, Further reading, External links |
Asgard | about | In Nordic mythology, Asgard (Old Norse: Ásgarðr; "Garden of the Æsir") is a location associated with the gods. It appears in several Old Norse sagas and mythological texts, including the Eddas, however it has also been suggested to be referred to indirectly in some of these sources. It is described as the fortified home of the Æsir gods and is often associated with gold imagery and contains many other locations known in Nordic mythology such as Valhöll, Iðavöllr and Hlidskjálf.
In some euhemeristic accounts, Asgard is portrayed as being a city in Asia or Troy, however in other accounts that likely more accurately reflect its conception in Old Norse religion, it is depicted as not conforming to a naturalistic geographical position. In these latter accounts, it is found in a range of locations such as over the rainbow bridge Bifröst, in the middle of the world and over the sea. |
Asgard | Etymology | Etymology
The compound word Ásgarðr combines Old Norse ("god") and ("enclosure"). Possible anglicisations include: Ásgarthr, Ásgard, Ásegard, Ásgardr, Asgardr, Ásgarth, Asgarth, Esageard, and Ásgardhr. |
Asgard | Attestations | Attestations |
Asgard | The Poetic Edda | The Poetic Edda
Asgard is named twice in Eddic poetry. The first case is in Hymiskviða, when Thor and Týr journey from Asgard to Hymir's hall to obtain a cauldron large enough to brew beer for a feast for Ægir and the gods. The second instance is in Þrymskviða when Loki is attempting to convince Thor to dress up as Freyja in order to get back Mjölnir by claiming that without his hammer to protect them, jötnar would soon be living in Asgard.
Grímnismál contains among its cosmological descriptions, a number of abodes of the gods, such as Álfheim, Nóatún and Valhalla, which some scholars have identified as being in Asgard. Asgard is not mentioned at any point in the poem. Furthermore, Völuspá references Iðavöllr, one of the most common meeting places of Æsir gods, which in Gylfaginning, Snorri locates in the centre of Asgard. |
Asgard | The Prose Edda | The Prose Edda |
Asgard | Prologue | Prologue
The Prose Edda's euhemeristic prologue portrays the Æsir gods as people who travelled from the East to northern territories. According to Snorri, Asgard represented the town of Troy before Greek warriors overtook it. After the defeat, Trojans moved to northern Europe, where they became a dominant group due to their "advanced technologies and culture". Eventually, other tribes began to perceive the Trojans and their leader Trór (Thor in Old Norse) as gods. |
Asgard | Gylfaginning | Gylfaginning
In Gylfaginning, Snorri Sturluson describes how during the creation of the world, the gods made the earth and surrounded it with the sea. They made the sky from the skull of Ymir and settled the on the shores of the earth. They set down the brows of Ymir, forming Midgard, and in the centre of the world they built Asgard, which he identifies as Troy:
Old Norse text Brodeur translationNext they made for themselves in the middle of the world a city which is called Ásgard; men call it Troy. There dwelt the gods and their kindred; and many tidings and tales of it have come to pass both on earth and aloft. There is one abode called Hlidskjálf, and when Allfather sat in the high-seat there, he looked out over the whole world and saw every man's acts, and knew all things which he saw.
After Asgard is made, the gods then built a hof named Glaðsheimr at Iðavöllr, in the centre of the burg, or walled city, with a high seat for Odin and twelve seats for other gods. It is described as like gold both on the inside and the outside, and as the best of all buildings in the world. They also built Vingólf for the female gods, which is described as both a hall and a hörgr, and a forge with which they crafted objects from gold. After Ragnarök, some gods such as Váli and Baldr will meet at Iðavöllr where Asgard once stood and discuss matters together. There they will also find in the grass the golden chess pieces that the Æsir had once owned.
Later, the section describes how an unnamed jötunn came to the gods with his stallion, Svaðilfari and offered help in building a burg for the gods in three winters, asking in return for the sun, moon, and marriage with Freyja. Despite Freyja's opposition, together the gods agree to fulfill his request if he completes his work in just one winter. As time goes on, the gods grow desperate as it becomes apparent that the jötunn will construct the burg on time. To their surprise, his stallion contributes much of the progress, swiftly moving boulders and rocks. To deal with the problem, Loki comes up with a plan whereupon he changes his appearance to that of a mare, and distracts Svaðilfari to slow down construction. Without the help of his stallion, the builder realises he cannot complete his task in time and goes into a rage, revealing his identity as a jötunn. Thor then kills the builder with Mjöllnir, before any harm to the gods is done. The chapter does not explicitly name Asgard as the fortress but they are commonly identified by scholars.
In Gylfaginning, the central cosmic tree Yggdrasil is described as having three roots that hold it up; one of these goes to the Æsir, which has been interpreted as meaning Asgard. In Grímnismál, this root instead reaches over the realm of men. The bridge Bifröst is told to span from the heavens to the earth and over it the Æsir cross each day to hold council beneath Yggdrasil at the Urðarbrunnr. Based on this, Bifröst is commonly interpreted as the bridge to Asgard. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.