Do you already have a basic understanding of Haskell, and want to take the next step towards Haskell mastery? This two day advanced course takes you to the next level of Haskell and help you learn how to create the best performing code!
This two-day Haskell course gives you the chance to deepen your understanding and master some of Haskell's more advanced concepts. To this end, we'll have a thorough look beyond the surface of the Haskell language and into the way things are implemented. You'll learn more about how Haskell's evaluation mechanism works, how data is represented in memory, how to reason about performance, how GHC's internal core language looks like, what design patterns to apply for writing idiomatic yet scalable and performant code, and how to parallelize Haskell programs to make use of several cores.
There'll be an overview of Haskell's most important data structures, what performance characteristics they have and advice on when to use which data structure.
We'll discuss the difference between parallelism and concurrency, and we'll look at Haskell's support for writing concurrent applications. Last but not least, we'll talk about patterns for structuring large applications: from applicative functors via various monads to monad transformers. We'll discuss the motivation for each of these concepts, provide examples, and look at their implementation and use.
All topics will be accompanied by small, carefully chosen exercises that can be solved during the course and serve to deepen the understanding of the concepts just discussed, but also illustrate common pitfalls and corner cases.
Learn how to:
- Reason about the performance of Haskell programs
- Debug Haskell code using the tools available
- Pick the right data structure for the job
- Write parallel and concurrent programs in Haskell
- Become comfortable with applicative functors, monads and monad transformers.
What the community says
"Very thorough and useful. Lots of tips and library/technology suggestions, an eye opening course."Andy Smith on 2nd May 2014
- The difference between immutable (persistent) and mutable data structures.
- Typical functional data structures and their performance.
- Memory layout of Haskell data structures.
Lazy evaluation and profiling
- How lazy evaluation really works.
- The advantages and pitfalls of lazy evaluation.
- Profiling Haskell programs.
- Space leaks and how to fix them.
- General advice on how to write Haskell code that performs well.
Parallelism and concurrency
- The difference between parallelism and concurrency.
- Writing deterministic parallel programs.
- Lightweight threads and communication between threads.
- High-level approaches to concurrency.
- Abstracting from recurring patterns.
- Applicative functors.
- Monads versus applicative functors.
- How to combine and add effects to your code.
- Monad transformers.
If you have some experience developing in Haskell, but would like to learn how to unleash the full power of the language, understand the details about lazy evaluation, learn how to write code that is not only robust but also fast, and dive into the details of Haskell's advanced type system - then this course is for you!
Some experience with Haskell and understanding of basic Haskell concepts such as covered by the course Fast Track to Haskell is assumed in this course.
Bring your own hardware
You are requested to bring your own laptop for this course, with the Haskell Platform installed - to learn how to develop within your own environment.
If you are unable to bring a laptop for this course, please contact the community team on +44 207 183 9040 or email us.