RPG

HISTORIA DE RPG
El lenguaje de programación RPG es un lenguaje de programación desarrollado por IBM en 1964 y diseñado para generar informes comerciales o de negocios. Sus siglas en inglés significan Report Program Generator.
En 1960 RPG es creado para la familia 1400, pero hasta 1964 no es lanzada la versión final para la IBM 360. Ha sido actualizado en diversas ocasiones, dando origen a las diferentes versiones del lenguaje. Una de las últimas actualizaciones que se ha realizado hasta la fecha es el RPG/IV en 1995, disponible con los ordenadores IBM de la familia AS/400. Posteriormente, en 2001, y con la aparición de la versión 5 del OS/400, surgió una nueva modificación sobre el lenguaje, soportándose a partir de ese momento la programación en formato libre. Así mismo, se desarrollan las funciones incoporadas que sustituyen a muchos de los antiguos indicadores y códigos de operación. Todas estas incorporaciones permiten que el RPG se convierta en un lenguaje mucho más legible, claro, flexible .

RPG es, probablemente, el lenguaje de programación más extendido en nuesto entorno (AS/400, iSeries e i5). Como heredero directo de la familia de ordenadores S/3x de IBM, y dada la política de compatibilidad con versiones anteriores seguida por IBM (gracias a la cual, programas diseñados para ejecutarse en un S/34 hace aproximadamente 20 años, continúan ejecutándose sin problemas en los modernos i5), RPG se ha convertido en el lenguaje por excelencia para los ordenadores de la gama AS/400, iSeries e i5.
Poco, o nada, queda ya del antiguo RPG II, con su ciclo lógico, sus rupturas por nivel de control (cabecera, detalle y totales), su absoluto control por medio de indicadores, etc. Y pocos lenguajes habrán experimentado una transformación tan importante en los últimos años como RPG.
Actualmente RPG es un lenguaje orientado a la gestión, con absoluta integración con bases de datos relacionales (DB2), que soporta SQL embebido, permite la ejecución de módulos diseñados en otros lenguajes (dentro del entorno integrado de lenguajes de IBM - ILE o Integrated Language Environment-), puede ser invocado por métodos Java, C, C++, etc.
Así pues, y después de describir brevemente el origen y la situación actual de RPG, pasaremos a analizar un poco más a fondo el lenguaje de programación y su estructura. Para ello, nos centraremos en la estructura y sintaxis de RPG/IV.
La estructura de un programa RPG está organizada por tipos de especificaciones (o instrucciones). En un programa RPG, encontraremos habitualmente, cuatro tipos de especificaciones:
1.- Especificaciones de Control: Irán siempre al inicio del programa, y en ellas indicaremos algunos parámetros generales de definición del programa.
2.- Especificaciones de definición de ficheros: Van inmediatamente detrás de las especificaciones de control y en ellas definiremos todos los ficheros, tanto de base de datos como de dispositivos (pantalla, impresora, etc.) que utilizará nuestro programa, así como el tipo de utilización de los mismos (Entrada, Salida, Entrada/Salida) , forma de acceso (secuencial, por claves, etc.) y otra serie de valores relativos a dichos ficheros y cómo nuestro programa manejará los mismos.
3.- Especificaciones de descripción de datos: En ellas describiremos todos aquellos datos adicionales (no incluidos en ficheros), tales como variables de programa, series, punteros, estructuras de datos, etc.
4.- Especificaciones de cálculo: Son las instrucciones ejecutables propiamente dichas. En ellas definiremos tanto las instrucciones de control de flujo del programa como las operaciones matemáticas, de acceso a datos, de lectura y escritura en ficheros y dispositivos, llamadas a otros programas o procedimientos, etc.

Historia de FORTRAN
Estrictamente hablando, FORTRAN no fue el primer
lenguaje de programación que existió (Laning & Zierler, del
MIT, ya tenían un compilador de un lenguaje algebraico en
1952), pero sí fue el primero en atraer la atención de una
parte importante de la reducida comunidad de usuarios de
computadoras de la época.

El desarrollo de FORTRAN comenzó en 1955 y el lenguaje se
liberó finalmente en abril de 1957, después de 18 años-hombre
de trabajo.
FORTRAN (FORmula TRANslating system) fue
desarrollado principalmente por John Backus en IBM. Backus
recibió el “Turing Award” en 1977.

El principal énfasis de FORTRAN fue la eficiencia. Su diseño
se basó en un intérprete llamado “Speedcoding”, que fue
desarrollado por Backus para la IBM 701.
FORTRAN fue desarrollado inicialmente en una IBM 704,
aprovechando sus rutinas de punto flotante (proporcionadas
en hardware).
La especificación preliminar de FORTRAN fue recibida con
frialdad y escepticismo. Pocos creían que pudiera diseñarse un
compilador que fuese equiparable (en eficiencia) a un humano.
John Backus fue fuertemente criticado incluso por luminarias
de la época como John von Neumann, quienes creían que el
desarrollo de FORTRAN sólo era un desperdicio de dinero
(el proyecto estuvo a punto de ser cancelado).
El secreto del éxito de FORTRAN se atribuye a su excelente
documentación y a las sofisticadas técnicas de optimización
que se usó en el diseño de su compilador. De acuerdo a John
Backus, las técnicas utilizadas en FORTRAN no fueron
superadas sino hasta los 1960s.
En 1958 se liberó FORTRAN II.
Otro dialecto, llamado FORTRAN III, fue liberado
también en 1958, pero no resultó muy exitoso debido a su
enorme dependencia de la IBM 704.
En 1962 se liberó FORTRAN IV, que ha sido quizás la
versión más popular del compilador.

En 1958, el American National Standards Institute (ANSI)
estandarizó FORTRAN (a esta versión se le llama ANS
FORTRAN).
Un nuevo estándar fue liberado en 1977 (se le conoce como
FORTRAN 77).
Las versiones más recientes de FORTRAN (FORTRAN
90 y FORTRAN 2 000)difieren mucho del lenguaje
original.
Estructura de los FORTRAN

programas en Los programas en FORTRAN se dividen en 2 partes:
1) Una parte declarativa, la cual describe las áreas de
datos, sus longitudes (tipos) y sus valores iniciales. Las
instrucciones declarativas existen en la mayor parte de
los lenguajes estructurados, aunque se les llama de
maneras distintas. En FORTRAN se les denomina
“sentencias no ejecutables”.
Estructura de los
programas en FORTRAN
2) Una parte imperativa que contiene los comandos
a ser ejecutados en el momento en que corre un
programa. A las instrucciones imperativas de
FORTRAN se les denomina “sentencias
ejecutables”.
Parte declarativa
de un programa
La parte declarativa del programa realiza 3 funciones
principales:
1) Asignar un área de memoria de un tamaño
especificado. Los tipos de datos disponibles en
FORTRAN son: INTEGER, REAL, DOUBLE
PRECISION y arreglos. El tipo de las variables
numéricas suele considerarse REAL por omisión.
Parte declarativa
de un programa
2) Asociar un nombre simbólico a un área
específica de memoria (a esto se le llama “binding”
o declaración de variables).
3) Inicializar el contenido de esa área de memoria.
En el caso de FORTRAN, las variables no tienen
que ser inicializadas. Esto suele ser una fuente
común de errores en FORTRAN.
Parte declarativa
de un programa
Ejemplo de una declaración:
DIMENSION MIARREGLO(100)
Esto inicializa el arreglo MIARREGLO a 100 posiciones de
memoria (se presuponen números reales por omisión).
Parte declarativa
de un programa
Ejemplo de inicialización:
DATA MIARREGLO, MIVAR/100*0.0,5.0
Esto inicializa las 100 posiciones del arreglo MIARREGLO a
0.0. Adicionalmente, inicializamos la variable MIVAR a
5.0.
Parte imperativa de un programa
Las sentencias imperativas son de 3 tipos diferentes:
1) Sentencias computacionales: Son análogas a las
operaciones aritméticas y de movimiento de datos del
pseudo-código que vimos anteriormente. La asignación
es la sentencia computacional más importante de
FORTRAN.
Parte imperativa de un programa
2) Sentencias de control de flujo: Comparaciones y
ciclos. FORTRAN proporciona instrucciones
condicionales (sentencias IF), ciclos (usando DO) y
saltos incondicionales (usando GOTO). El lenguaje
tiene sentencias muy primitivas para flujo de datos.
Parte imperativa de un programa
Sentencias de entrada/salida: FORTRAN I tenía 12
sentencias de entrada/salida de un total de 26 del lenguaje.
La razón era la enorme variedad de dispositivos de E/S que
debía ser capaz de manejar el compilador. Las versiones más
recientes de FORTRAN han reducido y/o simplificado la
necesidad de usar tantas sentencias de E/S.
Parte imperativa de un programa
Ejemplo de asignación:
RESULTADO = TOTAL/FLOAT(N)
Note que en este caso, FLOAT se usa para
convertir N (presumiblemente una variable entera)
a un valor real, de manera que el resultado de la
operación sea un número de punto flotante.
Parte imperativa de un programa
¿Qué otro lenguaje conoce donde deba hacerse una
reducción de tipo (casting) similar a ésta?
Es importante recordar que el uso de notación algebraica
convencional fue una de las principales contribuciones de
FORTRAN.

Notación algebraica
Un ejemplo de notación algebraica en FORTRAN es el
siguiente:
RESULTADO = A*B+C-9.0/D**3.4

Operadores aritméticos
en FORTRAN

Funciones matemáticas
FORTRAN tiene también una cantidad considerablemente
grande de rutinas matemáticas disponibles para el cálculo
de logaritmos, funciones trigonométricas, números
complejos, etc.
Jerarquías de los operadores
Los operadores aritméticos también tienen prioridades:
1) Exponenciación
2) Multiplicación y división
3) Suma y resta
Estas mismas prioridades han sido adoptadas en la mayoría
de los lenguajes de programación modernos.
Ciclos con DO
La sentencia DO es la única estructura de control de alto
nivel que proporciona FORTRAN, puesto que les permite
a los programadores expresar lo que quieren que se haga y
no cómo quieren que se haga.
Ciclos con DO
La sentencia DO ilustra el principio de Automatización (de
MacLennan):
Deben automatizarse las tareas mecánicas, tediosas o
propensas a errores.
Ciclos con DO
La sentencia DO permite realizar iteraciones definidas
(llamadas en inglés “counted loops”):
DO 100I=1,N
haz lo que quieras
100
CONTINUE

Ciclos con DO
En el ejemplo anterior, 100 es una etiqueta (sólo se
permiten etiquetas numéricas en FORTRAN) que indica lo
que está contenido dentro del ciclo. I es el contador del
ciclo en este caso y toma un valor inicial de 1, llegando
hasta N. CONTINUE no tiene ningún efecto y sólo se usa
para indicar la finalización del ciclo (como la sentencia
NEXT en BASIC).

Ciclos con DO
Los ciclos con DO también pueden ser anidados, lo que
proporciona mucha flexibilidad.

Ciclos con DO (ejemplo)
DO 100 I=1,M
.
DO 200 J=1,N
.
200
CONTINUE
.
100
CONTINUE
Ciclos con DO
FORTRAN tiene, en general, una estructura “lineal” y no
“jerárquica”, dado que la mayoría de sus instrucciones no
permiten ningún tipo de anidamiento. Por lo tanto, la
sentencia DO resulta ser más bien una excepción que una
función más del lenguaje.

Ciclos con DO
Adicionalmente, la seguridad del lenguaje se ve comprometida
por el hecho de que FORTRAN permite saltos
incondicionales (GOTOs) dentro y fuera de los ciclos DO
bajo ciertas circunstancias. Esta es una de las razones por las
cuales la sentencia GOTO se volvió obsoleta en la segunda
generación de lenguajes de programación.

Ciclos con DO
Finalmente, el ciclo DO está altamente optimizado, lo que lo
hace altamente útil y práctico desde la perspectiva de la meta
principal del FORTRAN: la eficiencia.

Ciclos con DO
La capacidad de optimización del ciclo DO puede atribuirse
parcialmente a su estructura y al hecho de que la variable de
control y sus valores iniciales y finales se especifican
explícitamente junto con la extensión del ciclo.
Ciclos con DO
Aunque parezca extraño, suele darse el caso de que las
estructuras de más alto nivel (como el DO en este caso)
resultan más fáciles de optimizar que las de bajo nivel.
Estructura básica de un programa en
FORTRAN
Declarations
Main program
Subprogram 1
Subprogram 2
.
Subprogram n

Subprogramas
Los subprogramas son realmente una adición posterior al
FORTRAN, ya que no aparecieron sino hasta en el
FORTRAN II.
Aunque FORTRAN I proporcionaba bibliotecas con
funciones matemáticas y de E/S, no permitía que los
programadores definieran sus propios subprogramas.

Subprogramas
FORTRAN II resolvió el asunto de los subprogramas al
agregar las declaraciones SUBROUTINE y FUNCTION.

Eficiencia en la compilación
Puesto que una de las metas primordiales de FORTRAN
durante su diseño fue la eficiencia, el enfoque tomado para
generar un archivo ejecutable estaba altamente optimizado:

Eficiencia en la compilación
1) Compilación: Traducir subprogramas individuales en
FORTRAN a código objeto relocalizable (código que usa
direcciones relativas en vez de direcciones absolutas de
memoria). Estas direcciones relativas se resolverán (o sea, se
convertirán a direcciones absolutas) en tiempo de cargado.

Eficiencia en la compilación
La mayor parte de los errores de sintaxis se interceptarán en
esta etapa (p.ej., sentencias inexistentes, uso erróneo de
variables u operadores, etc.)

Eficiencia en la compilación
2) Ligado (Linking): Incorporar bibliotecas de subprogramas
que han sido previamente escritos, depurados y compilados.
Los programas en FORTRAN contienen referencias externas
que deben resolverse durante esta etapa.

Eficiencia en la compilación
Cualquier referencia errónea a funciones externas se resuelve
en esta etapa.
3) Cargado: Es el proceso en el cual se coloca un programa en
la memoria de la computadora. Las direcciones relativas (o
direcciones relocalizables) se traducen a direcciones absolutas
de memoria.
Eficiencia en la compilación
4) Ejecución: El control de la computadora se pasa al
programa que se encuentra en memoria. Puesto que el
programa se ejecuta directamente y no a través de un
intérprete, tiene el potencial de correr significativamente más
rápido.
Pasos de la compilación
La compilación de un programa en FORTRAN se realiza
normalmente en 3 pasos:
1) Análisis sintáctico: El compilador debe clasificar las
sentencias y constructores de FORTRAN y extraer sus
partes.
Pasos de la compilación
2) Optimización: Los compiladores originales de
FORTRAN incluían un optimizador muy
sofisticado cuya meta era producir código tan
bueno como el de un buen programador humano.
Hasta la fecha, la mayor parte de los compiladores
de FORTRAN que existen realizan algún tipo de
optimización.
Pasos de la compilación
3) Síntesis de código: Juntar las porciones de las
instrucciones en código objeto en un formato
relocalizable.

Estructuras de control
En sus orígenes, FORTRAN fue un lenguaje muy
dependiente de la máquina en la que se desarrolló (la IBM
704). Esa es la razón por la que algunas de sus instrucciones
lucen un tanto extrañas, redudantes y hasta tontas.

Estructuras de control
Algunas de estas sentencias fueron removidas en versiones
posteriores del lenguaje, pero la mayor parte de ellas han
permanecido ahí durante más de 40 años.
Estructuras de control
La sentencia IF aritmética:
IF (e) n1, n2, n3
evalúa la expresión “e” y salta a n1,n2 o n3, dependiendo
de si el resultado de la evaluación es <0, =0 o >0.
Estructuras de control
La sentencia IF aritmética corresponde de manera exacta a
una instrucción en lenguaje máquina de la IBM 704 y es un
buen ejemplo de cómo NO diseñar una sentencia IF.
Estructuras de control
Llevar el control de 3 etiquetas es algo difícil y el hecho de
que en muchos casos dos de estas etiquetas pueden fusionarse
(por ser idénticas) hacen de ésta una instrucción muy
primitiva.

Estructuras de control
La sentencia IF lógica:
IF (X .EQ. 5) M=A+3
.LT., .GT., .GE., .LE., .AND., .OR.,
.NOT., .EQV., .NEQV.
Esta sentencia reemplaza a la primitiva sentencia IF
aritmética y la vuelve más fácil de usar y más regular.

Estructuras de control
Sentencias Condicionales
GOTO era el caballito de batalla del control de flujo en
FORTRAN, ya que no existía estructura IF-THEN-ELSE
como en la mayoría de los lenguajes de programación
modernos.

Estructuras de control
IF (se cumple) GOTO 100
. . . caso para condición falsa . . .
GOTO 200
100
. . . caso para condición cierta . . .
200
. . .

Estructuras de control
El uso de GOTO puede llevarnos (cuando no se aplica
adecuadamente) al desarrollo del denominado “código
spaghetti”, lo cual genera programas difíciles de leer y
modificar.

Estructuras de control
Sentencias para casos:
Como no había CASE como en los lenguajes de
programación modernos, se utilizaba en su lugar el
denominado “GOTO calculado” (computed GOTO).


COBOL


Generalidades
El lenguaje COBOL, acrónimo de "COmmon Business Oriented Language" nació en 1959 del deseo de crear un lenguaje de programación "universal", que pudiera ser usado en cualquier ordenador (en los años 60 existían numerosos modelos de ordenadores incompatibles entre sí) y que estuviera orientado principalmente a los negocios, es decir, a la Informática de gestión. En la creación de este lenguaje participó la comisión CODASYL, compuesta por fabricantes de ordenadores, usuarios y el departamento de defensa de Estados Unidos. El primer prototipo del lenguaje salió a la luz en 1960. A pesar del tiempo transcurrido, sigue siendo uno de los lenguajes de programación más usados en el mundo.
COBOL es un lenguaje en el que no se diferencian las minúsculas y las mayúsculas (no es case sensitive). Es un lenguaje de formato fijo, donde la estructura de cada instrucción viene definida por el lenguaje. En general, cada instrucción debe ir en una única línea y una línea solo puede tener una instrucción. Además, cada instrucción termina siempre con un punto (.). Por otro lado, las instrucciones deben comenzar en una determinada columna. Cada línea está formada por tres áreas, definidas por la columna (o posición) que ocupan dentro de la línea:
Números de Secuencia: Se representan en las columnas 1 a 6. Constituyen una numeración de las líneas de código y están formados por números de 6 dígitos. No es obligatorio que todas las líneas de código lleven el número de secuencia, pero si éstos aparecen, deben ser siempre crecientes (un número de secuencia de una línea siempre tiene que ser mayor que cualquier otro número de secuencia que pueda aparecer previamente) [no es obligatorio implementar los números de secuencia, pero siempre hay que dejar este hueco de seis columnas].
Área indicadora: Se representa por un carácter en la columna 7. Se utiliza para indicar ciertas características de cada línea: , continuación de la línea anterior (si se desea partir una instrucción en varias líneas, la segunda y sucesivas deben tener un guión "-" y comenzar en la columna 12) [es opcional implementar la continuación de líneas con el guión, pero se debe respetar el hueco de la columna 7].
Área de código fuente: Se representa en las columnas 8 a 80. Se utiliza para escribir todo el código fuente en COBOL [es opcional limitar las líneas a 80 columnas, pero cada línea de código debe comenzar en la columna 8].
Las más de 300 palabras clave que tiene el lenguaje son reservadas, aunque cada grupo de alumnos sólo ha de tener en cuenta las palabras asignadas a su grupo.
COBOL no es un lenguaje con estructura de bloques y, por tanto, no maneja los conceptos de nombres globales y no locales. Todos los nombres son locales.
En COBOL es necesario declarar previamente los identificadores (salvo las etiquetas) antes de que se utilicen. Además, hay que implementar el Compilador de COBOL considerando que es un lenguaje con recursividad, por lo que cualquier subprograma puede ser recursivo.
Estructura de un Programa
Para el Proyecto de Compiladores debe considerarse que un programa COBOL estará compuesto por un único fichero que ha de tener uno o varios subprogramas colocados uno tras otro. Un subprograma está estructurado en tres divisiones que han de aparecer exactamente en el siguiente orden:
IDENTIFICATION DIVISION.
DATA DIVISION.
PROCEDURE DIVISION.
Dentro de cada división se especifica un tipo de información. Seguidamente, se va a comentar la utilidad de cada una de las divisiones.
División de Identificación
Mediante esta división se asigna un nombre al subprograma (se usa la palabra reservada PROGRAM-ID seguida de un punto). El nombre del subprograma, que siempre debe aparecer, constituye un y va seguido de un punto. Opcionalmente, se puede añadir información (que se considera como un comentario) sobre autor (mediante la palabra AUTHOR), fecha de escritura (mediante la palabra DATE-WRITTEN), etc. [solo es obligatorio implementar el nombre del subprograma]. La sintaxis es:
IDENTIFICATION DIVISION.
PROGRAM-ID. Nombre-de-programa.
AUTHOR. Profesores de Compiladores.
DATE-WRITTEN. 19 de octubre de 2005.
División de Datos
En esta división se declaran los datos del subprograma, de forma que el compilador pueda reservar memoria para ellos. Dentro de esta división hay una serie de secciones opcionales de las que solo hay que considerar, en este orden, la LINKAGE SECTION, que es la que se utiliza para declarar los parámetros del subprograma, y la WORKING-STORAGE SECTION, que es la que se utiliza para declarar las variables locales del subprograma. Si alguna de las secciones no contiene ninguna declaración, no es necesario indicarla. Si la división no tiene ninguna sección, tampoco hay que indicarla. Por tanto, la estructura general de esta división sería:

División de Procedimiento
En esta división se declaran las sentencias del subprograma. Cuando se llame al subprograma, la ejecución comenzará por la primera sentencia que aparezca en esta división y proseguirá secuencialmente hasta que se llegue bien a la sentencia de retorno de subprograma (EXIT PROGRAM) o bien a la de fin de programa (STOP RUN) Esta división comienza con las palabras reservadas PROCEDURE DIVISION y termina con las palabras reservadas END PROGRAM, que indican también el final del código del subprograma.

Programa Principal
Existe un subprograma especial que constituye el programa principal. Tiene que ser siempre el último subprograma del programa. El programa principal (lo que se ejecutará al arrancar el programa) será siempre un subprograma sin parámetros. La finalización del programa principal se especifica mediante la instrucción de fin de programa (STOP RUN), que solo puede estar presente en el programa principal. Ejemplo:
IDENTIFICATION DIVISION.
PROGRAM-ID. Nombre-de-programa.
DATA DIVISION.
WORKING-STORAGE SECTION.
* declaración de las variables locales
PROCEDURE DIVISION.
* sentencias
STOP RUN.
* sentencias
END PROGRAM.
Comentarios
En COBOL los comentarios se especifican colocando el carácter "*" en la columna 7 de cada línea donde se desee introducir un comentario. Por lo tanto, las líneas de comentario, tantas como se quiera, solamente podrán contener comentarios. Ejemplos:
* Línea de Comentario con el asterisco en la columna 7
*Otra línea con comentario
Constantes
El lenguaje dispone de varios tipos de constantes, de las cuales solamente habrá que tener en cuenta las siguientes:
Enteros
Las constantes enteras se escribirán en notación decimal (por ejemplo, 159). El ensamblador que se utilizará dispone de números enteros de 2 bytes (con signo), por lo que el máximo entero será el 32767.
Cadenas de caracteres
Las constantes de cadena van encerradas entre comillas simples ('Hola, mundo'). Puede aparecer cualquier carácter imprimible en la cadena excepto la propia comilla, que siempre actuará como delimitador.
Constantes figurativas
Son constantes a las que se les ha asignado un nombre fijo (que se considera palabra reservada). Como ejemplos de constantes figurativas se tiene zero, que representa el valor numérico cero; space, que representa al carácter espacio, etc. [es opcional implementar las constantes figurativas].
Operadores
Este lenguaje presenta un conjunto de operadores con los que escribir distintas expresiones. Además, se pueden utilizar los paréntesis para agrupar subexpresiones. Cada símbolo de operador debe tener obligatoriamente al menos un espacio antes y otro después (esto no se aplica si el operador es una palabra reservada). De esta manera, la expresión 8 > 3 es correcta, mientras que 7+9 es incorrecta.
Operadores aritméticos
Son los operadores que permiten realizar la suma, resta, producto y división: +, -, * y / [obligatorio implementar al menos uno]. Se aplican sobre datos enteros, proporcionando un resultado entero.
También existen los operadores más y menos unarios: +, - [implementación opcional].
Operadores de relación
Son los operadores que permiten realizar las comparaciones de igual, distinto, menor, mayor, menor o igual, mayor o igual: =, <, >, IS EQUAL TO, IS NOT EQUAL TO, IS LESS THAN, IS GREATER THAN, IS NOT GREATER THAN e IS NOT LESS THAN (obsérvese que algunos operadores pueden escribirse de más de una forma) [obligatorio implementar al menos uno de los operadores]. Se aplican sobre datos enteros y proporcionan un resultado lógico.
Operadores lógicos
Representan las operaciones de conjunción, disyunción y negación: AND, OR y NOT [obligatorio implementar al menos uno]. Se aplican sobre datos lógicos y devuelven un resultado lógico.
Precedencia de operadores
En la tabla siguiente se muestra la precedencia de los operadores con el siguiente significado: los operadores del mismo grupo tienen la misma precedencia y, conforme se desciende por la tabla, la precedencia disminuye. En cualquier caso, el uso de paréntesis permite alterar el orden de evaluación de las expresiones [es obligatorio para todos los grupos implementar el uso de paréntesis y tener en cuenta las precedencias de sus operadores.

Identificadores
Los nombres de identificadores pueden estar formados por letras, dígitos y el guión ("-"), siendo el primero siempre una letra y no pudiendo empezar ni terminar con guión. Además, los identificadores deben tener una longitud máxima de 30 caracteres.
Declaraciones
La declaración de variables se considerará obligatoria en el lenguaje definido para este Proyecto. No se admite la redeclaración de nombres en un mismo ámbito. La declaracion de variables se realiza en la DATA DIVISION, dentro de la WORKING-STORAGE SECTION, mediante la cláusula PICTURE (que también puede escribirse como PIC [cada grupo eligirá una de las dos]). En el caso de los parámetros de un subprograma, se deben definir usando esta misma notación, dentro de la LINKAGE SECTION.
Para realizar una declaración de una variable, se escribe el número de nivel 77 (salvo para los registros, que se usan los números del 01 al 49) y a continuación el nombre de la variable seguido de una cláusula PICTURE con la especificación del tipo y tamaño de la variable, finalizando en un punto:
77 nombre PICTURE tipo-tamaño.
Tipos de Datos
El lenguaje dispone de distintos tipos de datos, que pueden ser clasificados en Tipos Básicos (o elementales) y Tipos Compuestos (que se forman a partir de tipos básicos).
Tipos Básicos
Se deben considerar los tipos de datos básicos entero y lógico (aunque no se pueden declarar variables de tipo lógico). Se define una variable entera utilizando el carácter 9 para determinar el número de dígitos que se reservan para la variable (la cantidad de nueves indica la cantidad de dígitos que puede tener el número entero). Teniendo en cuenta el tamaño determinado por el ensamblador, el tamaño máximo sera de 5 dígitos (según la especificación del ensamblador) [es opcional implementar tamaños de enteros inferiores a 5 dígitos].
Tipos Compuestos
Cada grupo tendrá que implementar uno de estos tipos compuestos, basándose en la opción que le corresponda. Todas las declaraciones de variables deben realizarse en la DATA DIVISION del subprograma correspondiente. En los ejemplos se va a hacer uso de elementos del lenguaje que se explicarán posteriormente.
Vectores
Un vector permite almacenar varios valores en una sola variable y acceder a ellos por su posición. Para usar una variable de tipo vector es obligatorio declararla mediante la cláusula OCCURS [implementación obligatoria para algunos grupos].
Cadenas
Una cadena permite almacenar en una variable una secuencia de caracteres alfanuméricos. Para usar una variable de tipo cadena es obligatorio declararla [implementación obligatoria para algunos grupos].
Registros
Un registro es una estructura compuesta de un número fijo de componentes, llamados campos, donde cada uno viene definido por su nombre y su tipo [implementación obligatoria para algunos grupos].
Sintaxis: núm-nivel-1 nombreRegistro. {núm-nivel-2 nombreCampo PICTURE tipoCampo.}
Descripción: Para declarar un registro se utilizan los números de nivel en cascada. El número de nivel (núm-nivel-1) del nombre del registro tiene que ser un número de dos dígitos entre 01 y 49. En primer lugar, se declara el nombre del registro (nombreRegistro). En las líneas siguientes se declaran los campos, cuya sintaxis es exactamente la misma que la explicada para las de enteros [solo hay que implementar campos enteros], salvo que el número de nivel (núm-nivel-2) tiene que ser un número entero de dos dígitos entre 01 y 49, pero con un valor superior al número utilizado para el nombre del registro (todos los campos de un mismo registro han de tener el mismo número de nivel). Los campos de un registro pueden tener el mismo nombre (nombreCampo) que otros identificadores situados fuera de dicho registro, no existiendo ambigüedad porque siempre se accede a un campo (mediante la palabra OF) utilizando el nombre del campo y el del registro.
Ejemplos:
01 empleado.
05 nombre PICTURE x(50).
05 sueldo PICTURE 9(5).

Instrucciones de entrada/salida
La instrucción DISPLAY expresiones escribe los datos recibidos en las expresiones (que deberán ir separadas entre sí por comas) y, a continuación, imprime un salto de línea. Si no hay ninguna expresión, se limita a imprimir un salto de línea. Las expresiones pueden ser de tipo entero, lógico o cadena. Por ejemplo:
Move 100 to a.
DISPLAY 'Precio: ', a, 'Euros. Con IVA: ', a + a * 16 / 10.
* imprime: “Precio: 100Euros. Con IVA: 116”
DISPLAY a > 50, a < 50.
* imprime: “TrueFalse”
La instrucción ACCEPT lista recibe una lista (no vacía) de variables enteras separadas por comas y lee números enteros del teclado, asignándole cada valor leído a cada una de las variables recibidas, respectivamente [los grupos que tengan el tipo cadena, también deberán implementar la lectura de variables cadena]:
77 an Picture 99999.
77 na Pic 9(5).
* ...
* imprime una cadena:
DISPLAY 'Escribe en qué año naciste y en qué año estamos' .
* lee dos números:
ACCEPT na, an.
* imprime entre dos cadenas la edad y salta de línea:
DISPLAY 'Hola, tienes ', an - na, ' años.' .
Sentencias
De todo el extenso grupo de sentencias del lenguaje COBOL, se han seleccionado para ser implementadas en el Proyecto las que aparecen a continuación (opcional u obligatoriamente, según se indique en cada caso):
Sentencias de Asignación
Existen dos sentencias de asignación en COBOL, MOVE y COMPUTE cuyo funcionamiento se explica a continuación [es obligatorio implementar la sentencia MOVE y es opcional implementar la sentencia COMPUTE].
Sentencia MOVE
Esta sentencia permite asignar un valor a una variable [implementación obligatoria]:
Sintaxis: MOVE expresión TO identificador.
Descripción: Se evalúa la expresión y se asigna el valor resultante al identificador.
Ejemplo:
MOVE 12 * x TO salario-anual-juan.
MOVE salario-anual-juan TO salario-anual-pedro.
Sentencia COMPUTE
Esta sentencia permite asignar un valor a una variable [implementación opcional]:
Sintaxis: COMPUTE identificador = expresión.
Descripción: Se evalúa la expresión y se asigna el valor resultante al identificador.
Ejemplo:
COMPUTE salario-anual-juan = 12 * x.
COMPUTE salario-anual-pedro = salario-anual-juan.
Sentencias Varias
Sentencia de llamada a un subprograma
Esta sentencia permite invocar la ejecución de un subprograma previamente definido.
Sintaxis: CALL nombre-subprograma [USING expresiones].
Descripción: La llamada a un subprograma se realiza mediante la instrucción CALL, que va seguida del nombre del subprograma y de los argumentos actuales indicados mediante la cláusula USING y separados por comas (si no tiene argumentos, no se indica esta cláusula).
Ejemplo:
* llamada al subprograma mul con dos parámetros:
CALL mul USING total, 8 + b.
* llamada al subprograma imprime, que no tiene parámetros:
CALL imprime.
ELSE
move 2 to tasa.
END IF.
Sentencia condicional GO TO DEPENDING
Esta sentencia constituye una sentencia de selección múltiple, similar a la que presentan otros lenguajes, aunque su ejecución presenta unos matices propios [implementación obligatoria para algunos grupos].
Sintaxis: GO TO etiqueta1 {etiqueta2} DEPENDING ON expresión.
Descripción: En primer lugar, las etiquetas indicadas identifican cuerpos de perform, tal como se ha explicado con anterioridad y, por tanto, se les imponen las mismas condiciones, incluido que deben aparecer después de la clausula STOP RUN o EXIT PROGRAM. El funcionamiento general del GO TO se basa en el valor de la expresión. Si ésta vale 1, se salta a etiqueta1 y una vez ejecutado el código correspondiente se termina el GO TO. Si la expresión vale 2, se salta a la etiqueta2, y así sucesivamente. Si no existiera la etiqueta correspondiente al valor de la expresión (por ejemplo, si la expresión vale 3 y sólo se especifican dos etiquetas), la ejecucion del GO TO finalizará. Lo mismo ocurre si la expresión vale 0 ó un valor negativo.
Ejemplo:
GO TO director subdirector empleado DEPENDING ON tipo.
* ...
Stop Run.
* si tipo es 1 se ejecuta:
director.
move 5000 to sueldo.
Exit.
* si tipo es 3 se ejecuta:
empleado.
move 900 to sueldo.
Exit.
* si tipo es 2 se ejecuta:
subdirector.
move 2500 to sueldo.
EXIT.
Subprogramas
Es necesario definir cada subprograma antes de poder utilizarlo. La definición de un subprograma se realiza indicando su nombre y las divisiones identification, data y procedure. Dentro de la DATA DIVISION se coloca la WORKING-STORAGE SECTION, donde se definen las variables locales (si las tiene) y la LINKAGE SECTION, donde se definen los nombres y tipos de los parámetros formales del subprograma (si los tiene). Además, en el título de la PROCEDURE DIVISION se vuelven a indicar los nombres de los parámetros recibidos mediante una lista tras la palabra USING. Dentro de esta PROCEDURE DIVISION se tiene el cuerpo del subprograma y el final de la ejecución del subprograma se indica con la sentencia EXIT PROGRAM. El final del código del subprograma se indica mediante la instrucción END PROGRAM.
Los parámetros de los subprogramas podrán ser de cualquiera de los tipos que le corresponda a cada grupo. Existen dos formas de pasar los parámetros: por valor (BY VALUE) y por referencia (BY REFERENCE). Estas palabras se indican tras la lista de parámetros en la declaración .

PHP es un lenguaje de programación (originario del nombre PHP Tools, o Personal Home Page Tools) que sirve principalmente para proporcionar características dinámicas a una página web. Puede combinarse con bases de datos MySQL, ofreciendo resultados muy interesantes para todas aquellas páginas web que pretendan figurar como activas y dinámicas.

El lenguaje PHP tiene la característica de poder mezclarse con el lenguaje HTML.
, al contrario que este último, se interpreta y ejecuta directamente en el servidor en el que está albergada la página web, con lo que el visitante a la misma únicamente recibe el resultado buscado por el código en el que está escrito.

ENGUAJE DE PROGRMACIóN JAVA

Lenguaje de programación Java

Paradigma: orientado a objetos
Aparición en: 1990s
Diseñado por: Sun Microsistemas

Java es un lenguaje de programación orientado a objetos desarrollado por James Gosling y sus compañeros de Sun Microsystems al inicio de la década de 1990. A diferencia de los lenguajes de programación convencionales, que generalmente están diseñados para ser compilados a código nativo, Java es compilado en un bytecode que es ejecutado (usando normalmente un compilador JIT), por una máquina virtual Java.
El lenguaje en sí mismo toma mucha de su sintaxis de C y C++, pero tiene un modelo de objetos mucho más simple y elimina herramientas de bajo nivel

Orígenes
La plataforma Java y el lenguaje Java empezaron como un proyecto interno de Sun Microsystems en diciembre de 1990. Patrick Naughton, ingeniero de Sun, estaba decepcionado con el estado de C++ y la API de C y sus herramientas. Mientras consideraba migrar a NeXT, Naughton recibió la oferta de trabajar en una nueva tecnología, y así comenzó el proyecto Stealth.
El Proyecto Stealth fue rebautizado, es decir, vuelto a bautizar, como Green Project (o Proyecto Verde) cuando James Gosling y Mike Sheridan se unieron a Naughton. Con la ayuda de otros ingenieros, empezaron a trabajar en una pequeña oficina en Sand Hill Road en Menlo Park, California. Intentaban desarrollar una nueva tecnología para programar la siguiente generación de dispositivos inteligentes, en los que Sun veía un campo nuevo a explotar.
El equipo pensó al principio usar C++, pero se descartó por varias razones. Al estar desarrollando un sistema empotrado con recursos limitados, C++ no es adecuado por necesitar mayor potencia además de que su complejidad conduce a errores de desarrollo. La ausencia de un recolector de basura (garbage collector) obligaba a los programadores a manejar manualmente el sistema de memoria, una tarea peligrosa y proclive a fallos.
Bill Joy había concebido un nuevo lenguaje que combinase lo mejor de Mesa y C. En un escrito titulado Further (más lejos), proponía a Sun que sus ingenieros crearan un entorno orientado a objetos basado en C++. la idea para crear un lenguaje completamente nuevo, al que llamó Oak, en referencia al roble que tenía junto a su oficina.
El equipo dedicó largas horas de trabajo y en el verano de 1992 tuvieron lista algunas partes de la plataforma, incluyendo el Sistema Operativo Green, el lenguaje Oak, las librerías y el hardware. La primera prueba, llevada a cabo el 3 de Septiembre de 1992, se centró en construir una PDA (Personal Digital Assistant o Asistente Digital Personal) llamada Star7, que contaba con una interfaz gráfica y un asistente apodado "Duke" para guiar al usuario.
En noviembre de ese mismo año, el Proyecto Verde se convirtió en FirstPerson, Inc, una división propiedad de Sun Microsystems.
.Java de Internet
En junio y julio de 1994, tras una sesión maratónica de tres días entre Jonh Gaga, James Gosling, Joy Naughton, Wayne Rosing y Eric Schmidt, el equipo reorientó la plataforma hacia la Web. Sintieron que la llegada del navegador Web Mosaic, propiciaría que Internet se convirtiese en un medio interactivo, como el que pensaban era la televisión por cable. Naughton creó entonces un prototipo de navegador, WebRunner, que más tarde sería conocido como HotJava.
Ese año renombraron el lenguaje como Java tras descubrir que "Oak" era ya una marca comercial registrada para adaptadores de tarjetas gráficas. El término Java fue acuñado en una cafetería frecuentada por algunos de los miembros del equipo. Pero no está claro si es un acrónimo o no, aunque algunas fuentes señalan que podría tratarse de las iniciales de sus creadores: James Gosling, Arthur Van Hoff, y Andy Bechtolsheim. Otros abogan por el siguiente acrónimo, Just Another Vague Acronym ("sólo otro acrónimo ambiguo"). La hipótesis que más fuerza tiene es la que Java debe su nombre a un tipo de café disponible en la cafetería cercana. Un pequeño signo que da fuerza a esta teoría es que los 4 primeros bytes (el número mágico) de los archivos .class que genera el compilador, son en hexadecimal, 0xCAFEBABE.

En octubre de 1994, se les hizo una demostración de HotJava y la plataforma Java a los ejecutivos de Sun. Java 1.0a pudo descargarse por primera vez en 1994, pero hubo que esperar al 23 de mayo de 1995, durante las conferencias de SunWorld, a que vieran la luz pública Java y HotJava, el navegador Web. El acontecimiento fue anunciado por John Gage, el Director Científico de Sun Microsystems. El acto estuvo acompañado por una pequeña sorpresa adicional, el anuncio por parte de Marc Andreessen, Vicepresidente Ejecutivo de Netscape, que Java sería soportado en sus navegadores. El 9 de enero del año siguiente, 1996, Sun fundó el grupo empresarial JavaSoft para que se encargase del desarrollarlo.

Historia reciente

La capacidad de los navegadores Web para ejecutar applets de Java ha asegurado la continuidad del uso de Java por el gran público. Flash está más extendido para animaciones interactivas y los desarrolladores estén empezando a usar la tecnología AJAX también en este campo. Java suele usarse para aplicaciones más complejas como la zona de juegos de Yahoo, Yahoo! Games, o reproductores de video (ej. [2]).

En el servidor
En la parte del servidor, Java es más popular que nunca, con muchos sitios empleando páginas JavaServer, conectores como Tomcat para Apache y otras tecnologías Java.

Disponibilidad del JRE de Java
Una versión del JRE (Java Runtime Environment) está disponible en la mayoría de equipos de escritorio. Sin embargo, Microsoft no lo ha incluido por defecto en su sistema operativo, ya que Windows XP fue lanzado en 2001. En el caso de Apple, éste incluye una versión propia del JRE en su sistema operativo, el Mac OS. También es un producto que por defecto aparece en la mayoría de las distribuciones de Linux. Debido a incompatibilidades entre distintas versiones del JRE, muchas aplicaciones prefieren instalar su propia copia del JRE antes que confiar su suerte a la aplicación instalada por defecto. Los desarrolladores de applets de Java o bien deben insistir a los usuarios en la actualización del JRE, o bien desarrollar bajo una versión antigua de Java y verificar el correcto funcionamiento en las versiones posteriores.
Tipos de versiones de java:
El lenguaje Java ha experimentado numerosos cambios desde la versión primigenia, JDK 1.0, así como un enorme incremento en el número de clases y paquetes que componen la librería estándar. Java IDL, una implementación de IDL (Interfaz para Descripción de Lenguaje) para la interoperabilidad con JLS son gestionados en JSR 901.
JDK 1.0 (23 de enero de 1996) — Primer lanzamiento.
comunicado de prensa
JDK 1.1 (19 de febrero de 1997) — Principales adiciones incluidas: comunicado de prensa
una reestructuración intensiva del modelo de eventos AWT (Abstract Windowing Toolkit)
clases internas (inner classes)
JavaBeans
JDBC (Java Database Connectivity), para la integración de bases de datos
RMI (Remote Method Invocation)
J2SE 1.2 (8 de diciembre de 1998) — Nombre clave Playground. Esta y las siguientes versiones fueron recogidas bajo la denominación Java 2 y el nombre "J2SE" (Java 2 Platform, Standard Edition), reemplazó a JDK para distinguir la plataforma base de J2EE (Java 2 Platform, Enterprise Edition) y J2ME (Java 2 Platform, Micro Edition). Otras mejoras añadidas incluían: comunicado de prensa
la palabra reservada (keyword) strictfp
reflexión o reflection
la API gráfica ( Swing) fue integrada en las clases básicas
la máquina virtual (JVM) de Sun fue equipada con un compilador JIT (Just in
Time) por primera vez

CORBA
Colecciones (Collections)

J2SE 1.3 (8 de mayo de 2000) — Nombre clave Kestrel.

Los cambios más notables fueron:comunicado de prensa lista completa de cambios
la inclusión de la máquina virtual de HotSpot JVM (la JVM de HotSpot fue lanzada inicialmente en abril de 1999, para la JVM de J2SE 1.2)
RMI fue cambiado para que se basara en CORBA
JavaSound
se incluyó el Java Naming and Directory Interface (JNDI) en el paquete de librerías principales (anteriormente disponible como una extensión)
Java Platform Debugger Architecture (JPDA)

J2SE 1.4 (6 de febrero de 2002) — Nombre Clave Merlin. Este fue el primer lanzamiento de la plataforma Java desarrollado bajo el Proceso de la Comunidad Java como JSR 59. Los cambios más notables fueron: press releasefull list of changes
Palabra reservada assert (Especificado en JSR 41.)
Expresiones regulares modeladas al estilo de las expresiones regulares Perl
Encadenación de excepciones Permite a una excepción encapsular la excepción de bajo nivel original.

non-blocking NIO (NE Input/Output) (Especificado en JSR 51.)
Logging API (Specified in JSR 47.)

API I/O para la lectura y escritura de imágenes en formatos como JPEG o PNG
Parser XML integrado y procesador XSLT (JAXP) (Especificado en JSR 5 y JSR 63.)
Seguridad integrada y extensiones criptográficas (JCE, JSSE, JAAS)
Java Web Start incluido (El primer lanzamiento ocurrió en Marzo de 2001 para J2SE 1.3) (Especificado en JSR 56.)
J2SE 5.0 (30 de septiembre de 2004) — Nombre clave: Tiger. (Originalmente numerado 1.5, esta notación aún es usada internamente.[4]) Desarrollado bajo JSR 176, Tiger añadió un número significativo de nuevas características press release
Plantillas (genéricos) — provee conversion de tipos (type safety) en tiempo de compilación para colecciones y elimina la necesidad de la mayoría de conversion de tipos (type casting). (Especificado por JSR 14.)
Metadatos — también llamados anotaciones, permite a estructuras del lenguaje como las clases o los métodos, ser etiquetados con datos adicionales, que puedan ser procesados posteriormente por utilidades de proceso de metadatos. (Especificado por JSR 175.)
Autoboxing/unboxing — Conversiones automáticas entre tipos primitivos (Como los int) y clases de envoltura primitivas (Como Plantilla:Javadoc:SE). (Especificado por JSR 201.)
Enumeraciones — la palabra reservada enum crea una typesafe, lista ordenada de valores (como Dia.LUNES, Dia.MARTES, etc.). Anteriormente, esto solo podía ser llevado a cabo por constantes enteras o clases construidas manualmente (enum pattern). (Especificado por JSR 201.)
Varargs (número de argumentos variable) — El último parámetro de un método puede ser declarado con el nombre del tipo seguido por tres puntos (e.g. void drawtext(String... lines)). En la llamada al método, puede usarse cualquier número de parámetros de ese tipo, que serán almacenados en un array para pasarlos al metodo.
Enuncie bucle — La sintaxis para el bucle for se ha extendido con una sintaxis especial para iterar sobre cada miembro de un array o sobre cualquier clase que implemente Plantilla:Javadoc:SE, como la clase estándar Plantilla:Javadoc:SE, de la siguiente forma:

Java SE 6 — Nombre clave Mustang. Estando en 2006 está en desarrollo bajo la JSR 270. Una versión Beta fue lanzada el 15 de febrero de 2006 . Se espera otra beta en verano de 200A con la versión final en otoño de 200n.

Orientado a Objetos
La primera característica, orientado a objetos (“OO”), se refiere a un método de programación y al diseño del lenguaje. Aunque hay muchas interpretaciones para OO, una primera idea es diseñar el software de forma que los distintos tipos de datos que use estén unidos a sus operaciones. Así, los datos y el código (funciones o métodos) se combinan en entidades llamadas objetos. Un objeto puede verse como un paquete que contiene el “comportamiento” (el código) y el “estado” (datos). El principio es separar aquello que cambia de las cosas que permanecen inalterables. Frecuentemente, cambiar una estructura de datos implica un cambio en el código que opera sobre los mismos, o viceversa. Esta separación en objetos coherentes e independientes ofrece una base más estable para el diseño de un sistema software.

La licencia sobre Java de Sun insiste que todas las implementaciones sean “compatibles”. Esto dio lugar a una disputa legal entre Microsoft y Sun, cuando éste último alegó que la implementación de Microsoft no daba soporte a las interfaces RMI y JNI además de haber añadido características ‘’dependientes’’ de su plataforma. Sun demandó a Microsoft y ganó por daños y perjuicios (unos 20 millones de dólares) así como una orden judicial forzando la acatación de la licencia de Sun. Como respuesta, Microsoft no ofrece Java con su versión de sistema operativo, y en recientes versiones de Windows, su navegador Internet Explorer no admite la ejecución de applets sin un conector (o plugin) aparte. Sin embargo, Sun y otras fuentes ofrecen versiones gratuitas para distintas versiones de Windows.
Las primeras implementaciones del lenguaje usaba una máquina virtual interpretada para conseguir la portabilidad. Sin embargo, el resultado eran programas que se ejecutaban comparativamente más lentos que aquellos escritos en C o C++. Esto hizo que Java se ganase una reputación de lento en rendimiento. Las implementaciones recientes de la JVM dan lugar a programas que se ejecutan considerablemente más rápido que las versiones antiguas, empleando diversas técnicas
Críticas
Harold dijo en 1995 que Java fue creado para abrir una nueva vía en la gestión de software complejo, y es por regla general aceptado que se ha comportado bien en ese aspecto. Sin embargo no puede decirse que Java no tenga grietas, ni que se adapta completamente a todos los estilos de programación, todos los entornos, o todas las necesidades.

El lenguaje
En un sentido estricto, Java no es un lenguaje absolutamente orientado a puobjetos, a diferencia de, por ejemplo, Ruby o Smalltalk. Por motivos de eficiencia, Java ha relajado en cierta medida el paradigma de orientación a objetos, y así por ejemplo, no todos los valores son objetos.
Por el contrario, los programadores de C++ pueden caer en la confusión con Java, porque en éste los tipos primitivos son siempre variables automáticas, y los objetos siempre residen en el montículo (heap), mientras que en C++ ambos casos están en manos del programador, usando el operador new.
El código Java puede ser a veces redundante en comparación con otros lenguajes. Esto es en parte debido a las frecuentes declaraciones de tipos y conversiones de tipo manual (casting). También se debe a que no se dispone de operadores sobrecargados, y a una sintaxis relativamente simple. Sin embargo, J2SE 5.0 introduce elementos para tratar de reducir la redundancia, como una nueva construcción para los bucles ‘’’foreach’’’.
A diferencia de C++, Java no dispone de operadores de sobrecarga definidos por el usuario. Sintaxis
La sintaxis de Java se deriva en gran medida de C++. Pero a diferencia de éste, que combina la sintaxis para programación genérica, estructurada y orientada a objetos, Java fue construido desde el principio para ser completamente orientado a objetos. Todo en Java es un objeto (salvo algunas excepciones), y todo en Java reside en alguna clase.

Ejemplo Hola Mundo
Aplicaciones autónomas
// Hola.java
public class Hola
{
public static void main(String[] args) {
System.out.println("Hola, mundo!");
}
}
Este ejemplo necesita una pequeña explicación.
Todo en Java está dentro de una clase, incluyendo programas autónomos.

El código fuente se guarda en archivos con el mismo nombre que la clase que contienen y con extensión “.java”. Una clase (class) declarada pública (public) debe seguir este convenio. En el ejemplo anterior, la clase es Hola, por lo que el código fuente debe guardarse en el fichero “Hola.java”
El compilador genera un archivo de clase (con extensión “.class”) por cada una de las clases definidas en el archivo fuente. Una clase anónima se trata como si su nombre fuera la concatenación del nombre de la clase que la encierra, el símbolo “$”, y un número entero.
Los programas que se ejecutan de forma independiente y autónoma, deben contener el método ”main()”.
La palabra reservada ”void” indica que el método main no devuelve nada.
El método main debe aceptar un array de objetos tipo String. Por acuerdo se referencia como ”args”, aunque puede emplearse cualquier otro identificador.
La palabra reservada ”static” indica que el método es un método de clase, asociado con la clase en vez de a instancias de la misma. El método main debe ser estático o ‘’’de clase’’’.
La palabra reservada public significa que un método puede ser llamado desde otras clases, o que la clase puede ser usada por clases fuera de la jerarquía de la propia clase. Otros tipos de acceso son ”private” o”protected”.
La utilidad de impresión (en pantalla por ejemplo) forma parte de la librería estándar de Java: la clase ‘’’System’’’ define un campo público estático llamado ‘’’out’’’. El objeto out es una instancia de ‘’’PrintStream’’’, que ofrece el método ‘’’println(String)’’’ para volcar datos en la pantalla (la salida estándar).
Las aplicaciones autónomas se ejecutan dando al entorno de ejecución de Java el nombre de la clase cuyo método main debe invocarse. Por ejemplo, una línea de comando (en Unix o Windows) de la forma java –cp . Hola ejecutará el programa del ejemplo (previamente compilado y generado “Hola.class”) . El nombre de la clase cuyo método main se llama puede especificarse también en el fichero “MANIFEST” del archivo de empaquetamiento de Java (.jar).
Applets
Las applets de Java son programas incrustados en otras aplicaciones, normalmente una página Web que se muestra en un navegador.
// Hola.java
import java.applet. Applet;
import java.awt. Graphics;

public class Hola extends Applet {
public void paint(Graphics gc) {
gc.drawString("Hola, mundo!", 65, 95);
}
}











La sentencia import indica al compilador de Java que incluya las clases java.applet. Applet y java.awt. Graphics, para poder referenciarlas por sus nombres, sin tener que anteponer la ruta completa cada vez que se quieran usar en el código fuente.
La clase Hola extiende (extends) a la clase Applet, es decir, es una subclase de ésta. La clase Applet permite a la aplicación mostrar y controlar el estado del applet. La clase Applet es un componente del AWT (Abstract Windowing Toolkit), que permite al applet mostrar una inteterfaz gráfica de usuario o GUI (Graphical User Interface), y responder a eventos generados por el usuario.
La clase Hola sobrecarga el método paint(Graphics) heredado de la superclase contenedora (Applet en este caso), para acceder al código encargado de dibujar. El método paint() recibe un objeto Graphics que contiene el contexto gráfico para dibujar el applet. El método paint() llama al método drawString(String, int, int) del objeto Graphics para mostrar la cadena de caracteres Hola, mundo! en la posición (65, 96) del espacio de dibujo asignado al applet.
Servlets
Los servlets son componentes de la parte del servidor de Java EE, encargados de generar respuestas a las peticiones recibidas de los clientes.
// Hola.java
import java.io.*;
import javax.servlet.*;

public class Hola extends GenericServlet {
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException
{
response.setContentType("text/html");
PrintWriter pw = response.getWriter();
pw.println("Hola, mundo!");
pw.close();
}
}

Aplicaciones con ventanas
Swing es la librería para la interfaz gráfica de usuario avanzada de la plataforma Java SE.
// Hola.java
Los programas más comunes de Java son las standalone programs (aplicaciones) y los applets. Las standalone programs son aplicaciones que se pueden ejecutar como cualquier otro lenguaje de programación, sin necesidad de ningún elemento soporte.
Los applets son pequeñas aplicaciones en Java, que se transfiere a través de la red y que necesita para su ejecución un browser (navegador o visualizador) de red compatible con Java.
Aquí le introduciremos con un sencillo ejemplo cómo deberá compilar sus aplicaciones y applets Java creados con cualquier procesador de texto.
La Aplicación "Hello world"
Siguiendo los pasos de esta página, usted podrá crear y ejecutar una sencilla aplicación en Java.
1) Crear un Archivo Java fuente.
Java requiere que todo el código resida dentro de una clase con nombre. Cree un archivo llamado HelloWorldApp.java con el siguiente código de Java mostrado aquí, asegurándose que las mayúsculas del nombre del archivo coincidan con el de la clase.
/**
* The HelloWorldApp clase implementa una aplicación que
* simplemente muestra "Hello World!" en la salida estándar.
*/

class HelloWorldApp {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
2) Compilar el Archivo fuente.
3) Ejecutar la Aplicación.
Para ejecutar la aplicación es necesario disponer de un intérprete de Java que nombre de cargue esta nueva clase y la ejecute. Esto se hace pasando al intérprete el la clase HelloWolrdApp. Según la plataforma en la que trabaje:
UNIX: java HelloWorldApp
DOS shell (Windows 95/NT): java HelloWorldApp
MacOS: Doble-click en el icono del fichero HelloWorldApp.class
Como resultado, usted debería ver en la pantalla el mensaje: "Hello world!"

El Applet "Hello Wor
Como crear un applet en Java:
1) Crear un Archivo Java fuente.
Cree un archivo llamado HelloWorld.java con el siguiente código de Java mostrado aquí, asegurándose que las mayúsculas del nombre del archivo coincidan con el de la clase.
import java.applet.Applet;
import java.awt.Graphics;

public class HelloWorld extends Applet {
public void paint(Graphics g) {
g.drawString("Hello world!", 50, 25);
}
}

2) Compilar Archivo fuente con el compilador de Java
UNIX: javac HelloWorld.java
DOS shell (Windows 95/NT): javac HelloWorld.java
MacOS: Arrastre el icono de el fichero HelloWorld.java al icono del compilador javac.
El compilador javac crea un archivo llamado HelloWorldApp.class que contiene el código de byte compilado del programa independientemente del procesador. Si la compilación fracasa, asegurese de haber escrito y nombrado correctamente el programa, tal y como se mostró arriba.
3) Crear un archivo HTML que Incluya el Applet
Cree un archivo en el mismo directorio con el nombre Hello.html, que deberá contener la HelloWorld.class creada anteriormente.
El texto contenido del archivo HTML es el sigt ejemplo:






Hello World!





4) Visualizar el archivo HTML.
Cargue el Archivo HTML en una aplicación que admita applets de Java (un browser compatible Java como por ejemplo el Appletviewer que se proporciona con el JDK (Java Developers Kit).
UNIX: appletviewer file:/home/kwalrath/java/Hello.html
DOS shell (Windows 95/NT): appletviewer file:/home/kwalrath/java/Hello.html
MacOS: Ejecute el AppletViewer desde el menú File, eligiendo abrir URL y entre el URL del fichero HTML que ha creado, por ejemplo:
file:/home/kwalrath/java/Hello.html.
Para cargar el archivo HTML, usted normalmente necesitará especificar a la aplicación (browser) el URL del archivo HTML que usted ha creado. Por ejemplo, usted podría entrar algo así en su URL .

DELPHI

Historia de Delphi. Desde los orígenes de la Informática hasta nuestros días
La verdad es que esta serie de artículos surgió originalmente como un único artículo para una revista a consecuencia de los 20 años (1983-2003) de Borland Delphi.
La idea era narrar como ha evolucionado esta herramienta en estos 20 años (en realidad más), pero yendo más allá de una simple enumeración de fechas, versiones y características, sino exponiendo las cosas en su contexto, tratando de explicar porque en momentos dados las cosas se hicieron de un modo determinado y no de otro, y en que consitía lo que se hizo y lo que se dejó de hacer.
Sin embargo, al enfocarlo de este modo, el plan se mostró cada vez más ambicioso. Hablar de Borland Delphi es hablar de Turbo Pascal, y hablar de Turbo Pascal es hablar del lenguaje Pascal y es hablar de los PCs. Hablar de Delphi es hablar de Windows, pero también es hablar de MS-DOS (Borland Pascal, Turbo Pascal) y de Linux (Kilyx), y eso es hablar de Unix, y es hablar de CP/M, y es hablar de microinformática y de lenguajes, y es...
Por lo tanto se ha decidido empezar de la forma más genérica posible, desde la (pre)historia a grandes rasgos de la informática, para ir cerrando paulatinamente el círculo a modo de embudo entorno a la microinformática, al universo PC, a MS-DOS y Windows, y paralelamente, la aparición de Linux en el mundo PC, para acabar centrándonos en Kompass Pascal y sus sucesores Turbo Pascal, Delphi y Kilyx. La intención es mostrar esta historia como un todo hilvanado en que las decisiones se toman en unas circustancias determinadas, decisiones que provocarán a su vez otros hechos y otras circustancias que determinarán futuros acontencimientos y decisiones. De como el azar, la casualidad o las presiones e intereses de marketing han influido en el rumbo que han tomado las cosas y por qué no siempre las soluciones más lógicas o más brillantes tecnológicamente hablando han sido las adoptadas. En resumen, el devenir de esta herramienta en el contexto en que se ha ido desarrollando, las circustancias que rodearon su nacimiento, los recursos disponibles en cada momento que la han hecho ir en una u otra dirección, o sea, los polvos que han traido estos lodos.
Además, este enfoque cronológico permite al lector que al conocer la historia, según el viejo adagio, no esté condenado a repetirla. En estos tiempos, en los que la prensa no especializada (y parte de la especializada también), los profesionales de la tertulia y "enterados" en general (no se me ocurre mejor adjetivo para definirlos) no se cansan de alabar públicamente, por ejemplo, las "novedades" de Java, como la máquina virtual o la recogida de basuras, "novedades" que llevan más de veinte años en la palestra, he creido conveniente mostrar no sólo el que sino el cuando y el como.
La Historia de Delphi

Delphi es el descendiente de Turbo Pascal, uno de los lenguajes más populares de la década de los 80 en el entorno de desarrollo de aplicaciones importantes en PC (al igual que C).
Fue creado por Borland International y salió a la luz a principios de 1995 con el propósito de unirse a la ola de herramientas de programación visuales, justo en el momento en que Microsoft Visual Basic 3.0 era el rey, y al que no tardó en desbancar.
El motivo de su superioridad se basaba en que era un compilador y no un intérprete de pseudocódigo
(p-code) como Visual Basic. Su biblioteca de controles visuale (VCL) cubría todo lo necesario para la programación en Windows 3.1, añadiendo innumerables facilidades de uso, e incluso permitía crear nuestros propios controles y añadirlos a la librería, algo tan solo posible con los compiladores de C.
El lenguaje de Delphi se apoyó en Object Oriented Pascal, conformando un verdadero lenguaje orientado a objetos llamado Object Pascal.
Por esto, y teniendo en cuenta que pertenecía a Borland, la empresa de lenguajes de programación por excelencia, parecía que podía equipararse incluso a los compiladores de C++, verdaderos reyes internacionales de la programación profesional en ese momento, y de hecho así fue y continua siendo en estos momentos en los que todo lo demás cede terreno a velocidades alarmantes ante el Delphi (y ante el Java).
Actualmente existen 3 versiones fundamentales de Delphi: Delphi 1 para Windows 3.1 y Windows 3.11, y Delphi 2, junto a Delphi 3, para Windows 95-Windows NT.
Su situación en el mercado es inmejorable, ya que cuenta con miles de páginas WEB, cientos de servidores dedicados exclusivamente a él, así como innumerables Foros de Debates, Sitios de FTP plagados de librerías, Chats e IRCs donde sólo se discute sobre Delphi, Servidores de News… y todo lo que pueda darse a través de Internet, además de una extensísima bibliografía internacional, con o que cualquier programador avanzado podrá buscar ayuda en cualquier sitio, resolver dudas compartiendo sus conocimientos con miles de programadores como él. Incluso para los que se inician en el mundo de Delphi, todo esto es un añadido más para que caiga en las redes de esta increíble plataforma de desarrollo, que hace que la programación de aplicaciones de verdad sea lo más asequible posible..
Requisitos para aprender Delphi
Los compiladores de Delphi ofrecen toda la potencia que una máquina apoyada en Windows puede ofrecer sin que ningún otro entorno se le acerque desde lejos (tan solo el de Visual Basic 5 se puede comparar al del Delphi 3, perdiendo por muy poco… pero como sigue siendo Basic…). Pero es necesario poner de parte del programador el tiempo y el esfuerzo necesario para convertirse en un verdadero profesional de la programación mediante Delphi, ya que la mejor herramienta no hace al artista.
Hasta el momento tan sólo un lenguaje (de los que verdaderamente sirven) es más fácil de aprender que Delphi. Este lenguaje es el Visual Basic, por supuesto. Pero ¿para qué utilizar un lenguaje si cuando se quiere hacer algo de verdad nos encontramos limitados por su falta de potencia?
Para empezar a aprender Delphi no es necesario ningún conocimiento avanzado en ningún tema (claro que si se tiene, obviamente será mucho mejor).
Si se conoce el lenguaje Pascal, se encontrará con que la sintaxis básica es prácticamente la misma (esto tambien sirve para Modula). Pero si tan sólo se conoce C, el cambio de sintaxis le costará más que a ningún otro porque la flexibilidad, y por qué no decirlo, los verdaderos jeroglíficos que se pueden hacer en C, serán totalmente imposibles debido a la mayor estructuración y rigurosidad del Object Pascal (no creo que exista nunca un concurso en Delphi como el Ofuscated-C, donde el premio es al programa en C más ilegible, más enrevesado y que, por supuesto, haga algo).
Así que lo primero en lo que hay que centrarse es en la sintaxis del lenguaje Object Pascal, pasando posteriormente al aprendizaje de la Programación Orientada a Objetos.
Otro de los puntos fuertes donde insistir es la Orientación a Eventos, debido a que al estar basado en Windows, todo lo que se haga se tendrá que preparar para este "sistema operativo", basándolo todo en el ratón y sus "eventos" como fuente principal de entrada de órdenes.
Habrá que saber qué son los formularios, los botones, las cajas de texto, las listas desplegables, las listas combo, los contenedores de imágenes…; es decir, todas las cosas que conforman Windows y lo convierten en un manejador de eventos (sucesos tales como pulsar el ratón, desplegar una lista, maximizar un formulario, etc).
Pero no hay que alarmarse, ya que, gracias a Delphi, se puede decir sin exagerar que su manejo es un auténtico juego de niños.
Resumiendo: estos son los tres pilares de Delphi
Object Pascal
Windows-Orientación a Eventos
Orientación a Objetos
En un primer lugar, tan sólo serán necesarios los dos primeros para hacer pequeñas aplicaciones, pero cuando el proyecto a desarrollar sea lo suficientemente importante, el tercer pilar será fundamental. Con esto no se pretende afirmar que sin la orientación a objetos no se pueda conseguir todo, es más, algunos programadores acostumbrados durante toda su vida a la programación funcional no usan los objetos (ni quieren saber nada de ellos). Pero cuando un programador cambia su modo de pensar "funcional" al de "objetos", se puede decir que ha alcanzado el mayor nivel para poder desarrollar con garantías aplicaciones profesionales, rigurosas, reutilizables y rápidas de desarrollar que al fin y al cabo es lo que importa.
A continuación vamos a ver dos partes que nos introducirán en lo que consiste hoy en día la programación a nivel profesional, ya que considero que quizás sea más interesante saber además de los precedentes del lenguaje Delphi expuestos anteriormente, la actualidad en el mundo de la programación.
Por esto, la primera parte va a estar totalmente centrada en:
Programación Orientada a Objetos,
y la segunda en el Diseño:
Programación Orientada a Eventos,
Entorno de Desarrollo Visual y
Herramienta de Desarrollo Rápido.
Pero antes que nada, una aclaración. Lo expuesto no va a estar todo lo rigurosamente que debería si esto fuera dirigido a otro tipo de público, así que como lo que importa es que se entienda, el puritanismo y las formalidad absolutas han sido erradicadas.
Programación Orientada a Objetos (OOP)
clasificar los lenguajes de programación en tres categorías:
Funcionales (C, Pascal, Modula2, Basic...)
Declarativos (Lisp, Prolog, Goffer-Haskell...)
Orientados a Objetos (Java, Delphi... ¿C++?)
Delphi se basa en Object Pascal, un lenguaje totalmente orientado a objetos, categoría en la que tan solo se pueden incluir lenguajes tales como Smalltalk (pero que tan solo sirve para el ámbito universitario), Eiffel (siquiera más inútil que el anterior hoy en día), Java (el verdaderamente útil si no se le saca de su terreno: Internet y multiplataformas) y C++ (con este último no me cansaré nunca de decir que es C con una librería de Objetos añadida, por muy potente que sea).
La OO (Orientación a Objetos) hace de Object Pascal un lenguaje muy potente, ya que simplifica en gran medida muchos de los problemas que se plantean en el desarrollo de aplicaciones complejas usando un lenguaje procedural, como pueden ser Pascal, C o Basic. ¿Y por qué esta afirmación? Pues porque cuando los programas que se realizan hoy en día en el mundo profesional dejan de llamarse "programas" para denominarse "Proyectos", la metodología funcional aplicada a un trabajo que raramente se hace ya por una sola persona, practicamente no sirve. Esto se produce en el momento en el que la programación es realizada por un equipo de programadores.
Imaginemos a varias personas programando en C o Pascal sobre un mismo programa, con un resultado final de decenas de miles de líneas de código....
Seguro que la coordinación tan sólo se tratará de hacer al final, cuando todas las partes estén terminadas, asegurando cuelgues, cabreos, noches perdidas buscando el maldito bug que hace que al pulsar sobre un simple botón REVIENTE el programa con mensajes tan conocidos como: Abnormal Program Termination, o Stack Overflow (para los amantes del DOS).
Y es que ya no vale que se diga: Quiero un programa que haga la gestión de mi VideoClub.
Y que el programador se cree un esquema de todo lo que va a ser el programa, en media hora, para rápida y ávidamente pasar a escribir líneas de código como un descosido.
Es verdad que existen técnicas de desarrollo de proyectos tipo Ingeniería del Software con Ciclos de Vida en Cascada, Desarrollo de Prototipos, incluso Métrica, Diagramas de Flujo de Datos, Diagramas de Arquitectura, Diagramas de Estados... (vamos, lo que se suele dar en 3º o 4º de Informática en nuestras queridas Universidades Españolas).
cualquier lugar, que podrán ser modificadas internamente sin que los programas que las utilizan se percaten de ello a no ser que sea para mejor... (bueno, algunas veces las mejoras tan solo son publicidad... como Windows).
Pues bien, con este repaso de lo que es la OO he intentado plantear como están las cosas desde un punto de vista informal, pero como existen gustos para todo, ahora es necesario que lo expuesto anteriormente sea expresado más formalmente, de modo que los futuros programadores de OO vayan conociendo los nombres propios de esta nueva forma de entender la programación. Pero ahora vamos a ir relacionándolos con Delphi. Estos nombres propios son:
Objetos y Clases
Encapsulación
Herencia y
Polimorfismo.
Objetos y Clases
En Delphi prácticamente todo son objetos, desde un botón hasta un formulario (que son componentes de Delphi).
Existen objetos predefinidos, como los citados componentes, pero nosotros también podemos definir nuestros propios objetos..
Un objeto siempre parte de un molde, al que habitualmente se conoce como Clase. En la definición de esta clase se establecen las características de los objetos y se implementan sus funciones y procedimientos, así como sus variables internas, sus valores inciales, la forma en que van a ser llamados, las partes que son públicas, las partes privadas...
Una vez que se tiene la clase, podemos crear objetos de esa clase, que se llamarán instancias de esa clase. Por ejemplo, dada la clase "Figuras" anterior, si queremos utilizarla, tendremos que hacer una instancia de ella. Puede que esto ahora no se entienda, así que pongamos un ejemplo más claro.
Supongamos la clase "Integer".
Ahora si se pone:
var contador:Integer;
Se puede decir que "contador" es un objeto que es una instancia de la clase "Integer"
Encapsulación
Se conoce con este nombre a una de las tres principales características de la programación OO. Un objeto contiene en su interior las variables necesarias para almacenar los datos sobre los que va a trabajar, así como los procedimientos y funciones precisas para manipularlos. Ningún código externo al propio objeto puede acceder a sus variables (a menos que se declaren como públicas), lo que evita muchos problemas.
De esta forma el código interno del objeto puede estar seguro de que su contenido no ha sido alterado externamente, y que, por tanto, será válido en cualquier momento
Un objeto desde esta perspectiva, es como una cápsula en la cual están contenidas las herramientas y los materiales necesarios para desempeñar la función que corresponda.
Herencia
La herencia es la segunda palabra mágica de la orientación a objetos, y seguramente la característica más útil dado que permite ahorrar la escritura de mucho código. Mediante la herencia, es posible definir una nueva clase de objetos a partir de otra que ya existe, quedando todos sus miembros, tanto datos como procedimientos disponibles por la nueva clase. E incluso es posible añadir nuevos miembros a esta clase, ampliando la anterior. De esta forma, la clase nueva va a ser una heredera de la clase padre antigua. Tomará toda su implementación y le añadirá nuevas cosas.
Esto constituye una jerarquía de clases entre padres e hijos que a su vez pueden ser padres de otros hijos, y lo que puede ser la clase inicial totalmente tonta, en los hijos finales se puede convertir en la repera. (¿Se ve la similitud de esto con la evolución humana?)
Polimorfismo
Seguramente este aspecto es el más incomprendido de la programación OO, pero también es de los más útiles. Un objeto polimórfico es aquel que en tiempo de edición, (cuando estamos escribiendo código), no conoce su tipo (la clase la que pertenece), información que obtiene posteriormente en tiempo de ejecución.
El polimorfismo permite que un programa manipule de una forma homogénea a objetos que son diferentes, ahorrando de paso la escritura de mucho código. Como es lógico, estos objetos deben disponer de una información mínima en tiempo de edición, y van a consumir muchos más recursos que los objetos normales.
Podrá parecer algo muy extraño este tipo de objetos, pero algunas veces son muy útiles.
Y hasta aquí lo concerniente a la OO.
Desarrollo.
Programación Orientada a Eventos (EOP)
Para tratar de que esto quede lo más sencillo de entender posible, pongamos un ejemplo de lo que sucede en Windows cuando se pulsa un botón.
Al que usa un programa y simplemente desplaza el cursor hasta ponerlo encima de un control y luego pulsa el botón izquierdo para que se haga una acción, no le importa para nada lo que está sucediendo dentro del programa; lo único que quiere es que lo que se supone que realiza el control se haga cuando se pulse. Pero para los programadores es prácticamente imprescindible saber qué está pasando.
Ante todo, lo primero que hay que tener en cuenta es que se trabaja sobre Windows, es decir, en un entorno donde en cada segundo se generan cientos de mensajes internos, entre todas las cosas que hay en pantalla por un lado, y el propio Windows interiormente por otro.
Los mensajes podemos verlos inicialmente como una especie de cartas que son escritas por un objeto del sistema y enviados a través de un sistema de manejo de mensajes que conforma el núcleo de Windows.
Imaginemos a una persona que escribe una carta, que será un objeto y un mensaje respectivamente. Al enviar la carta, se deja en el servicio de correos (en nuestro caso Windows), para que se encargue de hacer llegar la información a su destinatario o destinatarios.
Ahora pongámosle nombres propios a las cosas.
Supongamos que tenenos un objeto Ratón, un objeto botón, y Windows de por medio.
Supongamos tambien que el botón cambia al color rojo cuando el cursor está sobre él, y que vuelve a su color anterior cuando deja de estarlo.
Cuando se desplaza el cursor sobre la pantalla, el objeto Ratón está continuamente mandando mensajes a Windows para que actualize su posición y se vea donde se debe ver (mientras tanto, el botón está en espera de que pase algo). Pues cuando decidimos poner el cursor del ratón sobre el botón, ocurrirán los siguientes mensajes (hay muchos más, pero ahora nos centramos en los más importantes).
Ratón a Windows: Actualiza mi posición.
Windows a Vídeo: Pon el Cursor en la nueva posición.
Windows a Botón: El Cursor ha entrado en tu zona.
Botón a Windows: Cambia mi color al rojo.
Windows a Vídeo: Pon el Botón en rojo.
Ratón: BOTON IZQUIERDO PULSADO
Ratón a Windows: Botón Izquierdo pulsado.
Windows a Botón: El Ratón ha pulsado con el botón izquierdo sobre tí.
Botón: ORDEN DE EJECUCION.
Botón a Windows: Ejecuta mi código.
Windows a Vídeo: Pon el Botón primero hundido y luego no hundido.
Windows: EJECUTA CODIGO BOTON.
¡Y esto es tan solo un botón, una de las cosas más simples de Windows!
Puede parecer un auténtico follón, pero no hay que alarmarse ya que esto es prácticamente transparente para el programador que use un entorno de programaciín Visual, teniendo tan sólo que preocuparse de escribir el código que tiene que ejecutarse cuando se pulse el botón del ratón sobre el botón de la pantalla. Otra cosa sería si se quisieran hacer efectos de movimiento, cambios de colores y formas…
Podemos pensar ahora que cada vez que movamos el ratón pasarán cosas como esta, y se estará en lo cierto. Y además, tambien hay mensajes internos entre los objetos sin que medie el ratón, o el teclado, por ejemplo la ejecución de aninaciones, de música… en definitiva, de todo.
Pues para que el programador se encargue tan solo de los eventos que le interesen, despreocupándose de los demás, Delphi tiene una forma muy sencilla de hacerlo por nosotros.
Para cada objeto que se suelte sobre un formulario, y tal y como dijimos antes, hay un conjunto de propiedades y un conjunto de procedimientos predefinidos. Pues ahora es el momento de decir que esos procedimientos no son otra cosa que manejadores de los eventos más importantes que se pueden dar en ese objeto, es decir, son procedimientos para responder ante los mensajes de Windows.
Casi todos los objetos tienen en común un conjunto de procedimientos llamados: OnClick, OnMouseDown, OnMouseUp, OnKeyPress, OnKeyDown, OnKeyUp… y tan solo hay que traducir su significado al español para darnos cuenta de su utilidad.
Centrémonos por ejemplo en OnMouseDown.
Si no hacemos nada, cuando a nuestro objeto llegue el cursor y se pulse el botón izquierdo del ratón, Windows le enviará un mensaje indicándoselo y como no hemos dicho qué hacer, nuestro objeto ignorará ese mensaje. Pero si hemos creado código dentro de OnMouseDown, este código se ejecutará siempre que se reciba el mensaje de Windows de que han pulsado sobre él.
Así se puede fácilmente reaccionar ante todo lo que se produzca.
Ahora parece más sencillo ¿no?
Una vez expuesto todo esto, lo que queda por decir en esta parte es qué es la programación orientada a eventos. Es un modo de programar (que se tendrá que tener en cuenta juntamente con la programación orientada a objetos), totalmente distinto al modo tradicional del DOS. Ahora hay que pensar que sólo se va a reaccionar ante la entrada del usuario a través del ratón, teclado o cualquier otro dispositivo, que se vean afectadas en un determinado momento sin que se pueda decir que hay Entorno de Desarrollo Visual (IDE)
El término Visual se refiere al hecho de que Delphi permite crear aplicaciones "cogiendo" los componentes o elementos que necesitemos y "soltándolos" sobre un formulario de Windows. Pero lo realmente importante es el entorno de desarrollo en su conjunto, ya que como en el fondo un programa Delphi es una colección de objetos (componentes) relacionados entre sí, cuando se "suelte" un botón por ejemplo, sobre un formulario, automáticamente Delphi generará el código necesario para declarar y utilizarlo. Tan solo será necesario (y esto es lo verdaderamente importante) centrarnos en lo que debe hacer el botón cuando se pulse, y no perder el tiempo con declaraciones manuales, petición y liberación de recursos, manejadores de contexto, punteros a estructuras de mensajes…; vamos, todo lo que habría que hacer en Visual C manualmente si queremos salirnos algo de lo común (y eso que es Visual), lo hace el Delphi automáticamente, y aquí es donde está la gran diferencia entre los dos lenguajes.
En resumen, el Entorno Visual de Delphi se encarga de generar automáticamente los manejadores de mensajes de cada objeto, de sus declaraciones, de la importación de las librerías de objetos en las Herramienta de Desarrollo Rápido (RAD)
El conjunto de objetos que nos ofrece Delphi para su uso, junto al entorno visual y su generador automático de código, además de la orientación a objetos, lo hacen idóneo para desarrollar aplicaciones lo más rápidamente posible, ya que se puede diseñar un interfaz (lo que se va a ver externamente del programa) en muy poco tiempo.
Hoy en día, lo que importa es la productividad a la hora de desarrollar software, y si se pierde el poco tiempo que se suele tener para la programación en cosas que son externas al funcionamiento principal de la aplicación, tales como rutinas de manejo de mensajes, manejo de memoria, de dispositivos, el fracaso profesional está asegurado. Por eso, hoy en día, cualquier lenguaje o es Visual o no sirve, así de claro.
Y si además permite la reutilización de código (Delphi, Visual Basic, Visual C, Java), la reprogramación de los objetos que siempre usamos de la misma forma (Delphi, Visual C, Java), el entorno de desarrollo verdaderamente Visual (Delphi, Java, Visual Basic), y la potencia en todos los campos (Delphi), mejor que mejor ¿no?.
Algunos ejemplos de programas comerciales desarrollados con Delphi
Para acabar este segundo capítulo, vamos a conocer algunas curiosidades acerca de los programas hechos con Delphi.
El siguiente es un comunicado desde SCOTTS VALLEY, California. 7 de Octubre de 1996
El reciente aterrizaje del U.S. Space Shuttle Atlantis concluyó una excepcional semana para la NASA y Borland International, un líder en el suministro de herramientas de desarrollo de software.
Un mapa computerizado construido con la herramienta Borland Delphi, fue usado en el Atlantis

Otro ejemplo de uso de Delphi, es el reciente premio nacional al mejor programa español de gestión de control de datos y pacientes oncológicos, otorgado por la SEGO (Sociedad Española de Ginecología y Obstetricia). Este programa se llama CODEON-G (Control de Datos en Oncología Ginecológica) y fue desarrollado por VESALIO Software en 1997 (sí, por si alguien lo ha notado es la empresa donde trabajo, y fui uno de los programadores de CODEON). Esto no pretende ser autopublicidad, ya que lo que es el programa en sí y su codificación, conforman una pequeñísima parte de lo que supone este descomunal proyecto, donde las partes de investigación durante más de 3 años han sido desarrolladas por verdaderos profesionales, tanto informáticos como médicos. Tan solo quiero hacer ver que es posible que mortales como nosotros realicemos programas de calidad sobresaliente en nuestra propia tierra.
Por otro lado, corren también ciertos rumores de que desde la versión 6 de Corel Draw, el código desarrollado en Delphi sustituyó a una buena parte del desarrollado en C, sobre todo la parte concerniente al entorno del usuario e interfaces.
be PhotoShop y Corel PhotoPaint) aún son desarrolladas en C, tambien es cierto que comienzan a estar disponibles ficheros de declaraciones, de conversión de tipos y de reutilización de DLLs para

DELPHI

Historia de Delphi. Desde los orígenes de la Informática hasta nuestros días
La verdad es que esta serie de artículos surgió originalmente como un único artículo para una revista a consecuencia de los 20 años (1983-2003) de Borland Delphi.
La idea era narrar como ha evolucionado esta herramienta en estos 20 años (en realidad más), pero yendo más allá de una simple enumeración de fechas, versiones y características, sino exponiendo las cosas en su contexto, tratando de explicar porque en momentos dados las cosas se hicieron de un modo determinado y no de otro, y en que consitía lo que se hizo y lo que se dejó de hacer.
Sin embargo, al enfocarlo de este modo, el plan se mostró cada vez más ambicioso. Hablar de Borland Delphi es hablar de Turbo Pascal, y hablar de Turbo Pascal es hablar del lenguaje Pascal y es hablar de los PCs. Hablar de Delphi es hablar de Windows, pero también es hablar de MS-DOS (Borland Pascal, Turbo Pascal) y de Linux (Kilyx), y eso es hablar de Unix, y es hablar de CP/M, y es hablar de microinformática y de lenguajes, y es...
Por lo tanto se ha decidido empezar de la forma más genérica posible, desde la (pre)historia a grandes rasgos de la informática, para ir cerrando paulatinamente el círculo a modo de embudo entorno a la microinformática, al universo PC, a MS-DOS y Windows, y paralelamente, la aparición de Linux en el mundo PC, para acabar centrándonos en Kompass Pascal y sus sucesores Turbo Pascal, Delphi y Kilyx. La intención es mostrar esta historia como un todo hilvanado en que las decisiones se toman en unas circustancias determinadas, decisiones que provocarán a su vez otros hechos y otras circustancias que determinarán futuros acontencimientos y decisiones. De como el azar, la casualidad o las presiones e intereses de marketing han influido en el rumbo que han tomado las cosas y por qué no siempre las soluciones más lógicas o más brillantes tecnológicamente hablando han sido las adoptadas. En resumen, el devenir de esta herramienta en el contexto en que se ha ido desarrollando, las circustancias que rodearon su nacimiento, los recursos disponibles en cada momento que la han hecho ir en una u otra dirección, o sea, los polvos que han traido estos lodos.
Además, este enfoque cronológico permite al lector que al conocer la historia, según el viejo adagio, no esté condenado a repetirla. En estos tiempos, en los que la prensa no especializada (y parte de la especializada también), los profesionales de la tertulia y "enterados" en general (no se me ocurre mejor adjetivo para definirlos) no se cansan de alabar públicamente, por ejemplo, las "novedades" de Java, como la máquina virtual o la recogida de basuras, "novedades" que llevan más de veinte años en la palestra, he creido conveniente mostrar no sólo el que sino el cuando y el como.
La Historia de Delphi

Delphi es el descendiente de Turbo Pascal, uno de los lenguajes más populares de la década de los 80 en el entorno de desarrollo de aplicaciones importantes en PC (al igual que C).
Fue creado por Borland International y salió a la luz a principios de 1995 con el propósito de unirse a la ola de herramientas de programación visuales, justo en el momento en que Microsoft Visual Basic 3.0 era el rey, y al que no tardó en desbancar.
El motivo de su superioridad se basaba en que era un compilador y no un intérprete de pseudocódigo
(p-code) como Visual Basic. Su biblioteca de controles visuale (VCL) cubría todo lo necesario para la programación en Windows 3.1, añadiendo innumerables facilidades de uso, e incluso permitía crear nuestros propios controles y añadirlos a la librería, algo tan solo posible con los compiladores de C.
El lenguaje de Delphi se apoyó en Object Oriented Pascal, conformando un verdadero lenguaje orientado a objetos llamado Object Pascal.
Por esto, y teniendo en cuenta que pertenecía a Borland, la empresa de lenguajes de programación por excelencia, parecía que podía equipararse incluso a los compiladores de C++, verdaderos reyes internacionales de la programación profesional en ese momento, y de hecho así fue y continua siendo en estos momentos en los que todo lo demás cede terreno a velocidades alarmantes ante el Delphi (y ante el Java).
Actualmente existen 3 versiones fundamentales de Delphi: Delphi 1 para Windows 3.1 y Windows 3.11, y Delphi 2, junto a Delphi 3, para Windows 95-Windows NT.
Su situación en el mercado es inmejorable, ya que cuenta con miles de páginas WEB, cientos de servidores dedicados exclusivamente a él, así como innumerables Foros de Debates, Sitios de FTP plagados de librerías, Chats e IRCs donde sólo se discute sobre Delphi, Servidores de News… y todo lo que pueda darse a través de Internet, además de una extensísima bibliografía internacional, con o que cualquier programador avanzado podrá buscar ayuda en cualquier sitio, resolver dudas compartiendo sus conocimientos con miles de programadores como él. Incluso para los que se inician en el mundo de Delphi, todo esto es un añadido más para que caiga en las redes de esta increíble plataforma de desarrollo, que hace que la programación de aplicaciones de verdad sea lo más asequible posible..
Requisitos para aprender Delphi
Los compiladores de Delphi ofrecen toda la potencia que una máquina apoyada en Windows puede ofrecer sin que ningún otro entorno se le acerque desde lejos (tan solo el de Visual Basic 5 se puede comparar al del Delphi 3, perdiendo por muy poco… pero como sigue siendo Basic…). Pero es necesario poner de parte del programador el tiempo y el esfuerzo necesario para convertirse en un verdadero profesional de la programación mediante Delphi, ya que la mejor herramienta no hace al artista.
Hasta el momento tan sólo un lenguaje (de los que verdaderamente sirven) es más fácil de aprender que Delphi. Este lenguaje es el Visual Basic, por supuesto. Pero ¿para qué utilizar un lenguaje si cuando se quiere hacer algo de verdad nos encontramos limitados por su falta de potencia?
Para empezar a aprender Delphi no es necesario ningún conocimiento avanzado en ningún tema (claro que si se tiene, obviamente será mucho mejor).
Si se conoce el lenguaje Pascal, se encontrará con que la sintaxis básica es prácticamente la misma (esto tambien sirve para Modula). Pero si tan sólo se conoce C, el cambio de sintaxis le costará más que a ningún otro porque la flexibilidad, y por qué no decirlo, los verdaderos jeroglíficos que se pueden hacer en C, serán totalmente imposibles debido a la mayor estructuración y rigurosidad del Object Pascal (no creo que exista nunca un concurso en Delphi como el Ofuscated-C, donde el premio es al programa en C más ilegible, más enrevesado y que, por supuesto, haga algo).
Así que lo primero en lo que hay que centrarse es en la sintaxis del lenguaje Object Pascal, pasando posteriormente al aprendizaje de la Programación Orientada a Objetos.
Otro de los puntos fuertes donde insistir es la Orientación a Eventos, debido a que al estar basado en Windows, todo lo que se haga se tendrá que preparar para este "sistema operativo", basándolo todo en el ratón y sus "eventos" como fuente principal de entrada de órdenes.
Habrá que saber qué son los formularios, los botones, las cajas de texto, las listas desplegables, las listas combo, los contenedores de imágenes…; es decir, todas las cosas que conforman Windows y lo convierten en un manejador de eventos (sucesos tales como pulsar el ratón, desplegar una lista, maximizar un formulario, etc).
Pero no hay que alarmarse, ya que, gracias a Delphi, se puede decir sin exagerar que su manejo es un auténtico juego de niños.
Resumiendo: estos son los tres pilares de Delphi
Object Pascal
Windows-Orientación a Eventos
Orientación a Objetos
En un primer lugar, tan sólo serán necesarios los dos primeros para hacer pequeñas aplicaciones, pero cuando el proyecto a desarrollar sea lo suficientemente importante, el tercer pilar será fundamental. Con esto no se pretende afirmar que sin la orientación a objetos no se pueda conseguir todo, es más, algunos programadores acostumbrados durante toda su vida a la programación funcional no usan los objetos (ni quieren saber nada de ellos). Pero cuando un programador cambia su modo de pensar "funcional" al de "objetos", se puede decir que ha alcanzado el mayor nivel para poder desarrollar con garantías aplicaciones profesionales, rigurosas, reutilizables y rápidas de desarrollar que al fin y al cabo es lo que importa.
A continuación vamos a ver dos partes que nos introducirán en lo que consiste hoy en día la programación a nivel profesional, ya que considero que quizás sea más interesante saber además de los precedentes del lenguaje Delphi expuestos anteriormente, la actualidad en el mundo de la programación.
Por esto, la primera parte va a estar totalmente centrada en:
Programación Orientada a Objetos,
y la segunda en el Diseño:
Programación Orientada a Eventos,
Entorno de Desarrollo Visual y
Herramienta de Desarrollo Rápido.
Pero antes que nada, una aclaración. Lo expuesto no va a estar todo lo rigurosamente que debería si esto fuera dirigido a otro tipo de público, así que como lo que importa es que se entienda, el puritanismo y las formalidad absolutas han sido erradicadas.
Programación Orientada a Objetos (OOP)
clasificar los lenguajes de programación en tres categorías:
Funcionales (C, Pascal, Modula2, Basic...)
Declarativos (Lisp, Prolog, Goffer-Haskell...)
Orientados a Objetos (Java, Delphi... ¿C++?)
Delphi se basa en Object Pascal, un lenguaje totalmente orientado a objetos, categoría en la que tan solo se pueden incluir lenguajes tales como Smalltalk (pero que tan solo sirve para el ámbito universitario), Eiffel (siquiera más inútil que el anterior hoy en día), Java (el verdaderamente útil si no se le saca de su terreno: Internet y multiplataformas) y C++ (con este último no me cansaré nunca de decir que es C con una librería de Objetos añadida, por muy potente que sea).
La OO (Orientación a Objetos) hace de Object Pascal un lenguaje muy potente, ya que simplifica en gran medida muchos de los problemas que se plantean en el desarrollo de aplicaciones complejas usando un lenguaje procedural, como pueden ser Pascal, C o Basic. ¿Y por qué esta afirmación? Pues porque cuando los programas que se realizan hoy en día en el mundo profesional dejan de llamarse "programas" para denominarse "Proyectos", la metodología funcional aplicada a un trabajo que raramente se hace ya por una sola persona, practicamente no sirve. Esto se produce en el momento en el que la programación es realizada por un equipo de programadores.
Imaginemos a varias personas programando en C o Pascal sobre un mismo programa, con un resultado final de decenas de miles de líneas de código....
Seguro que la coordinación tan sólo se tratará de hacer al final, cuando todas las partes estén terminadas, asegurando cuelgues, cabreos, noches perdidas buscando el maldito bug que hace que al pulsar sobre un simple botón REVIENTE el programa con mensajes tan conocidos como: Abnormal Program Termination, o Stack Overflow (para los amantes del DOS).
Y es que ya no vale que se diga: Quiero un programa que haga la gestión de mi VideoClub.
Y que el programador se cree un esquema de todo lo que va a ser el programa, en media hora, para rápida y ávidamente pasar a escribir líneas de código como un descosido.
Es verdad que existen técnicas de desarrollo de proyectos tipo Ingeniería del Software con Ciclos de Vida en Cascada, Desarrollo de Prototipos, incluso Métrica, Diagramas de Flujo de Datos, Diagramas de Arquitectura, Diagramas de Estados... (vamos, lo que se suele dar en 3º o 4º de Informática en nuestras queridas Universidades Españolas).
cualquier lugar, que podrán ser modificadas internamente sin que los programas que las utilizan se percaten de ello a no ser que sea para mejor... (bueno, algunas veces las mejoras tan solo son publicidad... como Windows).
Pues bien, con este repaso de lo que es la OO he intentado plantear como están las cosas desde un punto de vista informal, pero como existen gustos para todo, ahora es necesario que lo expuesto anteriormente sea expresado más formalmente, de modo que los futuros programadores de OO vayan conociendo los nombres propios de esta nueva forma de entender la programación. Pero ahora vamos a ir relacionándolos con Delphi. Estos nombres propios son:
Objetos y Clases
Encapsulación
Herencia y
Polimorfismo.
Objetos y Clases
En Delphi prácticamente todo son objetos, desde un botón hasta un formulario (que son componentes de Delphi).
Existen objetos predefinidos, como los citados componentes, pero nosotros también podemos definir nuestros propios objetos..
Un objeto siempre parte de un molde, al que habitualmente se conoce como Clase. En la definición de esta clase se establecen las características de los objetos y se implementan sus funciones y procedimientos, así como sus variables internas, sus valores inciales, la forma en que van a ser llamados, las partes que son públicas, las partes privadas...
Una vez que se tiene la clase, podemos crear objetos de esa clase, que se llamarán instancias de esa clase. Por ejemplo, dada la clase "Figuras" anterior, si queremos utilizarla, tendremos que hacer una instancia de ella. Puede que esto ahora no se entienda, así que pongamos un ejemplo más claro.
Supongamos la clase "Integer".
Ahora si se pone:
var contador:Integer;
Se puede decir que "contador" es un objeto que es una instancia de la clase "Integer"
Encapsulación
Se conoce con este nombre a una de las tres principales características de la programación OO. Un objeto contiene en su interior las variables necesarias para almacenar los datos sobre los que va a trabajar, así como los procedimientos y funciones precisas para manipularlos. Ningún código externo al propio objeto puede acceder a sus variables (a menos que se declaren como públicas), lo que evita muchos problemas.
De esta forma el código interno del objeto puede estar seguro de que su contenido no ha sido alterado externamente, y que, por tanto, será válido en cualquier momento
Un objeto desde esta perspectiva, es como una cápsula en la cual están contenidas las herramientas y los materiales necesarios para desempeñar la función que corresponda.
Herencia
La herencia es la segunda palabra mágica de la orientación a objetos, y seguramente la característica más útil dado que permite ahorrar la escritura de mucho código. Mediante la herencia, es posible definir una nueva clase de objetos a partir de otra que ya existe, quedando todos sus miembros, tanto datos como procedimientos disponibles por la nueva clase. E incluso es posible añadir nuevos miembros a esta clase, ampliando la anterior. De esta forma, la clase nueva va a ser una heredera de la clase padre antigua. Tomará toda su implementación y le añadirá nuevas cosas.
Esto constituye una jerarquía de clases entre padres e hijos que a su vez pueden ser padres de otros hijos, y lo que puede ser la clase inicial totalmente tonta, en los hijos finales se puede convertir en la repera. (¿Se ve la similitud de esto con la evolución humana?)
Polimorfismo
Seguramente este aspecto es el más incomprendido de la programación OO, pero también es de los más útiles. Un objeto polimórfico es aquel que en tiempo de edición, (cuando estamos escribiendo código), no conoce su tipo (la clase la que pertenece), información que obtiene posteriormente en tiempo de ejecución.
El polimorfismo permite que un programa manipule de una forma homogénea a objetos que son diferentes, ahorrando de paso la escritura de mucho código. Como es lógico, estos objetos deben disponer de una información mínima en tiempo de edición, y van a consumir muchos más recursos que los objetos normales.
Podrá parecer algo muy extraño este tipo de objetos, pero algunas veces son muy útiles.
Y hasta aquí lo concerniente a la OO.
Desarrollo.
Programación Orientada a Eventos (EOP)
Para tratar de que esto quede lo más sencillo de entender posible, pongamos un ejemplo de lo que sucede en Windows cuando se pulsa un botón.
Al que usa un programa y simplemente desplaza el cursor hasta ponerlo encima de un control y luego pulsa el botón izquierdo para que se haga una acción, no le importa para nada lo que está sucediendo dentro del programa; lo único que quiere es que lo que se supone que realiza el control se haga cuando se pulse. Pero para los programadores es prácticamente imprescindible saber qué está pasando.
Ante todo, lo primero que hay que tener en cuenta es que se trabaja sobre Windows, es decir, en un entorno donde en cada segundo se generan cientos de mensajes internos, entre todas las cosas que hay en pantalla por un lado, y el propio Windows interiormente por otro.
Los mensajes podemos verlos inicialmente como una especie de cartas que son escritas por un objeto del sistema y enviados a través de un sistema de manejo de mensajes que conforma el núcleo de Windows.
Imaginemos a una persona que escribe una carta, que será un objeto y un mensaje respectivamente. Al enviar la carta, se deja en el servicio de correos (en nuestro caso Windows), para que se encargue de hacer llegar la información a su destinatario o destinatarios.
Ahora pongámosle nombres propios a las cosas.
Supongamos que tenenos un objeto Ratón, un objeto botón, y Windows de por medio.
Supongamos tambien que el botón cambia al color rojo cuando el cursor está sobre él, y que vuelve a su color anterior cuando deja de estarlo.
Cuando se desplaza el cursor sobre la pantalla, el objeto Ratón está continuamente mandando mensajes a Windows para que actualize su posición y se vea donde se debe ver (mientras tanto, el botón está en espera de que pase algo). Pues cuando decidimos poner el cursor del ratón sobre el botón, ocurrirán los siguientes mensajes (hay muchos más, pero ahora nos centramos en los más importantes).
Ratón a Windows: Actualiza mi posición.
Windows a Vídeo: Pon el Cursor en la nueva posición.
Windows a Botón: El Cursor ha entrado en tu zona.
Botón a Windows: Cambia mi color al rojo.
Windows a Vídeo: Pon el Botón en rojo.
Ratón: BOTON IZQUIERDO PULSADO
Ratón a Windows: Botón Izquierdo pulsado.
Windows a Botón: El Ratón ha pulsado con el botón izquierdo sobre tí.
Botón: ORDEN DE EJECUCION.
Botón a Windows: Ejecuta mi código.
Windows a Vídeo: Pon el Botón primero hundido y luego no hundido.
Windows: EJECUTA CODIGO BOTON.
¡Y esto es tan solo un botón, una de las cosas más simples de Windows!
Puede parecer un auténtico follón, pero no hay que alarmarse ya que esto es prácticamente transparente para el programador que use un entorno de programaciín Visual, teniendo tan sólo que preocuparse de escribir el código que tiene que ejecutarse cuando se pulse el botón del ratón sobre el botón de la pantalla. Otra cosa sería si se quisieran hacer efectos de movimiento, cambios de colores y formas…
Podemos pensar ahora que cada vez que movamos el ratón pasarán cosas como esta, y se estará en lo cierto. Y además, tambien hay mensajes internos entre los objetos sin que medie el ratón, o el teclado, por ejemplo la ejecución de aninaciones, de música… en definitiva, de todo.
Pues para que el programador se encargue tan solo de los eventos que le interesen, despreocupándose de los demás, Delphi tiene una forma muy sencilla de hacerlo por nosotros.
Para cada objeto que se suelte sobre un formulario, y tal y como dijimos antes, hay un conjunto de propiedades y un conjunto de procedimientos predefinidos. Pues ahora es el momento de decir que esos procedimientos no son otra cosa que manejadores de los eventos más importantes que se pueden dar en ese objeto, es decir, son procedimientos para responder ante los mensajes de Windows.
Casi todos los objetos tienen en común un conjunto de procedimientos llamados: OnClick, OnMouseDown, OnMouseUp, OnKeyPress, OnKeyDown, OnKeyUp… y tan solo hay que traducir su significado al español para darnos cuenta de su utilidad.
Centrémonos por ejemplo en OnMouseDown.
Si no hacemos nada, cuando a nuestro objeto llegue el cursor y se pulse el botón izquierdo del ratón, Windows le enviará un mensaje indicándoselo y como no hemos dicho qué hacer, nuestro objeto ignorará ese mensaje. Pero si hemos creado código dentro de OnMouseDown, este código se ejecutará siempre que se reciba el mensaje de Windows de que han pulsado sobre él.
Así se puede fácilmente reaccionar ante todo lo que se produzca.
Ahora parece más sencillo ¿no?
Una vez expuesto todo esto, lo que queda por decir en esta parte es qué es la programación orientada a eventos. Es un modo de programar (que se tendrá que tener en cuenta juntamente con la programación orientada a objetos), totalmente distinto al modo tradicional del DOS. Ahora hay que pensar que sólo se va a reaccionar ante la entrada del usuario a través del ratón, teclado o cualquier otro dispositivo, que se vean afectadas en un determinado momento sin que se pueda decir que hay Entorno de Desarrollo Visual (IDE)
El término Visual se refiere al hecho de que Delphi permite crear aplicaciones "cogiendo" los componentes o elementos que necesitemos y "soltándolos" sobre un formulario de Windows. Pero lo realmente importante es el entorno de desarrollo en su conjunto, ya que como en el fondo un programa Delphi es una colección de objetos (componentes) relacionados entre sí, cuando se "suelte" un botón por ejemplo, sobre un formulario, automáticamente Delphi generará el código necesario para declarar y utilizarlo. Tan solo será necesario (y esto es lo verdaderamente importante) centrarnos en lo que debe hacer el botón cuando se pulse, y no perder el tiempo con declaraciones manuales, petición y liberación de recursos, manejadores de contexto, punteros a estructuras de mensajes…; vamos, todo lo que habría que hacer en Visual C manualmente si queremos salirnos algo de lo común (y eso que es Visual), lo hace el Delphi automáticamente, y aquí es donde está la gran diferencia entre los dos lenguajes.
En resumen, el Entorno Visual de Delphi se encarga de generar automáticamente los manejadores de mensajes de cada objeto, de sus declaraciones, de la importación de las librerías de objetos en las Herramienta de Desarrollo Rápido (RAD)
El conjunto de objetos que nos ofrece Delphi para su uso, junto al entorno visual y su generador automático de código, además de la orientación a objetos, lo hacen idóneo para desarrollar aplicaciones lo más rápidamente posible, ya que se puede diseñar un interfaz (lo que se va a ver externamente del programa) en muy poco tiempo.
Hoy en día, lo que importa es la productividad a la hora de desarrollar software, y si se pierde el poco tiempo que se suele tener para la programación en cosas que son externas al funcionamiento principal de la aplicación, tales como rutinas de manejo de mensajes, manejo de memoria, de dispositivos, el fracaso profesional está asegurado. Por eso, hoy en día, cualquier lenguaje o es Visual o no sirve, así de claro.
Y si además permite la reutilización de código (Delphi, Visual Basic, Visual C, Java), la reprogramación de los objetos que siempre usamos de la misma forma (Delphi, Visual C, Java), el entorno de desarrollo verdaderamente Visual (Delphi, Java, Visual Basic), y la potencia en todos los campos (Delphi), mejor que mejor ¿no?.
Algunos ejemplos de programas comerciales desarrollados con Delphi
Para acabar este segundo capítulo, vamos a conocer algunas curiosidades acerca de los programas hechos con Delphi.
El siguiente es un comunicado desde SCOTTS VALLEY, California. 7 de Octubre de 1996
El reciente aterrizaje del U.S. Space Shuttle Atlantis concluyó una excepcional semana para la NASA y Borland International, un líder en el suministro de herramientas de desarrollo de software.
Un mapa computerizado construido con la herramienta Borland Delphi, fue usado en el Atlantis

Otro ejemplo de uso de Delphi, es el reciente premio nacional al mejor programa español de gestión de control de datos y pacientes oncológicos, otorgado por la SEGO (Sociedad Española de Ginecología y Obstetricia). Este programa se llama CODEON-G (Control de Datos en Oncología Ginecológica) y fue desarrollado por VESALIO Software en 1997 (sí, por si alguien lo ha notado es la empresa donde trabajo, y fui uno de los programadores de CODEON). Esto no pretende ser autopublicidad, ya que lo que es el programa en sí y su codificación, conforman una pequeñísima parte de lo que supone este descomunal proyecto, donde las partes de investigación durante más de 3 años han sido desarrolladas por verdaderos profesionales, tanto informáticos como médicos. Tan solo quiero hacer ver que es posible que mortales como nosotros realicemos programas de calidad sobresaliente en nuestra propia tierra.
Por otro lado, corren también ciertos rumores de que desde la versión 6 de Corel Draw, el código desarrollado en Delphi sustituyó a una buena parte del desarrollado en C, sobre todo la parte concerniente al entorno del usuario e interfaces.
be PhotoShop y Corel PhotoPaint) aún son desarrolladas en C, tambien es cierto que comienzan a estar disponibles ficheros de declaraciones, de conversión de tipos y de reutilización de DLLs para