pic_cooming_soonSoftware  Engineering

Development of Low-Level Languages

All computers operate by following machine language programs, a long sequence of instructions called machine code that is addressed to the hardware of the computer and is written in binary notation (see numeration), which uses only the digits 1 and 0. First-generation languages, called machine languages, required the writing of long strings of binary numbers to represent such operations as “add,” “subtract,” “and compare.” Later improvements allowed octal, decimal, or hexadecimal representation of the binary strings.

Because writing programs in machine language is impractical (it is tedious and error prone), symbolic, or assembly, languages—second-generation languages—were introduced in the early 1950s. They use simple mnemonics such as A for “add” or M for “multiply,” which are translated into machine language by a computer program called an assembler. The assembler then turns that program into a machine language program. An extension of such a language is the macro instruction, a mnemonic (such as “READ” ) for which the assembler substitutes a series of simpler mnemonics. The resulting machine language programs, however, are specific to one type of computer and will usually not run on a computer with a different type of central processing unit (CPU).

Evolution of High-Level Languages

The lack of portability between different computers led to the development of high-level languages—so called because they permitted a programmer to ignore many low-level details of the computer’s hardware. Further, it was recognized that the closer the syntax, rules, and mnemonics of the programming language could be to “natural language” the less likely it became that the programmer would inadvertently introduce errors (called “bugs” ) into the program. Hence, in the mid-1950s a third generation of languages came into use. These algorithmic, or procedural, languages are designed for solving a particular type of problem. Unlike machine or symbolic languages, they vary little between computers. They must be translated into machine code by a program called a compiler or interpreter.

Early computers were used almost exclusively by scientists, and the first high-level language, Fortran [Formula translation], was developed (1953–57) for scientific and engineering applications by John Backus at the IBM Corp. A program that handled recursive algorithms better, LISP [LISt Processing], was developed by John McCarthy at the Massachusetts Institute of Technology in the early 1950s; implemented in 1959, it has become the standard language for the artificial intelligence community. COBOL [COmmon Business Oriented Language], the first language intended for commercial applications, is still widely used; it was developed by a committee of computer manufacturers and users under the leadership of Grace Hopper, a U.S. Navy programmer, in 1959. ALGOL [ALGOrithmic Language], developed in Europe about 1958, is used primarily in mathematics and science, as is APL [A Programming Language], published in the United States in 1962 by Kenneth Iverson. PL/1 [Programming Language 1], developed in the late 1960s by the IBM Corp., and ADA [for Ada Augusta, countess of Lovelace, biographer of Charles Babbage], developed in 1981 by the U.S. Dept. of Defense, are designed for both business and scientific use.

BASIC [Beginner’s All-purpose Symbolic Instruction Code] was developed by two Dartmouth College professors, John Kemeny and Thomas Kurtz, as a teaching tool for undergraduates (1966); it subsequently became the primary language of the personal computer revolution. In 1971, Swiss professor Nicholas Wirth developed a more structured language for teaching that he named Pascal (for French mathematician Blaise Pascal, who built the first successful mechanical calculator). Modula 2, a Pascallike language for commercial and mathematical applications, was introduced by Wirth in 1982. Ten years before that, to implement the UNIX operating system, Dennis Ritchie of Bell Laboratories produced a language that he called C; along with its extensions, called C++, developed by Bjarne Stroustrup of Bell Laboratories, it has perhaps become the most widely used general-purpose language among professional programmers because of its ability to deal with the rigors of object-oriented programming. Java is an object-oriented language similar to C++ but simplified to eliminate features that are prone to programming errors. Java was developed specifically as a network-oriented language, for writing programs that can be safely downloaded through the Internet and immediately run without fear of computer viruses. Using small Java programs called applets, World Wide Web pages can be developed that include a full range of multimedia functions.

Fourth-generation languages are nonprocedural—they specify what is to be accomplished without describing how. The first one, FORTH, developed in 1970 by American astronomer Charles Moore, is used in scientific and industrial control applications. Most fourth-generation languages are written for specific purposes. Fifth-generation languages, which are still in their infancy, are an outgrowth of artificial intelligence research. PROLOG [PROgramming LOGic], developed by French computer scientist Alain Colmerauer and logician Philippe Roussel in the early 1970s, is useful for programming logical processes and making deductions automatically.

Many other languages have been designed to meet specialized needs. GPSS [General Purpose System Simulator] is used for modeling physical and environmental events, and SNOBOL [String-Oriented Symbolic Language] is designed for pattern matching and list processing. LOGO, a version of LISP, was developed in the 1960s to help children learn about computers. PILOT [Programmed Instruction Learning, Or Testing] is used in writing instructional software, and Occam is a nonsequential language that optimizes the execution of a program’s instructions in parallel-processing systems.

There are also procedural languages that operate solely within a larger program to customize it to a user’s particular needs. These include the programming languages of several database and statistical programs, the scripting languages of communications programs, and the macro languages of word-processing programs.

Compilers and Interpreters

Once the program is written and has had any errors repaired (a process called debugging), it may be executed in one of two ways, depending on the language. With some languages, such as C or Pascal, the program is turned into a separate machine language program by a compiler, which functions much as an assembler does. Other languages, such as LISP, do not have compilers but use an interpreter to read and interpret the program a line at a time and convert it into machine code. A few languages, such as BASIC, have both compilers and interpreters. Source code, the form in which a program is written in a high-level language, can easily be transferred from one type of computer to another, and a compiler or interpreter specific to the machine configuration can convert the source code to object, or machine, code.

This page discusses the different popular programming languages and help you choose one to learn. You shouldn’t worry too much about which language you choose, since the basic programming fundamentals are the same in each one. But you might as well pick the language that fits best with your goals. You can look at this chart to get an overall idea and read below to find out more about a language.

List of Programming Languages

  • A# .NET
  • A# (Axiom)
  • A-0 System
  • A+
  • A++
  • ABAP
  • ABC
  • ABC ALGOL
  • ABSET
  • ABSYS
  • ACC
  • Accent
  • Ace DASL
  • ACL1
  • ACT-III
  • Action!
  • ActionScript
  • Ada
  • Adenine
  • Agda
  • Agilent VEE
  • Agora
  • AIMMS
  • Alef
  • ALF
  • ALGOL 58
  • ALGOL 60
  • ALGOL 68
  • ALGOL W
  • Alice
  • Alma-0
  • AmbientTalk
  • Amiga E
  • AMOS
  • AMPL
  • Apex (Salesforce.com)
  • APL
  • App Inventor for Android’s visual block language
  • AppleScript
  • APT
  • Arc
  • ARexx
  • Argus
  • AspectJ
  • Assembly language
  • ATS
  • Ateji PX
  • AutoHotkey
  • Autocoder
  • AutoIt
  • AutoLISP / Visual LISP
  • Averest
  • AWK
  • Axum
  • Active Server Pages
  • ASP.NET

B

  • B
  • Babbage
  • Bash
  • BASIC
  • bc
  • BCPL
  • BeanShell
  • Batch (Windows/Dos)
  • Bertrand
  • BETA
  • Bistro
  • BitC
  • BLISS
  • Blockly
  • BlooP
  • Boo
  • Boomerang
  • Bourne shell (including bash and ksh)
  • BREW
  • BPEL
  • Business Basic

C

  • C
  • C–
  • C++ – ISO/IEC 14882
  • C# – ISO/IEC 23270
  • C/AL
  • Caché ObjectScript
  • C Shell
  • Caml
  • Cayenne
  • CDuce
  • Cecil
  • Cesil
  • Céu
  • Ceylon
  • CFEngine
  • CFML
  • Cg
  • Ch
  • Chapel
  • Charity
  • Charm
  • CHILL
  • CHIP-8
  • chomski
  • ChucK
  • CICS
  • Cilk
  • Citrine (programming language)
  • CL (IBM)
  • Claire
  • Clarion
  • Clean
  • Clipper
  • CLIPS
  • CLIST
  • Clojure
  • CLU
  • CMS-2
  • COBOL – ISO/IEC 1989
  • CobolScript – COBOL Scripting language
  • Cobra
  • CODE
  • CoffeeScript
  • ColdFusion
  • COMAL
  • Combined Programming Language (CPL)
  • COMIT
  • Common Intermediate Language (CIL)
  • Common Lisp (also known as CL)
  • COMPASS
  • Component Pascal
  • Constraint Handling Rules (CHR)
  • COMTRAN
  • Converge
  • Cool
  • Coq
  • Coral 66
  • Corn
  • CorVision
  • COWSEL
  • CPL
  • Cryptol
  • csh
  • Csound
  • CSP
  • CUDA
  • Curl
  • Curry
  • Cybil
  • Cyclone
  • Cython

D

  • DASL (Datapoint’s Advanced Systems Language)
  • DASL (Distributed Application Specification Language)
  • Dart
  • DataFlex
  • Datalog
  • DATATRIEVE
  • dBase
  • dc
  • DCL
  • Deesel (formerly G)
  • Delphi
  • DinkC
  • DIBOL
  • Dog
  • Draco
  • DRAKON
  • Dylan
  • DYNAMO

E

  • E#
  • EarSketch
  • Ease
  • Easy PL/I
  • Easy Programming Language
  • EASYTRIEVE PLUS
  • ECMAScript
  • Edinburgh IMP
  • EGL
  • Eiffel
  • ELAN
  • Elixir
  • Elm
  • Emacs Lisp
  • Emerald
  • Epigram
  • EPL
  • Erlang
  • es
  • Escher
  • ESPOL
  • Esterel
  • Etoys
  • Euclid
  • Euler
  • Euphoria
  • EusLisp Robot Programming Language
  • CMS EXEC (EXEC)
  • EXEC 2
  • Executable UML

F

  • F#
  • F*
  • Factor
  • Falcon
  • Fantom
  • FAUST
  • FFP
  • Fjölnir
  • FL
  • Flavors
  • Flex
  • FlooP
  • FLOW-MATIC
  • FOCAL
  • FOCUS
  • FOIL
  • FORMAC
  • @Formula
  • Forth
  • Fortran – ISO/IEC 1539
  • Fortress
  • FoxBase
  • FoxPro
  • FP
  • Franz Lisp
  • Frege
  • F-Script

G

  • Game Maker Language
  • GameMonkey Script
  • GAMS
  • GAP
  • G-code
  • GDScript
  • Genie
  • GDL
  • GJ
  • GEORGE
  • GLSL
  • GNU E
  • GM
  • Go
  • Go!
  • GOAL
  • Gödel
  • Golo
  • GOM (Good Old Mad)
  • Google Apps Script
  • Gosu
  • GOTRAN
  • GPSS
  • GraphTalk
  • GRASS
  • Groovy

H

  • Hack
  • HAGGIS
  • HAL/S
  • Hamilton C shell
  • Harbour
  • Hartmann pipelines
  • Haskell
  • Haxe
  • Hermes
  • High Level Assembly
  • HLSL
  • Hop
  • Hopscotch
  • Hope
  • Hugo
  • Hume
  • HyperTalk

I

  • IBM Basic assembly language
  • IBM HAScript
  • IBM Informix-4GL
  • IBM RPG
  • ICI
  • Icon
  • Id
  • IDL
  • Idris
  • IMP
  • Inform
  • INTERLISP
  • Io
  • Ioke
  • IPL
  • Inkling
  • IPTSCRAE
  • ISLISP
  • ISPF
  • ISWIM

J

  • J#
  • J++
  • JADE
  • JAL
  • Janus (concurrent constraint programming language)
  • Janus (time-reversible computing programming language)
  • JASS
  • Java
  • JavaScript
  • JCL
  • JEAN
  • Join Java
  • Jonathan

K

  • Kaleidoscope
  • Karel
  • Karel++
  • KEE
  • Kixtart
  • Klerer-May System
  • KIF
  • Kojo
  • Kotlin
  • KRC
  • KRL
  • KRL (KUKA Robot Language)
  • KRYPTON
  • ksh
  • Kodu

L

  • L
  • L# .NET
  • LabVIEW
  • Ladder
  • Lagoona
  • LANSA
  • Lasso
  • Lava
  • LC-3
  • Leda
  • Legoscript
  • LIL
  • LilyPond
  • Limbo
  • Limnor
  • LINC
  • Lingo
  • LIS
  • LISA
  • Lisaac
  • Lisp – ISO/IEC 13816
  • Lite-C
  • Lithe
  • Little b
  • Logo
  • Logtalk
  • LotusScript
  • LPC
  • LSE
  • LSL
  • LiveCode
  • LiveScript
  • Lua
  • Lucid
  • Lustre
  • LYaPAS
  • Lynx

M

  • M2001
  • M4
  • M#
  • Machine code
  • MAD (Michigan Algorithm Decoder)
  • MAD/I
  • Magik
  • Magma
  • make
  • Maude system
  • Maple
  • MAPPER (now part of BIS)
  • MARK-IV (now VISION:BUILDER)
  • Mary
  • MASM Microsoft Assembly x86
  • MATH-MATIC
  • Mathematica
  • MATLAB
  • Maxima (see also Macsyma)
  • Max (Max Msp – Graphical Programming Environment)
  • MaxScript internal language 3D Studio Max
  • Maya (MEL)
  • MDL
  • Mercury
  • Mesa
  • Metafont
  • Microcode
  • MicroScript
  • MIIS
  • Milk (programming language)
  • MIMIC
  • Mirah
  • Miranda
  • MIVA Script
  • ML
  • Model 204
  • Modelica
  • Modula
  • Modula-2
  • Modula-3
  • Mohol
  • MOO
  • Mortran
  • Mouse
  • MPD
  • Mathcad
  • MSIL – deprecated name for CIL
  • MSL
  • MUMPS
  • Mystic Programming Language (MPL)

N

  • NASM
  • Napier88
  • Neko
  • Nemerle
  • nesC
  • NESL
  • Net.Data
  • NetLogo
  • NetRexx
  • NewLISP
  • NEWP
  • Newspeak
  • NewtonScript
  • NGL
  • Nial
  • Nice
  • Nickle
  • Nim
  • NO
  • NPL
  • Not eXactly C (NXC)
  • Not Quite C (NQC)
  • NSIS
  • Nu
  • NWScript
  • NXT-G
  • NPL

O

  • o:XML
  • Oak
  • Oberon
  • OBJ2
  • Object Lisp
  • ObjectLOGO
  • Object REXX
  • Object Pascal
  • Objective-C
  • Objective-J
  • Obliq
  • OCaml
  • occam
  • occam-π
  • Octave
  • OmniMark
  • Onyx
  • Opa
  • Opal
  • OpenCL
  • OpenEdge ABL
  • OPL
  • OpenVera
  • OPS5
  • OptimJ
  • Orc
  • ORCA/Modula-2
  • Oriel
  • Orwell
  • Oxygene
  • Oz

P

  • P′′
  • P#
  • ParaSail (programming language)
  • PARI/GP
  • Pascal – ISO 7185
  • PCASTL
  • PCF
  • PEARL
  • PeopleCode
  • Perl
  • PDL
  • Perl 6
  • Pharo
  • PHP
  • Pico
  • Picolisp
  • Pict
  • Pike
  • PIKT
  • PILOT
  • Pipelines
  • Pizza
  • PL-11
  • PL/0
  • PL/B
  • PL/C
  • PL/I – ISO 6160
  • PL/M
  • PL/P
  • PL/SQL
  • PL360
  • PLANC
  • Plankalkül
  • Planner
  • PLEX
  • PLEXIL
  • Plus
  • POP-11
  • POP-2
  • PostScript
  • PortablE
  • Powerhouse
  • PowerBuilder – 4GL GUI application generator from Sybase
  • PowerShell
  • PPL
  • Processing
  • Processing.js
  • Prograph
  • PROIV
  • Prolog
  • PROMAL
  • Promela
  • PROSE modeling language
  • PROTEL
  • ProvideX
  • Pro*C
  • Pure
  • Pure Data
  • Python

Q

  • Q (equational programming language)
  • Q (programming language from Kx Systems)
  • Qalb
  • QtScript
  • QuakeC
  • QPL

R

  • R
  • R++
  • Racket
  • RAPID
  • Rapira
  • Ratfiv
  • Ratfor
  • rc
  • REBOL
  • Red
  • Redcode
  • REFAL
  • Reia
  • REXX
  • Rlab
  • ROOP
  • RPG
  • RPL
  • RSL
  • RTL/2
  • Ruby
  • RuneScript
  • Rust

S

  • S
  • S2
  • S3
  • S-Lang
  • S-PLUS
  • SA-C
  • SabreTalk
  • SAIL
  • SALSA
  • SAM76
  • SAS
  • SASL
  • Sather
  • Sawzall
  • SBL
  • Scala
  • Scheme
  • Scilab
  • Scratch
  • Script.NET
  • Sed
  • Seed7
  • Self
  • SenseTalk
  • SequenceL
  • SETL
  • SIMPOL
  • SIGNAL
  • SiMPLE
  • SIMSCRIPT
  • Simula
  • Simulink
  • Singularity
  • SISAL
  • SLIP
  • SMALL
  • Smalltalk
  • Small Basic
  • SML
  • Strongtalk
  • Snap!
  • SNOBOL(SPITBOL)
  • Snowball
  • SOL
  • Solidity
  • SPARK
  • Speedcode
  • SPIN
  • SP/k
  • SPS
  • SQL
  • SQR
  • Squeak
  • Squirrel
  • SR
  • S/SL
  • Stackless Python
  • Starlogo
  • Strand
  • Stata
  • Stateflow
  • Subtext
  • SuperCollider
  • SuperTalk
  • Swift (Apple programming language)
  • Swift (parallel scripting language)
  • SYMPL
  • SyncCharts
  • SystemVerilog

T

  • T
  • TACL
  • TACPOL
  • TADS
  • TAL
  • Tcl
  • Tea
  • TECO
  • TELCOMP
  • TeX
  • TEX
  • TIE
  • Timber
  • TMG, compiler-compiler
  • Tom
  • TOM
  • TouchDevelop
  • Toi
  • Topspeed
  • TPU
  • Trac
  • TTM
  • T-SQL
  • Transcript
  • TTCN
  • Turing
  • TUTOR
  • TXL
  • TypeScript

U

  • Ubercode
  • UCSD Pascal
  • Umple
  • Unicon
  • Uniface
  • UNITY
  • Unix shell
  • UnrealScript

V

  • Vala
  • Verilog
  • VHDL
  • Visual Basic
  • Visual Basic .NET
  • Visual DataFlex
  • Visual DialogScript
  • Visual Fortran
  • Visual FoxPro
  • Visual J++
  • Visual J#
  • Visual Objects
  • Visual Prolog
  • VSXu
  • vvvv

W

  • W-Language
  • WATFIV, WATFOR
  • WebDNA
  • WebQL
  • Whiley
  • Windows PowerShell
  • Winbatch
  • Wolfram Language
  • Wyvern

X

  • X#
  • X10
  • XBL
  • XC (exploits XMOS architecture)
  • xHarbour
  • XL
  • Xojo
  • XOTcl
  • XPL
  • XPL0
  • XQuery
  • XSB
  • XSharp
  • XSLT – see XPath
  • Xtend

Y

  • Yorick
  • YQL
  • Yoix

Z

  • Z notation
  • Zeno
  • ZOPL
  • Zsh
  • ZPL