Investigación de paradigmas
Tabla de contenido
Tipos de programación................................................................................................................1
Programación Imperativa............................................................................................................1
¿Qué es?..................................................................................................................................1
Lenguajes imperativos.............................................................................................................1
Características.........................................................................................................................2
Nociones Básicas.................................................................................................................2
Procedimiento......................................................................................................................2
Estructuras de Datos............................................................................................................2
Programa..............................................................................................................................3
Modelo de cálculo................................................................................................................3
Programación Declarativa...........................................................................................................3
¿Qué es?..................................................................................................................................3
Lenguajes Declarativos...........................................................................................................4
Características.........................................................................................................................4
Programación Orientada a objetos..............................................................................................5
¿Qué es?..................................................................................................................................5
Lenguajes Orientado a objetos................................................................................................6
Características.........................................................................................................................6
Programacion funcional..............................................................................................................8
¿Qué es?..................................................................................................................................8
Características.........................................................................................................................9
Tipos de datos......................................................................................................................9
Listas....................................................................................................................................9
Lenguajes Funcionales..........................................................................................................10
Programacion orientada a eventos............................................................................................10
¿Qué es?................................................................................................................................10
Caracteristicas.......................................................................................................................11
Detección de eventos.........................................................................................................11
Lenguajes orientado a eventos..............................................................................................12
Programacion procedural..........................................................................................................12
¿Qué es?................................................................................................................................12
Caracteristicas.......................................................................................................................12
Lenguajes Proceduarales.......................................................................................................13
Programacion orientada a aspectos...........................................................................................13
¿Qué es?................................................................................................................................13
Caracteristicas.......................................................................................................................15
Lenguajes orientados a aspectos............................................................................................15
Programacion logica.................................................................................................................15
¿Qué es?................................................................................................................................15
Caracteristicas.......................................................................................................................16
Prolog.................................................................................................................................17
Lenguajes Logicos.................................................................................................................17
Referencias............................................................................................................................18
1
Programación Imperativa
¿Qué es?
Es un paradigma de programación que describe la programación como cambios de
estados de un programa y las sentencias que cambian este estado. Un programa imperativo es un
conjunto de instrucciones que explican o indican a la máquina como debe realizar una tarea.
Básicamente todas las implementaciones de programas en hardware son de tipo imperativo,
debido a que el hardware de los computadores está diseñado para ejecutar código de máquina y
este está escrito en un lenguaje imperativo (paradigma Máquinas de Turing). En pocas palabras
un programa imperativo, es una fórmula que tiene pasos escritos por el programador, pasos que
cambian el estado del programa con el fin de llegar a obtener un resultado. (Pratt & Zelkowitz,
1996).
En el lenguaje imperativo podemos ver también el tipo de programación funcional, que trata
de declarar procedimientos comunes en funciones pequeñas, para distintos programas puedan
llamar la misma función sin tener que escribir de nuevo el mismo código. De esta forma en un
programa imperativo se puede escribir el código y los pasos seguir llamando funciones o
procedimientos para que cambien el estado del programa y así llegar el objetivo del programa.
Lenguajes imperativos
Algunos de los lenguajes que usan este paradigma de programación son:
2
ASP
BASIC
C
C#
C++
FORTRAN
PASCAL
Características
Nociones Básicas
Hace uso de:
Variables con estado (con un valor modificable).
Secuencias de cambios de estado.
Procedimientos.
Procedimiento
- Secuencia de actuaciones sobre el estado de ciertas variables para alcanzar unos valores que
cumplan unas determinadas condiciones. Tienen nombre y parámetros (de entrada y de salida).
- Los procedimientos colaboran pasando valores de los parámetros de salida de unos a los
parámetros de entrada de otros.
Estructuras de Datos
Datos predefinidos (v. lógicos, números, caracteres)-
3
Esquemas de array, de registro y variables Dinámicas.
Programa
Se desarrolla mediante la declaración de procedimientos más una rutina principal, que es una
secuencia de llamada a procedimientos.
Modelo de cálculo
Máquina de Turing, autómata de estados finitos cuyo comportamiento se basa en la transición
de estados.
Programación Declarativa
¿Qué es?
La programación declarativa es una forma de programación que implica la descripción de un
problema dado en lugar de proveer una solución para dicho problema, dejando la interpretación
de los pasos específicos para llegar a dicha solución a un intérprete no especificado. La
programación declarativa adopta, por lo tanto, un enfoque diferente al de la programación
imperativa tradicional, la que requiere que el programador especifique una lista completa de
instrucciones de modo de ejecutar una tarea determinada. (Pratt & Zelkowitz, 1996)
En otras palabras, la programación declarativa provee el “que”, pero deja el “como” liberado a
la implementación particular del intérprete. Por lo tanto se puede ver que la programación
declarativa tiene dos fases bien diferenciadas, la declaración y la interpretación.
Los lenguajes declarativos describen la relación entre variables en términos de funciones y
reglas de inferencia o transformación. El intérprete produce, mediante un algoritmo de
procesamiento de estas declaraciones, un resultado.
4
La programación declarativa incluye tanto aspectos de programación lógica como de
programación funcional.
Lenguajes Declarativos
Prolog
SQL
HTML
WSDL (Web Services Description Language)
XML Stylesheet Language for Transformation
Características
Los lenguajes declarativos están orientados a buscar la solución del problema, sin preocuparse
por la forma de llegar a ello; es decir, el programador debe concentrarse en la lógica del
algoritmo, más que en el control de la secuencia.
Los programas están formados por un conjunto de definiciones o ecuaciones, las cuales
describen lo que debe ser calculado, no en sí la forma de hacerlo.
Las variables sólo pueden tener asignado un solo valor a lo largo de la ejecución del
programa, lo cual implica que no puede existir asignación destructiva. Debido a esto, cobra
especial importancia el uso del anidamiento y la recursividad. Las listas representan la estructura
fundamental de datos.
El orden de la ejecución no resulta importante debido a que no existen efectos colaterales; es
decir, que al calcular un valor, resulta imposible afectar el cálculo de otros y con esto se puede
5
afirmar que cualquier secuencia de ejecución deberá conducir al mismo resultado.
Las expresiones o definiciones pueden ser usadas como valores y por lo tanto se pueden tratar
como argumentos de otras definiciones.
El control de la ejecución no es responsabilidad del programador.
Programación Orientada a objetos
¿Qué es?
En este tipo de programación se definen los programas en términos de "clases de objetos",
objetos que son entidades que combinan estado, comportamiento e identidad (propiedad del
objeto que lo diferencia del resto). La programación orientada a objetos expresa un programa
como un conjunto de estos objetos, que colaboran entre ellos para realizar tareas. Esto permite
hacer los programas módulos más fáciles de escribir, mantener y reutilizar.
Este tipo de programación difiere de los lenguajes imperativos tradicionales, en los que los
datos y los procedimientos están separados y sin relación, ya que lo único que se busca es el
procesamiento de unos datos y los procedimientos están separados y sin relación, ya que lo único
que se busca es el procesamiento de unos datos de entrada para obtener otros de salida. La
programación estructurada anima al programador a pensar sobre todo en términos de
procedimientos o funciones, y en segundo lugar en las estructuras de datos que esos
procedimientos manejan. Los programadores de lenguajes imperativos escriben funciones y
después les pasan los datos. Los programadores que emplean lenguajes orientados a objetos
definen objetos con datos y métodos y después envían mensajes a los objetos diciendo que
realicen esos métodos por sí mismos.
6
Un objeto se puede definir como un grupo de procedimientos que comparten un estado. Se
define al conjunto de datos como "estado", y "métodos" como el conjunto de procedimientos que
pueden alterar ese estado. Un programa orientado a objetos es un método de implementación en
el que los programas están organizados como colecciones de objetos, donde cada uno es una
instancia de alguna clase, y donde todas las clases son miembros de una jerarquía de clases
conectadas por relaciones de herencia. (Schach, 2006)
Lenguajes Orientado a objetos
Ada Objective-C
C++ Ocaml
C# Oz
VB.NET PHP
Clarion PowerBuilder
Delphi Pitón
Eiffel Ruby
Java Smalltalk
Características
ABSTRACCIÓN: Cada objeto en el sistema sirve como modelo de un agente abstracto que
puede realizar trabajo, informar y cambiar su estado, y comunicarse con otros objetos en el
sistema sin revelar cómo se implementan estas características. Los procesos, las funciones o los
métodos pueden también ser abstraídos y cuando lo están, una variedad de técnicas son
requeridas para ampliar una abstracción.
7
ENCAPSULAMIENTO: también llamado ocultación de la información. Cada objeto está
aislado del exterior, es un módulo natural, y cada tipo de objeto expone una interfaz a otros
objetos que específica cómo pueden interactuar con los objetos de la clase. El aislamiento
protege a las propiedades de un objeto contra su modificación por quien no tenga derecho a
acceder a ellas, solamente los propios métodos internos del objeto pueden acceder a su estado.
Esto asegura que otros objetos no pueden cambiar el estado interno de un objeto de maneras
inesperadas, eliminando efectos secundarios e interacciones inesperadas. Algunos lenguajes
relajan esto, permitiendo un acceso directo a los datos internos del objeto de una manera
controlada y limitando el grado de abstracción. La aplicación entera se reduce a un agregado o
rompecabezas de objetos. Esta característica o propiedad permite por tanto ejecutar la
información al resto de los objetos, impidiendo así accesos incorrectos o conflictos.
POLIMORFISMO: comportamientos diferentes, asociados a objetos distintos, pueden
compartir el mismo nombre, al llamarlos por ese nombre se utilizará el comportamiento
correspondiente al objeto que se esté usando. O dicho de otro modo, las referencias y las
colecciones de objetos pueden contener objetos de diferentes tipos, y la invocación de un
comportamiento en una referencia producirá el comportamiento correcto para el tipo real del
objeto referenciado.
HERENCIA: las clases no están aisladas, sino que se relacionan entre sí, formando una
jerarquía de clasificación. Los objetos heredan las propiedades y el comportamiento de todas las
clases a las que pertenecen. La herencia organiza y facilita el polimorfismo y el encapsulamiento
8
permitiendo a los objetos ser definidos y creados como tipos especializados de objetos
preexistentes. Estos pueden compartir (y extender) su comportamiento sin tener que re
implementar su comportamiento. Esto suele hacerse habitualmente agrupando los objetos en
clases y estas en árboles o enrejados que reflejan un comportamiento común. Cuando un objeto
pertenece a más de una clase se dice que hay herencia múltiple; esta característica no está
soportada por algunos lenguajes (como Java). Con esta propiedad, los objetos heredan
comportamientos dentro de una jerarquía de clases.
Programacion funcional
¿Qué es?
La programación en un lenguaje funcional consiste en construir definiciones y usando la
computadora para evaluar expresiones. El papel principal del programador es construir una
función para resolver un problema determinado. Esta función,que puede implicar una serie de
funciones subsidiarias, se expresa en notación que obedece a los principios matemáticos
normales. El papel principal de la computadora es actuar como un evaluador o calculadora: su
trabajo es evaluar expresionese imprime los resultados. En este sentido, la computadora actúa de
manera muy similar a una computadora calculadora de bolsillo. Lo que distingue una calculadora
funcional del la variedad más humilde es la capacidad del programador de hacer definiciones
para aumentar su poderes de cálculo. Expresiones que contienen ocurrencias de los nombres de
funciones definidas por el programador se evalúan mediante el uso de las definiciones dadas
como reglas de simplificación (o "reducción") para convertir expresiones a forma imprimible.
(Bird & Philip Wadler, 1988)
9
Características
La característica de la programación funcional es que si una expresión
posee un valor bien definido, luego el orden en que una computadora puede llevar
la evaluación no afecta el resultado. En otras palabras, el significado
de una expresión es su valor y la tarea de la computadora es simplemente obtener
eso. Se deduce que las expresiones en un lenguaje funcional se pueden construir,
manipulado y razonado, como cualquier otro tipo de expresión matemática,
usando leyes algebraicas más o menos familiares. El resultado, como esperamos
para justificar, es un marco conceptual para la programación que es a la vez muy
simple, muy conciso, muy flexible y muy poderoso.
Tipos de datos
Los lenguajes funcionales, en particular Haskell, tienen un rico
conjunto de datos atómicos predefinidos, tales como los numéricos int,
integer (de mayor precisión que el anterior), float, double, etc., y
además los tipos char y bool.
Listas
Las listas son colecciones de cero o más elementos de un mismo tipo (a diferencia de las
tuplas que pueden tenerlos de diferentes). Los operadores utilizados son el [] y (:). El primero
representa una lista vacía, y el segundo denominado cons o constructor, permite añadir un
elemento al principio de una lista, construyendo la lista en función de agregar elementos a la
misma.
10
Lenguajes Funcionales
Haskell,
Miranda,
R, Lisp,
Scala,
Scheme,
ML,
Erlang
Programacion orientada a eventos
¿Qué es?
La programación dirigida por eventos es un paradigma de programación en el que tanto la
estructura como la ejecución de los programas van determinados por los sucesos que ocurran en
el sistema, definidos por el usuario o que ellos mismos provoquen. Para entender la
programación dirigida por eventos, podemos oponerla a lo que no es: mientras en la
programación secuencial (o estructurada) es el programador el que define cuál va a ser el flujo
del programa, en la programación dirigida por eventos será el propio usuario —o lo que sea que
esté accionando el programa— el que dirija el flujo del programa. Aunque en la programación
secuencial puede haber intervención de un agente externo al programa, estas intervenciones
ocurrirán cuando el programador lo haya determinado, y no en cualquier momento como puede
ser en el caso de la programación dirigida por eventos. ( Luckham, 2002)
11
Caracteristicas
El creador de un programa dirigido por eventos debe defi- nir los eventos que manejarán su
programa y las acciones que se realizarán al producirse cada uno de ellos, lo que se conoce como
el administrador de evento. Los eventos soportados estarán determinados por el lenguaje de
programación utilizado, por el sistema operativo e incluso por eventos creados por el mismo
programador. En la programación dirigida por eventos, al comenzar la ejecución del programa se
llevarán a cabo las inicializaciones y demás código inicial y a continuación el programa quedará
bloqueado hasta que se produzca algún evento. Cuando alguno de los eventos esperados por el
programa tenga lugar, el programa pasará a ejecutar el código del correspondiente administrador
de evento. Por ejemplo, si el evento consiste en que el usuario ha hecho clic en el botón de play
de un reproductor de películas, se ejecutará el código del administrador de evento, que será el
que haga que la película se muestre por pantalla.
Detección de eventos
En contraposición al modelo clásico, la programación orientada a eventos permite interactuar
con el usuario en cualquier momento de la ejecución. Esto se consigue debido a que los
programas creados bajo esta arquitectura se componen por un bucle exterior permanente
encargado de recoger los eventos, y distintos procesos que se encargan de tratarlos.
Habitualmente, este bucle externo permanece oculto al programador que simplemente se encarga
de tratar los eventos, aunque en algunos entornos de desarrollo (IDE) será necesaria su
construcción. Ejemplo de programa orientado a eventos en pseudo lenguaje: While (true)
{ Switch (event){ case mousse_button_down: case mouse_click: case keypressed: case Else: } }
12
Lenguajes orientado a eventos
Javascript
Visual Basic
C#
J#
AS3
Programacion procedural
¿Qué es?
Son los lenguajes orientados a “sentencias”. La unidad de trabajo es la sentencia. Los efectos
de las sentencias individuales se combinan en un programa para obtener los resultados deseados.
Todos estos lenguajes se basan fundamentalmente en la arquitectura tradicional de la
computadora.
La idea básica de esta aproximación es la de definir los algoritmos o procedimientos más
eficaces para tratar los datos de nuestro problema. (Alvarado, Scribd , 2012)
Caracteristicas
Un programa completo está compuesto por una serie de sentencias, que pueden ser de
distintos tipos:
declarativas, que son las que empleamos para definir los tipos de datos, declarar las
variables o las funciones, etc., es decir, son aquellas que se emplean para definir de
forma explícita los elementos que intervienen en nuestro programa.
ejecutables, que son aquellas que se transforman en código ejecutable, y
13
compuestas, que son aquellas formadas de la unión de sentencias de los tipos
anteriores.
Por último indicaremos que el concepto de procedimiento introduce un nivel de abstracción
importante en la programación ya que, si queremos utilizar un procedimiento ya implementado
para resolver un problema, sólo necesitamos saber cuáles son sus parámetros y cuál es el
resultado que devuelve. De esta manera podemos mejorar o cambiar un procedimiento sin afectar
a nuestro programa, siempre y cuando no cambie sus parámetros, haciendo mucho más fácil la
verificación de los programas, ya que cuando sabemos que un procedimiento funciona
correctamente no nos debemos volver a preocupar por él.
Lenguajes Proceduarales
Fortran
Algol
C
Pascal
Programacion orientada a aspectos
¿Qué es?
La “Programación Orientada a Aspectos” es una propuesta reciente que brinda un
mayor grado de abstracción en el desarrollo de software, permitiendo realizar de
manera clara y eficiente una clara “separación de incumbencias”.
14
La definición actual de aspecto, de Gregor Kiezales de mayo de 1999 es la siguiente: “Un
aspecto es una unidad modular que se disemina (“cross-cuts”) por la estructura de otras unidades
funcionales. Los aspectos existen tanto en la etapa de diseño como en la de implementación. Un
aspecto de diseño es una unidad modular del diseño que se entremezcla en la estructura de otras
partes del diseño. Un aspecto de implementación es una unidad modular del programa que
aparece en otras unidades modulares del programa”.
Generalmente, el desarrollo de una aplicación involucra varias tareas que se deben realizar.
Hay tareas que pueden considerarse “principales”, y que son típicamente detalladas por los
usuarios como parte del análisis funcional de requerimientos. Pero, adicionalmente, existen
también tareas que pueden considerarse “servicios comunes”, generalmente no detalladas en el
análisis funcional. Ejemplos de estos “servicios comunes” pueden ser la necesidad de generar
registros de auditoria (logging), accesos a bases de datos, temas relacionados con las seguridad,
temas relacionados con la concurrencia del acceso a cierta información, etc. Es habitual que esta
clase de “servicios comunes” deba ser realizada en forma similar pero independiente en diversas
partes del código.
Cada una de estas tareas es considerada una “incumbencia” (“concern”, en inglés), en el
entendido que al código que la implementa le debería “incumbir” solamente esa tarea. La
“separación de incumbencias” es, por lo tanto, deseable en cualquier desarrollo de software. Sin
embargo, en los lenguajes de programación típicos (ya sea procedurales u orientados a objetos),
es difícil, o imposible, separar claramente las incumbencias de los “servicios comunes” de las
incumbencias “principales”, teniendo como consecuencia, por lo tanto, que las tareas de los
“servicios comunes” queden dispersas dentro del código de las incumbencias principales. Esto es
15
conocido como “incumbencias transversales” (“crosscutting concerns”, en inglés). (Joskowicz,
Fing , 2008)
Caracteristicas
En los lenguajes “tradicionales” (ya sea orientados a objetos o procedurales), se implementan
las funciones principales mediante objetos, métodos o procedimientos. Tal como se definió
anteriormente, esto representa a los componentes. Los lenguajes orientados a aspectos agregan
una nueva “dimensión”, encargada de concentrar la programación de conceptos tales como
persistencia, gestión de errores, registros de auditoria, sincronización, comunicación entre
procesos, o, en forma más general, lo que se ha definido previamente como aspectos.
Lenguajes orientados a aspectos
COOL
RIDL
MALAJ
AspectC
AspectC++
Programacion logica
¿Qué es?
Una forma de razonar para resolver problemas en matemáticas se fundamenta en la
lógica de primer orden. El conocimiento básico de las matemáticas se puede representar
en la lógica en forma de axiomas, a los cuales se añaden reglas formales para deducir
16
cosas verdaderas (teoremas) a partir de los axiomas. Gracias al trabajo de algunos
matemáticos de finales del siglo pasado y principios de éste, se encontró la manera de
automatizar computacionalmente el razonamiento lógico, particularmente para un
conjunto significativo de la lógica de primer orden, que permitió que la lógica
matemática diera origen a otros tipos de lenguajes de programación, conocidos como
lenguajes lógicos.
En los lenguajes lógicos se utiliza el formalismo de la lógica de primer orden para representar
el conocimiento sobre un problema y para hacer preguntas que, si se demuestra que se pueden
deducir a partir del conocimiento dado en forma de axiomas y de las reglas de deducción
estipuladas, se vuelven teoremas. Así se encuentran soluciones a problemas formulados como
preguntas. Con base en la información expresada dentro de la lógica de primer orden, se
formulan las preguntas sobre el dominio del problema y el intérprete del lenguaje lógico trata de
encontrar la respuesta automáticamente. (Silvio, Labsys, 2011)
Caracteristicas
La programación lógica tiene sus orígenes en los trabajos de prueba automática de teoremas.
Para esto se utiliza una única regla de inferencia llamada principio de resolución1, mediante la
cual la prueba de un teorema puede ser llevada a cabo en forma automática. La resolución es una
regla que se aplica sobre las fórmulas surgidas de la lógica de primer orden y la demostración de
teoremas mediante esta regla de inferencia se lleva a cabo por reducción al absurdo.
La lógica de primer orden o lógica proposicional es uno de los formalismos más utilizados
para representar conocimiento en Inteligencia Artificial. Esta lógica es la que utiliza
17
proposiciones y nexos entre éstas para expresar sus verdades. Las proposiciones equivalen a
frases u oraciones del lenguaje hablado, mientras que los nexos a través de los cuales puede
relacionar estas proposiciones son la conjunción (y), la disyunción (o) y la implicación (si).
Cuenta con un lenguaje formal mediante el cual es posible representar fórmulas llamadas
axiomas o predicados, que permiten describir fragmentos del conocimiento, y además consta de
un conjunto de reglas de inferencia que aplicadas a los axiomas, permiten derivar nuevo
conocimiento.
Prolog
Prolog forma su lenguaje a partir de un alfabeto que contiene sólo dos tipos de símbolos:
símbolos lógicos, entre los que se encuentran los símbolos de constantes
proposicionales true y false (verdadero y falso); los símbolos para la negación, la
conjunción, la disyunción y la implicación (que en Prolog se denota con los caracteres
:-); los símbolos de cuantificadores; y los símbolos auxiliares de escritura como
corchetes [,], paréntesis (,) y coma.
símbolos no lógicos, agrupados en el conjunto de símbolos constantes; el conjunto de
símbolos de variables individuales (identificadores); el conjunto de símbolos de
relaciones n-arias; y el conjunto de símbolos de funciones n-arias.
Lenguajes Logicos
Prolog
Mercury
Oz
18
Referencias
— Pratt,. and Marvin V. Zelkowitz. Programming Languages: Design and
Implementation, 3rd ed. Englewood Cliffs, N.J.: Prentice Hall, 1996.
— Schach, Stephen (2006). Object-Oriented and Classical Software Engineering,
Seventh Edition. McGraw-Hill.
— Richard Bird, and Philip Wadler (1988). Introduction to Functional Programming, 1er
ed. Prentice Hall International (UK) Ltd
— David, Luckham (2002). The Power of Events - An Introduction to Complex Event
Processing in Distributed Enterprise Systems, Addison-Wesley, ISBN 0-201- 72789-7 .
( Luckham, 2002)
— Lenguajes Procedurales y no Procedurales. Recuperado de;
https://es.scribd.com/doc/98355274/Procedural-vs-No-Porcedural.
— José, Joskowicz (2008). Programación Orientada a Aspectos, Recuperado de;
https://iie.fing.edu.uy/~josej/docs/Programacion%20Orientada%20Aspectos%20-%20Jose
%20Joskowicz.pdf
— Silvio, Serra(2011) Paradigmas de Programación Logica, Recuperado de;
https://labsys.frc.utn.edu.ar/ppr-2011/Unidad%20V%20-%20Paradigma%20L
%C3%B3gico/Unidad%20V%20-%20Paradigma%20LOGICO.pdf
19
