¿Cuál es la diferencia entre la torta y Leiningen?

Question

¿Cuál es la diferencia entre la torta y Leiningen?

Answer 1

Esta respuesta sigue recibiendo interés, presumiblemente como referencia para Leiningen en StackOverflow por lo que ahora se edita de manera significativa a actualizarlo para el 2014.

Leiningen y la torta incluido de nuevo en 2011. Leiningen (versión 2) ahora es el hecho de Clojure herramienta de automatización.

Leiningen es una herramienta de construcción y gerente de dependencia para Clojure, que incluye la posibilidad de establecer un REPL interactivo con la forma apropiada ruta de clase configurada y con todas las dependencias java y clojure adquiridas de una manera automatizada de maven repositorios y / o la comunidad basado Clojars .

pastel fue muy similar a Leiningen (abajo a utilizar el mismo formato de archivo project.clj en el momento), pero intento de evitar un montón de gastos de inicio, manteniendo las JVM persistentes alrededor en el fondo. Esto fue más sensible, pero negocia comodidad para los insectos debido al estado acumulado en los procesos persistentes (viejas definiciones de funciones dando vueltas, etc.) en el transcurso típico de desarrollo basado REPL iterativo. Esto resultó ser un mal negocio.

La experiencia con Leiningen y un deseo continuo de los tiempos de arranque más rápidos han llevado a una serie de recomendaciones y enfoques para acelerar las cosas: https://github.com/technomancy/leiningen/wiki/Faster

Answer 2

La principal diferencia está en la forma en que se implementan las tareas.

El enfoque de la torta es "que es difícil de ampliar las funciones después de que hayan sido definidos, así que vamos a inventar un nuevo mecanismo para tareas en lugar de utilizar las funciones", lo que resultó en el macro deftask.

El enfoque de Leiningen es "que es difícil de ampliar las funciones después de que hayan sido definidos, por lo que deberíamos hacer una manera de hacer esto fácilmente, de esta manera podemos utilizar las funciones para las tareas y también ser capaz de extender cosas que no son tareas ", lo que le permite aplicar todas las ventajas de la componibilidad de funciones con las tareas.

Answer 3

Mientras Alex se ha mencionado, la diferencia más llamativa es la velocidad de la línea de comandos. Torta utiliza una JVM persistente, por lo que sólo se produce el inicio sobrecarga JVM cuando se ejecuta una tarea de un proyecto por primera vez. Si no está usando emacs + limo + clojure-test-modo, esto puede ser un ahorro de tiempo enorme. Por ejemplo, un razonablemente grande conjunto de pruebas en uno de mis proyectos carreras en 0.3 segundos en la torta, frente a 11.2s en Lein.

Junto con el rendimiento, la idea central detrás de la torta es el modelo de tarea dependencia. Cada tarea sólo se ejecuta una vez en una estructura dada, teniendo en cuenta todos los requisitos previos transitivos en el gráfico de la dependencia. He aquí un ejemplo del artículo de Martin Fowler en el rastrillo en la sintaxis de la torta, que va directamente en su project.clj.

(deftask code-gen
  "This task generates code. It has no dependencies."
  (println "generating code...")
  ...)

(deftask compile #{code-gen}
  "This task does the compilation. It depends on code-gen."
  (println "compiling...")
  ...)

(deftask data-load #{code-gen}
  "This task loads the test data. It depends on code-gen."
  (println "loading test data...")
  ...)

(deftask test #{compile data-load}
  "This task runs the tests. It depends on compile and data-load."
  (println "running tests...")
  ...)

Para hacer lo mismo en Leiningen, primero tiene que crear un directorio Leiningen en su proyecto con 4 archivos:. Code_gen.clj, compile.clj, data_load.clj y my_test.clj

src / Leiningen / code_gen.clj

(ns leiningen.code-gen
   "This task generates code. It has no dependencies.")

(defn code-gen []
  (println "generating code..."))

src / Leiningen / my_compile.clj

(ns leiningen.my-compile
  "This task does the compilation. It depends on code-gen."
  (:use [leiningen.code-gen]))

(defn my-compile []
  (code-gen)
  (println "compiling..."))

src / Leiningen / data_load.clj

(ns leiningen.data-load
  "This task loads the test data. It depends on code-gen."
  (:use [leiningen.code-gen]))

(defn data-load []
  (code-gen)
  (println "loading test data..."))

src / Leiningen / my_test.clj

(ns leiningen.my-test
  "This task runs the tests. It depends on compile and data-load."
  (:use [leiningen.my-compile]
        [leiningen.data-load]))

(defn my-test []
  (my-compile)
  (data-load)
  (println "running tests..."))

Uno esperaría ...

generating code...
compiling...
loading test data...
running tests...

Sin embargo, tanto los datos de carga y mi-compilación dependen de generación de código, por lo que su ouput real es ...

generating code...
compiling...
generating code...
loading test data...
running tests...

Usted tendría que memoize código de generación de impedir que se ejecute varias veces:

(ns leiningen.code-gen
   "This task generates code. It has no dependencies.")

(def code-gen (memoize (fn []
                         (println "generating code..."))))

salida:

generating code...
compiling...
loading test data...
running tests...

¿Qué es lo que queremos.

Construye son más simples y más eficientes si una tarea sólo se corrió una vez por acumulación, por lo que la convirtió en el comportamiento por defecto en el pastel crece. La filosofía tiene décadas de antigüedad y compartidas por un linaje de herramientas de construcción. Puede seguir utilizando las funciones, todavía se puede llamar varias veces, y siempre tienes todo el poder de clojure a su disposición.

Lein sólo te da una función clara como una tarea, pero con la restricción adicional de que debe tener su propio espacio de nombres en src. Si una tarea depende de ello, será en un espacio de nombres separado, y debe usar / solicitar a la otra en ella de macro ns. Pastel crece parece mucho más limpio y conciso en comparación.

Otra diferencia clave es cómo las tareas se añaden al. Digamos que queríamos añadir my-test como requisito previo para la torta / Lein está construida en jar tarea. En la torta, puede utilizar la macro deftask para anexar a las formas y las dependencias de una tarea.

(deftask jar #{my-test})

Lein Robert Hooke utiliza para añadir a las tareas. Es una biblioteca muy fresco, el nombre de filósofo natural, favorito de todos, pero requeriría una macro para la concisión de deftask.

(add-hook #'leiningen.jar/jar (fn [f & args]
                                (my-test)
                                (apply f args)))

Cake también tiene la noción de un proyecto global. Puede agregar específicas de usuario dev-dependencias, como Swank, a ~/.cake/project.clj y tenerlo en todos sus proyectos. El proyecto global también se utiliza para iniciar una repl fuera de un proyecto para la experimentación. Lein implementa características similares mediante el apoyo de configuración por usuario en ~/.lein/init.clj, y plugins globales en ~/.lein/plugins. En general, Lein actualmente tiene un ecosistema complemento mucho más rica que la torta, pero la torta incluye más tareas fuera de la caja (guerra, implementar la compilación de Java, dependencias nativos, clojars, y Swank). Cljr también puede ser digno de la comprobación hacia fuera, es esencialmente sólo un proyecto global con un gestor de paquetes, pero sin capacidades de construcción (no tengo experiencia con él sin embargo).

La diferencia real es irreconcible DEFINCIONES de tareas, como Tecnomancia señaló. En mi opinión (con prioridad), se ocupa de la torta de tareas mucho mejor. La necesidad de un modelo de dependencia tarea se hizo evidente cuando comenzamos a usar búferes de protocolo en nuestro proyecto con Lein. Protobufs fueron pre-requisitos para todas nuestras tareas, sin embargo, recopilando ellos es muy lento. También tenemos una gran cantidad de tareas interdependientes, so cualquier acumulación fue doloroso. Además, no me gusta la exigencia de un espacio de nombres independiente, y por lo tanto un fichero src adicional, para cada tarea que creo. Los desarrolladores debe crear un lote tareas, el enfoque de Lein desalienta esto creando demasiada fricción. Con pastel, sólo puede utilizar la macro deftask dentro project.clj.

La torta es todavía joven, y un trabajo en progreso, pero es un proyecto muy activo.

Answer 4

Como 2011-11-15, el anuncio de pastel y de combinación de Lein