¿Cómo es su flujo de trabajo de Lisp? [cerrado]

Estoy aprendiendo Lisp en este momento, proveniente de una progresión de lenguaje que es Locomotora BÁSICA -> Ensamblador Z80 -> Pascal -> C -> Perl -> C # -> Ruby. Mi enfoque es simultáneamente:

• escriba un simple raspador web usando SBCL, QuickLisp, cierre-html y drakma
• mira las conferencias del SICP

Creo que esto está funcionando bien; Estoy desarrollando buenas 'gafas Lisp', en el sentido de que ahora puedo leer Lisp razonablemente fácilmente. También tengo una idea de cómo funciona el ecosistema Lisp, por ejemplo, Quicklisp para dependencias.

Lo que estoy realmente falta, sin embargo, es una idea de cómo un ceceoso sazonada realmente funciona .

Cuando estoy codificando para .NET, tengo Visual Studio configurado con ReSharper y VisualSVN. Escribo pruebas, implemento, refactorizo, me comprometo. Luego, cuando he terminado lo suficiente para completar una historia, escribo algunos AUAT. Luego, lancé una versión de lanzamiento en TeamCity para llevar la nueva funcionalidad al cliente para que la pruebe y, con suerte, la apruebe. Si se trata de una aplicación que necesita un instalador, utilizo WiX o InnoSetup, obviamente construyendo el instalador a través del sistema CI.

Entonces, mi pregunta es: como Lisper experimentado, ¿cómo es su flujo de trabajo? ¿Trabajas principalmente en REPL o en el editor? ¿Cómo se hacen las pruebas unitarias? ¿Integración continua? Embalaje y despliegue? Cuando te sientas en tu escritorio, humeando una taza de café a un lado y una foto enmarcada de John McCarthy al otro, ¿qué haces ?

Actualmente, siento que me estoy familiarizando con la codificación Lisp, pero no con el desarrollo de Lisp ...

La mayoría de las personas en comp.lang.lisp y Lisp Forum recomiendan una combinación de Emacs y SLIME, suponiendo que no desea pagar por una implementación comercial como Allegro o LispWorks. El video SLIME ilustra el proceso de trabajo. Utilizo Emacs y SLIME para desarrollar programas personales en casa, y la combinación puede ser muy eficiente.

SLIME le brinda integración entre Emacs y REPL. Lo que normalmente hago es cargar todos mis archivos, luego abrir el que estoy trabajando en Emacs. Después de escribir o cambiar cada función, presiono C-x C-e, que ejecuta la definición de la función en REPL. Entonces puedo cambiar al buffer REPL y probar la función. Todo el historial de REPL está disponible y editable utilizando secuencias de teclas estándar de Emacs, por lo que es fácil rehacer llamadas de función con diferentes parámetros.

Trabajo principalmente con Clojure, y aquí está mi configuración:

1. Eclipse IDE (lo uso porque también trabajo mucho en Java, a veces en el mismo proyecto que Clojure)
2. Complemento en sentido antihorario para Clojure (esto incluye un REPL)
3. Maven para la dependencia y la gestión de compilación
4. Egit para el control del código fuente

El flujo de trabajo durante la codificación generalmente es así:

1. Abra un REPL, cargando todos los archivos fuente actuales
2. Código y prueba en el REPL
3. Cuando esté satisfecho con algún código, copie / pegue nuevamente en el archivo fuente
4. Ocasionalmente reinicie el REPL (ya sea cuando haya desordenado un espacio de nombres irrevocablemente, o simplemente para verificar que todo sigue funcionando en los archivos fuente)
5. También escriba pruebas en los archivos de origen, que se ejecutan automáticamente en cada compilación de Maven. A veces, las pruebas informales que acabo de hacer en el REPL se convierten directamente en pruebas unitarias.
6. Comprometerse, etc., en este punto, prácticamente un flujo de trabajo de desarrollo

En general, no es muy diferente de un flujo de trabajo Java / C # normal, aparte del uso más interactivo de REPL durante el desarrollo.

Para complementar las otras respuestas, hago una combinación del tipo de desarrollo "Piensa bien sobre el problema, luego escribo la solución" y "Comienza con una respuesta, y dale forma iterativa a tu programa". Suele estar en el medio. Lo que hago es comenzar con una idea general de cómo quiero que se vea mi programa, y ​​luego empiezo a escribirlo, tratando de adquirir nuevos conocimientos sobre el dominio del problema a medida que avanzo, para revisar mi enfoque. En la práctica, eso significa que hago mucha experimentación y escribo mucho código desechable. Intento diferentes enfoques y puedo cambiar de dirección muy rápido. Lisp es bueno para este tipo de desarrollo. Es por eso que no me gusta tanto TDD, tengo que saber qué quiero hacer primero, para poder TDD de manera efectiva.

Otra cosa importante que trato de hacer es pensar más sobre el protocolo entre las diferentes partes de un programa. A diferencia de otros lenguajes OO, In Common Lisp CLOS se centra más en el concepto de una función genérica, los métodos IOW viven fuera de las clases y son el foco del desarrollo. A veces solo comienzo con un conjunto de GF que definen el protocolo que quiero, escribo una implementación simple y la uso para desarrollar el protocolo, antes de escribir una implementación real. Digamos que estoy escribiendo una capa que almacena un montón de publicaciones de blog, podría tener un conjunto de GF que definen cómo se crean, editan y buscan publicaciones de blog, y escribiría una implementación simple que guarda las publicaciones de blog en una lista en la memoria , y después de estar satisfecho con mi protocolo, escribo una implementación que guarda las publicaciones de blog en una base de datos, o las escribe en archivos.

Lisp hace que sea tan fácil cambiar de dirección y hacer un enfoque diferente cuando sabes que tu solución actual es subóptima que trato de maximizarla.

También es un punto importante: use su entorno al máximo, aprenda a usar diferentes configuraciones de compilación para compilar su código con más información de depuración, aproveche el hecho de que lisp se puede compilar e interpretar. Use instalaciones introspectivas de lisps, como el MOP, use características de slimes para buscar documentación, use el inspector para mirar dentro de los objetos, consulte el hiperespec regularmente, trate su sistema más como un sistema operativo, que un compilador estático para su código, es mucho más poderoso que eso.

Para un principiante, lisp no es una gran victoria sobre python y ruby, pero a medida que adquieres más experiencia, obtienes enormes ganancias sobre entornos menores.

Lo más importante es que debes divertirte y amar este idioma, a veces es muy fácil desanimarte y usar los idiomas blub actualmente populares. Si te quedas con lisp, te lo pagará.

Tiendo a trabajar en un editor que tiene una conexión a un REPL (típicamente, editando en emacs y usando SLIME como un puente a un entorno Common Lisp). Tiendo a comenzar tanto "en la parte inferior" como "en la parte superior", trabajando hacia el medio, revisando el diseño a medida que avanzo.

En cuanto a las pruebas, es por eso que tengo un REPL. Me parece que ayuda a probar el código a medida que avanzo. A veces escribiré más pruebas formales o puntos de referencia a medida que avance (generalmente una vez que esté en la etapa de optimización). Tenga una implementación más lenta y conocida de una funcionalidad, experimente (en una ventana del editor) con el código para una versión optimizada, envíela al código lisp subyacente y verifique que sea más rápido y devuelva los mismos resultados que el más lento código.

En lo que respecta al empaque, tengo un código de utilidad que me ayuda a empacar proyectos instalables en ASDF, incluirlos en un repositorio de descargas y manejar el control de versiones.