History of Programming Languages

RPG | 1959

RPG

• Predecessors: 9PAC, Fargo
• Year of introduction: 1959, last stable release was in 2014
• Characteristics: High level language for business applications, includes a program cycle that executes within a loop to process all records of a file
• Contribution: Developed by IBM to generate reports from data files, influenced RPG IV which is a modern programming language that handles a greater variety of expressions and built in functions
• Comments: Initially, Windows used the RPG compiler as an alternative to punch card processing
• Implementation: Microsoft Windows, .NET, Microsoft SQL, Open Database Connectivity, evolved to an equivalent of COBOL and PL/I
• Designed by: IBM
• Website: https://www.ibm.com/support/knowledgecenter/ssw_ibm_i_72/rzahg/rzahgrpgcode.htm

Fortran | 1954

• Predecessors : None
• Year of introduction: Published 1954 but active since 1957-present
• Current Version: Fortran 2018(fortran vi, fortran 77, fortran 90, fortran 2003)
• Characteristics: A complied imperative programing language
• Contribution: First high-level programming language ran by compilers
• Comments: After 63 years, it is still used today.
• Implementations: Absoft, Intel, Visual Fortran, Hitachi and more.
• Designed by: John backus and IBM
• Website: fortran-lang.org

Fortran

Flow-Matic | 1955

• Predecessors : None
• Year of introduction: Published in 1955
• Active years of the language: 1955-1959
• Characteristics: A complied imperative programing language that works
• Contribution: Influenced the creation of COBOL
• Comments: The first language to separate the distinction of data from the operations done on it
• Company or People that implemented the language: Remington Rand, Grace Hopper
• Website:http://www.osdata.com/topic/language/flowmatic.htm

Flow Matic

IPL | 1956

IPL

• Predecessors : None
• Year of introduction: 1956
• Active years of the language: 1956-1958
• Characteristics: structured assembly language designed for list manipulation
• Contribution: Introduced new language including virtual machines, list processing, dynamic memory allocation.
• Comments: It was replaced by LISP
• Designed by: RAND Corporation, Newell a., shaw c,
• Website: http://bitsavers.org/pdf/rand/ipl/

Lisp | 1958

Lisp

• Predecessors: IPL
• Year of introduction: 1958
• Active years of the language: after 62 years it is still active.
• Characteristics: used for manipulating lists and data easily.
• Contribution: first high-level programming language ran by compilers.
• Comments: fully parenthesized prefix notation, influenced Forth, Haskell, Logo, Perl, Python and more.
• Implementations: Clojure, Arc, Common Lisp, and more.
• Designed by: John McCarthy, Paul graham
• Website: https://lisp-lang.org/

Algol | 1958

• Predecessors : none
• Year of introduction: 1958-Present
• Characteristics: An algorithmic programming language with an imperative structure, designed to be machine independent. A complied imperative programing language
• Contribution: the first language to introduce nested functions and block structure
• Comments: Algol is short for algorithmic language, influenced PL/I, Simula, B, C and more.
• Designed by: Friedrich Bauer, Hermann Bottenbrunch, Heinz Rutishauser, Klaus Samelson, Backus, Katz, Perilis, Wegstein, Naur, Vauquios, Van Wijngaarden, Woodger, Green, mccarthy
• Website: http://www.algol68.org/

Algol

• Algol 68: Support for flexible arrays and a wider scope of applications
• Algol 58: added compound array support
• Algol 60: increased features such as nested functions with lexical scope. Influenced many other languages, such as C, Simula, Pascal and more.

Cobol | 1959

Cobol

• Predecessors : Flow-matic
• Year of introduction: 1959-Present
• Characteristics: Procedural, imperative, object-oriented.
• Contribution: Primarily used for business applications, relatively easier to use and understand
• Comments: Known as a business oriented language, influenced PL/B, PL/I, EGL, and CobolScript.
• Implementations: IBM COBOL, GncCOBOL
• Designed by: codasyl, ansi, iso
• Website: https://www.cobol-it.com/

Snobol | 1962

Snobol

• Predecessors: COMIT
• Year of introduction: in 1962, last stable release was in 1967
• Characteristics: Uses text-string orientations with data types that can be manipulated. The language also allows operators for concatenation and alternation
• Contribution: Short for ‘string oriented and symbolic language’, used in the 1970-80s as a text manipulator
• Comments: influenced AWK, bs, icon, Lua, and SL5, use slowed down as PERL and AWK introduced new methods of string manipulation
• Implementation: SNOBOL, SPITBOL
• Designed by: David j. Farber, Ralph Griswold, Ivan Polonsky, Bell Labs
• Website: www.snobol4.org

BASIC | 1964

• Predecessors: ALGOL 60, FORTRAN II, JOSS
• Year of Introduction: 1964, Active Years: 25 yrs. after 1964
• Characteristics: Non-Structured, later procedural, later Object Oriented
• Contribution: enabled for all users other than science and math to use computer, became the de factor programming language for the home computer systems in the 1970s
• Comments: User-friendly, easy to learn. Stands for “Beginners purpose Symbolic Instruction Code”
• Implementation: Microsoft Visual Basic, BASIC.NET, Apple BASIC, Atari BASIC, Sinclair BASIC, etc.
• Designed by: Jogn G. Kemeny and Thomas E. Kurtz
• Website:https://www.q7basic.org/History%20of%20BASIC.pdf

Basic

Successor Versions

• Basic-Plus: It is an extended dialect of BASIC , and it was developed for very specific, obsolete hardware
• Quick Basic: it is an IDE (integrated development environment) and compiler for BADIC and mainly runs on disk operating systems
• GW-Basic: it is a fully self contained executable and does not need the Read only memory (ROM) Basic. It was included in most versions of MS-DOS, and it was a low-cost way for many programmers to learn the fundamentals of computer programming.

APL | 1966

APL

• Predecessors: Influenced by mathematical notation (symbolic representation of mathematical objects and ideas)
• Year of introduction: 1966, 2001 was the last stable release
• Characteristics: Uses symbols rather than words to represent functions and operators, leading to concise code
• Contribution: its focus on having concise code influenced the development of concept modeling, functional programming and spreadsheets; the central data type being the multidimensional array
• Comments: Influenced many other programming languages, such as A, A+, Python, MATLAB, J, B, S, and more.
• Implementation: APL\360, APL *Plus, APL2, GNU APL and more
• Designed by: Kenneth E. Iverson, developed by Larry Breed, Dick Lathwell and Roger Moore
• Website: https://www.gnu.org/software/apl/

LOGO | 1967

Logo

• Predecessors: Lisp
• Year of introduction: 1967
• Characteristics: educational programming language, functional programming, artificial intelligence, mathematical logic and development psychology. Multi-paradigm and functional programming, known for turtle graphics shown on the screen.
• Contribution: Not widely used but influenced many successors, one being smalltalk. It was developed to influence children’s education, to be a program that allows them to play with words and sentences
• Comments: Logo influenced Smalltalk, NetLogo, Etoys, Scratch and more.
• Implementation: UCBLogo
• Designed by:Wally Feurzeig, Seymour Papert, Cynthia Solomon
• Website: https://el.media.mit.edu/logo-foundation/what_is_logo/logo_programming.html

SMALLTALK | 1969

Smalltalk

• Predecessors: Smalltalk 80, Lisp, Simula, Euler, IMP, Planner, Logo, etc.
• Year of introduction: 1969-1972, last stable release was in 1980
• Characteristics: Object oriented language that runs cross platform in a strong and dynamic fashion
• Contribution: Object oriented programming created for educational use, the rapid iterative development allowed for a highly productive environment
• Comments: Influenced Dart, Go, Java, Objective-C, PHP, Python, Ruby, Scala, and more.
• Implementation: Dolphin Smalltalk, GNU Smalltalk, Amber, VisualWorks and more.
• Designed by: Alan Kay, Dan Ingalls, Adele Goldberg
• Website: http://www.smalltalk.org/

Pl/1|1964

• Predecessors: ALGOL
• Year of introduction: 1964-Present
• Characteristics: A structured, imperative language which was designed to be used in a wide variety of contexts including scientific, educational and business applications
• Contribution: It is used primarily for data processing and in compilers
• Comments: Popular business software
• Designed by: IBM, Share language Development Committee
• Website: http://www.softpanorama.org/lang/pl1.shtml

PL/1

Simula | 1965

Simula

• Predecessors: Algol
• Year of introduction: 1965-present
• Characteristics: Object oriented simulation
• Contribution: The first object-oriented programming language, creating the framework for languages like Java and C++
• Comments: Simula was developed as an extension of ALGOL
• Designed by: Kirsten Nygaard and Ole-Johan Dahl
• Website: https://staff.um.edo.mt/jskl1/talk.html#basic_facts

BCPL|1967

• Predecessors : CPL
• Year of introduction: 1967-early 2000s
• Characteristics: intended for other language’s compilers.
• Contribution: Introduced curly braces and influenced different programming languages such as B, C and Go.
• Comments: BCPL only has one data type, it is typeless.
• Designed by: Martin Richards, Cambridge university.
• Website: http://gunkies.org/wiki/bcpl

BCPL

B | 1969

B

• Predecessors : BCPL
• Year of introduction: 1969-present
• Characteristics of the language: Modified version of BCPL, used for recursive machine independent applications.
• Contribution: Major influence on the development of the C language.
• Comments: B is used for recursive applications and also introduced operators like plus and minus.
• Designed by: Ken Thompson, Dennis Ritchie, Bell labs
• Website: https://www.bell-labs.com/usr/dmr/www/bintro.html

FORTH | 1970

Forth

• Predecessors: Burroughs large systems, LISP, APL
• Year of introduction: 1970
• Characteristics: imperative stack based language that features structured programming, concatenation, extensibility and reflection
• Contribution: Able to modify programs during execution, create new commands, interactive execution and early compilation for future execution. Used in many microcomputers (in the 80s) because of Forth’s portability and easy implementation
• Comments: influenced RPL, REBOL, Factor and Joy. Procedural language with steps to be carried out in any order during a programs execution
• Implementation: SwiftForth, Gforth, and VFX Forth. Used in space applications that are still actively maintained
• Designed by: Charles Moore
• Website: https://www.forth.com/forth/

PASCAL | 1970

Pascal

• Predecessors: ALGOL W, Simula 67
• Developed following the pattern of ALGOL 60 language
• Niklaus Wirth wanted to improve ALGOL 60, came up with ALGOL W, which was then released as Pascal.
• Year of introduction: 1970, last used in the 1980s where it was replaced by the growing popularity around C and C++
• Characteristics: imperative and procedural programming language
• Contribution: development of structured programming and data structuring
• Comments: influenced Ada, Go, Java, Object Pascal, VHDL, and more
• Implementations: CDC 6000, IBM System/370, GNU Pascal and more
• Designed by: Niklaus Wirth
• Website: http://www.pascal-programming.info/index.php

PROLOG | 1972

Prolog

• Predecessors: Planner
• Year of introduction: 1972
• Characteristics: Logic programming language used for Artificial intelligence, databases, language processing and more. Well suited for searching databases, filling templates and tasks with rule-based logical queries
• Contribution: One of the first logic programming languages, able to be used for type systems, automated planning, declarative programming, theorem proving and more.
• Comments: influenced Clojure, Datalog, Erlang, Mercury, Visual Prolog and more
• Implementation: B-Prolog, Ciao, GNU Prolog, YAP, SWI-Prolog, P# and more
• Designed by: Alain colmerauer, Robert Kowalski and Philippe Roussel
• Website: https://www.swi-prolog.org/

C | 1972

C

• Predecessors: B, ALGOL 68, FORTRAN, PL/I, Assembly
• Year of introduction: in 1972, last stable release in 2018
• Characteristics: general purpose imperative structured language. Includes structural programming, lexical variable scope, recursion, and compatibility with machine instructions.
• Contribution: Popular within machine instruction, first created to work within Unix. The language allows minimal runtime, low-level access to memory and efficient mapping to machine instructions. The language is known to be portable and can work in many different operating systems with minimal changes to its source code.
• Comments: Influenced C++, C--,m C#, Objective-C, Java, JS, PHP, Perl, Python, Rust and more.
• Implementation: Microsoft Visual C++, GCC, Watcom C, Intel C, Clang and more
• Designed by: Dennis Ritchie at Bell Labs
• Website: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

PL/M | 1973

PL/M

Predecessors: PL/I, ALGOL, XPL

Year of introduction: 1973, no longer supported by intel

Characteristics: No standard inputs or outputs, used to target microprocessors and has the ability to gain direct access to any location in memory

Contribution: Specifically made for Intel based micro computers, first higher level language to target microprocessors

Comments: Named ‘Programming language for microcomputers’ developed at intel, influenced PL/M to C source code translators

Designed by: Gary Kildall

Website: None

ML | 1973

• Predecessor: Lisp, ISWIM (syntax inspiration)
• Year of Introduction: 1973
• Active years: 1973- Present
• Characteristics: call-by-value evaluation strategy, first-class functions, automatic memory management through garbage collection, parametric polymorphism, static typing, type inference, algebraic data types, pattern matching, and exception handling
• Contribution: mostly applied in language design and manipulation, but it is a general-purpose language also used in other fields.
• Comments: Used in many fields and included many later languages
• Designed by: Robin Milner and others at the University of Edinburgh
• Website : https://en.wikipedia.org/wiki/ML_(programming_language)

ML

MODULA | 1975

Modula

Predecessors: Pascal

Year of introduction: 1975, discontinued soon after its publication

Characteristics: Multiprogramming, imperative, structured, modular

Contributions: Used a module system to group declarations into program units, influenced the creation of compilers that worked with microprocessors

Comments: influenced Go, Alma-0, Modula-2

Designed by: Niklaus Wirth

Website: https://www.modula2.org

ICON | 1977

Icon

• Predecessors: SNOBOL, SL5, ALGOL
• Year of introduction: 1977-2018
• Characteristics: dynamic high-level programming language that is structured, text oriented and multi paradigm
• Contribution: Manages string and textual patterns, derived from ALGOL structured programming. Icon's key concept is goal oriented programming, basing the language structure on the success or failure of the expressions.
• Comments: Similar syntax to C and Pascal, Influenced Python, Unicorn, and Goaldi
• Implementations: Icon, Jcon
• Designed by: Ralph Griswold
• Website: https://www2.cs.arizona.edu/icon/

sh | 1977

• Predecessor: Thomson shell and Mashey shell
• Year of Introduction: 1977
• Active Years: 1977-present
• Characteristics: Scripts can be invoked as commands by using their filename, maybe used interactively or non-interactively, allows both synchronous and asynchronous execution of commands, provides a se of built-in commands, flow control constructs, quotation facilities and functions, type less variables, global and local variable scope, doesn't require compilation before execution.
• Contribution: Command-line interpreter, operation system for computer.
• Comments: Quick Start, easy to program but slow and prone to costly error. Is called “wrapper”
• Implementation: UNIX
• Designed by: Stephen Bourne at Bell Labs
• Website: https://en.wikipedia.org/wiki/Bourne_shell

sh

AWK | 1977

AWK

• Predecessor: None
• Year of introduction: 1977
• Active years: 1977- Present
• Characteristics: data-driven scripting language
• Contribution: text processing and typically used as a data extraction and reporting tool.
• Comments: this language has a limited intended application domain
• Implementation: awk, GNU Awk, mawk, nawk, MKS AWK, Thompson AWK (compiler), Awke (compiler)
• Designed by: Alfred Aho, Peter Weinberger, and Brian Kerneghan
• Website: https://en.wikipedia.org/wiki/AWK

csh | 1978

• Predecessors: none
• Year of introduction: 1978
• Active years active: 1978 – present
• Characteristics: written in C, generally like other Unix shells but has interactive style and overall style.
• Contribution: introduced a large number of innovations including the history mechanism, aliases, tilde notation, interactive filename completion and more, that have since been copied by other Unix shells.
• Comments: faster and easier to user, more readable.
• Implementation: BSD, UNIX, Linux, MAC OS X
• Designed by: Bill joy
• Website : https://en.wikipedia.org/wiki/C_shell

csh

Scheme | 1975

• Predecessors : LISP
• Year of introduction: 1975-Present
• Characteristics: Similar to Lisp, a functional and imperative programming language.
• Contribution: Introduced functional programming and recursive algorithms using lexical scope. One of the first to support first-class continuations.
• Comments: Easier syntax to understand, influenced Clojure, Haskell, JavaScript, Rust, Ruby, and more.
• Designed by: Guy l. Steele and Gerald Jay Sussman
• Website: https://www.scheme.com/tspl4/

Scheme

ADA | 1980

ADA

• Predecessor: ALGOL 68, Pascal, C++(ada 95), Smalltalk (Ada 95), Modula-2 (Ada 95), Java (Ada 2005), Eiffel (Ada 2012)
• Year of Introduction: 1980
• Active years: 1980 – present
• Characteristics: structured, statically typed, imperative, and object-oriented high level computer programming language
• Contribution: Development of very large software systems
• Comments: the PL users English words, so its quite easier to read and memorize the syntax
• Implementation: AdaCore GNAT, Green Hills Software Optimizing Ada 95 compiler etc.
• Designed by: Jean Ichbiah (MIL-STD-1815/Ada 83) and Tucker Taft (other versions)
• Websites: https://en.wikipedia.org/wiki/Ada_(programming_language)

Successor Versions:

• Ada 95 – Improved object oriented programming
• Ada 2005 – Updated technical contents
• Ada 2012 – Became an international standard

Postscript | 1982

Postscript

• Predecessor: Interpress, Lisp
• Year of introduction: 1982
• Active years: 1982-Present
• Characteristics: dynamically typed, concatenative programming language
• Contribution: electronic publishing and desktop publishing business printing, display system
• Comments: this PL has been improved through time so that it has become useful, and still widely used.
• Implementation: Adobe PostScript, TrueImage, Ghostscript
• Designed by: Adobe Systems by John Warnock, Charles Geschke, Doug Brotz, Ed Taft and Bill Paxton
• Website: https://en.wikipedia.org/wiki/PostScript#:~:text=PostScript%20(PS)%20is%20a%20page,Paxton%20from%201982%20to%201984.

SML | 1983

SML

• Predecessor: ML
• Year of introduction: 1983
• Active years: 1983-Present (concepts still used)
• Characteristic: general-purpose, modular, functional programming language with compile-time type checking and type inference
• Contribution: used popularly by compiler writers, programming language researchers, and the development of theorem provers, and there are major projects using SML
• Comments: Influenced by ML, so widely applied but more efficiency and effectively.
• Implementation: SML/NJ, Moscow ML, MLton, ML Kit, Poly/ML etc.
• Developed by: Robin Milner
• Website: https://smlfamily.github.io

Objective C | 1984

Objective C

• Predecessor: C, Smalltalk
• Year of Introduction: 1984
• Active years: 1984-Present
• Characteristics: general-purpose, object-oriented, dynamic binding of messages to objects.
• Contribution: main PL used by Apple for macOS and iOS operating systems, Swift.
• Comments: this PL rise rapidly along with the rise of iPhone, however, it has all insecurities of C programming language
• Implementation : Clang , GCC
• Designed by: Tom Love and Brad Cox
• Website: https://en.wikipedia.org/wiki/Objective-C

C++ | 1985

C++

• Predecessor: C
• Year of Introduction: 1985
• Active years: 1985 – present
• Characteristics: general-purpose programming language. It has imperative, object oriented and generic programming features, while also providing facilities for low level memory manipulation.
• Contribution: because C++ supports both procedural and object-oriented programming, C++ has become a widely used language. C++ was the only available language that was suitable for large commercial software projects when it first appeared.
• Comments: Has a lot of innovation from C, bring more advantages bit it still remains the connection to C, thus relatively easy for C programmer to learn C++
• Implementation: LLVM Clang, GCC, Microsoft Visual C++, Embarcadero C++Builder, Intel C++ Compiler, IDM XL C++, EDG.
• Designed by: Bjarne Stroustrup.
• Website: http://www.cplusplus.com/info/history/

Successor Versions:

• C++03 – Considered as bug fixes with some changes
• C++11 – Added the support of lamda expressions, automatic type deduction, nullptr, rvalue references, etc.
• C++14 – Updated lambda expressions and type deductions.
• C++17 – Removed trigraph and some deprecated typed and functions from the std library.

Eiffel | 1986

• Predecessor: Ada, Simula, Z
• Year of introduction: 1986
• Active years: Present
• Characteristics: Objected-oriented, Class-based, Generic
• Contribution: Many things introduced with object-oriented programming have been used in Java, C# and other languages. Design by contact thing like assertions used to help ensure program correctness but also not sacrificing efficiency.
• Comments: provides an open architecture for interfacing with external software n any other programming language
• Implementation: EiffelStudio, LibertyEiffel, SmartEiffel, VisualEiffel, Bobo Eiffel, The Eiffel Compiler
• Designed by: Bertrand Meyer
• Website : https://www.eiffel.org/documentation

Eiffel

Successor Versions:

• The ECMA Standard Eiffel 2nd Edition - Revised preceding entry
• Liberty Eiffel 2013 Compiler based on SpartEiffel
• EiffelStudio – emphasizes backward compatibility combined with incremental language enhancements
• ELKS – originally formed to develop standards for Eiffel libraries useable by all Eiffel Compilers

Tcl

• Predecessor: Lisp, AWK, Tea
• Years introduction-active: Introduced 1988
• Characteristics of language: Command language. Uses dynamic programming. Can support Object-oriented, procedural, functional, and imperative programming methods
• Contribution of the language: Tcl code was Intended to be embedded in programs coded in other languages. Often used for GUI programming in python, and just generally used for some C programs.
• Comments about the language: It appears Tcl gained popularity primarily through developers' love of it, rather than raw good marketing or advertising. Known to be a fairly simple language to learn and use, as was the apparant intent of the language's inventor.
• Company or People: John Ousterhout
• Website: https://www.tcl.tk/about/language.html

Tcl

Perl

• Predecessor: C and Awk primarily, among a whole menagerie of others in varying degrees. Influenced in part by Lisp.
• Years introduction-active: 1987, continues to be used into 2020
• Characteristics of language: Interpreted, procedural, dynamic language.
• Contribution of the language: A great versatile, high-level language that is thought to be very good at processing data. Because of it's perceived capabilities in data processing, Perl has been widely utilized by programmers who, for example, need to generate reports for a business.
• Comments about the language: Apparently thought of colloquially as "the duct tape of programming", ugly but useful for everything.
• Company or People: Larry Wall
• Website: https://www.perl.org/

Perl

Bash

Bash

• Predecessor: Bourne shell
• Years introduction-active: 1989, continues to be used into 2020
• Characteristics of language: Command language
• Contribution of the language: Became widely implemented on Linex, remains the basic login shell for most Linux systems.
• Comments about the language: Apparently was vulnerable to an attack known as “Shellshock”, which led to a plethora of attacks in 2014.
• Company or People: Brian Fox
• Website: https://www.gnu.org/software/bash/

Ksh

• Predecessor: Bourne shell, C shell
• Years introduction-active: 1983, really kind of died off in 2014 though technically a version of the language is still around
• Characteristics of language: Command language, thought to be very readable.
• Contribution of the language: Enabled associative arrays, a feature that was unavailable in bash.
• Comments about the language: This language’s main purpose in history appears to have been to get absolutely annihilated by its competition, bash, and fade into the oblivion of non-competitiveness.
• Company or People: David Korn, Bell Labs.
• Website: http://www.kornshell.com/

Ksh

Caml

• Predecessor: ML
• Years introduction-active: 1985, ceased to be especially active in the early 2000’s.
• Characteristics of language: Statically typed, general-purpose.
• Contribution of the language: Versatile, became the basis for successor versions
• Comments about the language: The original Caml language doesn’t appear to be terribly exciting or impactful in and of itself.
• Company or People: Ascander Suarez, French Institute for Research in Computer Science and Automation
• Website: https://caml.inria.fr/

Caml

Common Lisp | 1984

Common LISP

• Predecessors : Lisp
• Year of introduction: 1984-Present
• Characteristics: Multi-paradigm, dynamic and object-oriented.
• Contribution: Extended and standardized maclisp dialects, supports a combination of functional, object oriented programming.
• Comments: It is used for research application development, influenced Clojure, Emacs Lisp, R and more.
• Implementations: ABCL, GCL, CLISP and more.
• Designed by: Scott Fahlman, Richard P. Gabriel, David A. Moon, Kent Pitman, Guy Steele, Dan Weinreb
• Website: https://common-lisp.net/

Haskell | 1990

Haskell

• Predecessor: Miranda
• Year of Introduction: 1990
• Active years: 1990 – present
• Characteristic: non-strict semantics and strong static typing, lazy functional language, used for academic and industry
• Contribution: Introduced new ideas in language design future functional languages.
• Comments: Companies like Facebook use the language in their anti-spam software
• Implementation: GHC, Hugs, NHC, JHC, Yhc, UHC
• Designed by: Many contributors including Lennart Augustsson, Dave Barton, Brian Boutel, Warren Burton, Joesph Fasel.
• Website: https://en.wikipedia.org/wiki/Haskell_(programming_language)#:~:text=functional%2Dlanguage%20design.-,Haskell%201.0%20to%201.4,%22)%20was%20defined%20in%201990.

Java | 1996

Java

• Predecessor: C++ primarily, sort of C
• Years introduction-active: Java was created in 1996, rapidly rose in popularity and is still popular today
• Characteristics: Strictly object-oriented. Intended to be simpler and more reliable than C++. Uses garbage collection, meaning that the program will delete objects that are no longer being used even if the programmer fails to specify that the object should be deleted.
• Contribution: Conceptually very similar to C++. But it is considered to be more secure, and has been widely implemented in the development of the web pages making up the world wide web as a result of it's portability and security.
• Comments: Originally developed for consumer electronics like microwaves rather than web pages. Sun Microsystems wanted a language that could reliably depended upon not to glitch and therefore require the recalls/repairs of their products, so they developed Java with the intention of creating a simple, reliable language.
• Designed by: James Gosling was the head developer, working for Sun Microsystems (which has since been acquired by Oracle.)
• Website: https://www.java.com/en/

Python | 1991

• Predecessor: ABC Programming Language
• Years introduction-active: Introduced in 1991
• Characteristics: Python is an Interpretive language that can be implemented as an objected-oriented language, but also supports procedural programming. Uses “try/accept” method for exception handling.
• Contribution: Very easy to use high-level language. Good exception handling.
• Comments: Can be easily integrated with C/C++ code, which makes it surprisingly versatile. Thought to be relatively easy to learn.
• Designed by: Guido Van Rossum, eventually created by the Python Software Foundation
• Website: https://www.python.org/

Python

Visual Basic | 1991

• Predecessor: Basic
• Years introduction-active: 1991, ceased to be active about 2008
• Characteristics: Programming is primarily centered around a “form”, and entails drag-and-dropping components onto the form. Event-driven language.
• Contribution: Widely implemented on Windows systems, helped form the basis for other “visual” languages.
• Comments: This is an altogether different program paradigm than what I, for one, am used to. Apparently it is very poorly compatible with object-oriented programming.
• Designed by: Microsoft
• Website: https://docs.microsoft.com/en-us/office/vba/language/reference/user-interface-help/visual-basic-language-reference

Visual Basic

Javascript | 1995

• Predecessor: Scheme, Java
• Years introduction-active: 1995, still used today in 2020
• Characteristics: Object-oriented, just-in-time compiled, curly-bracket syntax.
• Contribution: Instrumental in the functioning of the World Wide Web. Used by all major web browsers
• Comments: Though it began in 1995, Javascript is largely considered to have finished matured in 2016.
• Designed by: Brendan Eich
• Website: https://www.javascript.com/

Javascript

Ruby | 1995

• Predecessor: Lisp, Smalltalk, among others.
• Years introduction-active: 1995, continues to be used today in 2020
• Characteristics: Interpreted, object-oriented language
• Contribution: Human-centered programming language, meant to be very easy to read.
• Comments: The philosophy of the inventor of this language is apparently “we are the masters, computers are our slaves.” Apparently, Ruby was developed around this philosophy.
• Designed by: Yukihiro Matsumoto
• Website: https://www.ruby-lang.org/en/

Ruby

C# | 2005

• Predecessor: C, also Java and C++
• Years introduction-active: 2005, continues to be used today in 2020
• Characteristics: Object-oriented, intended to be very portable.
• Contribution: Became a competitor with Java, for a time was arguably locked in a sort of “arms race” driving both languages to become better and more expansive.
• Comments: The developers of C# wanted the language to be easy to internationalize. Part of Microsoft's .NET initiative.
• Designed by: Anders Hejlsberg, developed by Microsoft
• Website: https://docs.microsoft.com/en-us/dotnet/csharp/

C#

Swift | 2014

• Predecessor: Ruby, Python, C# among others
• Years introduction-active: 2014, continues to be used today in 2020
• Characteristics: Multi-paradigm, compiled language
• Contribution: Used to develop Apple applications, influenced Rust
• Comments: Seems to be in a cycle of being influenced by Rust and in turn influencing Rust.
• Designed by: Chris Lattner, Apple
• Website: https://developer.apple.com/swift/

Swift