Como é o seu fluxo de trabalho do Lisp? [fechadas]

Estou aprendendo Lisp no momento, vindo de uma progressão de idioma que é Locomotiva BÁSICA -> Z80 Assembler -> Pascal -> C -> Perl -> C # -> Ruby. Minha abordagem é simultaneamente:

• escreva um raspador da web simples usando SBCL, QuickLisp, encerramento-html e drakma
• assista às palestras do SICP

Eu acho que isso está funcionando bem; Estou desenvolvendo bons 'óculos Lisp', pois agora posso ler Lisp razoavelmente facilmente. Também estou sentindo como o ecossistema Lisp funciona, por exemplo, o Quicklisp para dependências.

O que realmente sinto falta, no entanto, é uma sensação de como um Lisper experiente realmente funciona .

Quando estou codificando para .NET, tenho o Visual Studio configurado com ReSharper e VisualSVN. Escrevo testes, implemento, refatoro, comprometo. Então, quando eu faço o suficiente para completar uma história, escrevo alguns AUATs. Então, inicio uma versão do TeamCity para enviar a nova funcionalidade ao cliente para teste e aprovação. Se é um aplicativo que precisa de um instalador, eu uso o WiX ou o InnoSetup, obviamente criando o instalador por meio do sistema de CI.

Então, minha pergunta é: como um Lisper experiente, como é o seu fluxo de trabalho? Você trabalha principalmente no REPL ou no editor? Como você faz testes de unidade? Integração contínua? Empacotamento e implantação? Quando você se senta em sua mesa, cozinhando uma caneca de café de um lado e uma foto emoldurada de John McCarthy para o outro, o que você faz ?

Atualmente, sinto que estou começando a entender a codificação Lisp, mas não o desenvolvimento Lisp ...

A maioria das pessoas no fórum comp.lang.lisp e Lisp recomenda uma combinação de Emacs e SLIME, supondo que você não queira pagar por uma implementação comercial como Allegro ou LispWorks. O vídeo SLIME ilustra o processo de trabalho. Uso Emacs e SLIME para desenvolver programas pessoais em casa, e a combinação pode ser muito eficiente.

O SLIME oferece integração entre o Emacs e o REPL. O que normalmente faço é carregar todos os meus arquivos e abrir o que estou trabalhando no Emacs. Depois de digitar ou alterar cada função, pressione C-x C-e, que executa a definição da função no REPL. Então eu posso mudar para o buffer REPL e tentar a função. Todo o histórico do REPL está disponível e editável usando as seqüências de teclas padrão do Emacs, por isso é fácil refazer chamadas de função com parâmetros diferentes.

Eu trabalho principalmente com Clojure, e aqui está a minha configuração:

1. IDE do Eclipse (eu uso isso porque também faço muito trabalho em Java, às vezes no mesmo projeto que o Clojure)
2. Plug-in no sentido anti-horário para Clojure (isso inclui um REPL)
3. Maven para gerenciamento de dependência e construção
4. Egit para controle de código fonte

O fluxo de trabalho durante a codificação geralmente é assim:

1. Abra um REPL, carregando todos os arquivos de origem atuais
2. Código e teste no REPL
3. Quando estiver satisfeito com algum código, copie / cole novamente no arquivo de origem
4. Ocasionalmente, reinicialize o REPL (quando atrapalhei um namespace irrevogavelmente ou apenas para verificar se tudo ainda está funcionando nos arquivos de origem)
5. Também escreva testes nos arquivos de origem, que são executados automaticamente por todas as versões do Maven. Às vezes, os testes informais que acabei de fazer no REPL são transformados diretamente em testes de unidade.
6. Confirme etc. neste momento - praticamente um fluxo de trabalho de desenvolvimento regular

No geral, não é muito diferente de um fluxo de trabalho Java / C # regular, além do uso mais interativo do REPL durante o desenvolvimento.

Para complementar as outras respostas, eu faço uma combinação do tipo de desenvolvimento "Pense bem sobre o problema e, em seguida, anote a solução" e "Comece com uma substituição e bata seu programa em forma iterativa". Geralmente é no meio. O que eu faço é começar com uma idéia geral de como eu quero que meu programa seja e, então, começo a escrevê-lo, tentando adquirir novos conhecimentos sobre o domínio do problema, a fim de revisar minha abordagem. Na prática, isso significa que eu faço muitas experiências e escrevo muito código descartável. Eu tento diferentes abordagens e posso mudar de direção muito rapidamente. Lisp é bom para esse tipo de desenvolvimento. É por isso que eu não gosto muito de TDD, tenho que saber o que quero fazer primeiro, para poder efetivamente TDD.

Outra coisa importante que tento fazer é pensar mais sobre o protocolo entre as diferentes partes de um programa. Diferentemente de outras linguagens OO, o In Common Lisp CLOS se concentra mais no conceito de uma função Genérica, os métodos IOW vivem fora das classes e são o foco do desenvolvimento. Às vezes, eu apenas começo com um conjunto de GFs que definem o protocolo que eu quero, escrevo uma implementação simples e a uso para detalhar o protocolo, antes de escrever uma implementação real. Digamos que estou escrevendo uma camada que armazena várias postagens no blog, talvez eu tenha um conjunto de GFs que definam como as postagens são criadas, editadas e pesquisadas, e eu escreveria uma implementação simples que salva as postagens do blog em uma lista na memória , e depois de ficar satisfeito com meu protocolo, escrevo uma implementação que salva postagens de blog em um banco de dados ou as grava em arquivos.

O Lisp facilita a mudança de direção e a adoção de uma abordagem diferente quando você sabe que sua solução atual é abaixo do ideal que eu tento maximizar.

Outro ponto importante: use seu ambiente ao máximo, aprenda sobre o uso de diferentes configurações de compilação para compilar seu código com mais informações de depuração, aproveite o fato de que o lisp pode ser compilado e interpretado. Use as instalações introspectivas dos lisps, como o MOP, use os recursos de slimes para pesquisar a documentação, use o inspetor para examinar objetos, consulte o hiperespécie regularmente, trate seu sistema mais como um SO, do que um compilador estático para o seu código, é muito mais poderoso que isso.

Para um iniciante, o lisp não é uma grande vitória sobre python e ruby, mas à medida que você se torna mais experiente, obtém enormes vitórias em ambientes menores.

Mais importante, você precisa se divertir e amar esse idioma; às vezes é fácil ficar desanimado e usar os idiomas blub atualmente populares. Se você ficar com o lisp, ele será recompensado.

Costumo trabalhar em um editor que tenha uma conexão com um REPL (normalmente, editando no emacs e usando o SLIME como uma ponte para um ambiente Common Lisp). Costumo começar tanto "na parte inferior" quanto "na parte superior", trabalhando para o meio, revisando o design à medida que vou.

Quanto aos testes, é por isso que tenho um REPL. Acho que isso ajuda a testar o código à medida que vou. Às vezes, escreverei testes ou benchmarks mais formais à medida que for (normalmente quando estou no estágio de otimização). Tenha uma implementação mais lenta e conhecida de uma funcionalidade, experimente (em uma janela do editor) o código para uma versão otimizada, envie-o para o código lisp subjacente e verifique se ele é mais rápido e retorna os mesmos resultados que o mais lento código.

No que diz respeito ao empacotamento, tenho algum código de utilitário para me ajudar a empacotar projetos instaláveis ​​em ASDF, colocá-los em um repositório de download e gerenciar versões.