Lesson 1: Welcome & Overview

[sampsyo]

There's not much to Lesson 1—just write your ideas about what goes into a good language implementation other than optimizations!

[charles-rs]

A good language implementation should tell you places in your code that it found difficult to optimize, in case there is something you can change to make the compiler's job easier

[sampsyo]

This is indeed a super valuable thing for language implementations to do, and something that very few modern compilers actually do! Seems like a good research area.

[charles-rs]

sbcl (lisp compiler) does this really well i think!

[zilberstein]

Toolchains: additional static analysis tools that programmers can use in the IDE to help them understand and improve their code. Some of this might be based on the languages type system

[michaelmaitland]

A good language implementation should have good error reporting (where was the error and why did it occur).

[andrewb1999]

A language implementation could check for common security issues, such as buffer overflows, or prevent them in the first place with types.

[chhzh123]

A good language implementation should have necessary type checking and prevent unexpected behaviors before execution. (Actually I'm not sure this is about the language itself or the implementation).

[sampsyo]

Yeah, good question. Certainly it's the case that typed languages both need to have an abstract design for their type systems and they need an implementation of that type system. Some type systems are easier to implement well than others… and one thing that most abstract designs don't dictate is what to do for ill-typed programs! (For example, what a good error message looks like.)

[s-ren]

Language implementations should be modular and extensible.

[anthonyyangdev]

A good language implementation should be able to check for potentially unsafe code or code with undefined behavior.

[atucker]

A good language implementation should let you use the hardware that it supports without too much hassle.

[sampsyo]

This is another thing that mainstream compilers do incredibly poorly! For example, gcc by default lets you compile code only for the host architecture, i.e., the hardware that the compiler itself is running on. And even Clang, which can technically generate code for many different targets out of the box, has lots of problems with ancillary toolchains (you will need to get your hands on a libc for the target architecture, for example!!).

[anshumanmohan]

A good language implementation should "lift" the domain it operates on to a higher level of abstraction, thus leaving the programmer with fewer things to worry about.

[yy665]

A good language implementation should make profiling and any performance evaluation easier.

[sampsyo]

Yeah! I'd argue that profilers themselves fall under the umbrella of language implementation.

[ayakayorihiro]

This may be a bit different from the prompt, but a good language implementation (as with any program) should not have bugs. (How have people tested/verified their compilers? Is the process different from testing/verifying any other kind of code?)

[sampsyo]

Super important, of course, and easier said than done! 😂

[5hubh4m]

A good language implementation should make type systems of said language easier to use; whether by making type error messages accurate, or having good type inference. One cool thing I have not yet seen in compilers I've used is the ability to say why a type inference failed in a human readable way and what can be done to correct it.

[tonyjie]

A good language (& domain-specific language) implementation should give some hints on optimizing on targeted hardwares.

[andreyyao]

A good language implementation should be conscious of people's programming habits and conventions. In other words, it shouldn't assume all valid programs are equally likely to appear in practice.

[JonathanDLTran]

A good language implementation should be able to generate code that performs how the user expects the code to, for example, not having slow-downs at surprising places in the code.

[sampsyo]

Indeed! This property is sometimes called "performance predictability".