|
Sistema operativo |
||||||||||||
|
Creador |
||||||||||||
|
Año de primera distribución |
COBOL
fue dotado de
unas excelentes capacidades de auto documentación, una buena
gestión de archivos y una excelente gestión de los tipos de datos
para la época, a través de la conocida sentencia PICTURE para la
definición de campos estructurados. Para evitar errores de redondeo en
los cálculos que se producen al convertir los números a binario y
que son inaceptables en temas comerciales, COBOL puede emplear y emplea por
defecto números en base 10. Para facilitar la creación de
programas en COBOL, la sintaxis del mismo fue creada de forma que fuese
parecida al idioma inglés, evitando el uso de símbolos que se
impusieron en lenguajes de programación posteriores.
El lenguaje fue
diseñado teniendo en cuenta que los programas serían escritos en
tarjetas perforadas de 80 columnas. Así por ejemplo, las líneas
debían ser numeradas y la única alteración posible en el
orden de ejecución era producida con la instrucción goto.
Estas características han evolucionado de versión en
versión. Las actuales contienen subprogramas, recursión y una
variada gama de estructura de control.
Lo que fue la primera
tentativa de proyección de un lenguaje de programación de alto
nivel, tiene una sintaxis considerada
arcaica por muchos programadores que aprenden lenguajes más
modernos. Es difícil escribir un bucle "for", y errores en la escritura de sólo un
carácter pueden llevar a errores durante el tiempo de ejecución
en vez de errores de compilación, en el caso de que no se usen las
construcciones más frecuentes. Algunas de las versiones anteriores no
poseían facilidades que son consideradas como útiles en las
máquinas modernas, como la asignación dinámica de memoria.
Se debe tener en cuenta que la sintaxis de Fortran fue afinada para el uso en
trabajos numéricos y científicos y que muchas de sus deficiencias
han sido abordadas en revisiones más recientes del lenguaje. Por
ejemplo, Fortran 95 posee comandos mucho más breves para efectuar
operaciones matemáticas con matrices y dispone de tipos. Esto no
sólo mejora mucho la lectura del programa sino que además aporta
información útil al compilador. Por estas razones Fortran no es
muy usado fuera de los campos de la informática y el análisis
numérico, pero permanece como el lenguaje a escoger para
desempeñar tareas de computación numérica de alto
rendimiento
Simula:
3. CARACTERÍSTICAS:
fue, probablemente, el primer lenguaje que presentó las
nociones de clase y herencia jerárquica. No se admite la herencia múltiple.
El ocultamiento de información se lleva a cabo “protegiendo”
una característica, lo cual, a su vez, evita que sea heredada en lo
sucesivo.
Admite la
sobrecarga de métodos.
La
comprobación de tipos se puede realizar, bien estáticamente en el
momento de la compilación, para mayor eficiencia, o bien en el momento
de la ejecución si se define una característica como
“virtual”.
Problema:
El sistema
necesita llevar a cabo la recolección de basura de vez en cuando, es
decir, necesita reutilizar la memoria que fue ocupada por instancias asignadas
anteriormente, pero que ya no se están utilizando. (Ralentiza los
programas)
Simula es un
lenguaje orientado a objetos, puro ya que no permite salirse de
la orientación a objetos para realizar programación
clásica.
Problema:
Simula, no
disponía de depuradores, visores y tampoco disponía de ninguna
aplicación que permitiese visualizar su Jerarquía de clases. Smalltalk
si disponía de ello, lo que facilitaba el trabajo de los programadores.
Consiguiendo una mejor difusión entre la comunidad de programadores que
Simula.
EJEMPLO
DE UN PRODUCTO MATRICIAL
- Estructura
de un procedimiento en Simula para multiplicar las matrices A y B y obteniendo
el resultado en C:
Procedure matmult (A, B, C, m, n, p);
Array A, B, C; integer m, n, p;
Begin integer i, j, k;
For i:=1 step 1 until m do
For j:=1 step 1 until n do
Begin
C [i, j]:=0;
For k:=1 step 1 until p do
C [i, j]:= C [i, j] + A [i, k] × B[k,j];
End
End;
Java
Características del
lenguaje
Java es un lenguaje orientado a objetos, eso implica que
su concepción es muy próxima a la forma de pensar humana.
También posee otras características muy importantes:
Es un lenguaje que es compilado,
generando ficheros de clases compilados, pero estas clases compiladas, son en
realidad interpretadas por la máquina virtual de java. Siendo la
máquina virtual de java la que mantiene el control sobre las clases que
se estén ejecutando.
Es un lenguaje multiplataforma: El mismo
código java que funciona en un sistema operativo, funcionará en
cualquier otro sistema operativo que tenga instalada la máquina virtual
java.
Es un lenguaje seguro: La
máquina virtual, al ejecutar el código java, realiza
comprobaciones de seguridad, además el propio lenguaje carece de
características inseguras, como por ejemplo los punteros.
Gracias al API de java podemos
ampliar el lenguaje para que sea capaz de, por ejemplo, comunicarse con equipos
mediante red, acceder a bases de datos, crear páginas HTML
dinámicas, crear aplicaciones visuales al estilo Windows, ...
Para poder trabajar con java es
necesario emplear un software que permita desarrollar en java. Existen varias
alternativas comerciales en el mercado: JBuilder, Visual Age, Visual
Café,... y un conjunto de herramientas shareware, e incluso freeware,
que permiten trabajar con java.
Práctica:
Construyamos una clase que pida un
número por teclado y muestre la tabla de multiplicar de dicho
número. Lo primero es escribir el código de dicha clase, para
ello emplearemos cualquier editor de texto, pero hay que guardar el fichero de
texto como texto plano.
El fichero vamos a llamarlo TablaMultiplicar.java y lo vamos a
almacenar en un directorio, por ejemplo c:\java
El código a escribir, y
todavía no nos preocupamos por como es, será:
Public class TablaMultiplicar {
Public static void main (String arg
[]){
Int numero = Integer.parseInt (arg
[0]);
For (int i = 1; i<=10; i++) {
System.out.println (""+numero+"
* "+i+" = "+ (i*numero));
}
}
}
Una vez escrito, debemos guardar
los cambios en el fichero fuente. Ahora debemos compilar la fuente, para ello
iremos a una ventana de Consola y mediante CD nos moveremos hasta el directorio
donde se encuentre el fichero fuente:
CD c:\java
Una vez allí debemos de
compilar el código fuente:
Javac TablaMultiplicar.java
Esto provocará, si no hay
errores en el código, que se genere un fichero llamado
TablaMultiplicar.class
Y ya podemos ejecutar la aplicación:
Java TablaMultiplicar 6
Ahora probaremos a compilar un
fuente con un error de sintaxis dentro del código, el fichero
TablaMultiplicarError.java lo obtendremos de la carpeta de ejemplos del manual.
Javac TablaMultiplicarError.java
Esto provocará que se
muestre por pantalla el siguiente error:
TablaMultiplicarError.java:3: ';'
expected
Int numero = Integer.parseInt (arg
[0])
^
1 error
Dentro del cuál podemos
apreciar que existe un error en el fichero TablaMultiplicarError.java en la
línea 3, siendo además el error que se esperaba un ';'.
Después aparece la línea en la cuál está situado el
error.
Práctica
Vamos a construir la clase
Persona, pero no estará completa hasta que no la completemos con
características que iremos viendo en capítulos posteriores.
Fabricaremos la clase Persona poco a poco, para ello:
Construir el fichero Persona.java
Agreguemos la clase dentro del
fichero:
Public class Persona
{
}
Agreguemos a la clase los
atributos de persona (en este caso seleccionaremos dos atributos):
private String nombre = null;
private int edad;
Como resultado final obtendremos:
public class Persona
{
private String nombre = null;
private int edad;
}
Ahora vamos a crear una clase que
emplearemos única y exclusivamente para que tenga la función
main, y así poder escribir código que queremos ejecutar.
Llamaremos a dicha clase Arranque, por tanto:
Creamos el fichero Arranque.java
Agreguemos la clase y el
método main en su interior:
public class Arranque {
public static void main (String arg[]){
}
}
Ahora agregaremos dentro de la
función main el siguiente código:
Persona per1 = new Persona ();
//per1.nombre = "Luís";
//System.out.println (per1.nombre);
en el que declaramos una variable de tipo
Persona y le damos el valor de un nuevo objeto de la clase Persona, en la
segunda línea asignamos al atributo nombre del objeto per1 el valor
Luis, y en la tercera línea mostramos por pantalla (gracias al
método System.out.println) el valor de dicha variable.
La segunda y tercera líneas
están comentadas, debido a que el atributo nombre está definido
como privado en la clase Persona.
Ejercicio: Descomentar la segunda
y tercera línea y compilar las clases, leer el error de
compilación provocado. Cambiar el tipo del atributo nombre de prívate
a public y compilar y ejecutar. Volver a dejar todo como al comienzo (Comentada
la línea y con nombre como variable privada).
Práctica:
Crear el fichero Array.java
Agregar el siguiente código
en el fichero:
Public class Array
{
Public static void main (String arg
[])
{
Int [] los valores = null;
Los valores [4] = 100;
System.out.println(los valores [4]);
}
}
Compilamos el código,
ejecutemos y...error!!! Parece extraño que el
error sea NullPointerException,
pero tiene sentido, recordemos que una variable java, que no sea de tipo
básico es una referencia que puede apuntar a objetos y por tanto los
valores también es una referencia y debe de apuntar a objetos de tipo
array de enteros. Es decir, el código de la función main es
necesario modificarlo:
Int [] los valores = new int [10];
Los valores [4] = 100;
La modificación consiste
básicamente en asignar a la variable los valores un objeto de tipo array
de enteros. La sintaxis para crear un objeto de tipo array es:
New tipo [cantidad]
Donde tipo es el tipo de datos que
contendrá el array. Cantidad es el número máximo de
elementos que podemos almacenar dentro del array. A la hora de acceder a las
posiciones del array hay que tener en cuenta que la primera posición es
0 y la última cantidad-1
Ahora vamos a tratar de escribir el mismo
código, pero empleando en lugar del tipo int, el tipo Persona:
Práctica:
Crear el fichero Array2.java
Agregar el siguiente código
en el fichero:
Public class Array2
{
Public static void main (String arg
[])
{
Persona [] las personas = new Persona
[10];
Las personas [4].setNombre ("Luis");
System.out.println (las personas
[4].getNombre ());
}
}
Veamos: definimos un array de 10
objetos de tipo Persona y lo asignamos a la variable las personas. Accedemos a
la persona 4 del array y la asignamos un nombre al objeto 4 mediante el
método setNombre de la clase Persona. Posteriormente mostramos por
pantalla el nombre del objeto Persona 4.
Compilemos y ejecutemos: ERROR!!! Al ejecutar genera el error NullPointerException. La
explicación es sencilla: Al crear un array de objetos en realidad el
array no contiene objetos, sino que contiene variables de tipo referencia para
apuntar a los objetos. Arreglemos nuestro código para poder ejecutarlo
de nuevo:
Persona [] las personas = new Persona
[10];
Las personas [4] = new Persona ();
Las personas [4].setNombre ("Luis");
System.out.println (las personas
[4].getNombre ());
Si es necesario se puede averiguar
el tamaño de cualquier array java, mediante de un atributo
público que poseen todos los objetos de tipo array, independientemente
del tipo de objetos que almacene dicho array en su interior. Este atributo se
denomina length y para usarlo:
miArray.length
En la siguiente práctica
usaremos dicho atributo para crear un bucle (los veremos más adelante)
que permita mostrar por pantalla todos los elementos que hay en un array
llamado arg.
Práctica:
Crear el fichero Array3.java
Lo que vamos a hacer es tratar de
ejecutar nuestra clase Array3, pero en lugar de ejecutarla mediante: "java
Array3" vamos a ejecutarla mediante "java Array3 Esto es una
prueba", es decir, vamos a pasar argumentos a nuestro programa. Dichos
argumentos son recibidos dentro del array llamado arg que existe en la
definición del método main.
Agreguemos el siguiente
código dentro del fichero Array3.java:
Public class Array3
{
Public static void main (String arg
[])
{
System.out.println (“Hay
" + arg.length + " parámetros.”);
System.out.println (“Los
parámetros son: " );
Int i = 0;
While (i<arg.length) {
System.out.println (“parámetro
" + i + ": " + arg[i]);
I++;
}
}
}
Ada:
Ada es un lenguaje de
programación orientado
a objetos y fuertemente tipado
de forma estática que fue diseñado por Jean Ichbiah de CII
Honeywell Bull por encargo del Departamento
de Defensa de los Estados Unidos. Es un lenguaje
multipropósito, orientado
a objetos y concurrente,
pudiendo llegar desde la facilidad de Pascal
hasta la flexibilidad de C++.
Fue diseñado con
la seguridad en mente y con una filosofía orientada a la
reducción de errores comunes y difíciles de descubrir. Para ello
se basa en un tipado muy fuerte y en chequeos en tiempo de ejecución
(desactivables en beneficio del rendimiento). La sincronización de tareas
se realiza mediante la primitiva rendezvous.
Ada se usa
principalmente en entornos en los que se necesita una gran seguridad y
fiabilidad como la defensa, la aeronáutica (Boeing o Airbus), la gestión
del tráfico aéreo (como Indra en España) y la industria aeroespacial entre otros.
Un compilador de Ada
muy usado es GNAT, originalmente desarrollado por
Existen otros
compiladores comerciales.
Éste es el
típico "Hola Mundo" escrito
en Ada:
with Ada.Text_IO;
procedure Hola_Mundo is
begin Ada.Text_IO.Put("¡Hola, mundo!");end Hola_Mundo;
Smalltalk
es un sistema
informático que permite realizar tareas de computación mediante
la interacción con un entorno de objetos virtuales.
Metafóricamente, se puede considerar que un Smalltalk es un mundo
virtual donde viven objetos que se comunican mediante el envío de
mensajes.
Un sistema Smalltalk
está compuesto por:
Se busca que todo lo
que se pueda realizar con un ordenador se pueda realizar mediante un Sistema
Smalltalk, por lo que en algunos casos se puede considerar que incluso sirve
como Sistema Operativo.
Smalltalk es
considerado el primero de los lenguajes orientados a objetos (OOP).
En Smalltalk todo es un objeto, incluidos los números reales o el
propio entorno Smalltalk.
Como lenguaje tiene las
siguientes características:
Smalltalk ha tenido gran influencia sobre
otros lenguajes como Java
o Ruby, y de su entorno han surgido muchas de las
prácticas y herramientas de desarrollo promulgadas actualmente por las metodologías
ágiles (refactorización, desarrollo incremental, desarrollo
dirigido por tests, etc.).
En Smalltalk todo es un
objeto, y a un objeto se le envían mensajes. Por ejemplo:
1 + 1
Significa que al objeto
"1" le enviamos el mensaje "+" con el colaborador externo,
otro objeto, "1". Este ejemplo entonces resulta en el objeto
"2".
Transcript show: '¡Hola, mundo!'
En el típico Hola mundo, el objeto es Transcript, que recibe el
mensaje show con el colaborador externo '¡Hola, Mundo!'.
Para crear una
instancia de un objeto, sólo hay que mandar un mensaje new a una clase:
Objeto new
Para obtener las
vocales de una cadena de texto:
'Esto es un texto' select: [:aCharacter | aCharacter isVowel
Pascal
es un lenguaje de
programación desarrollado por el profesor suizo
Niklaus Wirth a finales de los años 60. Su
objetivo era crear un lenguaje que facilitara el aprendizaje de la programación a sus alumnos. Sin embargo con
el tiempo su utilización excedió el ámbito
académico para convertirse en una herramienta para la creación de
aplicaciones de todo tipo.
Pascal se caracteriza
por ser un lenguaje de
programación estructurado fuertemente tipificado. Esto
implica que:
A diferencia de
lenguajes de programación descendientes de C,
Pascal utiliza el símbolo := para la
asignación en vez de =. Si bien el segundo es más conciso, la
práctica ha demostrado que muchos usuarios utilizan el símbolo de
igualdad para comparar valores en lugar del comparador de C que es el
símbolo ==. Esta sintaxis conduce a muchos errores o bugs
difíciles de rastrear en código C. Dado que Pascal no permite
asignaciones dentro de expresiones y utiliza sintaxis distinta para
asignaciones y comparaciones, no sufre estos errores.
Además sus
programas tienen definidas dos partes: declarativa y ejecutiva. En la primera
debe aparecer todo lo que se usará en la segunda, de lo contrario se
detecta como desconocido y evita ciertas incomprensiones como veremos
más adelante. En la parte declarativa se enuncian Unit existentes,
procedimientos, funciones, variables, constantes y nuevos tipos de datos
estructurados.
Otra diferencia
importante es que en Pascal, el tipo de una variable se fija en su
definición; la asignación a variables de valores de tipo incompatible
no están autorizadas (En C, en cambio, el compilador hace el mejor
esfuerzo para dar una interpretación a casi todo tipo de asignaciones).
Esto previene errores comunes donde variables son usadas incorrectamente porque
el tipo es desconocido. Esto también evita la necesidad de notación
húngara, esto es prefijos que se añaden a los nombres
de las variables y que indican su tipo
Ejemplo de código usando la estructura lineal:
program raiz(input, output);
(*
Obtener la raíz cuadrada de
un número real x cualquiera.
*)
var x, y: real; respuesta: string; beginwriteln('** Calcular la raíz cuadrada de x **');
writeln('Entrar x (> 0): '); readln(x); y := sqrt(abs(x)); (* Raíz cuadrada del valor absoluto de x para evitar raíces imaginarias *) writeln; if (x<0) then (* Si x es negativo, el resultado se notifica como imaginario *) writeln('La raíz cuadrada de ', x, ' es el número imaginario ', y,'i'); elsewriteln('La raíz cuadrada de ', x, ' es ', y);
writeln; writeln('** Fin **'); readln; (* Espera a que el usuario pulse enter para salir del programa *) end.
Otro Ejemplo:
program suma; uses crt; var x,s:integer; begin clrscr; x:=1; s:=0; repeat s:=s+x; x:=x+1; until x=50; writeln('la suma es ',s); readln; end.
Varios compiladores de
Pascal están disponibles para el uso del público en general:
C
es un lenguaje de
programación creado en 1972
por Ken Thompson y Dennis M. Ritchie en los Laboratorios Bell como evolución del
anterior lenguaje B,
a su vez basado en BCPL.
Al igual que B, es un
lenguaje orientado a la implementación de Sistemas Operativos, concretamente Unix
. C es apreciado por la eficiencia del código que produce y es el
lenguaje de programación más popular para crear software de
sistemas, aunque también se utiliza para crear aplicaciones.
Se trata de un lenguaje
débilmente tipificado de medio nivel
pero con muchas características de bajo nivel.
Dispone de las estructuras típicas de los lenguajes de alto nivel
pero, a su vez, dispone de construcciones del lenguaje que permiten un control
a muy bajo nivel.
Los compiladores suelen ofrecer extensiones al lenguaje que posibilitan mezclar
código en ensamblador con
código C o acceder directamente a memoria o dispositivos
periféricos.
La primera
estandarización del lenguaje C fue en ANSI,
con el estándar X3.159-1989. El lenguaje que define este estándar
fue conocido vulgarmente como ANSI C. Posteriormente, en
1990, fue ratificado como estándar ISO
(ISO/IEC 9899:1990). La adopción de este estándar es muy amplia
por lo que, si los programas creados lo siguen, el código es
portátil entre plataformas y/o arquitecturas. En la práctica, los
programadores suelen usar elementos no-portátiles dependientes del compilador
o del sistema operativo.
struct) que permiten que datos relacionados
(como un empleado, que tiene un id, un nombre y un salario) se combinen y
se manipulen como un todo (en una única variable
"empleado").
No hay comentarios:
Publicar un comentario