English {#english}
Learn Compilers Using CrabPascal
Series — Part 2: Previous: Audit Deep Dive: IDE, CI, and Docs (054-audit-ide-ci-docs). Course doc: resources/curso-compiladores-crabpascal. Technical depth: architecture/technical/tecnico-detalhado.
Textbooks teach compilers with toy languages — CALC, MiniJava, IMP. Useful, but abstract. CrabPascal is a real compiler: lexer, parser, semantic analyzer, dual backends, RTL shims, and a sprint history you can read in git. The Mintlify course resources/curso-compiladores-crabpascal turns that codebase into a one-hour guided tour. This post explains why that matters and how to use it.
Why learn compilers through a real project?
Compiler courses often stop at code generation for a language with ten constructs. Production compilers add:
- Error recovery and diagnostic spans
- Namespace resolution and unit loading
- Object layout, VMT, and properties
- Two execution modes (interpret vs native C)
- A runtime with 65+ builtins
CrabPascal exposes all of this in Rust, with Pascal fixtures you already understand if you know Delphi. You are not learning a compiler — you are learning how Delphi-like semantics get implemented.
Course structure (six modules)
The course in Mintlify walks six chapters:
- Introduction — Why translation is fascinating; compilers as protectors and optimizers
- Anatomy — Frontend (lexer, parser, semantic) vs backend (codegen, linker)
- Lifecycle — Source to executable; where CrabPascal's dual-mode fits
- CrabPascal case study — Concrete file map and pipeline phases
- Real-world compilers — GCC, LLVM, Rustc comparisons
- Next steps — How to contribute after the tour
Each section links theory to files you can open today.
Map theory to repository paths
| Concept | CrabPascal location |
|---|---|
| Lexical analysis | src/lexer/ |
| Parsing / AST |
src/parser/, src/ast/
|
| Semantic analysis | src/semantic/ |
| Interpretation | src/complete_runtime.rs |
| C code generation | src/codegen/ |
| Preprocessor | src/preprocessor/ |
| Unit graph | src/unit_resolver.rs |
| Delphi RTL surface | rtl/sys/*.pas |
Read architecture/technical/tecnico-detalhado alongside the course for VMT, heap layout, and builtin dispatch tables.
Hands-on exercises (self-paced)
After each module, try one small task:
After lexer module — Add a token trace to a failing fixture:
crab-pascal check tests/fixtures/your_file.pas
After parser module — Read a parser_hardening.rs test; find the AST node it asserts.
After semantic module — Introduce an undefined variable; confirm Sprint 1 span format in output.
After backend module — Compare run vs build-exe on a string fixture; note honest failures post-v2.21.0.
After runtime module — Trace a property read in complete_runtime.rs starting from a three-line class.
These exercises mirror what sprint contributors do — not exams, but navigation practice.
Who is this course for?
- Delphi developers curious why their code behaves differently in CrabPascal
- Rust developers wanting a large, readable compiler codebase
- CS students past the dragon book who need a maintained case study
- Contributors preparing for RTL, parser, or codegen sprints
Intermediate level assumed: you should read Pascal and basic Rust syntax.
Connection to the audit series
Posts 050–054 documented technical debt honestly. The course does not hide gaps — it shows where in the pipeline each feature lives so you can fix TD-IDs with context. Learning and contributing converge.
Suggested reading order
-
getting-started/quickstart— run hello world -
resources/curso-compiladores-crabpascal— full course -
architecture/technical/arquitetura-design— design decisions -
009-compiler-pipeline-five-phases(blog Part 1) — pipeline overview - Pick one sprint review matching your interest (generics, exceptions, strings)
Takeaway
Compiler education does not require starting from zero. CrabPascal offers a bilingual, open, sprint-documented laboratory. Work through the course, then claim one backlog item — parser fixture, RTL shim, or parity test. That is how compiler engineers are made in 2026.
Next: Mapping the Delphi Bible to CrabPascal (056-delphi-bible-analysis).
Português {#portugus}
Aprenda compiladores com CrabPascal
Série — Parte 2: Anterior: Auditoria: IDE, CI e documentação (054-audit-ide-ci-docs). Curso: resources/curso-compiladores-crabpascal. Profundidade técnica: architecture/technical/tecnico-detalhado.
Livros ensinam compiladores com linguagens de brinquedo — CALC, MiniJava, IMP. Útil, mas abstrato. CrabPascal é um compilador real: lexer, parser, analisador semântico, dual backends, shims RTL e histórico de sprints legível no git. O curso Mintlify em resources/curso-compiladores-crabpascal transforma esse codebase em tour guiado de uma hora. Este post explica por que importa e como usar.
Por que aprender compiladores via projeto real?
Cursos de compiladores often param em codegen para linguagem com dez construtos. Compiladores de produção adicionam:
- Recuperação de erro e spans de diagnóstico
- Resolução de namespaces e carregamento de units
- Layout de objetos, VMT e properties
- Dois modos de execução (interpretar vs C nativo)
- Runtime com 65+ builtins
CrabPascal expõe tudo isso em Rust, com fixtures Pascal que você já entende se conhece Delphi. Você não aprende um compilador — aprende como semântica Delphi-like é implementada.
Estrutura do curso (seis módulos)
O curso no Mintlify percorre seis capítulos:
- Introdução — Por que tradução fascina; compiladores como protetores e otimizadores
- Anatomia — Frontend (lexer, parser, semântica) vs backend (codegen, linker)
- Ciclo de vida — Fonte ao executável; onde dual-mode do CrabPascal encaixa
- Estudo de caso CrabPascal — Mapa concreto de arquivos e fases do pipeline
- Compiladores reais — Comparações GCC, LLVM, Rustc
- Próximos passos — Como contribuir após o tour
Cada seção liga teoria a arquivos que você pode abrir hoje.
Mapeie teoria para paths do repositório
| Conceito | Local no CrabPascal |
|---|---|
| Análise léxica | src/lexer/ |
| Parsing / AST |
src/parser/, src/ast/
|
| Análise semântica | src/semantic/ |
| Interpretação | src/complete_runtime.rs |
| Codegen C | src/codegen/ |
| Preprocessor | src/preprocessor/ |
| Grafo de units | src/unit_resolver.rs |
| Surface RTL Delphi | rtl/sys/*.pas |
Leia architecture/technical/tecnico-detalhado junto com o curso para VMT, layout de heap e tabelas de dispatch de builtins.
Exercícios práticos (auto-ritmo)
Após cada módulo, tente uma tarefa pequena:
Após módulo lexer — Adicione trace de token a fixture que falha:
crab-pascal check tests/fixtures/seu_arquivo.pas
Após módulo parser — Leia teste em parser_hardening.rs; ache o nó AST que ele asserta.
Após módulo semântica — Introduza variável indefinida; confirme formato de span Sprint 1 na saída.
Após módulo backend — Compare run vs build-exe em fixture de string; note falhas honestas pós-v2.21.0.
Após módulo runtime — Trace leitura de property em complete_runtime.rs partindo de classe de três linhas.
Esses exercícios espelham o que contribuidores de sprint fazem — não provas, mas prática de navegação.
Para quem é o curso?
- Desenvolvedores Delphi curiosos por que código se comporta diferente no CrabPascal
- Desenvolvedores Rust querendo codebase de compilador grande e legível
- Estudantes de CC pós-dragon book que precisam de case study mantido
- Contribuidores se preparando para sprints RTL, parser ou codegen
Nível intermediário assumido: leia Pascal e sintaxe Rust básica.
Conexão com série de auditoria
Posts 050–054 documentaram débito técnico honestamente. O curso não esconde gaps — mostra onde no pipeline cada feature vive para você corrigir TD-IDs com contexto. Aprender e contribuir convergem.
Ordem de leitura sugerida
-
getting-started/quickstart— rode hello world -
resources/curso-compiladores-crabpascal— curso completo -
architecture/technical/arquitetura-design— decisões de design -
009-compiler-pipeline-five-phases(blog Parte 1) — visão do pipeline - Escolha um sprint review alinhado ao seu interesse (generics, exceptions, strings)
Conclusão
Educação em compiladores não exige começar do zero. CrabPascal oferece laboratório bilíngue, aberto e documentado por sprint. Faça o curso, depois claim um item do backlog — fixture de parser, shim RTL ou teste de paridade. Assim se formam engenheiros de compiladores em 2026.
Próximo: Mapeando a Bíblia Delphi no CrabPascal (056-delphi-bible-analysis).
Published on dev.to/@crabpascal · Código em CrabPascal
Top comments (0)