Date: Thu, 10 Dec 2009 04:43:49 +0000 (+0100) Subject: Release Candidate 1 :) X-Git-Url: http://slack.codemaniacs.com/git/?a=commitdiff_plain;h=5638a961037b95b2b284ed9c11a8dcec62f56cc6;p=clojure-slides.git Release Candidate 1 :) --- diff --git a/clojure-slides.xhtml b/clojure-slides.xhtml index 9ced9ae..d02dfdb 100755 --- a/clojure-slides.xhtml +++ b/clojure-slides.xhtml @@ -14,8 +14,15 @@ + .Comment { color: #00ffff; font-weight: bold; } + .Constant { color: #ff40ff; font-weight: bold; } + .Statement { color: #009000; font-weight: bold; } + .Identifier { color: #8080ff; font-weight: bold; } + pre.source { font-family: monospace; color: #000000; background-color: #f9f9f9; } + .Special { color: #ff6060; font-weight: bold; } + .PreProc { color: #8080ff; font-weight: bold; } + .Type { color: #2e8b57; font-weight: bold; } +

@@ -23,12 +30,130 @@

-
-

Clojure

Jorge 'slack' Gorbe

slack@codemaniacs.com

+
+

+ + Clojure +

Jorge 'slack' Gorbe

slack@codemaniacs.com

C++ mola, Â¿por quÃ© no te gusta?

Montones de cosas que se intentan resolver en otros lenguajes: +
- No hay tipo string (y mejor no hablamos de Unicode)
- No hay sistema de mÃ³dulos (inclusion de cabeceras via preprocesador)
- etc
+
Pero si fuera sÃ³lo por esas cosas estarÃa usando C# +
- ...es mÃ¡s, gran parte de lo que voy a contar sobre programaciÃ³n + funcional estÃ¡ entrando poco a poco en C# y encima VS 2010 va a soportar + F# (una especie de Ocaml.NET) de serie...
+
Boilerplate

"In computer programming, boilerplate is the term used to describe + sections of code that have to be included in many places with little or no + alteration. It is more often used when referring to languages which are + considered verbose, i.e. the programmer must write a lot of code to do + minimal jobs."

+ http://en.wikipedia.org/wiki/Boilerplate_%28text%29#Boilerplate_code +

+ +

C++ mola, Â¿por quÃ© no te gusta?

No hay funciones anÃ³nimas => es incÃ³modo usar funciones de orden superior

Ejemplo: comprobar si todos los elementos de una colecciÃ³n son iguales a 0 +

A piÃ±Ã³n, repeticiÃ³n de cÃ³digo, error-prone, etc (ejemplo con C++0x): +

bool iguales=true;
+for (auto i=c.begin(); i!=c.end(); ++i) {
+    if (*i != 0) iguales=false;
+}

Boilerplate a montones si se usan functores (y este ejemplo + ni siquiera compilarÃa tal cual :P) +

// funcion definida en alguna parte
+bool es_distinto_de_0(T i) { return (i != 0); }
+
+// Y luego en el cÃ³digo...
+bool iguales = (c.end() == std::find_if(c.begin(), c.end(), es_distinto_de_0));
+

Usando funciones anÃ³nimas en Clojure +
```
(def iguales (every? #(= 0 %1) c))
```
+

+ +

C++ mola, Â¿por quÃ© no te gusta?

Falta un buen sistema de macros
Esta carencia se combate tradicionalmente a base de patrones de diseÃ±o
Algunos los consideran seÃ±al de madurez, otros los consideran una seÃ±al de alarma:
+
+
+ "When I see patterns in my programs, I consider it a sign of trouble. The + shape of a program should reflect only the problem it needs to solve. Any + other regularity in the code is a sign, to me at least, that I'm using + abstractions that aren't powerful enough - often that I'm generating by + hand the expansions of some macro that I need to write." +
+ -- Paul Graham +
+

+ +

C++ mola, Â¿por quÃ© no te gusta?

Falta un buen sistema de macros para extender el lenguaje
Si pensamos en metaprogramar, es MUY fÃ¡cil acabar con una mezcla + ilegible de macros y templates

Quien no me crea, que se lea boost/foreach.hpp +

// 800 lÃneas (literalmente) de definiciones despuÃ©s...
+#define BOOST_FOREACH(VAR, COL)                                                               \
+  BOOST_FOREACH_PREAMBLE()                                                                    \
+  if (boost::foreach_detail_::auto_any_t _foreach_col = BOOST_FOREACH_CONTAIN(COL)) {} else   \
+  if (boost::foreach_detail_::auto_any_t _foreach_cur = BOOST_FOREACH_BEGIN(COL)) {} else     \
+  if (boost::foreach_detail_::auto_any_t _foreach_end = BOOST_FOREACH_END(COL)) {} else       \
+  for (bool _foreach_continue = true;                                                         \
+            _foreach_continue && !BOOST_FOREACH_DONE(COL);                                    \
+            _foreach_continue ? BOOST_FOREACH_NEXT(COL) : (void)0)                            \
+      if  (boost::foreach_detail_::set_false(_foreach_continue)) {} else                      \
+      for (VAR = BOOST_FOREACH_DEREF(COL); !_foreach_continue; _foreach_continue = true)
+#endif
+

+ + +

Es mas... Â¿por quÃ© creemos que la OOP es la panacea?

Alexander Stepanov (coautor de la STL) dijo una vez:

I find OOP technically unsound. It attempts to decompose the world in + terms of interfaces that vary on a single type. To deal with the real + problems you need multisorted algebras - families of interfaces that span + multiple types.
I find OOP philosophically unsound. It claims that everything is an + object. Even if it is true it is not very interesting - saying that + everything is an object is saying nothing at all.

Â¿QuÃ© es Clojure?

Cuatro grandes ideas:

@@ -62,7 +187,11 @@

Clojure corre en la JVM

Compila a bytecode -
- Eficiente... relativamente ;-)
+
- Eficiente... relativamente ;-)
- Es tan rÃ¡pido como Java si se utilizan type hints para evitar + usar la introspecciÃ³n en momentos crÃticos
Los tipos bÃ¡sicos son los de Java
- java.lang.String, java.lang.Integer...
@@ -103,7 +232,17 @@
El cÃ³digo funcional puro es concurrente per se
- No hay estado mutable, por lo tanto no hay condiciones de carrera
El acceso al estado mutable se puede controlar mediante transacciones o "agentes"
Primitivas novedosas para controlar el acceso al estado mutable: +
- Software Transactional Memory: implementa actualizaciones sÃncronas + transaccionales a referencias a objetos mutables. +
- Agentes: guardan el acceso a una referencia y la actualizan de forma asÃncrona + a medida que extraen mensajes de una cola. +
  - (nombre desafortunado, nada que ver con IA!)
  +
+

@@ -118,6 +257,7 @@

Cadenas: "Hola, mundo"

Regex: #"patron" es un objeto de tipo java.util.regex.Pattern

Keywords: :cosa

SÃmbolos: cosa

Booleanos: true,false

@@ -134,17 +274,14 @@

Vectores: [1 2 3 4]

Acceso aleatorio: -
- (def v [1 2 3 4]) (v 0) => 1
-
Acceso aleatorio:
InserciÃ³n eficiente al final. Â¡Ojo! No son arrays

(def v [1 2 3 4])
(v 0)   => 1

Diccionarios: {:a 1, :b 2} -

({:a 1, :b 2} :b) => 2
({:a 1, :b 2} :x) => nil

({:a 1, :b 2} :b)   => 2
+({:a 1, :b 2} :x)   => nil

Conjuntos: #{1 2 :a "blah"}

@@ -153,7 +290,11 @@

Programas = Estructuras de datos

Una lista no vacÃa se considera una llamada a una funciÃ³n, a una forma especial o a una macro
Una lista no vacÃa se considera una llamada a una funciÃ³n, a una forma especial o a una macro +
- Llamada a funcion: (func arg1 arg2 ... argn)
+
Las formas especiales son excepciones a la norma de evaluaciÃ³n de funciones (primero argumentos, luego llamada)
- (def name val): crea una variable global

Es mas... Â¿por quÃ© creemos que la OOP es la panacea?

Alexander Stepanov (coautor de la STL) dijo una vez:

Lazy sequences

Clojure permite trabajar con secuencias que se evalÃºan de forma perezosa

Esto permite, por ejemplo, trabajar con secuencias infinitas +

user=> (def naturals (iterate inc 0))
+#'user/naturals
+user=> (take 10 naturals)
+(0 1 2 3 4 5 6 7 8 9)

...sin evaluarlas mientras no haga falta... +

user=> (def zeros (cycle '(0)))
+#'user/zeros
+user=> (take 10 (interleave naturals zeros))
+(0 0 1 0 2 0 3 0 4 0)
+

Hay muchas cosas seq-ables: +
- Listas, vectores, maps, colecciones Java, ficheros (por lÃneas), Ã¡rboles XML,...
+

+ + +

MultimÃ©todos

El polimorfismo estÃ¡ndar en la OOP realiza el dispatch de un mÃ©todo basÃ¡ndose + Ãºnicamente en el tipo en ejecuciÃ³n del objeto

Ejemplo tÃpico: +

struct Animal { virtual void encounter(Animal& other) = 0; }
+
+struct Lion : Animal {
+    void encounter(Animal& other) {
+        if (Lion* lion = dynamic_cast<Lion*>(&other)) { fight(); }
+        else if (Bunny* bunny = dynamic_cast<Bunny*>(&other)) { eat(); }
+        else { /* default handling here */ }
+    }
+}
+
+struct Bunny : Animal {
+    void encounter(Animal& other) {
+        if (Lion* lion = dynamic_cast<Lion*>(&other)) { run_away(); }
+        else if (Bunny* bunny = dynamic_cast<Bunny*>(&other)) { mate(); }
+        else { /* default collision handling here */ }
+    }
+}
+

+ +

I find OOP technically unsound. It attempts to decompose the world in - terms of interfaces that vary on a single type. To deal with the real - problems you need multisorted algebras - families of interfaces that span - multiple types.
I find OOP philosophically unsound. It claims that everything is an - object. Even if it is true it is not very interesting - saying that - everything is an object is saying nothing at all.

(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
+(defmethod encounter [:Bunny :Lion] [b l] :run-away)
+(defmethod encounter [:Lion :Bunny] [l b] :eat)
+(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
+(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
+(def b1 {:Species :Bunny :other :stuff})
+(def b2 {:Species :Bunny :other :stuff})
+(def l1 {:Species :Lion :other :stuff})
+(def l2 {:Species :Lion :other :stuff})
+
+
+(encounter b1 b2)
+-> :mate
+(encounter b1 l1)
+-> :run-away

En Clojure el dispatch se hace segÃºn el resultado de una expresiÃ³n + arbitraria, no sÃ³lo segÃºn los tipos implicados
...e internamente son macros :-D

+ +

Java interop

CreaciÃ³n de objetos Java: (new Clase) o simplemente Clase.
Acceso a miembros: (. clase miembro) +
```
(. "hola" toUpperCase)
+"HOLA"
```
+

La macro .. encadena accesos: +

(.. System getProperties (get "os.name"))
+"Linux"

Las funciones de Clojure implementan los interfaces Runnable y Callable de Java +
```
(.run (Thread. (fn [] (println "Hola"))))
```

+ +

Java interop (II)

Se pueden generar nuevas clases Java desde Clojure: +

(def PrintElementHandler
+  (proxy [DefaultHandler] []
+    (startElement [uri localName qname attributes]
+      (println (format "Saw element: %s" qname)))))

+ ...es equivalente a... +

public class SomeNewClass extends DefaultHandler {
+  public void startElement(String uri,
+                    String localName,
+                    String qName,
+                    Attributes attributes) {
+    System.out.println(*stuff*);
+  }
+}

Demasiados detalles para comentar aquÃ :(

+ + +

Problemas

Pocas herramientas (aunque hay plugins para Eclipse y Netbeans en desarrollo)
Software poco maduro
Comunidad muy pequeÃ±a
La JVM no permite Tail Call Optimizations +
- la recursiÃ³n consume pila, a menos que se utilice loop/recur (menos elegante)
+

+ +

Conclusiones

El futuro va a ser cada vez mÃ¡s funcional (IMHO)
Lisp es una especie de "kit para diseÃ±ar lenguajes"
Clojure parece molar, y espero poder comprobarlo pronto en algÃºn + proyecto personal

+ +

Fin

Â¿Preguntas, comentarios?

Clojure

+ + Clojure +

C++ mola, Â¿por quÃ© no te gusta?

C++ mola, Â¿por quÃ© no te gusta?

C++ mola, Â¿por quÃ© no te gusta?

C++ mola, Â¿por quÃ© no te gusta?

Es mas... Â¿por quÃ© creemos que la OOP es la panacea?

Â¿QuÃ© es Clojure?

Clojure corre en la JVM

Programas = Estructuras de datos

Entonces... Â¿quÃ© pinta tiene un programa?

Cool stuff

En busca del lenguaje de programaciÃ³n ideal

Pero... C++ mola, Â¿por quÃ© no te gusta?

Patrones de diseÃ±o

Macros: extendiendo Clojure

Macros: extendiendo Clojure

Es mas... Â¿por quÃ© creemos que la OOP es la panacea?

Lazy sequences

MultimÃ©todos

MultimÃ©todos (II)

Java interop

Java interop (II)

Problemas

Conclusiones

Fin