Programming language

INTRODUCTION

Computers do not speak our language, they are machines and as such,
they need a specific language designed by man for them. Additionally,
they constantly need to interpret all the instructions they receive. Given
the insurmountable difficulty of communication between the computer
and the programmer, programming languages soon appeared that make
communication with the microprocessor possible, using terms and
symbols related to the type of problem that must be solved, through the
use of tools provided by the computing.

These languages allow, on the one hand, to write the operations that are
necessary to solve the problem in a way similar to how it would be written
conventionally (that is, to properly write the algorithm for solving the
problem) and, on the other, they are responsible for translate the
algorithm into machine language (a process known as compilation) which
gives the program the ability to run (be executed) on the computer. The
computer is actually just a virtual machine, capable of solving all the
problems that users are capable of expressing through an algorithm
(program).

Currently there are many types of programming languages, each with its
own grammar, special terminology and particular syntax. For example,
there are some created especially for scientific or general mathematical
applications (BASIC, FORTRAN, PASCAL, etc.); others, however, are
oriented towards the business field and the management of texts and
files, that is, they are actually fundamentally information managers
(COBOL, PL/1, etc.), or closely related to computer machine language
(such as the C and the ASSEMBLER).
Computers were programmed in machine language but the difficulties
that this entailed, together with the enormous ease of making errors,
whose location was long and complex, led to the possibility of using
symbolic languages in the 1940s. The first to appear were the
assemblers, which basically consisted of giving a name (mnemonic) to
each type of instruction and each address (label). At first I used the
program on paper and then it was translated by hand with the help of
some tables, and entered into the machine in numerical form, but soon
programs appeared that were assembled automatically.

DEFINITIONS

It is difficult to define what a programming language is and what it is not.

It is generally assumed that the translation of instructions into a code
that the computer understands must be completely systematic. Normally
the computer makes the translation.

Next, I am going to write a series of definitions of programming

languages:

1° A programming language is a notation for writing programs, through

which we can communicate with the hardware and thus give the
appropriate orders to carry out a certain process. A language is defined
by a grammar or set of rules that apply to an alphabet made up of the set
of symbols used. The different existing programming levels allow us to
access the hardware, in such a way that depending on whether we use
one level or another, we will have to use a certain language linked to its
corresponding translators.

2nd Set of “linguistic” rules (words and symbols) that allow a program to
be written and for it to be understood by the computer and can be
transferred to similar computers for operation in other systems.

3° Set of instructions, commands and symbols recognizable by the PLC,

through its programming unit, which allows it to execute the desired
control sequence. The total set of these instructions, commands and
symbols that are available will be called automaton programming
languages. The program is made up of a set of instructions, sentences,
functional blocks and graphics that indicate the operations to be
performed. Instructions represent the most basic task of a program:
reading an input, performing an operation, activating an output, etc. The
statement represents the minimum set of instructions or statements that
perform a complex task or function: finding the value of a logical function
in combination of several variables, consulting a set of conditions, etc.
The functional block is the set of instructions or sentences that perform a
complex task or function: counters, shift registers, information transfers,
etc. All these elements are related to each other through symbols or
graphics.

4° It is a set of words and symbols that allow the user to generate

commands and instructions for the computer to execute. Programming
languages must have instructions that fall into the familiar categories of
input/output, calculation/manipulation, text, logic/comparison, and
storage/retrieval.

CLASSIFICATION OF PROGRAMMING LANGUAGES

MACHINE LANGUAGE:

Machine language is the only one that the computer understands directly,
since it is written in languages directly intelligible by the machine
(computer), it uses the binary alphabet, which consists of the only two
symbols 0 and 1, called bits (English abbreviation for digits). binary). Its
instructions are binary strings (strings or series of characters of digits 0
and 1) that specify an operation and the memory locations (address)
involved in the operation are called machine instructions or machine
code. It was the first language used in computer programming, but it was
no longer used due to its difficulty and complexity, being replaced by
other languages that were easier to learn and use, which also reduced
the possibility of making errors. Machine language is the well-known
binary code. Generally, the hexadecimal system was used in program
coding to simplify the writing work. All instructions prepared in any
machine language have at least two parts. The first is the command or
operation, which tells the computers what function it is going to perform.
All computers have an operation code for each function. The second part
of the instruction is the operand, which tells the computer where to find
or store the data and other instructions that are going to be manipulated,
the number of operands of an instruction varies in different computers.

Advantages of machine language: possibility of loading (transferring a

program to memory) without the need for subsequent translation, which
means a faster execution speed than any other programming language.

Disadvantages of machine language: difficulty and slowness in coding.

Poor reliability. Great difficulty in verifying and fine-tuning the programs.
The programs are only executable on the same processor (CPU).
Currently, the disadvantages outweigh the advantages, making machine
languages practically not recommended.

LOW LEVEL LANGUAGES (assembler):

They are easier to use than machine languages, but like them, they
depend on the particular machine. The low-level language par excellence
is assembly. Assembly language is the first attempt to replace machine
language with another language more similar to those used by people.
This attempts to make the representation of the different fields more
flexible. This flexibility is achieved by not writing the fields in binary and
by bringing writing closer to language. In the early 1950s, in order to
facilitate the work of programmers, mnemonic codes were developed for
symbolic operations and addresses. Mnemonic codes are the
alphabetical symbols of machine language. The computer still uses
machine language to process data, but assembly programs first translate
the specified opcode symbols into their machine language equivalents.
Currently, programmers do not assign actual address numbers to
symbolic data, they simply specify where they want the first location of
the program to be placed and the assembler program takes care of the
rest, assigning locations for both the instructions and the data. These
assembly programs also allow the computer to convert the programmer's
assembly language instructions into its own machine code. A program of
instructions written in assembly language by a programmer is called a
source program. After the assembler converts the source program into
machine code, it is called an object program. It is easier for programmers
to write instructions in assembly language than in machine language
code, but two computer runs may be required before the source program
instructions can be used to produce the desired outputs.

The low-level language is the programming language that the computer

can understand when executing programs, which increases its execution
speed, since it does not need an interpreter to translate each line of
instructions.
Seen at a very low level, microprocessors process exclusively binary
electronic signals. Giving an instruction to a microprocessor actually
involves sending a series of ones and zeros spaced in time in a certain
way. This sequence of signals is called machine code. Code typically
represents data and numbers and instructions for manipulating them. An
easier way to understand machine code is to give each instruction a
mnemonic, such as STORE, ADD or JUMP. This abstraction results in
assembler, a very low-level language that is specific to each
microprocessor.

Low-level languages allow you to create very fast programs, but they are
often difficult to learn. More important is the fact that programs written
at a low level are highly processor-specific. If you take the program to
another machine, you must rewrite the program from the beginning.

Advantages of assembly language over machine language: greater ease

of coding and, in general, speed of calculation, saving time and requiring
less attention to details. Fewer errors are made and those that are made
are easier to locate. Both machine language and assembly language
have the advantage of minimum memory footprint and minimum
execution time compared to the compilation result of the equivalent
program written in other languages. Assembly language programs are
easier to modify than machine language programs.

Disadvantages of assembly language: total dependence on the machine,

which prevents the transportability of programs (possibility of executing a
program on different machines). The assembly language of the PC is
different from the assembly language of the Apple Machintosh. The
training of programmers is more complex than that corresponding to
high-level programmers, since it requires not only programming
techniques, but also knowledge of the inside of the machine. The
programmer must know the equipment's hardware perfectly, since It
directly manages memory locations, processor registers and other
physical elements. All instructions are elementary, that is, the program
must describe in maximum detail all the operations that must be carried
out on the machine to carry out any process.

Assembly languages have very limited applications; they are basically

focused on real-time applications, process control and electronic devices.

HIGH LEVEL LANGUAGES:

These languages are the most used by programmers. They are designed
to make it much easier for people to write and understand programs than
machine and assembly languages. A program written in a high-level
language is machine independent (the instructions do not depend on the
hardware design or a particular computer), so these programs are
portable or transportable. Programs written in a high-level language can
be run with little or no modification on different types of computers. They
are programming languages in which the instructions sent for the
computer to execute certain commands are similar to human language.
Since the computer is not capable of recognizing these commands, it is
necessary to use an interpreter to translate the high-level language into a
low-level language that the system can understand.
Computers are generally thought of as machines that perform calculation
or word processing tasks. The above description is just a very schematic
way of looking at a computer. There is a high level of abstraction between
what is asked of the computer and what it actually understands. There is
also a complex relationship between high-level languages and machine
code.

High-level languages are usually easy to learn because they are made
up of elements of natural languages, such as English. In BASIC, the
most popular high-level language, commands such as “IF COUNT=10
THEN STOP” can be used to ask the computer to stop if COUNT is equal
to ten. Unfortunately for many people this way of working is a bit
frustrating, given that although computers seem to understand natural
language, they actually do so in a rigid and systematic way.

High-level languages, also called evolved languages, emerge after the

previous ones (machine language, low-level or assembly languages) with
the following objectives, among others:

Achieve independence from the machine, being able to use the same
program on different computers with the only condition of having a
translator or compiler program, which is supplied by the manufacturer, to
obtain the executable program in binary language for the machine in
question. Additionally, you do not need to know the specific hardware of
said machine. Approach natural language, so that the program can be
written and read in a simpler way, eliminating many of the possibilities of
making errors that occurred in machine language, since words (in
English) are used instead of strings. symbols without any apparent
meaning.

Include frequently used routines, such as input/output routines,

mathematical functions, table management, etc., which appear in a kind
of language library, so that they can be used whenever you want without
having to program them each time.

Advantages of high-level languages: the training time for programmers is

relatively short compared to other languages. Program writing is based
on syntactic rules similar to human languages, instruction names such as
READ, WRITE, PRINT, OPEN, etc. Modifications and fine-tuning of
programs are easier. Reduction in the cost of programs. Transportability.
They allow for better documentation. They are easier to maintain.

Disadvantages of high-level languages: increased development time as

different translations of the source program are needed to obtain the
final program. The internal resources of the machine are not used, which
are much better exploited in machine and assembly languages.
Increased memory occupancy. The execution time of the programs is
much longer.

It can be said that the main problem that high-level languages present is
the large number of them that currently exist in use, in addition to the
different versions or dialects that have been developed for some of them.
It is difficult to establish a general classification of them, since in any that
is carried out there will be languages that belong to more than one of the
established groups. A very widespread classification, based on the way
the programs work and the philosophy with which they were conceived, is
the following:

 Imperative languages . They use instructions as the work unit of the

programs (Cobol, Pascal, C, Ada).
 Declarative languages . Programs are built using function
descriptions or logical expressions (Lisp, Prolog).
 Object-oriented languages . The design of the programs is based
more on the data and its structure. The process unit is the object
and it includes the data (variables) and the operations that act on
them (Smalltalk, C++).
 Problem-oriented languages . Designed for specific problems,
mainly management, they are usually application generators.
 Natural languages . New languages are being developed with the
main objective of bringing the design and construction of programs
closer to people's language.
Another classification that can be made is based on the development of
languages since the appearance of computers, which follows a certain
parallelism with the generations established in their evolution:

1.2. History of programming languages

From 1954 to the present, more than 2,500 programming languages
have been documented. Between 1952 and 1972, the first era of
programming languages, around 200 languages were developed, of
which a dozen were really significant and had an influence on the
development of later languages.
A partial list of some of the most important programming languages,
along with their year of creation:

Predecessor(s) Year Name Lead Developer , Company

Pre 1950
* ~ 1840 program booklet Ada Lovelace
* 1945 Plankalkül (Concept) Konrad Zuse
1950
* 1952 A-0 Grace Hopper
* 1954 Mark I Autocode Tony Brooker
1954-
A-0 FORTRAN "0" (Concept) John W. Backus at IBM
1955
A-0 1954 Arith-MATIC Grace Hopper
A-0 1954 MATH-MATIC Grace Hopper
* 1954 IPL V (Concept) Allen Newell , Cliff Shaw , Herbert Simon
A-0 1955 FLOW-MATIC Grace Hopper
1956-
IPL LISP (Concept) John McCarthy
1958
FLOW-MATIC 1957 COMTRAN Bob Bemer
1960
ALGOL 58 1960 ALGOL 60
FLOW-MATIC,
1960 COBOL 61 (Implementation) The CODASYL Committee
COMTRAN
* 1961 COMIT (Implementation)
FORTRAN II 1962 FORTRAN IV
* 1962 APL (Concept) Kenneth E. Iverson
ALGOL 58 1962 MAD Bruce Arden , and Others
ALGOL 60 1962 Simulates (Concept)
II FORTRAN,
1962 SNOBOL Ralph Griswold , and Others
COMMITTEE
SNOBOL 1963 SNOBOL3 Ralph Griswold , and Others
ALGOL 60 1966 CORAL66
CPL 1967 BCPL Martin Richards
FORTRAN, TELCOMP 1967 MUMPS Massachusetts General Hospital
* 1967 APL (Implementation) Kenneth E. Iverson
-Johan Dahl Ole , Myhrhaug Bjørn , Kristen
ALGOL 60 1967 Simula 67 (Implementation)
Nygaard in Norsk Regnesentral
SNOBOL3 1967 SNOBOL4 Ralph Griswold , and Others
W. M. McKeeman , and Others at the
University of California Santa Cruz, California
PL/I 1967 XPL
JJ Horning , and Others at Stanford
University
DIBOL 1968 DIBOL-8 December
COWSEL 1968 POP-1 Burstall Rod , Popplestone Robin
1968 Forth (Concept) Chuck Moore
LISP 1968 LOGO Seymour Papert
* 1968 REFAL (Implementation) Valentin Turchin
ALGOL 60 1969 ALGOL 68 (Implementation) Adriaan van Wijngaarden , and Others
ALGOL 60, COBOL,
1969 PL/1 (Implementation) IBM
FORTRAN
1970
1970 Forth (Implementation) Chuck Moore
POP-1 1970 POP-2
ALGOL 60 1971 Pascal Niklaus Wirth , Kathleen Jensen
Pascal, XPL 1971 sue Holt and Others at the University of Toronto
SIMULA 67 1972 Smalltalk-72 Xerox PARC
B, BCPL, ALGOL 68 1972 c Dennis Ritchie
* 1972 INTERCAL
2-level W-Grammar 1972 Foreword Alain Colmerauer
Pascal, BASIC 1973 COMAL Børge Christensen , Löfstedt Benedict
Pascal, Sue 1973 LIS Ichbiah Others and in CII Honeywell Bull
ESSENTIAL 1974 GRASS Tom DeFanti

MUMPS 1977 MUMPS Standard

SNOBOL 1977 ICON (Concept) Ralph Griswold
Ichbiah Others and CII Honeywell Bull for the
ALGOL 68, LIS 1977 Green
United States Department of Defense
Benjamin M. Brosgol and Others in
ALGOL 68, CS-4 1977 Red Intermetrics for the US Department of
Defense
Goodenough and Others at Softech for the
ALGOL 68, 1977 Blue
US Department of Defense
Spitzen Others and at SRI International For
ALGOL 68, 1977 Yellow
The United States Department of Defense
FORTRAN IV 1978 FORTRAN 77
Modulate 1978? Modula-2 Niklaus Wirth
* 1978? MATLAB Grind at the University of New Mexico
Dr Nevil Brownlee at the University of
Algol60 1978? LITTLE
Auckland
* 1978 VisiCalc Dan Bricklin , Bob Frankston at VisiCorp
PL/I, Basic, EXEC 2 1979 REXX Mike Cowlishaw
C, SNOBOL 1979 Awk Aho , Weinberger , Brian Kernighan
SNOBOL 1979 ICON (Implementation) Ralph Griswold
* 1979 Vulcan dBase II Ratliff
1980
C, SIMULATION 67 1980 C With Classes Bjarne Stroustrup
Smalltalk-76 1980 Smalltalk-80 Xerox PARC
Smalltalk, C. 1982 Objective-C Brad Cox
Green 1983 Ada 83 US Department of Defense
C With Classes 1983 C++ Bjarne Stroustrup
John Kemeny George , Thomas Kurtz at
ESSENTIAL 1983 It's true BASIC
Dartmouth College
SH 1984? Korn Shell ( ksh ) Dave Korn
* 1984 standard ml
dBase 1984 CLIPPER Nantucket
Smalltalk 1987 Selfconcept ) Sun Microsystems Inc.
* 1987 HyperTalk Apple Computer
* 1987 SQL-87
C, sed, awk, SH 1987 perl Larry Wall
MATLAB 1988 Eighth
dBase-III 1988 dBase IV
Awk, Lisp 1988 Tcl John Ousterhout
REXX 1988 Object REXX Simon Nash
Adam 1988 SPARK Bernard A. Carré
Turbo Pascal object-oriented
Turbo Pascal 1989 Borland
programming
ANSI C3.159-1989 (approved by ISO in
c 1989 Standard C89/90
1990)
Modula-2 1989 Modula-3 Cardeli, and Others
Modula-2 1989 Oberon Niklaus Wirth
VisSim 1989 VisSim Pedro A. Darnel
1990
Oberon 1990 Oberon Object Niklaus Wirth
Kenneth Iverson , Roger Hui Software
APL, F.P. 1990 J.
Iverson in
Miranda 1990 Haskell
1984 MUMPS 1990 1990 MUMPS
Fortran 77 1991 Fortran 90
Oberon Object 1991 Oberon-2 Niklaus Wirth
ABC 1991 Python Van Rossum
1991 Q
QuickBASIC 1991 VisualBasic Alan Cooper at Microsoft
SQL-87 1992 SQL-92
Turbo Pascal object-
oriented 1992 Borland Pascal
programming
ksh 1993? Z shell ( zsh )
Smalltalk 1993? Auto (Implementation) Sun Microsystems Inc.
1995 ColdFusion Allaire
C, Simula67 or C++,
1995 Java James Gosling at Sun Microsystems
Smalltalk
1990MUMPS 1995 1995 MUMPS
I, from Java 1995? LiveScript Brendan Eich at Netscape
Fortran 90 1996 Fortran 95
Karl Glazebrook , Jarle Brinchmann , Tuomas
APL, Perl 1996 Perl Data Language (PDL)
Lukka , and Christian Soeller
REXX, Java 1996 NetREXX Cowlishaw
LiveScript 1997? JavaScript Brendan Eich at Netscape
SML 84 1997 SML 97
PHP 3 1997 PHP
Scheme 1997 Beak Free University of Brussels
Smalltalk-80, on
1997 Squeak Smalltalk Alan Kay , Others and at Apple Computer
vacation
JavaScript 1997? ECMAScript ECMA TC39-TG1
C++, C standard 1998 C++ Standard ANSI /ISO C++ standard
Foreword 1998 Erlang Open Source Erlang at Ericsson
Standard C89/90 1999 Standard C99 ISO / IEC 9899:1999
2000
C, C++, Java, Eiffel 2000 d Brilliant Walter on digital Mars
C, C++, Delphi, Java 2000 C# Anders Hejlsberg at Microsoft ( ECMA )
2005 Seed7 Thomas Mertes
Adam 95 2007 Adam 2005 Ada Rapporteur Group
 First generation. Machine and assembly languages.
 Second generation. First high-level imperative languages
(FROTRAN, COBOL).
 Third generation. High-level imperative languages. They are the most
used and are still valid today (ALGOL 8, PL/I, PASCAL, MODULA).
 Fourth generation. Basically oriented to management applications and
database management (NATURAL, SQL).
 Fifth generation. Oriented towards artificial intelligence and natural
language processing (LISP, PROLOG).

The first known computer programmer was Ada Lobelace, daughter of

Anabella Milbanke Byron and Lord Byron . Anabella introduced Ada to
mathematics who, after meeting Charles Babbage , translated and
expanded a description of his analytical engine. Even though Babbage
never completed the construction of any of his machines, the work Ada
did on them earned her the title of the world's first computer
programmer. The name of the programming language Ada was chosen
as a tribute to this programmer.

In late 1953 , John Backus submitted a proposal to his superiors at IBM

to develop a more practical alternative to assembly language for
programming the IBM 704 mainframe computer . Backus' historic
Fortran team consisted of programmers Richard Goldberg, Sheldon F.
Best, Harlan Herrick, Peter Sheridan, Roy Nutt, Robert Nelson, Irving
Ziller, Lois Haibt, and David Sayre.

The first manual for the Fortran language appeared in October 1956 ,
with the first Fortran compiler delivered in April 1957 . This was an
optimized compiler, because customers were reluctant to use a high-level
language unless their compiler could generate code whose performance
was comparable to that of hand-written assembly language code.

In 1960 , COBOL was created, one of the languages still used in

management computing in 2010.

As the complexity of the tasks performed by computers increased, it

became necessary to have a more efficient method of programming
them. Then, high-level languages were created, such as BASIC in the
versions introduced on microcomputers in the 1980s . While a task as
simple as adding two numbers may require several instructions in
assembly language, in a high-level language only one will suffice.