Técnicas de criação de interpretadores

 (craftinginterpreters.com)
3 pontos por GN⁺ 2024-07-13 | 1 comentários | Compartilhar no WhatsApp
  • Crafting Interpreters é um livro estruturado para que leitores que queiram criar sua própria linguagem possam acompanhar do começo ao fim a implementação completa de uma linguagem de script
  • Ele aborda em um fluxo contínuo desde conceitos de projeto de linguagens, como parsing e semântica, até a implementação da execução, como representação em bytecode e coleta de lixo
  • O leitor começa em main() e implementa diretamente uma linguagem com tipagem dinâmica, escopo léxico, funções de primeira classe, closures, classes e herança
  • Ao fazer com que todo o código, com alguns milhares de linhas, seja escrito diretamente pelo leitor, o foco fica mais na compreensão do funcionamento interno do que apenas no resultado final
  • Está disponível em formatos impresso, eBook, PDF e web, e na web é possível ler gratuitamente todos os capítulos, textos complementares e ilustrações

Escopo de implementação do livro

  • Crafting Interpreters é voltado para leitores que querem criar sua própria linguagem de programação ou entender como linguagens são projetadas e implementadas
  • O livro cobre em conjunto os principais tópicos necessários para implementar uma linguagem de script completa
    • parsing
    • semântica
    • representação em bytecode
    • coleta de lixo
  • A implementação começa em main() e, no fim, evolui para uma linguagem com os seguintes recursos
    • sintaxe rica
    • tipagem dinâmica
    • escopo léxico
    • funções de primeira classe
    • closures
    • classes
    • herança

Forma de leitura e resultado

  • Em vez de apenas olhar o código de exemplo, o leitor acompanha a estrutura interna de um interpretador escrevendo cada linha por conta própria
  • O código final tem alguns milhares de linhas e é estruturado com o objetivo de alcançar uma implementação limpa e rápida
  • Em vez de separar conceitos de alto nível e implementação de baixo nível, o livro foi pensado para que ambos sejam entendidos juntos no processo de concluir uma única linguagem

Formatos disponíveis

Leituras relacionadas

1 comentários

 
GN⁺ 2024-07-13
Opiniões no Hacker News

  • Sou o autor. Ver a reação positiva ao meu livro aquece muito o coração. Dediquei muito tempo e carinho a ele, e é muito gratificante ver que teve o efeito que eu esperava

    • Sou engenheiro de software autodidata e só comecei a programar aos 21 anos; no meu primeiro emprego, recebi a tarefa de criar uma linguagem de consulta simples e seu interpretador. Eu não fazia ideia do que era um interpretador, mas encontrei este livro online em 2017 e, em 3 ou 4 dias, consegui criar um protótipo funcional; 1 ou 2 semanas depois, já tinha algo em produção.
      Esse material me deu muita confiança, e até hoje lembro desse projeto como um dos trabalhos de que mais gostei
    • Obrigado por escrever o livro. Estou quase terminando a Parte 1 e, só porque quis experimentar, estou acompanhando em Haskell; a cada capítulo percebo que algum “truque esperto” em que pensei não era tão esperto assim diante dos requisitos que aparecem depois.
      Também fico curioso se você pensa em escrever um livro de continuação, como um compilador ou JIT para Lox. E o lexical analygator é sensacional: ele apareceu várias vezes, com a devida fonte, em apresentações internas da empresa, e por um tempo até houve fan art dele no quadro branco
    • Game Programming Patterns também é excelente. Em ambos os livros, sinto que o estilo é honesto e direto.
      Alguns autores parecem achar que precisam fingir que essa área é toda magia negra; mas talvez eu é que não tenha sido capaz de entender os padrões de projeto do GoF
    • Ainda não terminei o livro inteiro, mas agradeço muito por ele estar disponível gratuitamente online. Comprei a versão impressa, o PDF e a versão Kindle, e recomendo a outras pessoas que apoiem o autor da mesma forma
    • Este livro e Writing An Interpreter In Go são livros que quero muito ler quando tiver mais tempo. Tenho várias ideias para criar uma linguagem básica de composição tipográfica

  • Li Crafting Interpreters quando criei o Crumb (https://github.com/liam-ilan/crumb), e especialmente as partes sobre escopos e variáveis locais foram essenciais.
    O equilíbrio entre implementação técnica e insight conceitual é muito bom, então o livro ajuda bastante mesmo quando você tenta sair do caminho estabelecido por ele. Esse tipo de escrita técnica é um material de tão alto nível que serve como referência a aspirar

    • Você disse “engenheiro aspirante”, mas, olhando para o Crumb que você criou, há boas notícias
    • Já pode se chamar de engenheiro. Não precisa ser modesto, e não é preciso concluir um diploma em ciência da computação para virar engenheiro.
      A documentação é boa e o projeto é legal
    • Parece bacana. Fico curioso sobre como você decidiu quais tipos de dados incluir

  • A parte de que mais gostei no livro é que ele conduz você a escrever dois interpretadores diferentes para a mesma linguagem.
    Isso permite entender bem as partes mais complexas e sutis do processo de criar uma linguagem de programação. Na primeira metade do livro, você encontra e se familiariza com as grandes ideias; quando as reencontra no segundo interpretador, consegue absorver de verdade as partes interessantes. É um livro realmente incrível

  • Já que também estamos falando de outros materiais sobre compiladores, ainda não terminei de assistir, mas gostei dos vídeos em que Immo Landwerth cria um compilador em C#, gerando IL, símbolos de depuração etc.
    O material é de cerca de 5 anos atrás, então não usa a sintaxe mais recente de C# e parece ser da época do .NET Core 3 ou algo assim, mas isso não deve causar grandes problemas na maior parte do trabalho. Só que podem aparecer muitos avisos relacionados à nulidade de tipos.
    https://www.youtube.com/playlist?list=PLRAdsfhKI4OWNOSfS7EUu...

  • Sinto que a maioria dos programadores deveria, algum dia, seguir este livro até o fim. Quando fiz isso, passei a entender muito melhor o que realmente acontece por dentro de compiladores e ferramentas de linguagem.
    Está entre os guias técnicos mais bem escritos que já acompanhei, e me ajudou muito a internalizar os conceitos. Esses conceitos são úteis em muitos lugares além de compiladores

    • Fico curioso sobre onde eles são úteis além de compiladores. Por exemplo, poderia ser em coisas como análise de formatos de dados

  • Uma vantagem secundária deste livro, mas talvez igualmente importante, é que ele ensina clareza.
    O texto, o código, a estrutura e o ritmo são todos claros e essenciais. A palavra “Crafting” se encaixa perfeitamente: parece um livro escrito por um artesão para artesãos

  • Acho que este livro deveria ser a segunda ou terceira etapa na jornada de compiladores de linguagens de programação.
    A primeira etapa é, sem saber nada sobre interpretadores ou design de linguagens, tentar escrever sozinho um interpretador para uma linguagem simples criada por você. A segunda etapa é reescrevê-lo, cometendo menos erros.
    Sem fazer isso, é difícil realmente apreciar as sutilezas do tema, e você acaba passando batido por conceitos que não parecem importantes

    • Para mim, este livro fez esses assuntos deixarem de parecer misteriosos e, na verdade, me permitiu começar a segunda e a terceira etapas.
      Não há problema em não reinventar todas as técnicas por conta própria desde o início. Ficar sobre os ombros de gigantes é algo natural
    • Eu não sabia por onde começar e achava que um projeto desses era uma espécie de magia além da minha capacidade. Mas, depois de ler Crafting Interpreters, percebi que meu pensamento só precisava de um pequeno empurrão.
      Se eu não tivesse lido algo como CI primeiro, nem teria tentado escrever um interpretador por conta própria, e não teria chegado à terceira etapa
    • Lembro que, quando estava começando a aprender Java, queria criar minha própria linguagem. Implementei um algoritmo de precedência de operadores sem procurar nada, varrendo a lista de tokens e encontrando a subexpressão de maior precedência a cada vez.
      Não havia recursão; eu colocava e tirava coisas manualmente de uma pilha. O problema é que eu não entendia parsing direito, então implementei a maior parte da linguagem com string.split e string.replace e, como esperado, surgiram conceitos que não podiam ser aninhados. Tenho pena de não ter guardado o código-fonte
    • Eu fiz exatamente isso também. Como primeira etapa, criei uma linguagem parecida com TeX e implementei definição e substituição de macros.
      Poucos dias depois, ao encontrar bugs demais, passei a adotar uma postura mais acadêmica e comecei a ler livros. Ainda assim, foi uma ótima primeira etapa: sem essa tentativa, talvez eu nem soubesse que esse era um assunto para um livro inteiro

  • Respeito muito pessoas com esse nível de dedicação e todos que mantêm a infraestrutura de desenvolvimento, mas fico feliz que minha fase de “quero criar uma linguagem” tenha acabado sendo só um interesse passageiro
    O volume de trabalho é realmente enorme

    • Não precisa necessariamente ser um volume enorme de trabalho. O Lisp-em-Lisp do livro original SICP ou um interpretador de cálculo lambda escrito em Haskell cabem até em uma tela

  • Fico curioso se alguém conhece bons materiais sobre como criar uma linguagem com tipagem estática que tenha coisas como polimorfismo paramétrico e inferência básica de tipos

    • Já me pediram várias vezes para escrever um livro desse tipo, mas um grande motivo de eu ainda não ter feito isso é que o tema é aberto demais
      Em Crafting Interpreters, senti que era possível criar uma linguagem pequena e autocontida que contivesse quase todos os conceitos que eu queria ensinar: escopo de variáveis, funções, closures, classes e despacho dinâmico, fluxo de controle etc.
      Já em sistemas de tipos, há bifurcações demais no espaço de design e não existe um caminho “melhor” claro. Todas estas escolhas são bifurcações: há subtipagem? Genéricos são apagados ou reificados? Código genérico é especializado em tempo de compilação? A inferência de tipos é local ou Hindley-Milner?
      Qualquer que seja a escolha, você deixa de fora conteúdos importantes dos ramos não escolhidos e pode decepcionar leitores que esperavam outro caminho. Talvez um livro panorâmico mais amplo, como Types and Programming Languages, seja o mais adequado; mas aí se perde a diversão de ir construindo uma coisa única e coerente
    • Existe o Modern Compiler Implementation in ML, de A. W. Appel
      Também há edições em C e Java do mesmo livro, mas considero inferiores. Eu preferiria usar junto com a edição em ML
    • O núcleo do polimorfismo paramétrico e da inferência de tipos acaba sendo a implementação do Algorithm W. Dá para procurar implementações de brinquedo online e mexer nelas por conta própria
      Eu vi que a implementação em https://github.com/wh5a/Algorithm-W-Step-By-Step/blob/master... tinha um estilo muito antigo, então a modernizei e organizei até chegar a https://gist.github.com/kccqzy/fa8a8ae12a198b41c6339e8a5c459.... Depois, “quebrei” de propósito várias partes para ver como o algoritmo falhava
    • É um pouco mais teórico, mas acompanhar com calma o curso de compiladores do Coursera foi um grande ponto de virada para mim. Tive de rever alguns vídeos várias vezes
      Recomendo fortemente tentar, de uma forma acessível, uma daquelas tarefas de ciência da computação que a gente acha que só magos conseguem fazer. Depois que você conclui uma ou duas, percebe que, embora seja difícil, em geral é uma questão de ir avançando aos trancos e barrancos, e isso dá muita confiança. Quem quiser seguir esse caminho pode entrar em contato em zellyn@(most things)

  • Acabei de terminar a parte 2 e é um livro realmente excelente. Fazer por conta própria um ou dois dos exercícios sugeridos em cada capítulo ajuda muito a entender o conteúdo