In this intensive two-day Haskell training course, you will take a look beyond the surface of Haskell to how things are implemented. You will discuss the internal representation of data on the heap; what exactly lazy evaluation means and how it works; how the compiler translates Haskell code to a target language via several internal representations (plus what you can reasonably expect the compiler to do); and how you can tweak the optimizer behaviour with compiler pragmas such as inlining annotations and rewrite rules.
- Boost your understanding of Haskell to build robust Haskell programs that scale -
Join Andres Löh, Haskell consultant and co-owner of Well-Typed LLP, as he looks at existing, widely used and highly optimized libraries and how they are implemented internally. The course will work through several crafted, hands-on exercises and examples to deepen the understanding of the concepts discussed and to illustrate common pitfalls and corner cases.
Who you will be sitting next to
Find yourself seated next to experienced Haskell developers who have a solid understanding of basic Haskell concepts and want to write large(r) Haskell programs that scale.
How to apply these skills
Develop your understanding of and experience with Haskell to an expert level so that you can write larger, robust Haskell programs that scale.
Book early to receive a discount on the course price and in doing so you will not only commit to growing your own skillset, but help us grow our community of over 140,000 passionate techies.
Interested in taking Guide to Haskell Performance and Optimization on 15th - 16th October? Make it a week of learning by joining us for Haskell eXchange 2018, and get a special discount on your conference ticket!
Call or email our team for more information on the HaskellX Fringe Package.
Learn how to:
- Understand common Haskell data structures and their performance characteristics.
- How to avoid common performance pitfalls.
- Understand how custom rewrite rules work.
- Use interesting optimizations such as lambda lifting, (stream) fusion and worker-wrapper.
Common Haskell data structures and their performance characteristics, such as lists, sequences, finite maps, hash maps, byte strings, text and arrays.
Unboxed types and the tradeoffs between boxed and unboxed types.
Lambda calculus and evaluation strategies; the differences between call-by-value, call-by-name and call-by-need (lazy evaluation).
GHC's compilation process and its intermediate languages: Core, STG and C--, with an emphasis on understanding Core.
Strictness analysis and space leaks.
Common performance pitfalls and how to avoid them.
Debugging tools such as time and space profiling.
How the inliner works and how it can be tweaked. How custom rewrite rules work.
Some interesting optimizations such as lambda lifting, (stream) fusion and worker-wrapper.
This course targets Haskell developers who have a solid understanding of basic Haskell concepts and want to write large(r) Haskell programs that scale. In terms of language concepts, knowing the contents of "Well-Typed's Fast Track to Haskell" is sufficient, and the two courses can in principle be taken back to back. In practice, the benefit of this course will be higher if participants have already gained some experience writing Haskell code on their own.
Bring your own hardware
You are expected to bring your own laptop with your preferred IDE.