Quais são os prós e os contras do Coffeescript? [fechadas]

É claro que um grande profissional é a quantidade de açúcar sintático que leva ao código mais curto em muitos casos. Em http://jashkenas.github.com/coffee-script/, existem exemplos impressionantes. Por outro lado, tenho dúvidas de que esses exemplos representem códigos de aplicações complexas do mundo real. No meu código, por exemplo, nunca adiciono funções a objetos nus, mas a seus protótipos. Além disso, o recurso de protótipo está oculto do usuário, sugerindo OOP clássico em vez de Javascript idiomático.

O exemplo de compreensão da matriz ficaria no meu código provavelmente assim:

cubes = $.map(list, math.cube); // which is 8 characters less using jQuery...

Sou o autor de um próximo livro sobre o CoffeeScript:
http://pragprog.com/titles/tbcoffee/coffeescript

Eu estava convencido de que valia a pena usar o CoffeeScript após cerca de uma semana brincando com ele, mesmo que a linguagem tivesse apenas alguns meses na época e tivesse muito mais arestas do que agora. O site oficial faz um ótimo trabalho ao listar (a maioria) os recursos do idioma, por isso não os repetirei aqui. Em vez disso, vou apenas dizer que os profissionais da linguagem são:

1. Incentiva o uso de bons padrões de JavaScript
2. Desencoraja anti-padrões de JavaScript
3. Torna o código JavaScript ainda mais curto e mais legível

O número 3 recebe muito mais atenção do que os dois primeiros (mesmo no meu livro), mas quanto mais penso nisso, mais percebo que não dei o salto apenas pela bonita sintaxe; Fiz o salto porque a linguagem me levou a um JavaScript melhor e menos propenso a erros. Para dar alguns exemplos rápidos:

• Como as variáveis ​​têm escopo automático, você não pode substituir acidentalmente globais omitindo var, sombreando uma variável com o mesmo nome (exceto com argumentos nomeados) ou possuindo variáveis ​​em arquivos diferentes que interagem (consulte https://stackoverflow.com/questions / 5211638 / pattern-for-coffeescript-modules / 5212449 ).
• Como ->é muito mais fácil escrever do que function(){}, é mais fácil usar retornos de chamada. O recuo semântico deixa claro quando os retornos de chamada são aninhados. E =>facilita a preservação thisquando apropriado.
• Como unless xé mais fácil para os falantes de inglês analisar if (!x), e if x?é mais fácil do que if (x != null), dar apenas dois exemplos, você pode gastar menos ciclos cerebrais na sintaxe da lógica e mais na própria lógica.

Uma ótima biblioteca como o Underscore.js pode cuidar de alguns desses problemas, mas não de todos.

Agora, os contras:

1. Compilação pode ser uma dor. Os erros de sintaxe que o compilador CoffeeScript gera são frequentemente vagos. Espero que sejam feitos progressos nessa via no futuro. (Na defesa do compilador, geralmente é detectado algo que, se você o escrevesse em JavaScript, não seria descoberto até que essa linha de código fosse executada. Melhor capturar esses erros mais cedo ou mais tarde.)
2. Da mesma forma, a depuração pode ser uma dor. Ainda não há como corresponder as linhas JS compiladas ao CoffeeScript original (embora o pessoal do Firefox tenha prometido que isso está chegando).
3. É propenso a mudar. Seu código pode ser executado de maneira diferente, ou não ser executado, em uma versão futura do CoffeeScript. Obviamente, esse é o caso da maioria das linguagens - a mudança para uma nova versão do Ruby ou Python é semelhante - mas não é o caso do JavaScript, onde você pode esperar razoavelmente que o código que funciona bem nos principais navegadores hoje funcione bem nos principais navegadores enquanto a web como a conhecemos existir.
4. Não é tão conhecido. JavaScript é uma lingua franca . O CoffeeScript se tornou muito popular em pouco tempo, mas é improvável que ele desfrute de uma comunidade tão vasta quanto o JavaScript.

Obviamente, acho que os profissionais superam os contras para mim pessoalmente, mas esse não será o caso de todas as pessoas, equipes ou projetos. (Até Jeremy Ashkenas escreve muito JavaScript.) O CoffeeScript é melhor visualizado como um excelente complemento para JavaScript, não como um substituto.

Temos uma grande base de código JavaScript e, cerca de um mês atrás, decidimos experimentar o CoffeeScript. Um de nossos desenvolvedores começou a migrar um de nossos módulos de JS para CS usando http://js2coffee.org/ . Essa ferramenta foi bastante útil e demorou cerca de duas ou três horas para portar uma linha de algo mais do que 1000. Algumas observações que observamos naquele momento:

1. O código CoffeeScript resultante era bastante legível.

2. Nós o compilamos de volta ao JavaScript e foi muito fácil navegar e depurar. Enquanto estávamos portando esse módulo, outro desenvolvedor da nossa equipe encontrou um bug nele. Esses dois desenvolvedores corrigiram esse bug em nosso antigo código JavaScript e no novo código JavaScript que saiu do compilador CS. Eles trabalharam independentemente e levaram a mesma quantidade de tempo (15 a 20 minutos).

3. Devido ao fato de ser uma porta, o código resultante não estava usando recursos específicos do café que eram apropriados ou desejáveis. Se escrevermos no CoffeeScript do zero, o código seria mais idiomático. Por causa disso, decidimos que não portaríamos o código existente.

4. Em geral, a legibilidade de funções mais curtas e objetos menores aumentou até certo ponto. No entanto, para métodos mais longos, esse não era o caso. As maiores economias surgiram ->e foram explícitas return, mas, além disso, nosso código não havia sido significativamente mais curto ou mais simples. Algumas partes da sintaxe pareciam bastante confusas, especialmente literais de objetos. O CS omite chaves entre definições de membros e combinado com "tudo é uma expressão" e implícito, o returnque dificultava a leitura de alguns bits de código.

   Aqui está o JavaScript:

   var rabbitGenerator = {
       makeRabbit: function(rabbitName, growCarrots) {
           if (growCarrots) {
               carrots.growMore(10);
           } else {
               carrots.ensureSupply();
           }
           return {
               name: rabbitName, 
               height: 0,
               actions: {
                   jump: function (height) {
                       this.height += height;
                   },
                   eatCarrot: function () {
                       // etc
                   }
               }
           };
       },
       // more members
   }

   E aqui está a aparência do código CoffeeScript correspondente:

   rabbitGenerator = 
     makeRabbit: (rabbitName, growCarrots) ->
       if growCarrots
         carrots.growMore 10
       else
         carrots.ensureSupply()
       name: rabbitName // (*)
       height: 0
       actions: 
         jump: (height) ->
           @height += height
   
         eatCarrot: ->

   Agora, é muito difícil descobrir que a declaração de retorno começa na (*)linha. Em nosso projeto, dependemos muito de literais de objetos: passamos como parâmetros de função e os retornamos de outras funções. Em muitos casos, esses objetos tendem a ser bastante complexos: com membros de diferentes tipos e vários níveis de aninhamento. No nosso caso, a sensação geral era de que o código CoffeeScript era realmente mais difícil de ler do que o código JavaScript comum.

5. Embora a depuração do CoffeeScript tenha sido mais fácil do que esperávamos, a experiência de edição diminuiu bastante. Não foi possível encontrar um bom editor / IDE para este idioma. Não padronizamos no editor / IDE o código do lado do cliente para o nosso projeto e, de fato, todos usamos ferramentas diferentes. De fato, todos os membros de uma equipe concordam que, quando mudam para o CoffeeScript, recebem um suporte bastante ruim de sua ferramenta. Os plug-ins de editor e IDE estão em uma forma muito precoce e, em alguns casos, eles nem sequer podem nos dar um suporte apropriado para realçar ou recuar na sintaxe. Não estamos falando de trechos de código ou refatoração. Usamos WebStorm, Eclipse, NetBeans, VisualStudio, Notepad ++ e SublimeText2.

6. Falando em ferramentas, devo mencionar que o próprio compilador CoffeScript vem como um pacote Node JS. Como somos uma loja Java / .NET principal, todos estão desenvolvendo caixas do Windows. Até recentemente, o suporte do Windows era quase inexistente no Node. Não conseguimos fazer com que o compilador CoffeeScript fosse executado no Windows; por enquanto, decidimos manter as <script type="text/coffeescript">tags e o compilador em tempo real baseado no navegador.

   O compilador é bastante rápido e não aumenta muito o tempo de inicialização. A desvantagem é que o JavaScript resultante é evaleditado e é um pouco difícil colocar pontos de interrupção nas ferramentas de desenvolvedor de navegadores (especialmente no IE8). Se tivermos dificuldade com a depuração, pré-compilamos o código CoffeeScript com a mesma ferramenta de migração listada acima, mas isso ainda não é muito conveniente.

7. Outras promessas do CoffeeScript, como varinserção automática ou gerenciamento semitransparente do thisoperador de seta gorda ( =>), não deram tanto ganho quanto esperávamos. Já usamos JSLint como parte do nosso processo de construção e escrevemos código no ES3 x ES5-Strictsubconjunto da linguagem. De qualquer forma, o fato de o Coffee produzir o mesmo tipo de código "limpo" é uma coisa boa . Desejo que todas as estruturas do lado do servidor também produzam marcações HTML5 e CSS3 válidas!

   Dito isto, eu não diria que o CoffeeScript economiza muito tempo colocando varpalavras-chave para mim. Os vars ausentes são facilmente capturados pelo JSLint e são facilmente corrigíveis. Além disso, depois de corrigido por algum tempo, você começa a escrever um bom JavaScript automaticamente de qualquer maneira. Assim, eu não diria que o café é realmente que útil a este respeito.

Avaliamos o CoffeeScript por cerca de uma semana. Todos os membros da equipe estavam escrevendo um código e compartilhamos nossas experiências. Escrevemos um novo código com ele e portamos um código existente quando acharmos melhor. Nossos sentimentos sobre o idioma foram confusos.

Em geral, eu diria que isso não acelerou nosso desenvolvimento, mas também não nos atrasou. Alguns ganhos de velocidade devido à menor digitação e menos superfície de erro foram compensados ​​por desacelerações em outras áreas, principalmente no suporte a ferramentas. Depois de uma semana , decidimos que não exigiríamos o uso do CoffeeScript, mas também não o proibiríamos . Dada a livre escolha, na prática ninguém a usa, pelo menos por enquanto. De tempos em tempos, penso em criar um novo recurso para a criação de protótipos e depois converter o código em JavaScript antes de integrar-se ao restante do projeto para obter um início mais rápido, mas ainda não tentei essa abordagem.

Prós

veja a resposta de Trevor Burnham .

além disso, você pode pensar em si mesmo como um cara descolado, que está fazendo coisas da moda, em vez de mexer com a sujeira do javascript.

Contras

O CoffeeScript nada mais é do que açúcar sintático e óculos cor de rosa.

Para coisas fáceis - o CoffeeScript é redundante, porque fazer coisas fáceis é fácil em qualquer idioma. E o jQuery é provavelmente ainda mais simples que o CoffeeScript.

Para coisas difíceis - você deve entender seu meio. E seu meio é HTML, DOM e CSS; o Javascript é apenas uma ferramenta para interconectá-los - todas as APIs são escritas especificamente para Javascript. O uso de outra linguagem, que seria compilada para uma versão "real" - é bastante arriscado, seja Java (GWT), Dart ou CoffeeScript.

Os antipadrões ou a ignorância banal das regras de linguagem podem ser corrigidos lendo um ou dois bons livros. E tenho certeza de que o Coffeescript tem seus próprios antipadrões.

O suporte ao IDE para Coffeescript é ainda pior que para JS.

O maior profissional, em minha mente, é:

Coffescript simples compila no javascript que você deveria ter escrito, mas não o fez, porque não era direto.

Existem alguns cantos desagradáveis ​​de javascript que são evitados apenas com vigilância - exemplos em cima da minha cabeça:

• configurando o protótipo corretamente
• usando === em vez de ==
• verificando nulo
• declarando todas as variáveis ​​com var
• agrupando tudo em uma função anônima de execução automática.

Se você escrever um coffeescript, todos eles serão tratados automaticamente .

Os contras são, na OMI, principalmente pequenos:

• Depurar é uma dor
• Existem menos programadores de café
• Você precisa traduzir a documentação de javascript para coffeescript.

profissionais

1. O CoffeeScript me ajudou a aprender mais sobre JavaScript
2. é bastante fácil de ler, mesmo para retornos de chamada aninhados complexos
3. fornece segurança em relação a alguns dos problemas difíceis de localizar javascript

O exemplo de trabalho de Andrew I acima foi esclarecedor. Acredito que a legibilidade de seus retornos literais de objetos existentes seria aprimorada simplesmente identificando manualmente o retorno

Retorna

// literal do objeto aqui

As ferramentas IDE foram aprimoradas, o TextMate e o Cloud9 oferecem suporte ao CoffeeScript. É certo que o suporte do Windows está atrasado (isso não é verdade para o desenvolvimento da web em geral?)

contras

O CoffeeScript interpretado pelo navegador pode ser um desafio para depurar.

É uma camada adicional sobre JavaScript que requer alguma compreensão e consideração dos desenvolvedores.

profissionais

1. eles realmente otimizaram os casos comuns sintaticamente; na verdade, o CoffeeScript é uma das, se não a linguagem mais concisa "usada" com frequência " http://redmonk.com/dberkholz/2013/03/25/programming-languages-ranked- por expressividade /
2. oculta as partes ruins do JavaScript (coerção automática ==, globais implícitos, sistema de classes mais tradicional facilita as coisas comuns)
3. extremamente fácil de aprender para programadores Python / Ruby
4. funções anônimas de várias linhas + sintaxe de espaço em branco

contras

1. remoção de var significa que você não pode alterar uma variável de escopo externo dentro de um escopo interno sem usar um objeto ou `var fall_back_to_js;` hacks [por que não outra declaração de atribuição ': =' que apenas reatribui um valor para obj.naem: = 5 erros de digitação mais fáceis de depurar]
2. você deve informar todas as ferramentas sobre isso, a menos que queira depurar JavaScript :(; btw: você pode depurar o CoffeeScript do Chrome adicionando suporte para mapas de origem; yeoman (npm install yeoman) pode ajudá-lo a escrever um arquivo de configuração gulp ou grunt para CoffeeScript
3. sem digitação estática opcional (precisa aguardar o próximo padrão EcmaScript)
4. ainda precisa de bibliotecas de terceiros para um sistema de módulos
5. armadilhas de sintaxe para ter cuidado com: retornos implícitos, abgo significa a (b (g (o))) , fp, b: 2, c: 8 significa f (p, {b: 2, c: 8}) em vez de f (p, {b: 2}, {c: 8})
6. não altera o número / tipo de sistema JavaScript quebrado