Inside the Compiler: Language design and compilation

Kinomodus Slå av kinomodus Minispiller

Live on April 28 at 5:25 PM

If you're a programmer, you know at least one programming language. You probably know more than one. But what does it take to create a language? We've lined up speakers Noah Hall, Olle Fredriksson and Robin Heggelund Hansen who have implemented their own languages, to help demystify language development.

Some questions we'll try to answer:

• How does a compiler work?
• What exactly is a lexer or a tokenizer?
• How do performant compilers handle large amounts of text parsing, coupled with dependency chains between files?
• How does mapping input code to a final output work?
• What's the language server protocol?
• Why on earth might you want to do this?

You'll walk away with knowledge on how compilers and the process of language design works. We hope you'll also walk away with some inspiration to create your own compiler or language.

The programme:

• The "Make your own programming language" checklist

  Noah Hall:

  Picture the scene. You're fighting with the Java compiler about bracket placement, wishing it was blocks were controlled by whitespace instead. The more you think about it, the bigger the pot of programining language features cook in your head. So.. what's next? Next, you implement a basic parser, of course! Once the code's parsed, you'll need to turn it into something that can run. Now you need dependency support, to avoid having one giant file. You wish your editor had syntax highlighting, and autocomplete. So you write a language server. You're still annoyed by minor formatting mistakes, so you make an auto-formatter. You want to share your code between projects, so you make a package manager. In this talk, I'll go through all these steps. You'll come away knowing how to get started turning your programming language day dreams into reality, and hopefully get inspired to write your own!

• Compiling polymorphism: existing techniques and new directions

  Olle Fredriksson:

  Polymorphism is a fundamental tool in programming languages, but how is it actually compiled? This talk explores existing strategies—such as uniform representations and monomorphization—and their trade-offs. I'll also introduce a novel approach to unboxing polymorphic values in my dependently typed language, Sixten, which enables unboxing in a language with highly expressive features that resist monomorphization. Finally, we'll look at how monomorphization techniques can be extended to more expressive type systems, such as those with higher-rank types.

• Language design 101

  Robin Hansen:

  How do you design a programming language? Which decisions do you have to make, and which trade-offs do you constantly have to balance?