martes, 29 de abril de 2014

Programación funcional

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 años 1930 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.
En la práctica, la diferencia entre una función matemática y la noción de una "función" utilizada en la programación imperativa es que las funciones imperativas pueden tener efectos secundarios, al cambiar el valor de cálculos realizados previamente. Por esta razón carecen de transparencia referencial, es decir, la misma expresión sintáctica puede resultar en valores diferentes en diferentes momentos dependiendo del estado del programa siendo ejecutado. Con código funcional, en contraste, el valor generado por una función depende exclusivamente de los argumentos alimentados a la función. Al eliminar los efectos secundarios se puede entender y predecir el comportamiento de un programa mucho más fácilmente, y esta es una de las principales motivaciones para utilizar la programación funcional.

Sistemas de tipos en lenguajes lógico-funcionales.

La programación lógico-funcional es un paradigma de programación declarativa muy expresivo, fruto de la combinación de la programación funcional y la programación lógica. Entre sus principales características destacan la posibilidad de de1nir funciones indeterministas, los patrones de orden superior y el uso de variables libres que se ligan a valores adecuados durante el cómputo. Desde el punto de vista de tipos, los sistemas lógico-funcionales han adoptado de manera directa el sistema de tipos de Damas-Milner, proveniente del ámbito funcional, debido a su sencillez y a la existencia de tipos principales y métodos efectivos para la inferencia de tipos. Sin embargo, esta adaptación directa no maneja adecuadamente algunas de las principales características de los lenguajes lógico-funcionales como los patrones de orden superior o las variables libres, dando lugar errores de tipos durante la evaluación. En esta tesis proponemos tres sistemas de tipos adecuados para la programación lógico-funcional cuyo objetivo es manejar correctamente estas características problemáticas desde el punto de vista de los tipos. Los sistemas de tipos propuestos, que tratan diferentes mecanismos de cómputos lógico funcionales (reescritura y estrechamiento), dan solución a los mencionados problemas, proporcionando resultados técnicos de corrección. Además, suponen un mejora sobre propuestas previas de sistemas de tipos para programación lógico-funcional, ya que salvan algunas de sus limitaciones. Aparte de los resultados teóricos, en esta tesis también se han desarrollado implementaciones de los sistemas de tipos, integrándolos como fase de comprobación de tipos en ramas del sistema lógico-funcional Toy.

Aplicación de Rutinas en Pseudocódigo en C++

Probablemente la mejor manera de comenzar a aprender un lenguaje de programación es escribir un programa.

// my first program in C++

#include <iostream>
using namespace std;

int main ()
{
  cout << "Hello World!";
  return 0;
}


// my first program in C++
Esta es una línea de comentario. Todas las líneas que comienzan con dos signos de barra (/ /) se consideran comentarios y no tienen ningún efecto en el comportamiento del programa. El programador puede utilizar para incluir breves explicaciones u observaciones dentro del propio código fuente.

# Include <iostream>
Las líneas que comienzan con una almohadilla (#) son directivas para el preprocesador. No son líneas de código con expresiones regulares, pero las indicaciones de preprocesador del compilador. En este caso, la directiva # include <iostream> dice al preprocesador para incluir el archivo iostream estándar. Este archivo específico (iostream) incluye las declaraciones de la biblioteca de sistema básico de entrada-salida estándar de C + +

using namespace std;
Todos los elementos del estándar de C + + biblioteca se declaran dentro de lo que se llama un espacio de nombres, el espacio de nombres con el nombre std. Así que con el fin de acceder a su funcionalidad, declaramos con esta expresión que vamos a utilizar estas entidades.

int main ()
Esta línea se corresponde con el principio de la definición de la función principal. La función principal es el punto por donde todos los programas en C + + comienzan su ejecución, independientemente de su ubicación dentro del código fuente.

cout << "Hello World!";
Esta línea es una declaración de C + +. Una declaración es una expresión simple o compuesto que en realidad puede producir algún efecto. De hecho, esta declaración lleva a cabo la única acción que genera un efecto visible en nuestro primer programa. ( cout es el nombre de la secuencia de salida estándar en C + +)
cout se declara en el archivo iostream estándar dentro del espacio de nombres std, así que por eso teníamos que incluir ese archivo específico y declarar que íbamos a utilizar este espacio de nombres específico a principios de nuestro código.
Tenga en cuenta que la declaración termina con un punto y coma (;). Este carácter se utiliza para marcar el final de la instrucción y de hecho debe ser incluida al final de todas las declaraciones de expresión en todos los programas en C + +

return 0;

La sentencia return hace que la función principal a fin. retorno puede ser seguido por un código de retorno (en nuestro ejemplo es seguido por el código de retorno con un valor de cero). Un código de retorno de 0 para la función principal es interpretado en general como el programa funcionó como se esperaba sin ningún error durante su ejecución. Esta es la forma más habitual de terminar un programa de consola C + +.

Programación funcional (Lenguajes)

Programa funcional
Concepto


La programación funcional es un paradigma de programación declarativas basado en la utilización de funciones aritméticaque 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 años 1930 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.

Caracteristicas


Los programas escritos en un lenguaje funcional están constituidos únicamente por definiciones de funciones, entendiendo éstas no como subprogramas clásicos de un lenguaje imperativo, sino como funciones puramente matemáticas, en las que se verifican ciertas propiedades como la transparencia referencial (el significado de una expresión depende únicamente del significado de sus su expresiones), y por tanto, la carencia total de colaterales.
Otras
 características propias de estos lenguajes son la no existencia de asignaciones de variables y la falta de construcciones estructuradas como la secuencia o la iteración (lo que obliga en la práctica a que todas las repeticiones de instrucciones se lleven a cabo por medio de funciones recursivas. Existen dos grandes categorías de lenguajes funcionales: los funcionales puros y los híbridos. La diferencia entre ambos estriba en que los lenguajes funcionales híbridos son menos dogmáticos que los puros, al admitir conceptos tomados de los lenguajes imperativos, como las secuencias de instrucciones o la asignación de variables. En contraste, los lenguajes funcionales puros tienen una mayor potencia expresiva, conservando a la vez su transparencia referencial, algo que no se cumple siempre con un lenguaje funcional híbrido.



Lenguajes



Lisp es un lenguaje tipo funcional, es el segundo lenguaje de alto nivel más viejo, los dialectos de Lisp más ampliamente conocidos son el Scheme y Common Lisp. El nombre Lisp viene de "LISt Processing" (Proceso de LIStas). Una de las estructuras de datos importante de Lisp son las listas encadenadas, el código fuente de lisp está compuesto de listas.

El lenguaje funcional Hope puede considerarse como una notación para escribir programas en forma de expresiones funcionales. Una expresión puede estar constituida por un conjunto de símbolos básicos como; "-,+, >, (, 2", etc.


CamelCase es un estilo de escritura que se aplica a frases o palabras compuestas. El nombre se debe a que las mayúsculas a lo largo de una palabra en CamelCase se asemejan a las jorobas de un camello. El nombre CamelCase se podría traducir como mayúsculas/minúsculas Camello. El término Case se traduce como "Caja tipográfica", que a su vez implica si una letra es mayúscula o minúscula y tiene su origen en la disposición de los tipos móviles en casilleros o cajas.

Erlang es un lenguaje funcional y de programación concurrente, fue diseñado por la compañía Ericsson con el propósito de hacer aplicaciones que puedan soportar fallos, funcionamiento ininterrumpido, aplicaciones distribuidas, entre otras cosas. Tiene una característica muy importante "el cambio de código en caliente" el cual se refiere a poder modificar el código aun cuando la aplicación está corriendo. Erlang no seguía la filosofía de código abierto hasta 1998 cuando Ericsson lo cedió como tal.

F# (pronunciado F Sharp) es un lenguaje de programación multiparadigma de código abierto,para la plataforma .NET, que conjunta la programación funcional con las disciplinas imperativa y orientada a objetos. Es una variante del lenguaje de programación ML y es compatible con la implementación Objetive Caml. F# fue inicialmente desarrollado por Don Syme de Microsoft Research, pero actualmente está siendo desarrollado por la División de Desarrolladores de Microsoft y es distribuido como un lenguaje totalmente soportado en la plataforma .NET y Visual Studio 2010, 2012 y 2013.

Unidad 2 R.A.2.1

Unidad 2
R.A.2.1
Elabora rutinas en pseudocódigo mediante recursividad para su aplicación, en lenguaje de programación.

a) Programación funcional

-Conceptos
-Características y lenguajes
-Lenguajes
*Lips
*Camel
*Hope
*Erlang
*F#(Funcional)

b) Programación funcional con recursividad

-Sistemas de tipos
-Modelos de evaluación
-Técnicas de programación recursiva
-Clase de tipos
-Aplicaciones en rutinas de pseudocódigos

2.1
*Desarrollo del programa...............................................45%
*Propuesta de solución....................................................35%
*Representación de resultado......................................10%
*Actitudes...............................................................................10%

Unidad de Aprendizaje 2

Unidad de aprendizaje
Desarrolla algoritmos con rutinas de programación de estructura.
                       
Resultado de aprendizaje
1.1 Diseña secuencias de pasos lógicas con herramientas de desarrollo, algoritmos para implementación de una situación a problemas dados.

Actividad de evaluación
Indicadores 1.1
Diseña y desarrollo, de algoritmos.................................................................45%
Presentación de solución................................................................................... 35%
Propuesta de resultados.....................................................................................10%
Actitudes................................................................................................................... 10%

Nota 
-Carpeta de evidencias
- Asistencia
- Blog de binas

- Previsiones por correo institucional


Resultado de aprendizaje

Unidad de aprendizaje
Desarrolla algoritmos con rutinas de programacion de estructura.

Resultado de aprendizaje
1.1 Diseña secuencias de pasos logicas con herramientas de desarrollo, algoritmos para implementacion de una situacion a problemas dados.

Actividad de evaluacion
Indicadores 1.1
Diseña y desarrollo, de algoritmos...................................................................45%
Presentacion de solucion.................................................................................... 35%
Propuesta de resultados .....................................................................................10%
Actitudes............................................................................................................ .......10%

Nota 
-Carpeta de evidencias
- Asistencia
- Blog de binas

- Previsiones por correo institucional

Ciclo del Sofware