El origen de los lenguajes de
programación se remonta a mediados del siglo XIX, fruto de la idea del
británico Charles Babagge, quien es considerado como “El Padre de la
Computación”. Babagge fue un profesor matemático de la universidad de Cambridge
e inventor que al principio del siglo XIX predijo muchas de las teorías en las
que se basan los actuales ordenadores.
Su primer intento de construir un “computador”
fue la máquina diferencial. La presentó en la Royal Astronomical Society en
1822 y su función era tabular polinomios usando un método numérico llamado el
método de las diferencias. No llegó a ser terminada puesto que los engranajes
internos disponibles no eran suficientemente buenos y porque Babbage cambiaba
constantemente el diseño de la máquina.
Después del intento de la máquina
diferencial, intentó entre 1833 y 1842 la construcción de una máquina que fuera
programable para hacer cualquier tipo de cálculo, la que llamó la máquina
analítica. Estaba basada en el telar de Joseph Marie Jacquard, quien en 1801
creó un telar que utilizaba en tarjetas perforadas para representar los
movimientos de un brazo de la máquina de tejer, con el objetivo de generar
patrones decorativos automáticamente.
Esta máquina tenía dispositivos de entrada
basadas en las tarjetas perforadas del telar de Jacquard, un procesador
aritmético, una unidad de control que determinaba qué tarea se debía realizar,
un mecanismo de salida y una memoria para almacenar números hasta ser
procesados. Esta máquina no fue construida hasta mediados del siglo XX debido a
los pocos medios de la época y a la poca financiación. En 1842, Ada Lovelace escribió
varios programas para esta máquina, por lo que es considerada la primera
programadora de la historia.
Máquina analítica de Babbage, construida por su hijo
En 1936 Alan Turing diseñó la máquina de
Turing, la que estableció las bases para almacenar programas como datos en la
arquitectura de von Neuman. Hubo que esperar hasta la década de 1940 para que
se crearan las primeras computadoras modernas, con alimentación eléctrica, las
que se programaban con lenguaje ensamblador muy afinado.
A mediados de la década de 1950, John W.
Backus quiso desarrollar una alternativa más práctica que la utilización de
tediosos lenguajes de ensamblador, por lo que propuso a sus superiores en IBM
la creación de un lenguaje de mayor nivel para programar el computador IBM 704.
En 1956 apareció el primer manual del que sería el primer lenguaje de
programación de alto nivel, FORTRAN.
Este lenguaje cambió la forma de concebir
la programación, pues ya no era el programador quien escribía el lenguaje
máquina, si no que éste era traducido mediante un compilador. Muchos clientes fueron
en un principio reacios a este cambio, pues pensaban que el compilador
generaría más código ensamblador que escribir directamente en ensamblador. Sin
embargo, esto redujo en un factor 20 el número de sentencias de programación
necesarias para operar una máquina.
Este lenguaje fue ampliamente adoptado
por los científicos para escribir programas con gran cantidad de números, lo
que incentivó a escritores de compiladores a diseñar compiladores que generaran
un código más rápido y eficiente. Poco a poco se fueron introduciendo mejoras y
nuevas funcionalidades, como tipos de datos y aritmética de números complejos,
lo que amplió cada vez más la gama de aplicaciones para las que el lenguaje se
adaptaba.
Un ejemplo de programa FORTRAN es el
siguiente:
REGRESION LINEAL.FORTRANS
APLICACION
DIMENSION TIEMPO(1000),PROD(1000)
OPEN(1,FILE='HISTORIA.txt')
I=0
10 READ(1,*,END=80)T,P
I=I+1
TIEMPO(I)=T
PROD(I)=P
GO TO 10
80 NDATOS=I
CALL AJULIN(TIEMPO,PROD,NDATOS,A,B)
WRITE(*,90)A,B
90 FORMAT('LA ECUACION ES:Y=',F10.2,'+',F10.2,'X')
20 FORMAT(20F10.0)
END
SUBROUTINE AJULIN(X,Y,N,A,B)
DIMENSION X(1),Y(1)
SUMX=0.
SUMY=0.
SUMX2=0.
SUMY2=0
SUMXY=0
DO 20 I=1,N
SUMX=SUMX+X(I)
SUMY=SUMY+Y(I)
SUMX2=SUMX2+(X(I)*X(I))
SUMY2=SUMY2+Y(I)**2
SUMXY=SUMXY+(X(I)*Y(I))
20 CONTINUE
PROD=SUMX*SUMY
B=(SUMXY-PROD/N)/(SUMX2-SUMX**2/N)
A=(SUMY/N-B*SUMX/N)
RETURN
END
En esta década
también se empezó a diseñar otro lenguaje de alto nivel llamado Lisp. Su
creador fue John McCarthy allá por el 1958. Su nombre viene de LISt Processing
(procesamiento de listas), pues este lenguaje emplea las listas como su
estructura de datos más importante, de hecho su código fuente está compuesto de
listas. Fue creado originalmente como una notación matemática práctica para los
programas de computadora, aunque poco a poco ha ido incorporando mayores
funcionalidades, llegando a ser el lenguaje preferido para la investigación en
Inteligencia Artificial. Fue pionero, además, en muchas ideas en ciencias de la
computación, como estructuras de datos de árbol, el manejo de almacenamiento
automático, los tipos dinámicos y el compilador auto contenido.
El lenguaje se
caracteriza, además de por las listas, por su sintaxis completamente entre
paréntesis. Además introdujo la estructura IF THEN ELSE de una forma más
general (la estructura cond).
Dos ejemplos de
programas Lisp son:
*******************************************************************
Definición de la función:
(defun vacia (l)
(cond ((null l) 1) ; si la lista esta vacia devuelve 1
(t 0))) ; en otro caso (lista llena) devuelve 0
Llamada a la función:
(vacia '(1 3 4)) ; La lista no esta vacia, devolvería 0
(vacia '()) ; La lista esta vacia, devolvería 1
*******************************************************************
; ---FACTORIAL----
(defun factorial (n)
(if (= 0 n)
1 ; caso base
(* n (factorial (- n 1))))) ; caso recursivo
(factorial 4) ;esto nos devolvería 24=4*3*2*1
*******************************************************************
En mayo de 1959
se creó en Estados Unidos una comisión llamada CODASYL (Conference On Data Systems Languages), quienes, junto con el
Departamento de Defensa de Estados Unidos crearon COBOL (COmmon Business-Oriented Language).
Éste era un lenguaje orientado completamente a negocios y fue llamado COBOL-60
en su primera versión por su año de lanzamiento.
COBOL fue ganando usuarios según fueron
pasando los años. Hubo varias revisiones en distintos años (1961, 1963 y 1965),
dando lugar a varias versiones del lenguaje. Todas las anteriores dieron paso a
la primera versión Standard la cual nació en 1968, a su vez ésta fue revisada
en 1974 y fue denominada COBOL ANSI o COBOL-74. La última versión revisada es
la de 1985 llamada COBOL-85.
Características de este lenguaje son:
- Dotado con grandes capacidades de autodocumentación.
- Buena gestión de archivos y de tipos de datos para la época a través la de sentencia PICTURE.
- Más tarde, en 2002, se le añadió orientación a objetos.
Un ejemplo de programa COBOL es:
IDENTIFICATION DIVISION.
PROGRAM-ID. HOLAMUNDO.
ENVIRONMENT DIVISION.
DATA DIVISION.
WORKING-STORAGE SECTION.
PROCEDURE DIVISION.
DISPLAY 'Hola mundo'.
STOP RUN.
Alrededor de las décadas de los 60 y 70,
IBM creó un nuevo lenguaje de programación de nivel alto llamado PL/I
(Programming Language 1). Nació como parte del desarrollo de la arquitectura
system 360, fabricada por IBM en aquel tiempo.
Su desarrollo fue llevado a cabo en los
laboratorios hursley, ubicados en el reino unido y propiedad de IBM, y su
diseño iba orientado a satisfacer las necesidades existentes en las
aplicaciones científicas y comerciales. Esta necesidad, era producida debido a
que los lenguajes de programación antecesores a este, como por ejemplo Cobol y
Fortran, podían resolver problemas de carácter científico o comercial, pero era
necesario realizar aplicaciones que pudieran resolver tanto los problemas de
carácter científico, como los referentes al negocio, y dado esto se procedió a
realizar este lenguaje.
Este lenguaje tenía muchas de las
características que más adelante adoptaron lenguajes como C y C++. Entre ellas
estaba el multiprocesamiento, la recursión, estructuras de control modernas,
asignación dinámica de espacio para estructuras de datos, procedimientos, etc. No
fue muy utilizado fuera de IBM, puesto que registraron el nombre del lenguaje
para mantener el control sobre su desarrollo. Fue probablemente el primer
lenguaje comercial cuyo compilador estaba escrito en el lenguaje que compilaba.
Un ejemplo de programa PL/1 es:
Test: procedure options(main);
declare My_String char(20) varying initialize('Hola, mundo!');
put skip list(My_String);
end Test;
Miguel Martínez del Horno
No hay comentarios:
Publicar un comentario