5 Things you need to know about Scala compilation

We all love Scala, but the one aspect we have a hard time accepting are long compile times. It’s not uncommon for a project to experience compilation times of a handful of minutes, if not worse. On top of that, compilation times are unpredictable, depending on a combination of language features, external libraries, and type annotations. A single line change may increase compilation times ten fold.

Don’t bow to the compiler and accept long compilation times. Rather, understand how the compiler works and optimize your usage of Scala to compile faster!

Transcript

1. 5 Thing You Need To Know About Scala Compilation Iulian Dragos Triplequote co-founder ScalaSphere Krakow, 2018-05-16
2. #1 Build time ≠ Compilation time
3. Build time ≠ Compilation time • Before starting compilation: • Dependency resolution • Source generators • Formatter • Settings evaluation
4. Build time ≠ Compilation time • Before starting compilation: • What do we need to compile? • Hash classpath, hash sources (a LOT of I/O) • Load analysis data
5. Build time ≠ Compilation time • Finally Sbt starts compiling: Zinc and incremental compiler: 15% overhead
6. Use an IDE to build!
7. #2 Type Classes + Macro Derivation =
8. Type Classes, Macro • Imports take precedence over companion objects • Cost: implicit resolution • Cost: additional code to be generated
9. Type Classes, Macro
10. Type Classes, Macro Decoders/ implicits 0 1 2 Code size after type-checking 8 KB 31 KB 54 KB
11. #3 Whitebox macros are type-checked 3x!
12. What’s the different between whitebox and blackbox macros?
13. Which one takes part in type-inference?
14. Which one takes part in type-inference? Shapeless macros are whitebox
15. #4 Type-checking should be around 30%
16. #4 Type-checking should be around 30% • Type-checking Scala sources takes time • but should not go above 30% of total compilation time! • Use -verbose to see times for each phase (and a lot of noise)
17. #4 Type-checking should be around 30% • If more, you can bet your money on one (or more) of: • Macro expansion • Implicit resolution • Quasiquotes, type tags, string interpolation (macros in disguise)
18. #5 The Typer Multiplier
19. How does the size of the AST change through phases?
20. #5 The Typer Multiplier • Generally, type checking adds nodes • Mo’ nodes, mo’ time, mo’ coffee • What is a typical value of the TP? 1.2x • but it can vary wildly, between 0.8 and 5x
21. #6 Scala compiler is single-threaded
22. #6 Scala compiler is single- threaded • It’s a batch compiler • Careful interplay of laziness and mutability • Laziness required for recursive types • Mutability for performance • Bigger/more powerful machines won’t make a dent in compilation times • Unless you have a parallel Scala compiler! • Hint: there is one that works today!
23. How fast is scalac? Simple code (Spark) FP-heavy (Cats) Play Framework (LiChess) Average Views Controllers 1’200 LoC/s 480 LoC/s 1’500 LoC/s 2’000 LoC/s 500 LoC/s (2.12.4 numbers, with a warm compiler — except LiChess: 2.11.11)
24. Trusted by https://triplequote.com/early-access Join the EAP