TECNOLÓGICO DE ESTUDIOS

SUPERIORES DE COACALCO

Ingeniería en Sistemas Computacionales

Programación Lógica y Funcional

Profesor
Ovando Brito Luis Alberto

Grupo
3811

Alumno
Cruz Guzman Saúl Yael

“C1.1 Conceptos Fundamentales”

Resumen
El estilo de programación imperativa (es decir, la programación a través de acciones
que modifican el estado del computador) ha dominado el panorama de la
programación desde sus inicios; los lenguajes de más amplio uso están basados en
este paradigma: Fortran, e, C++, Pascal, Basic, etc. Una razón fundamental de este
dominio reside en que los lenguajes imperativos son más cercanos a la forma como
realmente funciona la máquina. Existen otros paradigmas de programación
diferentes al imperativo como la programación funcional y la programación lógica,
cuyo estudio, desarrollo y uso han estado principalmente restringidos al ámbito
académico. La programación funcional, es casi tan antigua como la imperativa; el
primer lenguaje funcional, LlSP, fue desarrollado en la misma época en la que se
desarrolló FORTRAN. Sin embargo, la programación funcional ha estado
tradicionalmente circunscrita a áreas de aplicación específicas como la inteligencia
artificial. A pesar de la hegemonía de la programación imperativa la programación
funcional cada vez toma más fuerza gracias a su capacidad expresiva, que permite
escribir programas más compactos, y a su transparencia referencial que posibilita
la sencilla verificación matemática de propiedades de los
Índice

Paradigmas o Estilos de Programación ............................................................ 4

Programación Imperativa. ................................................................................. 4
Programación estructurada. ............................................................................. 4
Programación procedural. ................................................................................ 4
Programación orientada a objetos. .................................................................. 4
Ejemplo de programación imperativa: ...............................................................4
Programación declarativa. .................................................................................4
Programación Funcional. ................................................................................. .5
Programación Lógica. ........................................................................................5
Evaluación de expresiones. ...............................................................................6
Tipos de expresiones. .......................................................................................10
Tipos de datos. ..................................................................................................10
Disciplina de tipos. .............................................................................................10
Pascal ................................................................................................................10
Ada ....................................................................................................................10
C ........................................................................................................................10
Java....................................................................................................................10
ML y Haskell .......................................................................................................10
Funciones. ........................................................................................................ ..10
Estilos De Programación

Estilo de programación (también llamado estándares de código o convención de

código) es un término que describe convenciones para escribir código fuente en
ciertos lenguajes de programación. El estilo de programación es frecuentemente
dependiente del lenguaje de programación que se haya elegido para escribir. Por
ejemplo el estilo del lenguaje de programación C variará con respecto al del lenguaje
BASIC. El buen estilo, al tratarse de algo subjetivo, es difícil de categorizar
concretamente; con todo, existen un número de características generales. Con el
advenimiento de software que da formato al código fuente de forma automática, el
foco en cómo éste debe de ser escrito debe evolucionar de forma más amplia a la
elección de nombres, lógica y otras técnicas. Desde un punto de vista práctico, el
uso de un computador para dar formato al código fuente ahorra tiempo, y es posible
forzar el uso de estándares a nivel de una compañía completa sin debates
religiosos.[1]

Tipos De Paradigmas De Programación

Programación Imperativa
La programación imperativa, en contraposición a la programación declarativa es un
paradigma de programación que describe la programación en términos del estado
del programa y sentencias que cambian dicho estado. Los programas imperativos
son un conjunto de instrucciones que le indican al computador cómo realizar una
tarea.

La implementación de hardware de la mayoría de computadores es imperativa;

prácticamente todo el hardware de los computadores está diseñado para ejecutar
código de máquina, que es nativo al computador, escrito en una forma imperativa.
Esto se debe a que el hardware de los computadores implementa el paradigma de
las Máquinas de Turing. Desde esta perspectiva de bajo nivel, el estilo del programa
está definido por los contenidos de la memoria, y las sentencias son instrucciones
en el lenguaje de máquina nativo del computador (por ejemplo, el lenguaje
ensamblador).

Los lenguajes imperativos de alto nivel usan variables y sentencias más complejas,
pero aún siguen el mismo paradigma. Los primeros lenguajes imperativos fueron
los lenguajes de máquina de los computadores originales. En estos lenguajes, las
instrucciones fueron muy simples, lo cual hizo la implementación de hardware fácil,
pero obstruyendo la creación de programas complejos. Fortran, cuyo desarrollo fue
iniciado en 1954 por John Backus en IBM, fue el primer gran lenguaje de
programación en superar los obstáculos presentados por el código de máquina en
la creación de programas complejos.
Programación lógica
La programación lógica consiste en la aplicación del corpus de conocimiento sobre
lógica para el diseño de lenguajes de programación; no debe confundirse con la
disciplina de la lógica computacional. La programación lógica es un tipo de
paradigmas de programación dentro del paradigma de programación declarativa. El
resto de los subparadigmas de programación dentro de la programación declarativa
son: programación funcional, programación basada en restricciones, programas
DSL (de dominio específico) e híbridos. La programación lógica gira en torno al
concepto de predicado, o relación entre elementos. La programación funcional se
basa en el concepto de función (que no es más que una evolución de los
predicados), de corte más matemático.

Programación funcional
En ciencias de la computación, la programación funcional es un paradigma de
programación declarativa basado en la utilización de funciones aritméticas que no
maneja datos mutables o de estado. Enfatiza la aplicación de funciones, en
contraste con el estilo de programación imperativa, que enfatiza los cambios de
estado. La programación funcional tiene sus raíces en el cálculo lambda, un sistema
formal desarrollado en los 1930s para investigar la definición de función, la
aplicación de las funciones y la recursión. Muchos lenguajes de programación
funcionales pueden ser vistos como elaboraciones del cálculo lambda.
Los lenguajes de programación funcional, especialmente los que son puramente
funcionales, han sido enfatizados en el ambiente académico principalmente y no
tanto en el desarrollo de software comercial. Sin embargo, lenguajes de
programación importantes tales como Scheme, Erlang, Objective Caml y Haskel,
han sido utilizados en aplicaciones comerciales e industriales por muchas
organizaciones. La programación funcional también es utilizada en la industria a
La programación funcional también puede ser desarrollada en lenguajes que no
están diseñados específicamente para la programación funcional. En el caso de
Perl, por ejemplo, que es un lenguaje de programación imperativo, existe un libro
que describe cómo aplicar conceptos de programación funcional. JavaScript, uno
de los lenguajes más ampliamente utilizados en la actualidad, también incorpora
capacidades de programación funcional.
Programación declarativa
La Programación Declarativa, es un paradigma de programación que está basado
en el desarrollo de programas especificando o “declarando” un conjunto de
condiciones, proposiciones, afirmaciones, restricciones, ecuaciones o
transformaciones que describen el problema y detallan su solución. La solución es
obtenida mediante mecanismos internos de control, sin especificar exactamente
cómo encontrarla (tan sólo se le indica a la computadora que es lo que se desea
obtener o que es lo que se está buscando). No existen asignaciones destructivas, y
las variables son utilizadas con Transparencia referencial

Programación estructurada
La programación estructurada es una forma de escribir programas de ordenador
(programación de computadora) de manera clara. Para ello utiliza únicamente tres
estructuras: secuencia, selección e iteración; siendo innecesario el uso de la
instrucción o instrucciones de transferencia incondicional (GOTO, EXIT FUNCTION,
EXIT SUB o múltiples RETURN).

Evaluación De Expresiones

Una expresión es una combinación de operadores y operandos de cuya evaluación

se obtiene un valor. Los operandos pueden ser nombres que denoten objetos
variables o constantes, funciones, literales de cualquier tipo adecuado de acuerdo
con los operadores u otras expresiones más simples. La evaluación de una
expresión da lugar a un valor de algún tipo, una expresión se dice que es del tipo
de su resultado. Ejemplos de expresiones:

a + 5*b
(a >= 0) and ((b+5) > 10)
a
-a * 2 + b
-b + sqrt(b**2 – 4*a*c)
length(s) > 0
Las expresiones se evalúan de acuerdo con la precedencia de los operadores. Ante
una secuencia de operadores de igual precedencia, la evaluación se realiza según
el orden de escritura, de izquierda a derecha. El orden de evaluación puede
modificarse usando paréntesis.

Tipos de expresiones

Dentro de las expresiones distinguimos dos clases según el tipo de datos que
devuelven al evaluarlas:

Aritméticas: las que devuelven un valor numérico

Lógicas: las que devuelven true o false

Las expresiones se utilizan fundamentalmente en las asignaciones y en las partes

condicionales de las sentencias if, while y repeat.[2]
Definición De Funciones

Las funciones se crearon para evitar tener que repetir constantemente fragmentos
de código. Una función podría considerarse como una variable que encierra código
dentro de sí. Por lo tanto cuando accedemos a dicha variable (la función) en realidad
lo que estamos es diciendo al programa que ejecute un determinado código
predefinido anteriormente.

Todos los lenguajes de programación tienen algunos elementos de formación

primitivos para la descripción de los datos y de los procesos o transformaciones
aplicadas a estos datos (tal como la suma de dos números o la selección de un
elemento que forma parte de una colección). Estos elementos primitivos son
definidos por reglas sintácticas y semánticas que describen su estructura y
significado respectivamente.[3]

Disciplina De Tipos.

“Los tipos se infieren, es decir se comprueban, de forma estática, en tiempo de

compilación.”

En los lenguajes de programación con disciplina de tipos, cada tipo representa una
colección de valores o datos similares. El conocer los tipos de las funciones ayuda
a documentar los programas y evitar errores en tiempo de ejecución.

Un lenguaje tiene disciplina de tipos si los errores de tipos se detectan siempre ⇒

es necesario determinar los tipos de todos los operandos, ya sea en tiempo de
compilación o de ejecución.
 Pascal
 Cercano a tener disciplina de tipos pero no realiza comprobación de tipos en los
registros variantes (incluso puede omitirse la etiqueta discriminatoria en dichos
registros)
 Ada
 Resuelve el problema de los registros variantes realizando comprobación dinámica
de tipos (sólo en este caso)
 Tiene una función de biblioteca que permite extraer un valor de una variable de
cualquier tipo (como una cadena de bits) y usarlo como un tipo diferente (no es una
conversión de tipos) ⇒ se trata de una suspensión temporal de la comprobación de
tipos
 C
 No tiene disciplina de tipos por:

− No se realiza comprobación de tipos sobre las uniones

− Permite funciones con parámetros sobre los que no se realiza comprobación de

tipos

 Java
 Tiene disciplina de tipos (no hay uniones)

 ML y Haskell

 Poseen disciplina de tipos

 Los tipos de los parámetros de las funciones (y de estas mismas) se conocen en
tiempo de compilación (ya sea por declaración del usuario o por inferencia de
tipos)Haskell y otros lenguajes funcionales utilizan el sistema de tipos de Milner, que
tiene dos características fundamentales:

 Disciplina estática de tipos: Los programas bien tipados se pueden conocer en
tiempo de compilación. Un programa bien tipado se puede utilizar sin efectuar
comprobaciones de tipo en tiempo de ejecución, estando garantizado que no se
producirán errores de tipo durante el computo.
 Polimorfismo: Permite que una misma función se pueda aplicar a parámetros de
diferentes tipos, dependiendo del contexto en el que la función se utilice.[4]
Tipos De Datos

En lenguajes de programación un tipo de dato es un atributo de una parte de los

datos que indica al ordenador (y/o al programador) algo sobre la clase de datos
sobre los que se va a procesar.

En un sentido amplio, un tipo de datos define un conjunto de valores y las

operaciones sobre estos valores. Casi todos los lenguajes de programación
explícitamente incluyen la notación del tipo de datos, aunque lenguajes diferentes
pueden usar terminología diferente. La mayor parte de los lenguajes de
programación permiten al programador definir tipos de datos adicionales,
normalmente combinando múltiples elementos de otros tipos y definiendo las
operaciones del nuevo tipo de dato. Por ejemplo, un programador puede crear un
nuevo tipo de dato llamado “Persona” que especifica que el dato interpretado como
Persona incluirá un nombre y una fecha de nacimiento.
Un tipo de dato entero en computación es un tipo de dato que puede representar un
subconjunto finito de los números enteros. El número mayor que puede representar
depende del tamaño del espacio usado por el dato y la posibilidad (o no) de
representar números negativos. Los tipos de dato entero disponibles y su tamaño
dependen del lenguaje de programación usado así como la arquitectura en cuestión.
Por ejemplo, si para almacenar un número entero disponemos de 4 bytes de
memoria tememos que:4 Bytes = 4×8 = 32 bits Con 32 bits se pueden representar
232=4294967296 valores: Sólo positivos: del 0 al 4294967295 Positivos y
negativos: del -2147483648 al 2147483647.

[1]http://itpn.mx/recursosisc/8semestre/programacionlogicayfuncional/Unidad%20I.
pdf

[2] http://programacionlogicafun.blogspot.mx/2014/02/12-evaluacion-de-
expresiones.html

[3] http://karlaprogramacionfuncional.blogspot.mx/2014/02/unidad-1-conceptos-
fundamentales.html

[4]https://programacionlogicayfuncional.wordpress.com/2014/02/13/disciplina-de-
tipos/