Premiação

Tendo os resultados do teste de desempenho, escolhi dar alguns “prêmios” para as linguagens.

Prêmio Rapidez com consistência

C++

Prêmio Lentidão com consistência

Python. É lento, mas pelo menos inicializa num tempo razoável. Além disso, é a única linguagem com tipagem dinâmica dos testes, então não dá bem pra comparar.

Prêmio Lentidão de inicialização

As linguagens com máquinas virtuais e JIT: Java e F#, principalmente na versão 64 bits. Perderam até pro Python.

Acho melhor tirarem aqueles loops vazios até um milhão que puseram lá :-P

Prêmio Concisão

Python e F#. Apesar de eu não ter me preocupado com coisas como linhas em branco e comentários, essas duas linguagens tiveram os códigos mais concisos (quase empatadas). As duas usam da indentação para delimitar blocos.

Prêmio Verbosidade

PL/SQL. A implementação em PL/SQL não estava nos testes porque ela funciona dentro do banco de dados, coisa completamente diferente das outras linguagens. Mas ela merece o prêmio por ultrapassar a marca de 800 linhas para fazer o que Python e F# fazem com 500.

Java, D e C++ ficaram com resultados muito mais parecidos do que eu imaginava. Algumas implementações têm algumas checagens a mais e outras a menos no código, mas fora isso não tem muita diferença.

Prêmio Imaturidade

D versão 2. Esbarrei em 2 bugs (um era que to!double("0") falhava e outro é que o executável com otimização não fechava os arquivos sozinho*, ao contrário do que a documentação afirmava). O bug do to!double foi corrigido quando atualizei da versão 2.048 para 2.049, mas o fechamento dos arquivos teve que continuar manual (ainda bem que D tem o recurso scope(exit), muito mais legal que finally. É na verdade genial). Nessas horas eu penso que deveria ter usado D 1, que é mais estável (o D 2 ainda recebia modificações radicais até recentemente, mas está começando a estabilizar). Não sei se D não foi injustiçado por eu ter usado a versão bleeding-edge, mas praticamente todas as [implementações de ] linguagens que eu usei são bem recentes.

*Depois descobri que eu estava criando sem querer cópias do objeto File, porque ele é uma struct e não uma class. Corrigindo isso o problema sumiu e o desempenho melhorou. Certas linguagens parecem ser menos amigáveis para iniciantes, como C++ e D…

Prêmio Mas eu tenho que fazer isso na mão?

1º lugar:

C++, por:
– ter que implementar uma função hash para fazer uma chave composta num unordered_map.
– por seus copy constructors, move constructors, fucking constructors, smart pointers, dumb pointers e references.

E para a STL do C++, por:
– ter que comparar com string::npos ou container.end() para saber se um elemento foi encontrado depois de uma busca;
– ser uma complicação aplicar a função hash personalizada ao unordered_map (struct com operator() const);
– find num map retornar um pair, sendo que eu só estou interessado no segundo elemento.

Sorte que por causa das novidades do C++1x eu não precisei usar um sstream (ou o inseguro sprintf) para converter números para strings…

2º lugar: Java, também por ter que implementar uma função hash para fazer uma chave composta num HashMap. Eu poderia ter concatenado os campos numa string e ter pegado o hash dessa string (como eu fiz em PL/SQL), mas resolvi fuçar na implementação do tipo Long e peguei a função hash de lá. Dei uma alterada pra fazer hash de 2 longs, não sei se prestou. Depois fiz algo parecido no C++.

Prêmio Viva, não preciso implementar funções hash!

Por conseguinte, pode-se dizer que Python, F# e D ganharam o prêmio “Viva, não preciso implementar funções hash!”

Prêmio Não tá faltando nada, não?

F#, por não precisar (nem permitir) usar return no final das funções.

— Pra retornar um 0 do main é só deixar o 0 solto ali no fim?

— É.

— Puxa!

Prêmio Union

F#. Definir o tipo PdfObject foi muito fácil em F#, disparado.

Prêmio Metaprogramação

D. Defini todas as subclasses de PdfObject usando geração de código a partir de strings. Demorou um pouco até eu conseguir fazer algo que não desse uma mensagem de erro bizarra, mas foi legal.

Ctrl+C, Ctrl+V é para fracos. Em D, o compilador faz isso por você.

Prêmio Diferente de todo o resto

F#. Eu já tinha lido um pouco sobre a família dessa linguagem (ML), mas foi a primeira vez que programei numa linguagem dessas. Refrescante, mesmo que eu tenha usado poucas abordagens novas. O legal é F# não tem a distinção de statement e expression (tudo é expressão). Longe de ser característica exclusiva de F#, mas acabou que de todas as linguagens que testei, ela foi a única com essa característica.

Prêmio {Curly braces}, que tédio

D, Java, C++. Depois de tanto programar com {chaves}, dá um certo tédio ver mais uma linguagem nesse estilo. Não que eu prefira estudar coisas bizarras como APL, Forth ou Lisp*, nem morto. Mas é legal de vez em quando escrever um then ou apenas dois-pontos depois da condição de um if.

*Trollando lispeiros só pra rir um pouco

Prêmio Menor linha de comando

Python. Não precisa passar nada de especial na linha de comando pra rodar. As otimizações das opções -O e -OO são o mesmo que nada, praticamente.

Menção especial ao Java também, por não precisar de nenhuma opção de otimização e ainda assim ter bom desempenho (sem contar a inicialização, claro).

Prêmio Pipes e foreach, viva!

PowerShell, claro. Facilitou muito os testes. Se não fosse o PowerShell, teria escrito em Python, seria interessante também.

Prêmio Pseudocódigo

Python, que é praticamente pseudocódigo que executa (junto com Lua). Linguagens sempre acabam tendo esquisitices, Python e Lua se destacam por não se renderem à criação de $sintaxes <| bizarras. D e Java também têm potencial de se parecerem com pseudocódigo (só que com {chaves}), mas não acertaram exatamente no alvo, falta ou sobra algo…

Prêmio REPL

Python, por permitir testar trechos de código num ambiente interativo (Read-Eval-Print Loop) e permitir listar membros, ver os tipos das variáveis e sua documentação.

F#, porque também tem um REPL (o F# Interactive) e ajudou muito. Mas para alguns detalhes era mais prático usar o IntelliSense do Visual Studio do que o F# Interactive.

Prêmio Complicação desgraçada fiadapu

C++. Vejamos um exemplo:

Em Python, uma estrutura do tipo hash table, se chama dict. Esse é o nome do tipo, e existe a sintaxe com {} para construir um diretamente (embora seja possível construir com dict também).

Em Java, um tipo equivalente seria:

HashMap<String, PdfObject>

É necessário declarar o tipo dos elementos e não há sintaxe especial para inicializar a estrutura, mas tudo bem.

Na verdade, o nome completo do tipo é

java.util.HashMap<java.lang.String, PdfObject>

Um pouco mais complicado, mas nada de mais.

Em C++, eu usei um

unordered_map<string, shared_ptr<PdfObject>>

É um pouquinho maior, e eu precisei usar um shared_ptr para não ter que me preocupar com a desalocação dos PdfObject. Não é tão ruim, né?

Bom, internamente esse tipo é traduzido para:

std::tr1::unordered_map<
  std::basic_string<
    char,
    std::char_traits<char>,
    std::allocator<char>
  >,
  std::tr1::shared_ptr<PdfObject>,
  std::hash<
    std::basic_string<
      char,
      std::char_traits<char>,
      std::allocator<char>
    >
  >,
  std::equal_to<
    std::basic_string<
      char,
      std::char_traits<char>,
      std::allocator<char>
    >
  >,
  std::allocator<
    std::pair<
      std::basic_string<
        char,
        std::char_traits<char>,
        std::allocator<char>
      > const,
      std::tr1::shared_ptr<PdfObject>
    >
  >
>

“Simples”, né? E é isso que aparece nas mensagens de erro e no IntelliSense, só que sem indentação!

Prêmio C++ está afundando na própria complexidade, vamos começar de novo e fazer certo

Esse prêmio vai para o D, obviamente. Pena que D (pelo menos a versão 2) também ganhou o prêmio de imaturidade…

Prêmio Máquina virtual? E se eu não quiser levar 100MiB junto com o meu programa?

C++ e D. Dispensas explicações. Queria colocar mais linguagens nessas categoria, o que eu incluiria?

Anúncios

3 pensamentos sobre “Premiação

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s