Functional Programming Courses

All of our course material is open source and we encourage everyone to provide feedback. These courses are for you and the community, so if we can make them better then we want to know!

Keep reading to find out more about our pricing options, or click on the links below to find out more about each course:

Course Pricing

We have free and paid courses with the same content for each course.

Update as of February 2020: QFPL has come to a close, and so the free courses are no longer offered. It is possible that Data61 may run public courses for a fee in the future, although at the time of writing that it is unclear how likely that is.

The Difference

The timing and location of the free courses is based on demand. You are more than welcome to attend, we encourage it! But it is still open to the general public and we will run the course when and where we deem it the most beneficial. Additionally the content of the course will not be altered.

If you pay for the course, then we come to you. We run a focussed version of the course for only your list of attendees. We’re also able to tweak the course content to suit your needs.

Or maybe a boot camp for a specific focus, if you have internal Functional Programming skills already but are in need of further training in a particular topic.

Course Tiers

Free - no longer offered as of February 2020

  • When:TBD
  • Where:TBD
  • Cost:Free!
  • Catering and Travel:Lunch is on us!

Paid *min 5 attendees

  • When:Contact Us
  • Where:Contact Us
  • Cost:

    • ( 5-10) $2500 / person
    • ( 10-20 ) $2000 / person
    • ( 20+ ) $1500 / person
  • Catering and Travel:

    • within Australia, it is included.
    • outside of Australia? Contact us.

Introduction to Functional Programming [top]

January 2018, Melbourne 01

This training course is targeted at professional software engineers within organisations who aspire to improve their programming skills and deploy those skills in a professional environment. The introductory course is generally considered intense since it covers a diverse range of the fundamental Functional Programming tools.

The introductory training course runs over 3 full days and can be modified prior to meet any specific requests. For example, you might want to learn what monads are all about, and what practical application they have in production software. We can provide a specific focus on achieving this goal within the 3 days of the course.

After course completion, attendees are introduced to support forums to assist in their continued development in exploring Functional Programming. The Queensland FP Lab is supported by experts around the world who volunteer their time and knowledge to ensure that anyone committed to learning FP has all the resources that they need.

Functional Programming is a skill and practice that promises to improve software development time, quality and lowering development costs by taking advantage of the mathematical principles of computer programming. This introductory course prepares your organisation to directly exploit these benefits.

There is no prior knowledge of Functional Programming to attend the introductory training course. The only pre-requisite is bringing in your work laptop and general knowledge of navigating your operating environment on that laptop e.g. using a text editor and a command line.


Day 1

  • introduction to the Haskell programming language
  • introduction to the fundamental definition of Functional Programming
  • exercises with Haskell using basic FP programming constructs

Day 2

  • review of exercises on Day 1
  • introduction to higher-order generalisation with exercises; (the “Don’t Repeat Yourself” principle, taken to its conclusion)
  • exercises with Haskell on monad-based parsing
  • exploration of external programming tools that are enabled by Functional Programming

Day 3

  • review of exercises on Day 2
  • more review of exercises on Day 2 :)
  • exercises writing I/O programs in a purely-functional programming environment
  • an introduction to Functional Programming support forums for further independent learning i.e. “where to now?”


The introductory FP course prepares you to overcome the initial learning barriers to Functional Programming, such that you can confidently explore more advanced FP topics independently. This course has been very popular in the past since it provides a concrete motivation for Functional Programming in a production software environment and empowers a participant to continue exploring FP independently and to their own productive advantage.

On completion of this course, attendees will be able to confidently explain the definition of Functional Programming and answer questions such as:

  • why would I use Functional Programming?
  • why do Functional Programmers use mathematics terminology for their practice?
  • how does Functional Programming save me money in software development?
  • by what means does Functional Programming improve software quality?

What do you need to bring?

  1. A suitable development computer (e.g. laptop) for working through the exercises. You will also need to install the Glasgow Haskell Compiler version 7.10 or higher on that machine.

  2. A copy of the introductory FP course material on that machine. The material is open-source and available on github.

If there are any issues with this preparation, please contact the QFPL who will set you up.

Applied Functional Programming [top]

January 2018, Melbourne 00

This is the follow-up course to the Introduction to Functional Programming, which is targeted toward programmers who have become proficient with navigating Functional Programming concepts and would like to progress to building a complete application. The Applied FP course activities involve writing (from scratch) a REST web application with a sqlite database backend.

Similar to the introductory FP course, the applied FP course is run over 3 full days. Some participants of the applied FP course prefer a modification where the initial exercises are condensed to focus on the more advanced topics.

After completion of the applied FP course, attendees will be fully equipped to tackle large software projects using Functional Programming in their organisation. The applied FP course structure includes various techniques of applying FP principles to more general software development tasks, such as; project structure, database integration, configuration, and testing.

Prior Functional Programming knowledge is required for this course. Although there is no hard and fast rule for this, a useful guide for determining a participants suitability for the applied FP course is the ability to confidently read, implement, and explain to others, a function with this type signature:

f :: Applicative f => [f a] -> f [a]

If not, the introductory FP course is for you, to better prepare you for the applied FP course.


This agenda is a rough guide, only. The applied course is self-paced, with the instructors there for guidance and questions. Some sections of the applied FP course can be particularly challenging and are worked through as a group exercise. Discussion amongst participants is encouraged as each person will become stuck at different stages.

The overall ordering is as follows:

  • “Hello, World!” - Every project starts somewhere. We begin with defining the structure of our application and how to go about declaring project dependencies and configuration.

  • Type driven development - We take a specification and define a data type to represent it. Being able to almost directly translate a specification to a type that we can use to guide our development is a powerful Functional Programming feature. We demonstrate and discuss how such a type can improve and produce more robust and accurate software.

  • Testing - Functional Programming is immensely powerful, but this doesn’t obviate the need for testing. Functional Programming has wonderful tools for testing and we lay the groundwork for them here. Covering the configuration as well as writing some of our own.

  • Database integration - In this, we cover how to create and maintain a connection to a database. We also visit techniques for handling the error conditions that may arise with database programming, and how to encode and decode the information. We use SQLite, for the sake of simplicity. Through discussion and example, we cover off some of the more advanced database packages that are available to functional programmers.

  • Abstracting error handling - Participants will, from first principles, create an entirely abstracted technique of error handling that is then applied to the application. This process demonstrates how Functional Programming allows you to abstract away code repetition in a way that is excludes certain classes of common software bugs that otherwise arise. All of the error handling that participants have been using up to this point will disappear. It is subsequently demonstrated to participants how to leverage the compiler and libraries, such that they never need to write this code themselves, saving immeasurable amounts of time and effort.

  • Configuration - Applications are rarely static, they are configurable through either files or direct input. This application is no different and the participants will add configuration to the application. Both file based and command line options are implemented.

  • Abstracting argument passing - Similar to the process of removing the error handling code from the application, we will remove the need to pass around a common parameter through an application. Participants will have the lesson driven home that if you’re repeating something when using Functional Programming, you are most likely able to abstract it away. Identifying these opportunities to ntake advantage of the tools of abstraction to improve software robustness is a critical component of the applied FP course.

  • Finally we finish with a Q & A session that covers what the participants have learned, and what the next steps in learning and deploying their new skills in an organisation. The discussion covers topics such as already-established FP libraries and some more advanced programming techniques. The participants are also encouraged to engage in open discussion about Functional Programming and the techniques they’ve learned. Additional reference material for more advanced topics is also provided.


At this stage of their education, participants are often self-motivated and in search of suitable materials to learn from. This course provides the structure, material and guidance required for participants to progress.

On completion of this course, participants will:

  • Have a working example application to experiment with, refer to, and build upon.
  • Know how to write their own applications using Functional Programming.
  • Be able to explain and demonstrate how type driven development can prevent bugs and improve design.
  • Be able to understand and apply Functional Programming techniques to abstract entire problem domains, reducing duplication, preventing bugs, improving design, and reducing time required.
  • Be able to understand and demonstrate the power of composing functions as an application design technique.
  • Know where and how to start learning the more advanced topics to be able to use more powerful techniques and libraries.
  • Be inspired to keep learning.

What do you need to bring?

  1. A suitable development computer (e.g. laptop) for working through the exercises. You will also need to install the minimal Haskell Platform version 7.10 or higher on that machine. This should include the Glasgow Haskell Compiler and the cabal-install build tool. To ensure you have both, run the following commands:
$ ghc --version
The Glorious Glasgow Haskell Compilation System, version XXXX

$ cabal --version
cabal-install version XXXXXXX
compiled using version XXXXXXX of the Cabal library
  1. A copy of the introductory FP course material on that machine. The material is open-source and available on github.

  2. Working install of SQLite (

If there are any issues with this preparation, please contact the QFPL who will set you up.