Existe una gran cantidad de paradigmas. Sin embargo, todos derivan de 3 paradigmas principales: imperativo, declarativo y dirigido por eventos (este último se verá en una próxima clase).
Programación imperativa
Se trata de expresar cómo debe solucionarse un problema paso a paso. Es el paradigma más utilizado. Se encuentra en lenguajes como Fortran, Java, C, Python, Ruby, etc. De él se derivan paradigmas como la programación orientada a objetos o procedimental.
Programación declarativa
La programación declarativa consiste en expresar qué problema debe solucionarse, sin especificar cómo hacerlo. Se enfoca en el resultado, y en reducir o evitar los efectos colaterales. Algunos lenguajes en este paradigma son LISP, Haskell, Prolog, SQL, Elixir, XPath, etc. De la programación reactiva se derivan paradigmas como el funcional, el lógico, reactivo o matemático.
Woh, no sabía cómo funcionaba Haskell jaja, algo curioso y MindBlow es que CSS es un lenguaje declarativo también porque se enfoca en el resultado, de hecho CSS es un lenguaje de query's porque usas selectores.
.
Y si hablamos de query's y lenguajes declarativos, también está SQL, ya que se enfoca en qué es lo que quieres obtener, no en cómo lo vas a obtener :D
:0000 me iluminaste el tema con el ejemplo de css xd no había entendido el paradigma declarativo
Jajaja es simple, a un lenguaje declarativo solo le dices qué quieres hacer, por ejemplo, con CSS tú le dices: "Seleccioname este elemento y ponle estos estilos", y CSS lo hará, ¿cómo lo hará? Eso no importa porque es un lenguaje declarativo :D
Grande Dross dando las mejores explicaciones de programacion 😎👍
Recuerde que el libro, Luna de Plutón, está siendo un éxito de ventas en todo el sistema solar. Por favor léelo, se que te va a encantar. (voz de Dross)
Se parece más a Zorman.
un buen ejemplo de Programación Declarativa e Imperativa :
Con este ejemplo todo me quedó más claro. ¡Gracias!
muy bueno
¿Cuáles son los principales paradigmas de programación?
Existen mas de 100 paradigmas distintos
Principales paradigmas
Imperativo
Por procedimientos
Orientado a objetos
Declarativo
Funcional
Lógico
Matemático
Reactivo
Dirigido por eventos
Programación imperativa
Ordenes directas de qué hacer
Enfocado al "Cómo"
Instrucciones paso a paso
Fortran, Java, C, Python, Ruby, PHP, etc.
Ejemplos
int total =0;for(int i =0; i <0; i++){ total++;printf("%i\", total)}
Resultado
>1>2>3>4>5>6>7>8>9
Programación declarativa
Se enfoca en el resultado
Reduce o elimina efectos colaterales
Prolog, LISP, Haskell, SQL, Elixir, XPath, Regex, etc.
Ejemplos
--Haskellsum[1..10]
Resultado
>551+2+3+4+5+6+7+8+9...
Muy buen resumen 👍👍
gracias
Solo una pequeña aclaración, el programa debe tener primero la salida (printf...) y luego la acumulación (total++), (respetando las instrucciones del ciclo for) para tener una salida de 0 - 9, de lo contrario tendremos salida de 1 - 10😢.
Es lo que estaba pensando yo también, si debería ser así
¿Qué son los paradigmas de programación?Paradigma imperativo
Los programas consisten en una sucesión de instrucciones o conjunto de sentencias, como si el programador diera órdenes concretas. El desarrollador describe en el código paso por paso todo lo que hará su programa.
Algunos lenguajes: Pascal, COBOL, FORTRAN, C, C++, etc.
Otros enfoques subordinados al paradigma de programación imperativa son:
Programación estructurada: La programación estructurada es un tipo de programación imperativa donde el flujo de control se define mediante bucles anidados, condicionales y subrutinas, en lugar de a través de GOTO.
_Programación procedimental: _Este paradigma de programación consiste en basarse en un número muy bajo de expresiones repetidas, englobarlas todas en un procedimiento o función y llamarlo cada vez que tenga que ejecutarse.
_Programación modular: _consiste en dividir un programa en módulos o subprogramas con el fin de hacerlo más manejable y legible. Se trata de una evolución de la programación estructurada para resolver problemas de programación más complejos.
Paradigma declarativo
Este paradigma no necesita definir algoritmos puesto que describe el problema en lugar de encontrar una solución al mismo. Este paradigma utiliza el principio del razonamiento lógico para responder a las preguntas o cuestiones consultadas.
Este paradigma a su vez se divide en dos:
Programación Lógica: Prolog
Programación funcional: Lisp, Scala, Java, Kotlin
Programación orientada a objetos
En este modelo de paradigma se construyen modelos de objetos que representan elementos (objetos) del problema a resolver, que tienen características y funciones. Permite separar los diferentes componentes de un programa, simplificando así su creación, depuración y posteriores mejoras. La programación orientada a objetos disminuye los errores y promociona la reutilización del código. Es una manera especial de programar, que se acerca de alguna manera a cómo expresaríamos las cosas en la vida real.
Podemos definir un objeto como una estructura abstracta que, de manera más fiable, describe un posible objeto del mundo real y su relación con el resto del mundo que lo rodea a través de interfaces. Ejemplos de lenguajes de programación orientados a objetos serían Java, Python o C#.
La programación orientada a objetos se sirve de diferentes conceptos como:
Abstracción de datos
Encapsulación
Eventos
Modularidad
Herencia
Polimorfismo
Programación reactiva
Este paradigma se basa en escuchar lo que emite un evento o cambios en el flujo de datos, en donde los objetos reaccionan a los valores que reciben de dicho cambio. Las librerías más conocidas son Project Reactor, y RxJava. React/Angular usan RxJs para hacer uso de la programación reactiva.
Excelente aporte, gracias!
Programación dirigida por eventos
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. Fuente: Programación dirigida por eventos
🤔 Tenemos paradigmas de programación: Imperativo, declarativo y dirigido por eventos.
PRINCIPALES PARADIGMAS DE PROGRAMACIÓN
imperativo:
por procedimientos: se enfoca en el como
orientado directamente en el “que hacer”
instruye del paso a paso.
orientado a objetos
Lenguajes: Fortran, Java, C, Python, Ruby, PHP, etc. orientado a objetos
declarativo: funcional, lógico, matemático, relativo
enfocado en el resultados
reduce o elimina efectos colaterales
lenguajes: Prolog, LISP, Haskell, SQL, Elixir, Xpath, Regex
La programación imperativa (del latín imperare = ordenar) es el paradigma de programación más antiguo. De acuerdo con este paradigma, un programa consiste en una secuencia claramente definida de instrucciones para un ordenador.
El código fuente de los lenguajes imperativos encadena instrucciones una detrás de otra que determinan lo que debe hacer el ordenador en cada momento para alcanzar un resultado deseado. Los valores utilizados en las variables se modifican durante la ejecución del programa. Para gestionar las instrucciones, se integran estructuras de control como bucles o estructuras anidadas en el código.
Los lenguajes de programación imperativa más conocidos son:
Fortran
Java
Pascal
ALGOL
C
C#
C++
Ensambladores
BASIC
COBOL
Python
Ruby
Los distintos lenguajes de programación imperativa pueden clasificarse a su vez en tres estilos distintos de programación subordinados: el estructurado, el procedimental y el modular.
El estilo estructurado de programación amplía el principio imperativo central con las estructuras concretas de control: secuencias, selección e iteración. Esto se hace para mitigar o evitar por completo las instrucciones de salto que añaden una complejidad innecesaria al código imperativo.
El enfoque procedimental divide las tareas de las que se debe ocupar un programa en tareas parciales más pequeñas que se describen en el código por separado. De esta forma, se crean principios básicos de programación que también se pueden reutilizar en otros programas.
Un paso más allá, en el modelo de programación modular, cada uno de los componentes de programa se diseñan, desarrollan y prueban con total independencia los unos de los otros. No es hasta el final del proceso cuando los módulos se combinan para conformar el software real.
Principales paradigmas:
Imperativo: .-Procedimientos .- Orientado a objetos
Órdenes directas de qué hacer, enfocado al cómo, instrucciones paso a paso. EJ: Fortrean, Python, Java.
Declarativo: .-Funcional .-Logico .- Matematico .-Reactivo
Se enfoca en resultados, reduce o elimina efectos colaterales, EJ: PROLOG,LISP HASKELL
No tenía clara la diferencia entre Imperativo y Declarativo.
Esta clase explica muchas cosas. :O
PARADIGMAS DE PROGRAMACIÓN
🔹 Imperativo → Paso a paso, sin abstracciones ni automatizaciones
suma_total =0# Variable inicializada manualmentenumero =1# Se define explícitamente antes del buclewhile numero <=10:# Iteración controlada sin automatización de rango suma_total += numero # Se suma manualmente cada número numero +=1# Se incrementa manualmenteprint(suma_total)# 55```✅ Inicialización manual: numero =1 se define explícitamente antes de entrar al bucle. ✅ Iteración controlada: numero +=1 se incrementa manualmente, sin abstracciones ocultas. ✅ Condición visible:while numero <=10 muestra claramente el criterio de finalización.✅ Define cada paso con total control sobre la ejecución. ✅ No usa funciones que oculten la lógica (sum(),range()). ✅ Mantiene la claridad sin ambigüedades.
🔹 Declarativo → Expresa el resultado sin especificar los pasos
```python
print(sum(range(1,11)))# 55print(max(range(1,11)))# 10print(min(range(1,11)))# 1print(list(map(lambda x: x**2,range(1,11))))# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]print(list(filter(lambda x: x %2==0,range(1,11))))# [2, 4, 6, 8, 10]```📌 Características clave del enfoque declarativo: ✅ Usa funciones como sum(),max(),min() para cálculos rápidos sin definir procesos manuales. ✅ map() transforma cada elemento de la lista sin escribir un bucle explícito. ✅ filter() selecciona ciertos elementos sin usar estructuras condicionales detalladas. ✅ Evita el uso de variables mutables y cambios de estado manuales.
🔹 Dirigido por eventos → Se ejecuta en respuesta a interacciones
```js
mport flet as ft
defboton_presionado(e):print("¡Botón clickeado!")defmain(pagina: ft.Page): boton = ft.ElevatedButton("Haz clic aquí", on_click=boton_presionado) pagina.add(boton)ft.app(target=main)```✅ Se ejecuta cuando ocurre un evento (clic del usuario). ✅ No define un flujo manual, sino que espera interacciones. ✅ Se usa en interfaces gráficas y sistemas interactivos.📌 Conclusión Los sistemas modernos combinan estos paradigmas para lograr eficiencia y flexibilidad. Imperativo da control total, declarativo simplifica cálculos con funciones avanzadas, funcional reduce repetición y evita la inicialización innecesaria de variables, y dirigido por eventos maneja la interacción de el usuario con la app.COMBINACIÓN DE PARADIGMA DE PROGRAMACIÓN (Lo actual)📌 Caso práctico: Simularemos una tienda en línea con productos. 🔹 Imperativo: Definimos paso a paso la ejecución y modificamos variables manualmente. 🔹 Declarativo: Usamos funciones que resumen cálculos (sum(),filter()). 🔹 Funcional: Aplicamos transformaciones con funciones puras (map(),reduce()). 🔹 Dirigido por eventos: La tienda responde a interacciones del usuario.
```python
from functools importreduce# Para aplicar operaciones funcionalesimport flet as ft # Para manejar la interacción con el usuario# 🔹 IMPERATIVO: Definimos una lista de productos con preciosproductos =[{"nombre":"Laptop","precio":800},{"nombre":"Mouse","precio":20},{"nombre":"Teclado","precio":50},{"nombre":"Monitor","precio":200},]# 🔹 FUNCIONAL: Aplicamos transformaciones para obtener lista de preciosprecios =list(map(lambda p: p["precio"], productos))# Extraemos preciostotal =reduce(lambda x, y: x + y, precios)# Sumamos los precios# 🔹 DECLARATIVO: Filtramos productos caros sin usar bucles explícitosproductos_caros =list(filter(lambda p: p["precio"]>100, productos))# 🔹 EVENTOS: Interfaz gráfica que responde a la interacción del usuariodefmostrar_total(e):print(f"Total de compra: ${total}")defmain(pagina: ft.Page): boton = ft.ElevatedButton("Calcular Total", on_click=mostrar_total) pagina.add(boton)ft.app(target=main)# Ejecutamos la app con eventos de usuario```📌 ¿Cómo se combinan los paradigmas? ✅ Imperativo: Se definen los productos manualmente en una lista. ✅ Funcional: Se aplican map() y reduce() para transformar datos sin modificar estados manuales. ✅ Declarativo:filter() selecciona productos sin escribir for. ✅ Eventos: Se usa flet para manejar la interacción del usuario en este caso con botones.🔥 El enfoque mixto crea un sistema eficiente y flexible, combinando la claridad del imperativo, la concisión del declarativo, la reutilización del funcional y la interactividad del dirigido por eventos. 
Gracias por esta explicación. Que buenos ejemplos
Entiendo que basicamente un paradigma imperativo es el como hacer algo mientras que el declarativo es el que hacer, mi pregunta es... el paradigma declarativo no termina siempre apoyandose en el imperativo?
Cuando se muestra la definición de la función sum en Haskell, creo que hay un error. En primer lugar, creo que el pattern mathing debería estar completo, considerando el caso de recibir una lista vacía, en el caso que sí considera, corríjanme si estoy mal, la lista, si se quiere describir como cabeza cola, debe ser (n:ns) en vez de la coma.
Es correcto, en este ejemplo estamos asumiendo que la parte de la lógica que mencionas ya está definida y solo estamos ejecutando la función sum con los argumentos del slide.
Los paradigmas imperativos se basan en órdenes directas paso a paso, centradas en cómo se va a hacer algo, son instrucciones. Ej: Fortran, Java, C, Python, etc.
Por otro lado, los paradigmas declarativos se enfocan en el resultado más allá del cómo, con la finalidad de reducir los efectos secundarios. Ej: Haskell, XPath, etc.
