Aleksandra Sikora
Making Sense of Programming Languages
#1about 4 minutes
The value of understanding language internals
Learning how programming languages work is valuable for all developers, enabling the creation of custom linting rules, IDE extensions, and domain-specific languages (DSLs).
#2about 3 minutes
Understanding language grammars and structure
Programming languages are defined by grammars, which are sets of rules that distinguish between regular grammars (predictable, sequential) and context-free grammars (recursive, complex).
#3about 3 minutes
Distinguishing between interpreters and compilers
Languages are not inherently interpreted or compiled; their implementations are, with some systems like V8 using both a compiler and an interpreter.
#4about 3 minutes
Exploring the code processing pipeline
Code is processed through a pipeline that includes scanning (lexing), parsing into an abstract syntax tree (AST), analysis, and finally evaluation by an interpreter or compiler.
#5about 6 minutes
Building a lexer and parser with typescript-parsec
A live demonstration shows how to use typescript-parsec to build a lexer that creates a stream of tokens and a parser that organizes them into an abstract syntax tree (AST).
#6about 3 minutes
Implementing a simple tree-walk interpreter
The interpreter is built as a recursive function that walks the abstract syntax tree (AST), evaluating each node to produce a final result while managing variable scope.
#7about 8 minutes
Extending the language with a custom print syntax
A new print feature using a question mark suffix is added by updating the lexer to recognize the token, the parser to create a new AST node, and the interpreter to handle the new logic.
#8about 1 minute
Conclusion and resources for language development
The talk concludes by sharing the open-source project and providing resources for anyone interested in exploring programming language creation further.
Related jobs
Jobs that call for the skills explored in this talk.
Matching moments
03:28 MIN
Introducing the Langium framework for language engineering
Langium: Design your own language in Node.js and VS Code
00:57 MIN
Approaching the live pair programming challenge
Coffee with Developers - Jonathan Tang
02:27 MIN
Final thoughts on learning from alien programming languages
Java with a Clojure mindset
03:34 MIN
How Langium processes code into an abstract syntax tree
Langium: Design Your Own Language in Node.js and VS Code
02:45 MIN
An overview of the Langium framework
Langium: Design Your Own Language in Node.js and VS Code
13:13 MIN
Manipulating code reliably with Abstract Syntax Trees
Let's build a VS Code extension for automated refactorings
16:54 MIN
Q&A on type systems and legacy code
Typed Security: Preventing Vulnerabilities By Design
06:43 MIN
The evolution from simple scripts to compilation
The Eternal Sunshine of the Zero Build Pipeline
Featured Partners
Related Videos
Langium: Design your own language in Node.js and VS Code
Irina Artemeva
Langium: Design Your Own Language in Node.js and VS Code
Miro Spönemann
Building a Compiler with C#
Florian Rappl
How to become an AI toolsmith
Clemens Helm
Create DSL (Domain Specific Language) on top of Swift
Milan Todorović
Python: Behind the Scenes
Diana Gastrin
Where we're going we don't need JavaScript - Programming with Type Annotations
Peter Kröner
JavaScript the Grumpy Parts
Rob Richardson
Related Articles
View all articles



From learning to earning
Jobs that call for the skills explored in this talk.




Speech Processing Solutions
Vienna, Austria
Intermediate
CSS
HTML
JavaScript
TypeScript


doinstruct Software GmbH
Berlin, Germany
Senior
GIT
JavaScript
TypeScript

CONTIAMO GMBH
Berlin, Germany
Senior
Python
Docker
TypeScript
PostgreSQL

autoiXpert GmbH & Co. KG
Stuttgart, Germany
Senior
Node.js
Angular
MongoDB
TypeScript
