Clojure - Historial de revisiones

Rosarino: corrijo

2016-05-28T23:20:17Z

corrijo

UnionReyes2 jc: /* Ejemplos de código */

2015-06-26T12:58:03Z

‎Ejemplos de código

UnionReyes2 jc en 12:54 26 jun 2015

2015-06-26T12:54:26Z

UnionReyes2 jc en 12:44 26 jun 2015

2015-06-26T12:44:18Z

UnionReyes2 jc en 12:30 26 jun 2015

2015-06-26T12:30:46Z

UnionReyes2 jc en 12:29 26 jun 2015

2015-06-26T12:29:27Z

UnionReyes2 jc en 14:14 18 jun 2015

2015-06-18T14:14:40Z

UnionReyes2 jc en 14:11 18 jun 2015

2015-06-18T14:11:19Z

UnionReyes2 jc en 14:06 18 jun 2015

2015-06-18T14:06:16Z

UnionReyes2 jc: /* Principios */

2015-06-18T13:47:34Z

‎Principios

@@ Línea 1: / Línea 1: @@
 {{Definición
 |nombre= Clojure
 |imagen= clojure.png
-|concepto= Lenguaje de [[Programación funcional]] de la familia [[Lisp]].
+<div align=justify>
-}}
+'''Clojure''' (pronunciado [cloushur]), es un dialecto del lenguaje de programación [[Lisp]]. Es un lenguaje de propósito general que ofrece un estilo de [[programación interactiva]] y que incentiva una forma de programar funcional, simplificando así la [[programación concurrente]]. Clojure puede ejecutarse tanto en la [[máquina virtual de Java|máquina virtual Java]] (JVM) como en la máquina virtual de la plataforma .Net, e incluso se puede compilar hacia [[Javascript]].
 ==Principios==
-[[Rich Hickey]] crea el lenguaje Clojure en el año 2007, describe el desarrollo de este lenguaje  como la búsqueda de un lenguaje que no pudo encontrar: un lisp funcional por defecto, integrado sobre un entorno robusto en lugar de ser su propia plataforma, y con la programación concurrente en mente.
+[[Rich Hickey]] creó el lenguaje Clojure en el año 2007. Describe el desarrollo de este lenguaje como la búsqueda de un lenguaje que no pudo encontrar: un lisp funcional por defecto, integrado sobre un entorno robusto en lugar de ser su propia plataforma, y con la programación concurrente en mente.
 Asimismo, en principio se rechaza la orientación a objetos, ofreciendo un enfoque en el que los programas se expresan como la aplicación de funciones sobre datos, más que como la interacción entre entidades mutables que mezclan representación de datos, y comportamiento. Por otra parte, características tales como instanciabilidad, [[Polimorfismo (Informática)|Polimorfismo]] e [[interfaces]] son efectivamente parte del lenguaje.
 ==Sintaxis==
 La sintaxis de Clojure se basa en S-expresiones (estructuras de datos basadas en listas) que son parseadas y posteriormente compiladas. Soporta sintaxis literal para listas (), vectores [], mapas {} y conjuntos #{}. Es un Lisp-1 soporta usar funciones en variables como una función normal pero no es compatible en código con otros dialectos de Lisp.
@@ Línea 22: / Línea 22: @@
 *Función elevar al cuadrado
- (defn square [x] (* x x))
+(defn square [x] (* x x)).
 *Factorial recursivo
-   (defn fact [n]
+(defn fact [n]
-     (if (> n 1)
+(if (> n 1).
-         (* n (fact (dec n)))
+(* n (fact (dec n))).
-))
+)).
-*Factorial con loop (Falso recursivo)
+*Factorial con loop (Falso recursivo).
-      (defn fact [n]
+(defn fact [n]
-       (loop [current 2 accum 1]
+(loop [current 2 accum 1]
-         (if (< current n)
+(if (< current n).
-             (recur (inc current) (* accum current))
+(recur (inc current) (* accum current)).
-                 (* accum current))))
+(* accum current)))).
 *Factorial con reduce
-        (defn fact [n] (reduce * (range 2 n)))
+(defn fact [n] (reduce * (range 2 n))).
 *Interoperabilidad con Java
-     (javax.swing.JOptionPane/showMessageDialog nil "Hello World")
+(javax.swing.JOptionPane/showMessageDialog nil "Hello World").
 *Un generador de números únicos y consecutivos que soporta llamadas concurrentes
-     (let [i (atom 0)]
+(let [i (atom 0)]
-       (defn generar-id-unica
+(defn generar-id-unica
-          "Devuelve un identificador numérico distinto para cada llamada."
+"Devuelve un identificador numérico distinto para cada llamada."
-             []
+[]
-            (swap! i inc)))
+(swap! i inc))).
 ==Características de Clojure==
 *'''Simplicidad''': En Clojure hay un conjunto de componentes básicos(tipos de datos, estructuras de control, funciones ofrecidas por el lenguaje) apropiado para un lenguaje que ofrece soporte al paradigma de programación funcional . Al ser Clojure un dialecto de [[Lisp]] es un poco más simple que este y ofrece una sintaxis un poco más concisa.
 *'''Ortogonalidad''': Clojure es un lenguaje que posee una alta ortogonalidad debido a que con el conjunto de constructores primitivos, se pueden combinar de una gran cantidad de formas y así construir estructuras de control y de datos más complejas. La ortogonalidad manejada por este lenguaje afecta positivamente a la legibilidad por su grado de regularidad.
-*'''Tipos de Datos''':  En el paradigma funcional los programas manipulan los datos. Básicamente, Clojure soporta Números, Strings, Caracteres, Palabras claves, Símbolos y Colecciones. Además de estas colecciones, el lenguaje también ofrece la posibilidad de importar colecciones y clases desde [[Java]].
+*'''Tipos de datos''': En el paradigma funcional los programas manipulan los datos. Básicamente, Clojure es compatible con números, strings, caracteres, palabras claves, símbolos y colecciones. Además de estas colecciones, el lenguaje también ofrece la posibilidad de importar colecciones y clases desde [[Java (lenguaje de programación)|Java]].
 *'''Soporte para la abstracción''': Clojure mediante las colecciones permite crear nuevos tipos de datos con los cuales se puede modelar de una mejor manera la realidad que se intenta reflejar en el código.
@@ Línea 56: / Línea 57: @@
 *'''Expresividad''': La expresividad del lenguaje es sumamente alta debido a que hay operadores muy poderosos que permiten que permiten lograr mucho cálculo con pocas líneas de código. Esto se le atribuye a la naturalidad con que se expresa este paradigma funcional.
-*'''Chequeo de tipos''': Durante la fase en la que el Reader lee el código fuente para traducirlo a las estructuras de datos, se hace un chequeo de tipos para que los tipos de datos coincidan con los esperados  por las funciones y expresiones a evaluar. Las expresiones no válidas generan un “error de lectura” , con lo que se muestra un mensaje de error apropiado y se aborta el programa. En la segunda fase se evalúan las expresiones y sus valores de retorno. El código es compilado a bytecode, y se ejecuta sobre la [[JVM]](Máquina Virtual de Java). Este punto afecta positivamente la confiabilidad del lenguaje, ya que el chequeo de tipos que realiza el lenguaje es riguroso.
+*'''Chequeo de tipos''': Durante la fase en la que el Reader lee el código fuente para traducirlo a las estructuras de datos, se hace un chequeo de tipos para que los tipos de datos coincidan con los esperados por las funciones y expresiones a evaluar. Las expresiones no válidas generan un “error de lectura”, con lo que se muestra un mensaje de error apropiado y se aborta el programa. En la segunda fase se evalúan las expresiones y sus valores de retorno. El código es compilado a bytecode, y se ejecuta sobre la [[JVM]] (máquina virtual Java). Este punto afecta positivamente la confiabilidad del lenguaje, ya que el chequeo de tipos que realiza el lenguaje es riguroso.
-*'''Manejo de excepciones''': En Clojure el manejo de excepciones es muy similar a Java, pero está mucho más simplificado. Provee mecanismos que hacen que no sea tan necesario capturar explícitamente las excepciones que se generan en tiempo de ejecución, a menos que sea sumamente necesario. No se necesita capturar las excepciones explícitamente en Clojure  Se pueden utilizar las macros with-open que ofrecen una funcionalidad similar al finally en [[Java]], que garantizan que después de utilizar un recurso, por más que se genere una excepción, el recurso sea borrado o cerrado (internamente , la macro genera una estructura try y la atiende de ser necesario) Esta característica del lenguaje afecta positivamente su Confiabilidad, ya que el programador no tiene que estar tan pendiente de atender explícitamente al manejo de excepciones y a los errores que pueden ocurrir en la ejecución.
+*'''Manejo de excepciones''': En Clojure el manejo de excepciones es muy similar a Java, pero está mucho más simplificado. Provee mecanismos que hacen que no sea tan necesario capturar explícitamente las excepciones que se generan en tiempo de ejecución, a menos que sea sumamente necesario. No se necesita capturar las excepciones explícitamente en Clojure Se pueden utilizar las macros with-open que ofrecen una funcionalidad similar al finally en [[Java]], que garantizan que después de utilizar un recurso, por más que se genere una excepción, el recurso sea borrado o cerrado (internamente, la macro genera una estructura try y la atiende de ser necesario) Esta característica del lenguaje afecta positivamente su Confiabilidad, ya que el programador no tiene que estar tan pendiente de atender explícitamente al manejo de excepciones y a los errores que pueden ocurrir en la ejecución.
-*'''Concurrencia''':  Como técnicas de Clojure para el soporte de concurrencia se puede incluir a los agentes, que realizan las acciones de manejo de estado y manejo de ejecución. Como las variables son tratadas como trataría cualquier lenguaje a una constante, es decir, permanecen inmutables, es ahí donde entra en acción el manejo de estados ya que poco podríamos modelar si no podríamos modificar las variables. En el manejo de estados lo que realiza el agente es, como todos los elementos internamente los trata como secuencias, si necesitamos eliminar o insertar datos en una variable, crea una nueva variable y los enlaza o los borra temporalmente. En el manejo de ejecución, los agentes son los que dan ejecución, pausa o muerte a los subprogramas, y su propósito es, obviamente, la concurrencia pero con un aprovechamiento eficiente de los procesadores por lo cual requiere de la JVM para no solo saber cuántos procesadores hay sino los costos de los accesos remotos a los recursos.
+*'''Concurrencia''': Como técnicas de Clojure para el soporte de concurrencia se puede incluir a los agentes, que realizan las acciones de manejo de estado y manejo de ejecución. Como las variables son tratadas como trataría cualquier lenguaje a una constante, es decir, permanecen inmutables, es ahí donde entra en acción el manejo de estados ya que poco podríamos modelar si no podríamos modificar las variables. En el manejo de estados lo que realiza el agente es, como todos los elementos internamente los trata como secuencias, si necesitamos eliminar o insertar datos en una variable, crea una nueva variable y los enlaza o los borra temporalmente. En el manejo de ejecución, los agentes son los que dan ejecución, pausa o muerte a los subprogramas, y su propósito es, obviamente, la concurrencia pero con un aprovechamiento eficiente de los procesadores por lo cual requiere de la JVM para no solo saber cuántos procesadores hay sino los costos de los accesos remotos a los recursos.
 ==Ventajas de Clojure sobre otros lenguajes ==
@@ Línea 68: / Línea 69: @@
 *Recursión BIEN implementada.
-*Tiene una REPL(read eval print loop), desarrollo dinámico con una consola de evaluación.
+*Tiene una REPL (read eval print loop), desarrollo dinámico con una consola de evaluación.
 *Las funciones son objetos de primera clase.
 *Listas perezosas (se puede tener programados TODOS los números naturales sin ningún problema de memoria).
@@ Línea 92: / Línea 93: @@
 *[http://es.slideshare.net/fontanemmanuel/trabajo-prctico-sobre-clojure-evaluacin-de-un-lenguaje-de-programacin Trabajo Práctico sobre Clojure]
-[[Category:Programación]][[Category:Informática]]
+[[Categoría: Programación]]
-[[Category:Lenguajes_de_programación_orientada_a_objetos]]
+[[Categoría: Informática]]

@@ Línea 22: / Línea 22: @@
 *Función elevar al cuadrado
-.	(defn square [x] (* x x))
+ (defn square [x] (* x x))
 *Factorial recursivo
-.	(defn fact [n]
+   (defn fact [n]
-.	  (if (> n 1)
+     (if (> n 1)
-.	      (* n (fact (dec n)))
+         (* n (fact (dec n)))
-.	      1))
+))
 *Factorial con loop (Falso recursivo)
-.	(defn fact [n]
+      (defn fact [n]
-.	  (loop [current 2 accum 1]
+       (loop [current 2 accum 1]
-.	    (if (< current n)
+         (if (< current n)
-.	        (recur (inc current) (* accum current))
+             (recur (inc current) (* accum current))
-.	        (* accum current))))
+                 (* accum current))))
 *Factorial con reduce
-.	(defn fact [n] (reduce * (range 2 n)))
+        (defn fact [n] (reduce * (range 2 n)))
 *Interoperabilidad con Java
-.	(javax.swing.JOptionPane/showMessageDialog nil "Hello World")
+     (javax.swing.JOptionPane/showMessageDialog nil "Hello World")
 *Un generador de números únicos y consecutivos que soporta llamadas concurrentes
-(let [i (atom 0)]
+     (let [i (atom 0)]
-.	  (defn generar-id-unica
+       (defn generar-id-unica
-.	    "Devuelve un identificador numérico distinto para cada llamada."
+          "Devuelve un identificador numérico distinto para cada llamada."
-.	    []
+             []
-.	    (swap! i inc)))
+            (swap! i inc)))
 ==Características de Clojure==

@@ Línea 18: / Línea 18: @@
 ==Sintaxis==
 La sintaxis de Clojure se basa en S-expresiones (estructuras de datos basadas en listas) que son parseadas y posteriormente compiladas. Soporta sintaxis literal para listas (), vectores [], mapas {} y conjuntos #{}. Es un Lisp-1 soporta usar funciones en variables como una función normal pero no es compatible en código con otros dialectos de Lisp.
 ==Características de Clojure==

← Revisión anterior		Revisión del 12:44 26 jun 2015
Línea 66:		Línea 66:
	*[http://es.slideshare.net/fontanemmanuel/trabajo-prctico-sobre-clojure-evaluacin-de-un-lenguaje-de-programacin Trabajo Práctico sobre Clojure]		*[http://es.slideshare.net/fontanemmanuel/trabajo-prctico-sobre-clojure-evaluacin-de-un-lenguaje-de-programacin Trabajo Práctico sobre Clojure]

−	[[Category:Programación ]]	+	[[Category:Programación]][[Category:Informática]]
		+	[[Category:Lenguajes_de_programación_orientada_a_objetos]]

@@ Línea 12: / Línea 12: @@
 ==Principios==
-[[Rich Hickey]] crea el lenguaje Clojure en el año 2007, describe el desarrollo de este lenguaje  como la búsqueda de un lenguaje que no pudo encontrar: un lisp funcional por defecto, integrado sobre un entorno robusto en lugar de ser su propia plataforma, y con la [[Programación Concurrente]] en mente.
+[[Rich Hickey]] crea el lenguaje Clojure en el año 2007, describe el desarrollo de este lenguaje  como la búsqueda de un lenguaje que no pudo encontrar: un lisp funcional por defecto, integrado sobre un entorno robusto en lugar de ser su propia plataforma, y con la programación concurrente en mente.
 Asimismo, en principio se rechaza la orientación a objetos, ofreciendo un enfoque en el que los programas se expresan como la aplicación de funciones sobre datos, más que como la interacción entre entidades mutables que mezclan representación de datos, y comportamiento. Por otra parte, características tales como instanciabilidad, [[Polimorfismo (Informática)|Polimorfismo]] e [[interfaces]] son efectivamente parte del lenguaje.

@@ Línea 8: / Línea 8: @@
 }}
-<div align=justify>'''Clojure''' (pronunciado “cloushur”), es un dialecto del lenguaje de programación [[Lisp]]. Es un lenguaje de propósito general que ofrece un estilo de [[programación interactiva]] y que incentiva una forma de programar funcional, simplificando así la [[Programación Concurrente]]. Clojure puede ejecutarse tanto en la [[Máquina virtual de java]] (JVM) como en la máquina virtual de la plataforma .Net, e incluso se puede compilar hacia [[Javascript]].
+<div align=justify>'''Clojure''' (pronunciado “cloushur”), es un dialecto del lenguaje de programación [[Lisp]]. Es un lenguaje de propósito general que ofrece un estilo de [[Programación Interactiva]] y que incentiva una forma de programar funcional, simplificando así la [[Programación Concurrente]]. Clojure puede ejecutarse tanto en la [[Máquina virtual de java]] (JVM) como en la máquina virtual de la plataforma .Net, e incluso se puede compilar hacia [[Javascript]].
 ==Principios==