Definición

 “Un paradigma de programación indica un método de realizar

cómputos y la manera en que se deben estructurar y organizar las
tareas que debe llevar a cabo un programa ”
 Los paradigmas fundamentales están asociados a determinados
modelos de cómputo.
 Tambien se asocian a un determinado estilo de programación
 Los lenguajes de programación suelen implementar, a menudo de
forma parcial, varios paradigmas.
Tipos de paradigmas
 Los paradigmas fundamentales están basados en diferentes
modelos de cómputo y por lo tanto afectan a las construccio-
nes más básicas de un programa.
 La división principal reside en el enfoque imperativo (indicar el
cómo se debe calcular) y el enfoque declarativo (indicar el qué
se debe calcular).
 El enfoque declarativo tiene varias ramas diferenciadas: el
paradigma funcional, el paradigma lógico, la programación
reactiva y los lenguajes descriptivos.
 Otros paradigmas se centran en la estructura y organización de
los programas, y son compatibles con los fundamentales:
 Ejemplos: Programación estructurada, modular, orientada a
objetos, orientada a eventos, programación genérica.
 Por último, existen paradigmas asociados a la concurrencia y a
los sistemas de tipado.
El zoo de los paradigmas

Modular Imperativo
Código

Módulos Procedimental

Procedimientos
Estructurado Declarativo
Control de flujo
Acciones Funcional
elementales

Orientado a Eventos
Lógico
Relación

Orientado a Objetos Reactivo

Datos Programación Programación

Genérica Concurrente
Paradigma Imperativo
 Describe cómo debe realizarse el cálculo, no el porqué.
 Un cómputo consiste en una serie de sentencias,
ejecutadas según un control de flujo explícito, que
modifican el estado del programa.
 Las variables son celdas de memoria que contienen
datos (o referencias), pueden ser modificadas, y
representan el estado del programa.
 La sentencia principal es la asignación.
 Es el estándar ‘de facto’.
 Asociados al paradigma imperativo se encuentran los paradigmas
procedural, modular, y la programación estructurada.
 El lenguaje representativo sería FORTRAN-77, junto con COBOL,
BASIC, PASCAL, C, ADA.
 También lo implementan Java, C++, C#, Eiffel, Python, ...
Paradigma Declarativo
 Describe que se debe cálcular, sin explicitar el cómo.
 No existe un orden de evaluación prefijado.
 Las variables son nombres asociados a definiciones, y
una vez instanciadas son inmutables.
 No existe sentencia de asignación.
 El control de flujo suele estar asociado a la composición
funcional, la recursividad y/o técnicas de reescritura y
unificación.
 Existen distintos grados de pureza en las variantes del paradigma.
 Las principales variantes son los paradigmas funcional, lógico, la
programación reactiva y los lenguajes descriptivos.
Programación Funcional
 Basado en los modelos de cómputo cálculo lambda (Lisp,
Scheme) y lógica combinatoria (familia ML, Haskell)
 Las funciones son elementos de primer orden
 Evaluación por reducción funcional. Técnicas:
recursividad, parámetros acumuladores, CPS, Mónadas.
 Familia LISP (Common-Lisp, Scheme):
 Basados en s-expresiones.
 Tipado debil.
 Meta-programación
 Familia ML (Miranda, Haskell, Scala):
 Sistema estricto de tipos (tipado algebraico)
 Concordancia de patrones.
 Transparencia referencial
 Evaluación perezosa (estruct. de datos infinitas)
Programación Lógica
 Basado en la lógica de predicados de primer orden
 Los programas se componen de hechos, predicados y
relaciones.
 Evaluación basada en resolución SLD: unificación +
backtracking.
 La ejecución consiste en la resolución de un problema de
decisión, los resultados se obtienen mediante la
instanciación de las variables libres.
 Lenguaje representativo: PROLOG
Programación Reactiva
(Dataflow)
 Basado en la teoria de grafos.
 Un programa consiste en la especificación del flujo de datos
entre operaciones.
 Las variables se encuentran ligadas a las operaciones que
proporcionan sus valores. Un cambio de valor de una variable
se propaga a todas las operaciones en que participa.
 Las hojas de cálculo se basan en este modelo.
 Lenguajes representativos: Simulink, LabView.
A := 10
B := A + 1
print B 11
A := 3
print B 4
Diagrama de flujo
#1 #2 #1 #2

mcd resto
A  Entrada #1 A  Entrada #1
B  Entrada #2 B  Entrada #2

A B NO
C  resto(A,B)
B  C A>B

SI
NO
C=0 A A-B
SI

Salida #1  B Salida #1  A

#1 #1
FORTRAN-77
 Imperativo, procedural, no estructurado

FUNCTION MCD(NA, NB) Paso por referencia

IA = NA
IB = NB Tipado implícito
1 IF (IB.NE.0) THEN
ITMP = IA
IA = IB
IB = MOD(ITMP, IB)
Saltos
GOTO 1
END IF
MCD = IA
RETURN
END
PASCAL
 Imperativo, procedural, estructurado

function MCD(a,b: integer): integer;

var c: integer;
begin Paso por valor
while b <> 0 do
begin Tipado explícito
c := a;
a := b;
b := c mod b
end;
MCD := b
end;
SCHEME, HASKELL, PROLOG
 Lenguajes funcionales y lógicos (recursividad)
 Scheme
(define (mcd a b) s-expresiones
(if (= b 0) a
(mcd b (modulo a b))))
tipado estricto
 Haskell
mcd :: Int ‐> Int ‐> Int concordancia
mcd a 0 = a de patrones
mcd a b = mcd b (rem a b)
predicados, unificación
 Prolog

mcd(A,0,D) :‐ A = D.
mcd(A,B,D) :‐ B > 0, C is A mod B, mcd(B,C,D).
Lenguajes de Programación
 Lenguaje artificial diseñado para expresar cómputos que
pueden ser llevados a cabo por una máquina.
 Basado en un modelo de cómputo (que puede o no coincidir con
el de la máquina en que se va a ejecutar)
 Define un nivel de abstracción más elevado (más cercano al
programador)
 Debe traducirse a un código que pueda entender el procesador:
el código máquina.
 Modos de traducción:
 Lenguaje Compilado
 Lenguaje Interpretado (Entorno interactivo)
 Lenguaje traducido a Código Intermedio (Java  Bytecodes,
.NET  IDL)
Estrategias de traducción
 Código compilado:
Código Máquina
Programa

Compilación Ejecución

Entorno
(SO)

Librerías Librerías
Módulos estáticas dinámicas
Estrategias de traducción
 Código interpretado:

Programa
(Sesión interactiva) Intérprete

Ejecución

Interpretación

I/O

Estado
Sesión
Comando actual
Resultado
Estrategias de traducción
 Código intermedio: (Pascal IDL, Java, .NET)
Código Máquina
Programa Intermedio Virtual

Compilación Interpretación Ejecución

Módulos
Estado

Interacción S.O.
Librerías estándard

Universal Específico
 Generaciones
Generación Lenguajes Hardware Movimientos
Primera (1945-55) Código Máquina Relés, Válvulas de
vacío
Segunda (1955-68) FORTRAN Transistores, Prog. Estructurada
COBOL Memorias de y Modular
LISP ferrita Proceso por Lotes
Tercera (1968-1980) ALGOL Circuitos Ingeniería de
PASCAL integrados, Software
C Memorias de Orientación a
BASIC transistores Objetos
ADA Bases de Datos
Cuarta (1980-) C++ VLSI Comp. Distribuida
JAVA MultiCore Interfaces Gráficas
HASKELL Flash Multimedia
PYTHON Internet
Linea del Tiempo
Crisis del Software, Ingeniería del Software

Programación Procedimental Programación Estructurada y Modular

Orientación a Objetos

Programación Genérica

60s 70s 80s

Basic ADA Common Lisp

COBOL
ALGOL Pascal Modula-2

FORTRAN
C C++ Scheme
Prolog
LISP
Simula Smalltalk Objective C
Linea del Tiempo
Internet

Interfaces de Usuario Dispositivos Móviles

Computación Distribuida

90s 00s

Haskell Java Scala Clojure F#

Delphi

Perl PHP .NET Swift Go

Visual C++
C#
Eiffel Visual Basic Python R Kotlin

Erlang Ruby Javascript Rust

Evolución BASIC

Modula-2
VB
FORTRAN PASCAL
Delphi

ADA C#
Java
ALGOL
SIMULA Eiffel

JavaScript
C++ PHP
COBOL C

AWK Perl

SmallTalk TCL Python

PROLOG
Ruby

CLisp

LISP Scheme Objective-C

Scala
ML Haskell
Clean
Paradigmas BASIC

Modula-2
FORTRAN PASCAL VB
Delphi

ADA C#
Java
ALGOL
SIMULA Eiffel
Imperativo
JavaScript
Funcional PHP
Orient. Objeto
C++
Scripting C

AWK Perl

COBOL SmallTalk TCL Python

Ruby
PROLOG
CLisp

LISP Scheme Objective-C

Scala
ML Haskell
Clean
Evolución Histórica
 FORTRAN (Formula Translating) 1957
 Orientado al cálculo científico
 Proceso de arrays
 GOTO asignado
 Versiones II, III, IV, 66 (subrutinas), 77, 90 (array slicing,
recursividad, modularidad, sobrecarga, TADs), 96-03-08
(paralelismo, orientación a objeto)
 COBOL (Common Business Oriented Languaje) 1959:
 Orientado al mundo empresarial
 Sintaxis basada en lenguaje natural: 400 palabras reservadas,
con verbos, nombres, modificadores, etc.
 Código auto-modificable: ALTER X TO PROCEED TO Y
 Especificación detallada de valores numéricos (PIC)
 Modularidad mediante Copybooks
Familias y Evolución Histórica
 LISP (List Processing) 1958, McCarthy
 Orientado a la investigación (Inteligencia Artificial)
 Basado en s-expresiones
 Código y datos intercambiables
 Tipado débil
 Familia Lisp:
 Common Lisp , 1984 (Generalización, Orientación a Objeto)
 Scheme, 1975 (Simplificación, Closures)
 Clojure, 2007
 Familia ML:
 Sistema de tipado Hindler-Millner
 Haskell, 1990
 Clean (1987), Scala (2003)
Ejemplo programa COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. PerformFormat4.
AUTHOR. Michael Coughlan.
* An example program using the PERFORM..VARYING format.
* Pay particular attention to the values produced by the
* WITH TEST BEFORE and WITH TEST AFTER loops.
* Note that the PERFORM within a PERFORM produces the same
* results as the PERFORM..VARYING..AFTER

DATA DIVISION.
WORKING-STORAGE SECTION.
01 LoopCount PIC 9 VALUE ZEROS.
01 LoopCount2 PIC S9 VALUE ZEROS.

PROCEDURE DIVISION.
Begin.
DISPLAY "Start WHILE Iteration of LoopBody"
PERFORM LoopBody WITH TEST BEFORE
VARYING LoopCount FROM 1 BY 2
UNTIL LoopCount GREATER THAN 5.
DISPLAY "Finished WHILE iteration. LoopCount = " LoopCount.
...
Ejemplo programa LISP
(defun simplify (expression)
(simplify-2 (rules) expression))

(defun simplify-2 (rules expression)

(cond
((null rules) expression)
(T (simplify-2 (cdr rules) (apply-rule (car rules) expression)))))

(defun apply-rule (rule expression)

(substitute (car rule) (cadr rule) expression))

(defun substitute (pattern replacement expression)

(cond
((null expression) ())
((occurs-at-front pattern expression)
(substitute-at-front pattern replacement expression))
(T (cons (car expression)
(substitute pattern replacement (cdr expression))))))

(defun occurs-at-front (pattern expression)

(cond ((null pattern) T) ((null expression) nil)
((matches (car pattern) (car expression))
(occurs-at-front (cdr pattern) (cdr expression)))
(T nil)))
Familias y Evolución Histórica
 ALGOL (Algorithmic Languaje) 1958/60/68 N.Wirth
 Familia de lenguajes, diseñados por un comité de expertos
 Bloques de código, recursividad, funciones internas, paso de
parámetros
 Arrays dinámicos, paralelismo, definición de operadores
 Familia ALGOL
 PASCAL, 73  Modula-2, 80
 Delphi/ Free-Pascal, 93
 ADA, 83
 C, 74  C++, 80
 Objective-C, 86
 C#, 95
 Java, 95
Orientación a objeto
 SIMULA, 67
 Ortodoxa:
 SmallTalk, 80  Objective-C, 86
 Eiffel, 86
 Parcial
 ADA, 83 (Genericidad)
 C++, 80 (Templates)
 Java, 95 (Interfaces)
 C# , 2001 (.NET)
 Basada en prototipos
 JavaScript, 96
 Python, 91
Lenguajes de Scripting
 Cliente (navegador):
 HTML / CSS
 ACMEScript: JavaScript, ActionScript (Flash), 1995
 Java (applets), 1995
 Servidor
 PHP, ASP, 1995
 Java (servlets), 2000
 Ruby, 1995
 Propósito general
 Perl, 1987
 Tcl/Tk, 1989
 Python, 1991
Otros lenguajes
 Programación lógica:
 PROLOG, 1972
 Concurrencia
 Erlang, 1986
 Oz , 1991
 Bases de Datos
 SQL (No es Turing-completo)
 Minimalistas
 Forth, 1970
 APL (1964)  J (1990)
 BrainFuck