INTERCAL (1972)
INTERCAL is a languaged developed by Don Woods and James Lyon while they were freshman students at Princeton University. It was created to spoof the languages at the time and the methodologies that surrounded programming in the early 70s, and this is reflected in everything from the programming manual, the name of its compiler (“ick”) to its choice of keywords.
It is also virtually illegible to anyone without a deep understanding of the language and the program being viewed, as its use of nonsensical keywords is only outdone by the heavy emphasis on cryptic symbols in expressions. Rather than named variables, it contains numbered stacks of various types (denoted by the symbol in front of the number, “,” being the symbol for an array of 16-bit integers) where you push data. Text is represented by their numerical values and can only be seen when the program is run.
The language was made as a joke and is unnecessarily complicated for that reason, barring it from any other use than as a challenge for would-be hackers. The creators moved on to bigger and better things and never thought the language would gain such popularity.
helloworld.i
DO ,1 <- #13
PLEASE DO ,1 SUB #1 <- #238
DO ,1 SUB #2 <- #108
DO ,1 SUB #3 <- #112
DO ,1 SUB #4 <- #0
DO ,1 SUB #5 <- #64
DO ,1 SUB #6 <- #194
DO ,1 SUB #7 <- #48
PLEASE DO ,1 SUB #8 <- #22
DO ,1 SUB #9 <- #248
DO ,1 SUB #10 <- #168
DO ,1 SUB #11 <- #24
DO ,1 SUB #12 <- #16
DO ,1 SUB #13 <- #162
PLEASE READ OUT ,1
PLEASE GIVE UP
Source(s):
Note: Thanks to Olav Frengstad for the code example.
ALGOL (1958)
ALGOL is a set of languages defined by reports written in collaboration between America and a set of European countries. It was the result of conferences held concerning the portability of programming languages and it was designed to be a translatable language which was highly machine-independent.
The three documents, titled ALGOL 58, ALGOL 60 and ALGOL 68, defined the syntax and implementation of the language with an intent to provide comparable high-level features as found in other contemporary languages while being open to localized implementations when it came to grammar, syntax and number formats.
The language never gained as much popularity as other languages at the time, as machine vendors were hesitant towards the difficult implementation due to the heavy focus on portability and interoperability. However, ALGOL took several major strides in terms of syntax design and hardware-independence and modern languages are still referred to as ALGOL-like.
helloworld.algol
main: (
printf($"Hello world!"l$)
)
Source(s):
Lisp (1958)
Lisp is a set of functional programming languages that follow a particular format, using parentheses around Polish prefix notation to describe instructions. It was created by John McCarthy at MIT and spread quickly as the implementation was very straightforward and simple, having just a few operators and a syntax for functions.
Due to its widespread portability, lots of diverse dialects splintered off from the main idea and it wasn’t until the mid-80s that a standard, referred to as “Common Lisp” was defined and agreed upon. Common Lisp was attempt to remove the chaotic separation of the Lisp dialects and have a set of standard supported features. It trimmed away a lot of the unconventional features and set in stone a standard for Lisp implementations to follow.
Another variant of Lisp which is still used is Scheme, which is popular due to its small size and relatively basic implementation. It was created by Gerald Jay Sussman and Guy Steele as a way to bring object-orientation to Lisp in the form of actors which could receive and respond to messages. It changed Lisp to become more modular and pieces of the program could be run independently.
Lisp is still used in functional programming where heavy computability and stability is necessary and, being one of the earliest programming languages, stands as an inspiration for newer langauges.
helloworld.lisp
(format t "Hello world!~%")
helloworld.scheme
(display "Hello world!")
Source(s):
PostScript (1985)
PostScript is a “page description language” developed by Adobe. It was created for printing graphics and text on paper and was meant as a device-independent way of sending instructions to the printer so that any printer, independent of its resolution or paper size, could use the same instructions to print the desired image.
PostScript uses Reverse Polish notation where the operator would be placed after the operands in an expression and the resulting value would be pushed to the stack to be used later. Later versions of the language have added features such as functions and greater support for images and fonts, but the basic format is unchanged.
PostScript is still considered an industry standard and is supported by most, if not all, printer manufacturers. However, as a format for producing documents, the PDF format, also developed by Adobe, has overtaken postscript as the de-facto format for transferring formatted text documents and PDF processors, which are needed to read the PDF document, are more commonly packaged with operating systems as a result.
helloworld.eps
(Hello world!) ==
Source(s):
Logo (1967)
Logo is a functional programming language, loosely based on Lisp, which was created at MIT which was intended to be a learning tool for budding programmers. Logo was designed to be accessible to novices while still retaining the power to build complicated systems and simulations.
The most popular use of Logo is the Turtle, an entity which will draw a line wherever it goes and can be programmed to construct complex shapes by using forward motion and rotation instructions. It has become a popular way to teach the concepts of programming and computer instruction to schoolchildren.
MIT developed versions of Logo to run on Apple and Texas Instruments machines, which cemented its use in education. This, coupled with the very basic syntax which could be translated to other languages, meant it was a natural choice for schools starting to place computers in their classrooms during the late 70s. There was a major boom in Logo during the early 80s as educators saw its benefits, but the popularity waned as MSDOS machines were starting to become the norm in classrooms around the world. The Logo Foundation continued to focus on Mac platforms and still has existing software for drawing graphics and producing sound.
helloworld.logo
print [Hello world!]
Source(s):
BASIC (1964)
BASIC is an acronym for Beginners All-purpose Symbolic Instruction Code and the name reflects the intent behind the creation of the language. It was developed at Dartmouth College in 1964 by Thomas E. Kurtz and John George Kemeny. They felt that the languages being used at the time (Fortran and Algol) were designed by professionals for other professionals and there didn’t exist a language built for students to learn the basic concepts of programming, so they set about making one.
BASIC was to be the antithesis to Fortran and consisted of basic instructions, few keywords and a simplistic syntax. All the instructions were numbered and the programs used goto commands to jump to the various numbered lines. The language became incredibly popular and was a major part of the growth of hobby coding, especially for video games.
Since its initial creation, BASIC has been ported to tons of platforms and has a large variety of dialects. A major leap in the adoption of BASIC came with the explosion of home computing and many hobby computers shipped with a BASIC interpreter and little else. Its popularity was such that when Microsoft was building its PC-DOS platform they created a custom BASIC interpreter to go with it and Microsoft’s relationship with BASIC has continued to this day with a dialect of BASIC called Visual Basic being an integral part of their .NET development platform.
helloworld.bas
10 PRINT "Hello world!"
Source(s):
Go (2009)
Go was built at Google with the intent to create a language that combined the strength of compiled languages with the dynamic nature of scripted languages. It was released in an early alpha form in 2009, but gained popularity amongst the open-source community and has been growing steadily, to the point where it is being used by Google to build parts of their ever-complicated infrastructure.
The intent behind Go was to leverage the strengths of scripting languages, which tend to be favored amongst programmers who want to work fast and efficiently, but still be able to rely on the speed and stability of compiled languages. Many systems languages weren’t designed for the recent evolution of computers (networking clusters, layered modules, multi-core processors and front-/backend segregation) so Go was designed from the ground up to be a modern programming language capable of the heavy lifting that Google faces every day while still remaining easy to learn and fun to program.
Since its release, the language has seen a lot of releases driven by open-source contributions and its list of features has grown to support multi-assignment, closures, structs and a slew of packages ranging from basic HTTP protocols to GUI and image manipulation with version 1.0 being released in early 2012. Google is continuing to support the development and adoption of Go and is steadily using it for more projects internally.
helloworld.go
package main
import "fmt"
func main() {
fmt.Println("Hello world!")
}
Source(s):
Ada (1980)
Ada started its life in a language design competition led by the Department of Defense in an attempt to reduce the cost of their IT department by removing the chaotic use of a myriad of programming languages. Through a series of eliminations, the final language was chosen, nicknamed DOD-1, it was developed by a series of contractors led by Jean Ichbiah. It was later renamed Ada, in honor of Augusta Ada Byron, in 1979 and the reference manual which defined the standard was written and approved in 1980, signifying the official birth of the language.
Ada was developed further and has seen several ISO standards leading up to the modern variant Ada 2005, which consists mostly of minor corrections and amendments to Ada-95. Ada’s strengths lie in its security, support for multi-threading and real-time control, all of which has influenced modern languages. Its main application is still within the security sector, where safety is paramount, and Ada remains a niche language with no open-source community around it, but has been and still is an inspiration for contemporary languages.
helloworld.adb
with Ada.Text_IO; use Ada.Text_IO;
procedure Hello is
begin
Put_Line("Hello world!");
end Hello;
Source(s):
Eiffel (1985)
Eiffel is an object-oriented programming language created by Bertrand Meyer in 1985, together with his company Interactive Software Engineering, which was later renamed to Eiffel Software. The choice of name for Eiffel is to reference the Eiffel Tower in Paris and invoke thoughts of robust and efficient construction.
It was made to be highly modular and easy to read, consciously focusing on readability over micro-optimization. As such, the entire language is case-insensitive and can work without instruction terminators, but a formal coding standard is available. However, Eiffel follows a strict structured format and will only allow sections and clauses in specific order and will throw errors where other languages would be more relaxed.
This focus on readability and a strict structure has led to Eiffel being mainly used for enterprise development and no open-source variant is available. Everything is maintained and licensed by the Eiffel Software corporation, who has ported Eiffel to the major industry platforms and have built IDE plugins to allow for Eiffel development.
helloworld.e
class
HELLO_WORLD
create
make
feature
make
do
print ("Hello world!%N")
end
end
Source(s):
Smalltalk (1971)
Smalltalk, is a dynamically-typed, object-oriented programming language which is the culmination of a lot of work in the 60s to move programming languages in a more object-oriented direction. The initial work was mainly done at Xerox Palo Alto Research Center (PARC), but there have been many variations of Smalltalk and the term “Smalltalk” is generally used to refer to Smalltalk-80, which was the first variant released outside of PARC.
Smalltalk was initially created to be the programming language for Xerox’s planned Dynabook, a touch-screen device meant to provide users of all ages with useful programs and usher in the age of the laptop. However, this device demanded a degree of programming knowledge from its users and the languages of the time were too math-focused to be usable so a new language had to be created. The name “Smalltalk” was chosen to reflect the simplicity of the language, as it was intended to be taught to schoolchildren who had no prior experience with computers.
Smalltalk was built around bitmapped images and a pointing device, but ran on a Virtual Machine which meant that any system which supported those two requirements could run Smalltalk code. Variations of Smalltalk were built to be run by IBM PCs, Apple Machintoshs and Sun workstations, all which iterated on the original codebase, adding support for colors, native window managers and other features as the language evolved.
The use of Smalltalk isn’t as prevalent as it once was, it being superseded by modern object-oriented languages, but there still exists open source implementations of Smalltalk available for modern platforms.
helloworld.sm
'Hello world!'
Source(s):
1.
