UANL FIME

ACTIVIDAD 2

NOMBRE: Wyatt Valdes Almanza

MATRICULA: 1812480
MATERIA: LENGUAJES DE PROGRAMACION
CARRERA: ITS
LENGUAJE DE CONSULTA
Un lenguaje de consulta es un lenguaje de computadora utilizado para realizar consultas
en bases de datos y sistemas de información. Esto le permite extraer información de la
base de datos, a través de un DBMS (sistema gestor de base de datos).
En inglés es conocido como QL o Query Language.
En un lenguaje de consulta de sistemas de información, la semántica de la consulta se
define no por una sintaxis formal precisa, sino a través de la interpretación de los
resultados más adecuados de la consulta. Los elementos importantes en este tipo de
lenguaje de consulta incluyen la clasificación y el peso de los resultados, la orientación a
la relevancia y la semántica relativa. Un ejemplo es el Common Query Language (CQL),
un lenguaje formal para representar consultas a sistemas de información como índices
web, catálogos bibliográficos e informaciones de colecciones de museos.
Básicamente pueden clasificarse como:
- Lenguajes de consulta de bases de datos.
- Lenguajes de consulta de recuperación de información.
Algunos ejemplos de lenguajes de consulta

 SQL: lenguaje de consulta propietario orientado a objetos para consultar bases de

datos relacionales.
 EPL: lenguaje de consulta para el procesado de eventos complejos en tiempo real.
 LDAP: protocolo de aplicación para consultar y modificar servicios de directorios
corriendo sobre TCP/IP.
 OQL: lenguaje de consulta de objetos.
 SPARQL: lenguaje de consulta para grafos RDF.
 SQL: es el lenguaje de consulta más empleado y conocido para bases de datos
relacionales.
 XQuery: lenguaje de consulta para fuentes de datos XML.

Características Generales
SQL es un lenguaje de acceso a bases de datos que explota la flexibilidad y potencia de
los sistemas relacionales y permite así gran variedad de operaciones.
Es un lenguaje declarativo de "alto nivel" o "de no procedimiento" que, gracias a su fuerte
base teórica y su orientación al manejo de conjuntos de registros y no a registros
individuales permite una alta productividad en codificación y la orientación a objetos. De
esta forma, una sola sentencia puede equivaler a uno o más programas que se utilizarían
en un lenguaje de bajo nivel orientado a registros.
SQL también tiene las siguientes características:
Lenguaje de definición de datos: El LDD de SQL proporciona comandos para la definición
de esquemas de relación, borrado de relaciones y modificaciones de los esquemas de
relación.
Lenguaje interactivo de manipulación de datos: El LMD de SQL incluye lenguajes de
consultas basado tanto en álgebra relacional como en cálculo relacional de tuplas.
Integridad: El LDD de SQL incluye comandos para especificar las restricciones de
integridad que deben cumplir los datos almacenados en la base de datos.
Definición de vistas: El LDD incluye comandos para definir las vistas.
Control de transacciones: SQL tiene comandos para especificar el comienzo y el final de
una transacción.
SQL incorporado y dinámico: Esto quiere decir que se pueden incorporar instrucciones de
SQL en lenguajes de programación como: C++, C, Java, PHP, Cobol, Pascal y Fortran.
Autorización: El LDD incluye comandos para especificar los derechos de acceso a las
relaciones y a las vistas.

Creamos la base de datos

CREATE DATABASE empresa

Creamos la tabla Personas

CREATE TABLE dbo.Personas

P_id int PRIMARY KEY IDENTITY,

Nombre nchar(20) NOT NULL,

Apellidos nchar(30) NOT NULL,

Direccion nchar(40) NOT NULL,

Ciudad nchar(10) NOT NULL

GO

Insertamos algunos registros:

INSERT INTO Personas

VALUES ('Marco Antonio','Trejo Lemus','Calle E 822','Tampico')

INSERT INTO Personas

VALUES ('Martha Beatriz','Trejo Lemus','Calle E 822','Tampico')

INSERT INTO Personas

VALUES ('Juana Elvira','Trejo Lemus','Calle E 822','Tampico')

INSERT INTO Personas

VALUES ('Nora Zulma','Trejo Lemus','Calle E 822','Tampico')

INSERT INTO Personas

VALUES ('Laura Lucero','Sobrevilla Trejo','Calle E 822','Tampico')

INSERT INTO Personas

VALUES ('Maria de la luz','Trejo Campos','Calle E 822','Tampico')

INSERT INTO Personas

VALUES ('Trinidad','Trejo Bautista','Calle E 822','Tampico')

INSERT INTO Personas

VALUES ('Marcel Abisag','Sobrevilla Trejo','Calle E 822','Tampico')

INSERT INTO Personas

VALUES ('Jose Abraham','Sobrevilla Trejo','Calle E 822','Tampico')

INSERT INTO Personas

VALUES ('Samuel Salomon','Olmeda Trejo','Calle E 822','Tampico')

Muchas de las acciones que necesitas realizar en una base de datos se hacen con sentencias SQL

Seleccionamos todos los registros de la tabla

Las siguiente sentencia seleccionara todos los registros de la tabla "Personas" :

SELECT * FROM Personas

Abajo esta un ejemplo del resultado de la

sentencia a la tabla llamada "Personas":

La parte DML del SQL de los comandos de

consulta y actualizacion son:

SELECT - extrae datos de una base de datos

UPDATE - actualiza datos en una base de

datos

DELETE - borra datos de una base de datos

INSERT INTO - inserta datos dentro de una base de datos

DLL del SQL que permite a bases de datos y tablas ser creadas o borradas.

Tambien define indices(llaves). especifica enlaces entre tablas, y impone relaciones entre tablas.

La parte DLL del SQL, las sentencias mas importante DDL en SQL son:
CREATE DATABASE - crea una nueva base de datos

ALTER DATABASE - modifica una base de datos

CREATE TABLE - crea una nueva tabla

ALTER TABLE - modifica una tabla

DROP TABLE - borra una tabla

CREATE INDEX - crea un indice (llave de busqueda)

DROP INDEX - borra un indice

La sentencia SELECT

La sentencia SELECT es usada para seleccionar datos de una base de datos.

El resultado es almacenado en una tabla temporal, llamada tabla-resultado

La sintaxis SQL de la sentencia SELECT es:

1) SELECT nombre_columna(s)

FROM nombre_tabla

2) SELECT * FROM nombre_tabla

LENGUAJE DE ALTO NIVEL

Un lenguaje de alto nivel permite al programador escribir las instrucciones de
un programa utilizando palabras o expresiones sintácticas muy similares al inglés. Por ejemplo, en
C se pueden usar palabras tales como: case, if, for, while, etc. para construir con ellas
instrucciones como:

if( numero > 0 ) printf( "El número es positivo" )

que traducido al castellano viene a decir que: si numero es mayor que cero, entonces, escribir por
pantalla el mensaje: "El número es positivo".

Ésta es la razón por la que a estos lenguajes se les considera de alto nivel, porque se pueden
utilizar palabras de muy fácil comprensión para el programador. En contraposición, los lenguajes
de bajo nivel son aquellos que están más cerca del "entendimiento" de la máquina. Otros lenguajes
de alto nivel son: Ada, BASIC, COBOL, FORTRAN, Pascal, etc.

Otra carácterística importante de los lenguajes de alto nivel es que, para la mayoría de las
instrucciones de estos lenguajes, se necesitarían varias instrucciones en un lenguaje ensamblador
para indicar lo mismo. De igual forma que, la mayoría de las instrucciones de un lenguaje
ensamblador, también agrupa a varias instrucciones de un lenguaje máquina.

Se puede decir que el principal problema que presentan los lenguajes de alto nivel es la gran
cantidad de ellos que existen actualmente en uso (FORTRAN, LISP, ALGOL, COBOL, APL,
SNOBOL, PROLOG, MODULA2, ALGOL68, PASCAL, SIMULA67, ADA, C++, LIS, EUCLID,
BASIC), además de las diferentes versiones o dialectos que se han desarrollado de algunos de
ellos.

CARACTERÍSTICAS

Los lenguajes de programación de alto nivel se caracterizan por expresar los algoritmos de una
manera adecuada a la capacidad cognitiva humana, en lugar de a la capacidad ejecutora de las
máquinas. Los lenguajes de muy alto nivel se crearon para que el usuario común pudiese
solucionar tal problema de procesamiento de datos de una manera más fácil y rápida.

Los lenguajes de ” Alto Nivel” son los más utilizados como lenguaje de programación. Aunque no
son fundamentalmente declarativos, estos lenguajes permiten que los algoritmos se expresen en
un nivel y estilo de escritura fácilmente legible y comprensible por otros programadores. Además,
los lenguajes de alto nivel tienen normalmente las características de ” Transportabilidad”. Es decir,
están implementadas sobre varias maquinas de forma que un programa puede ser fácilmente ”
Transportado ” (Transferido) de una maquina a otra sin una revisión sustancial. En ese sentido se
llama “Independientes de la maquina”. Se tratan de lenguajes independientes de la arquitectura del
ordenador. Por lo que, en principio, un programa escrito en un lenguaje de alto nivel, lo puedes
migrar de una máquina a otra sin ningún tipo de problema. Estos lenguajes permiten al
programador olvidarse por completo del funcionamiento interno de la maquina/s para la que están
diseñando el programa. Tan solo necesitan un traductor que entiendan el código fuente como las
características de la maquina.

Suelen usar tipos de datos para la programación y hay lenguajes de propósito general (cualquier
tipo de aplicación) y de propósito especifico (como FORTRAN para trabajos científicos). Los
lenguajes de alto nivel logran la independencia del tipo de máquina y se aproximan al lenguaje
natural. Se puede decir que el principal problema que presentan los lenguajes de alto nivel es la
gran cantidad de ellos que existen actualmente en uso.

VENTAJAS Y DESVENTAJAS

La principal ventaja de los lenguajes de alto nivel sobre los de bajo nivel, es que son más fáciles de
leer, escribir y mantener por humanos. Al final, los programas escritos en alto nivel deben ser
traducidos en un lenguaje máquina específico empleando un compilador o un intérprete. De esta
manera pueden ser ejecutados por una máquina específica.

En los primeros lenguajes de alto nivel la limitación era que se orientaban a un área específica y
sus instrucciones requerían de una sintaxis predefinida. Se clasifican como lenguajes
procedimentales. Otra limitación de los lenguajes de alto nivel es que se requiere de ciertos
conocimientos de programación para realizar las secuencias de instrucciones lógicas.

Se puede decir que el principal problema que presentan los lenguajes de alto nivel es la gran
cantidad de ellos que existen actualmente en uso (FORTRAN, LISP, ALGOL, COBOL, APL,
SNOBOL, PROLOG, MODULA2, ALGOL68, PASCAL, SIMULA67, ADA, C++, LIS, EUCLID,
BASIC), además de las diferentes versiones o dialectos que se han desarrollado de algunos de
ellos.
Fortran

Abreviatura de Fórmula Translator (traductor de fórmulas), fue

definido alrededor del año 1955 en los Estados Unidos por la
compañía IBM. Es el más antiguo de los lenguajes de alto nivel,
pues antes de su aparición todos los programas se escribían en
lenguaje ensamblador o en lenguaje máquina.

Es un lenguaje especializado en aplicaciones técnicas y

científicas, caracterizándose por su potencia en los cálculos
matemáticos, pero estando limitado en las aplicaciones de
gestión, manejo de archivos, tratamiento de cadenas de
caracteres y edición de informes.

Cobol

Es el lenguaje más usado en las aplicaciones de

gestión, creado en 1960 por un comité
denominado CODASYL, patrocinado por el
Departamento de Defensa de los Estados
Unidos, a fin de disponer de un lenguaje
universal para aplicaciones comerciales como
expresa su nombre (COmmon Business Oriented
Language).

Entre sus características se pueden citar su

parecido al lenguaje natural (inglés), es auto-
documentado y tiene gran capacidad en el
manejo de archivos, así como en la edición de informes escritos. Entre sus inconvenientes están
sus rígidas reglas de formatos de escritura, la necesidad de describir todos los elementos al
máximo detalle, la extensión excesiva en sus sentencias e incluso duplicación en algunos casos, la
inexistencia de funciones matemáticas y, por último, su no adecuación a las técnicas de
programación estructurada.

Pl/1

Fue creado a comienzos de los años 60 por IBM para ser usado en sus equipos del sistema 360.
El PL/I (Programming Language 1) se desarrolló inspirándose en los lenguajes ALGOL, COBOL y
FORTRAN, tomando las mejores características de los anteriores y añadiendo algunas nuevas,
con el objetivo de obtener un lenguaje lo más general posible, útil para aplicaciones técnico-
científicas, comerciales, de proceso de textos, de bases de datos y de programación de sistemas.

Entre sus novedades está su gran libertad en el formato de escritura de los programas, soportar la
programación estructurada y el diseño modular. No obstante, no ha superado a sus progenitores
en sus aplicaciones específicas debido en parte a su amplitud y por ello, al tamaño de su
compilador, que hasta ahora sólo se podía instalar en grandes equipos.

Basic

Fue diseñado por los profesores John G. Kemeny y Thomas E.

Kurtz del Dartmouth College en 1965 con el objetivo principal de
conseguir un lenguaje fácil de aprender para los principiantes,
como se indica en su nombre Benginner’s All-purpose Symbolic
Instruction Code (Código de instrucción simbólico de propósito
general para principiantes).

Entre sus principales novedades están las de ser un lenguaje

interpretado y de uso conversacional, útil para aplicaciones
técnicas y de gestión. Estas características, unidas a la
popularización de las microcomputadoras y computadoras
personales, ha hecho que su utilización se haya extendido enormemente, a la vez que ha
propiciado el surgimiento de una gran diversidad de versiones que extienden y adaptan a
necesidades particulares el lenguaje original. Existen multitud de intérpretes y compiladores del
lenguaje.

Pascal

Fue creado por el matemático suizo Niklaus Wirth en 1970, basándose en el lenguaje AL-GOL, en
cuyo diseño había participado en los años 60. Su nombre proviene del filósofo y matemático
francés del siglo xvii Blaise Pascal, que inventó la primera máquina de tipo mecánico para sumar.

Aunque en principio la idea del diseñador era proporcionar un lenguaje adecuado para la
enseñanza de los conceptos y técnicas de programación, con el tiempo ha llegado a ser un
lenguaje ampliamente utilizado en todo tipo de aplicaciones, poseyendo grandes facilidades para la
programación de sistemas y diseño de gráficos.

Aporta los conceptos de tipo de datos, programación estructurada y diseño descendente, entre
otros, además de haberse convertido en predecesor de otros lenguajes más modernos, como
MODULA-2 y ADA.

C
Fue creado en 1972 por Dennis Ritchie a partir del trabajo elaborado por su colega de los
Laboratorios Bell Telephone, Ken Thompson. Estos habían diseñado con anterioridad el sistema
operativo UNIX, y su intención al desarrollar el lenguaje C fue la de conseguir un lenguaje idóneo
para la programación de sistemas que fuese independiente
de la máquina con el cual escribir su sistema UNIX.

Aunque fue diseñado inicialmente para la programación de

sistemas, posteriormente su uso se ha extendido a
aplicaciones técnico-científicas, de bases de datos, de
proceso de textos, etc.

La utilización óptima de este lenguaje se consigue dentro

de su entorno natural, que es el sistema operativo UNIX.
Entre sus características destaca el uso de programación
estructurada para resolver tareas de bajo nivel, así como la
amplia librería de rutinas de que dispone.

Ada

Es el último intento de obtener un único lenguaje para todo tipo de

aplicaciones e incluye los últimos avances en técnicas de
programación. Su diseño fue encargado por el Departamento de
Defensa de los Estados Unidos a la empresa Honeywell-Bull después
de una selección rigurosa entre varias propuestas realizadas sobre una
serie de requerimientos del lenguaje y de haber evaluado
negativamente veintitrés lenguajes existentes. De éstos se
seleccionaron como base para la creación del nuevo lenguaje el
PASCAL, el ALGOL y el PL/I. La estandarización del lenguaje se
publicó en 1983 con el nombre de ADA en honor de la considerada
primera programadora de la historia Augusta Ada Byron, condesa de
Lovelace.

Entre las características del lenguaje se encuentran la compilación

separada, los tipos abstractos de datos, programación concurrente,
programación estructurada, libertad de formatos de escritura, etc.,
presentando como principal inconveniente su gran extensión.

/*

ejemplo.c

*/

#include <stdio.h>

int main(void) /* Función principal del programa */

char resultado;

resultado=5+2; /*Realizamos una suma.*/

printf("Resultado de la suma: %i\n",resultado);

resultado=5-2; /*Realizamos una resta.*/

printf("Resultado de la resta:%i\n",resultado);
 resultado=5*2; /*Realizamos una multiplicación.*/

printf("Resultado de la multiplicación: %i\n",resultado);

resultado=5/2; /*Realizamos una división entera.*/

printf("Resultado de la división:%i\n",resultado);

return(0); /* Salimos del programa con el código 0 porque no ha habido errores. */

Simulación de trenes en ada

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Numerics.Float_Random;

with Semaforos;

procedure Simulador_Trenes is

Num_Estaciones : constant := 5;

Num_Trenes : constant := 3;

type Num_Estación is range 1 .. Num_Estaciones;

type Num_Tren is range 1 .. Num_Trenes;

package Num_Estación_IO is new Ada.Text_IO.Integer_IO (Num_Estación);

use Num_Estación_IO;

package Num_Tren_IO is new Ada.Text_IO.Integer_IO (Num_Tren);

use Num_Tren_IO;

package Semaforos_Inicial_1 is new

Semaforos (Valorinicial => 1);

use Semaforos_Inicial_1;

Semaforos_Estaciones : array (Num_Estación) of TSemaforo;

task type Tren is

entry Comenzar (Tu_Num : in Num_Tren);

end Tren;

Lista_Trenes : array (Num_Tren) of Tren;

task body Tren is

Mi_Num: Num_Tren;

procedure Pon_Nombre is

begin
 Put ("Tren nº"); Put (Mi_Num); Put (": ");

end Pon_Nombre;

Espera_En_Estación: constant Duration := 5.0;

Duración_Mínima: constant Duration := 2.0;

Factor_Duración: constant Duration := 10.0;

Azar_Gen: Ada.Numerics.Float_Random.Generator;

Actual, Siguiente: Num_Estación;

begin

Ada.Numerics.Float_Random.Reset (Azar_Gen);

accept Comenzar (Tu_Num : in Num_Tren) do

Mi_Num := Tu_Num;

end Comenzar;

Pon_Nombre;

Put_Line ("Comienzo el trayecto");

Actual := 1;

loop

Pon_Nombre; Put ("En estación "); Put (Actual); New_Line;

delay Espera_En_Estación;

if Actual = Num_Estaciones then

Siguiente := 1;

else

Siguiente := Actual + 1;

end if;

Wait (Semaforos_Estaciones (Siguiente));

Pon_Nombre;

Put ("Trayecto hacia estación ");

Put (Siguiente);

New_Line;

Signal (Semaforos_Estaciones (Actual));

delay Duration (Ada.Numerics.Float_Random.Random (Azar_Gen))

* Factor_Duración + Duración_Mínima;
 Actual := Siguiente;

end loop;

end Tren;

begin

for I in Lista_Trenes'Range loop

Lista_Trenes (I).Comenzar (Tu_Num => I);

end loop;

end Simulador_Trenes;

ejemplo en cobol

IDENTIFICATION DIVISION.
PROGRAM-ID ADCDAP13.
*
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT CON-DATOS ASSIGN TO PERSONA
FILE STATUS IS FS-CON-DATOS.
*
SELECT COPIA ASSIGN TO COPIA
FILE STATUS IS FS-COPIA.
*
DATA DIVISION.
FILE SECTION.
FD CON-DATOS
RECORDING MODE IS F.
01 REG-CON-DATOS PIC X(10).
*
FD COPIA
RECORDING MODE IS F.
01 REG-COPIA PIC X(10).
*
WORKING-STORAGE SECTION.
******************************************************************
* V A R I A B L E S *
******************************************************************
01 FS-CON-DATOS PIC 99.
01
FS-COPIA PIC 99.
*
01 DETALLE.
05 GENERO PIC X.
05 EDAD PIC 99.
05 TIPO-DOC PIC XXX.
05 FECHA.
10 SIGLO PIC XX.
 10 ANNO PIC XX.
*
01 VARIABLES.
05 VA-CONT PIC 99.
05 VA-EDAD PIC 999.
05 VA-PROM PIC 99.
05 VA-CONTM PIC 99.
05 VA-EDADM PIC 999.
05 VA-PROMM PIC 99.
*
******************************************************************
* S W I T C H E S *
******************************************************************
01 SWITCH.
05 SWITCH-FIN PIC XX VALUE 'NO'.
88 FIN-OK VALUE 'SI'.
88 FIN-NO VALUE 'NO'.
*
******************************************************************
* *
* P R O C E D U R E D I V I S I O N *
* *
******************************************************************
PROCEDURE DIVISION.
INDICE.
PERFORM 10-INICIO
PERFORM 20-PROCESO
PERFORM 30-FIN.
*
******************************************************************
* 10-INICIO *
* *
******************************************************************
10-INICIO.
INITIALIZE SWITCH-FIN
VARIABLES
*
OPEN INPUT CON-DATOS
OUTPUT COPIA
*
IF FS-CON-DATOS NOT = 0
DISPLAY 'ERROR FILE STATUS AL ABRIR F-E: ' FS-CON-DATOS
STOP RUN
END-IF
*
IF FS-COPIA NOT = 0
DISPLAY 'ERROR FILE STATUS AL ABRIR F-S: ' FS-COPIA
STOP RUN
END-IF
*
PERFORM 100-LEER-FICHERO
*
IF FIN-OK
DISPLAY 'FINALIZO EL FICHERO'
PERFORM 30-FIN
END-IF
.
*
******************************************************************
* 100-LEER-FICHERO *
* *
******************************************************************
100-LEER-FICHERO.
READ CON-DATOS INTO DETALLE
IF FS-CON-DATOS NOT = 0 AND 10
DISPLAY 'ERROR AL LEER F-E: ' FS-CON-DATOS
PERFORM 30-FIN
END-IF
*
IF FS-CON-DATOS = 10
SET FIN-OK TO TRUE
END-IF
.
******************************************************************
* 20-PROCESO *
* *
******************************************************************
20-PROCESO.
PERFORM 200-TRATAR UNTIL FIN-OK
PERFORM 2000-ESTADISTICA
.
******************************************************************
* 1000-INICIO *
* *
******************************************************************
*
200-TRATAR.
EVALUATE GENERO
WHEN 'H'
COMPUTE VA-CONT = VA-CONT + 1
COMPUTE VA-EDAD = VA-EDAD + EDAD
WHEN 'M'
COMPUTE VA-CONTM = VA-CONTM + 1
COMPUTE VA-EDADM = VA-EDADM + EDAD
WHEN OTHER
DISPLAY 'GENERO: NO CORRESPONDE A NINGUNO'
END-EVALUATE

WRITE REG-COPIA FROM REG-CON-DATOS

*
IF FS-COPIA NOT = 0
DISPLAY 'ERROR AL ESCRIBIR F-S: ' FS-COPIA
STOP RUN
END-IF
*
PERFORM 100-LEER-FICHERO

* IF FS-CON-DATOS = 10 THEN
* SET FIN-OK TO TRUE
* END-IF
.
******************************************************************
* 2000-ESTADISTICA *
* *
******************************************************************
2000-ESTADISTICA.
COMPUTE VA-PROM = VA-EDAD / VA-CONT
COMPUTE VA-PROMM = VA-EDADM / VA-CONTM

DISPLAY 'SE LEYERON EN EL FICHERO TANTOS HOMBRES: ' VA-CONT

DISPLAY 'LA SUMA DE LA EDAD EN HOMBRES ES: ' VA-EDAD
DISPLAY 'EL PROMEDIO EN HOMBRES ES: ' VA-PROM

DISPLAY 'SE LEYERON EN EL FICHERO TANTAS MUJERES: ' VA-CONTM

DISPLAY 'LA SUMA DE LA EDAD EN MUJERES ES: ' VA-EDADM
DISPLAY 'EL PROMEDIO EN MUJERES ES: ' VA-PROMM
.
*
******************************************************************
* 30-FIN *
* *
******************************************************************
30-FIN.
CLOSE CON-DATOS
*
IF FS-CON-DATOS NOT = 0
DISPLAY 'ERROR FILE STATUS AL CERRAR F-E: ' FS-CON-DATOS
STOP RUN
END-IF
*
IF FS-COPIA NOT = 0
DISPLAY 'ERROR FILE STATUS AL CERRAR F-S: ' FS-COPIA
STOP RUN
END-IF
*
STOP RUN
.
*
******************************************************************
* 30-FIN *
* *
******************************************************************
LENGUAJES DE REPRESENTACION
La representación del conocimiento como tal, es una materia en la que se lleva trabajando desde
hace varias décadas, desde mucho antes de que surgiera la web semántica. Surgió en el ámbito
de la Inteligencia Artificial al tratar de crear representaciones de conocimiento que pudieran ser
utilizadas por mecanismos que simulasen el razonamiento humano.

A partir de las técnicas de representación del conocimiento del punto anterior, se han diseñado a lo
largo de los años diversos formalismos y lenguajes que permiten modelar de un modo formal el
conocimiento representado mediante ellas. Existen diversos formalismos para la representación del
conocimiento, cada uno con sus propios lenguajes y cada uno con sus ventajas e inconvenientes.
En esto, al igual que en la Ingeniería del Software, no existe la técnica ideal que nos permita
resolver cualquier problema de la mejor manera. Dependerá del tipo de problema, del conocimiento
que se quiera representar, de la expresividad que se necesite, y del uso que se le quiera dar, el
que un formalismo y un lenguaje sea más conveniente que otro.

Muchos de los sistemas de representación del conocimiento de la actualidad se basan en algún

tipo de lógica formal. La lógica formal aporta un buen número de ventajas para la representación
del conocimiento y su manejo, partiendo de una sintaxis y semántica bien definidas que detallan
perfectamente la forma de construir sentencias y razonamientos sobre ellas.

Una proposición es una sentencia que puede decirse que es falsa o verdadera. En la lógica
proposicional se asigna símbolos a cada sentencia y se utilizan operadores lógicos sobre ellos
para crear proposiciones más complejas. Los símbolos utilizados son AND (∧), OR (∨), NOT (¬),
IMPLIES (→ o ⇒), y EQUIVALENCE (⇔). Partiendo de los símbolos y utilizando los diferentes
operadores se construyen proposiciones complejas, las cuales es posible obtener si son ciertas o
falsas operando a partir de los valores de verdad de cada uno de los símbolos iniciales, utilizando
el cálculo proposicional.

Por ejemplo la sentencia si “El libro está en casa (A) y Juan está en el trabajo (B), Juan no puede
leer el libro (C)”, podría representarse como: A ∧ B → C

Es una ampliación de la lógica proposicional a partir de dos operadores más, el cuantificador

universal ∀ y el existencial ∃. Utiliza también símbolos para representar conocimiento y operadores
lógicos para construir sentencias más complejas, pero a diferencia de la lógica proposicional, los
símbolos pueden representar constantes, variables, predicados y funciones.

Las constantes son símbolos que comienzan por minúsculas y las variables símbolos que
empiezan por mayúsculas. Los predicados representan afirmaciones sobre objetos, por ejemplo, la
afirmación “El libro está en casa” se representaría como un predicado de nombre in:

in(libro, casa)

Se podría reescribir el predicado de forma más general sustituyendo las constantes por variables
de la forma: in(X, Y). Con él podríamos representar diferentes proposiciones como “El libro está en
casa”, “El coche está en el garaje”, “Juan está en el trabajo”.

El último símbolo que queda por explicar son las funciones. Éstas permiten asociar elementos de
un conjunto a un elemento de otro conjunto, por ejemplo: propietario(casa) = juan.

Con todo esto podríamos representar el mismo ejemplo que con lógica proposicional de la
siguiente forma:

in(libro, casa) ∧ in(juan, trabajo) → ¬puedeLeer(juan, libro)

En cuanto a los dos nuevos operadores, ∀ y ∃, permiten delimitar el alcance de las variables en las
sentencias, de forma que “∀X” se leería como “para toda x” y “∃X” como “existe un x tal que”.

∃X puedeLeer(X, libro): alguien puede leer el libro

∀X puedeLeer(X, libro): todo el mundo puede leer el libro

Las lógicas descriptivas están muy relacionadas con el desarrollo de las ontologías tal como se
usan en la actualidad en la web semántica. La lógica descriptiva se basa en representar el
conocimiento utilizando por una una terminología o vocabulario del dominio (TBOX) y por otra un
conjunto de afirmaciones (ABOX).

El vocabulario consiste en conceptos y roles. Los conceptos corresponden a conjuntos de

elementos y los roles a relaciones binarias entre elementos. Existen conceptos y roles atómicos y
complejos.

Por ejemplo, si tenemos como conceptos atómicos “Persona” y “Hembra” y como role atómico
“tieneHijo”, podríamos tener como TBOX representando las relaciones familiares algo como lo
siguiente:

Mujer ≡ Persona ∩ Hembra

Hombre ≡ Persona ∩ ¬Mujer

Madre ≡ Mujer ∩ ∃tieneHijo.Persona

Padre ≡ Hombre ∩ ∃tieneHijo.Persona

Progenitor ≡ Madre ∪ Padre

Esposa ≡ Mujer ∩ tieneMarido.Hombre

Marido ≡ Hombre ∩ tieneEsposa.Mujer

La información recogida en la ABOX podría ser algo como:

tieneHijo(Juan, Miguel)

Padre(Juan)

Esposa(Juan, María)

Se pueden construir y existen razonadores que permiten razonar sobre las TBOX y ABOX,
pudiendo determinar por ejemplo si el contenido de la TBOX es factible, o qué relaciones están
incluidas en otras. Al trabajar sobre el ABOX, un razonador puede indicar que a partir de las
afirmaciones existentes un determinado elemento es una instancia de un concepto y si las
afirmaciones son consistentes con el modelo.

Bibliografías

http://www.webscolar.com/lenguajes-de-alto-nivel-de-programacion

https://www.marcoteorico.com/curso/51/fundamentos-de-programacion/387/lenguaje-de-alto-nivel

http://www.eslomas.com/2006/12/tecnicas-y-lenguajes-para-la-representacion-del-conocimiento/

http://perrocobolero.blogspot.com/2016/06/ejemplo-de-programa-en-cobol.html
http://www.carlospes.com/minidiccionario/lenguaje_de_alto_nivel.php

https://docs.microsoft.com/es-es/sql/t-sql/queries/queries?view=sql-server-2017

https://www.virtuniversidad.com/greenstone/collect/informatica/archives/HASHf1c1.dir/doc.pdf