Beta: F# in the Workplace

Domain Modelling & TDD
5.0 (1 rating)
Instead of using a simple lifetime average, Udemy calculates a
course's star rating by considering a number of different factors
such as the number of ratings, the age of ratings, and the
likelihood of fraudulent ratings.
7 students enrolled
Take This Course
  • Lectures 12
  • Length 1 hour
  • Skill Level Intermediate Level
  • Languages English
  • Includes Lifetime access
    30 day money back guarantee!
    Available on iOS and Android
    Certificate of Completion
Wishlisted Wishlist

How taking a course works


Find online courses made by experts from around the world.


Take your courses with you and learn anywhere, anytime.


Learn and practice real-world skills and achieve your goals.

About This Course

Published 3/2016 English

Course Description

This course aimed at students with beginner to intermediate skill in F#, basic understanding of the F# syntax and a light functional understanding would be beneficial. You'll also need a computer with Linux, OSX or Windows with F# installed and an internet connection.

Have you wanted to understand how to 'do' F# in your day job? Well, this course demonstrates how you can use Test Driven Development and the F# type system in tandem to write a domain for any problem you are attempting to solve.

What will we do?
We will complete an F# library project together,

  1. We will start by defining the concepts of the domain, using some tips from Domain Driven Design, but predominantly working in the area of Test-Driven Development whilst harnessing the power of the F# type system. We will explore every line of code together and point out all the important programming concept as we progress.

What is f#?
F# is a mature, functional-first, general purpose language especially well suited to computer science, machine learning, distributed computing and web applications, Domain Driven Design and Test-Driven Development too. There really is no limit to what F# can do for you!

We’ve structured the course to make learning all the material as easy and accessible as possible. We’ll challenge you to complete an F# programming task in every video to make sure you’ve got a great grip on all the concepts. But don’t worry, because after every challenge, we’ll also walk you through a solution line by line.

We have structured the course to introduce you to some computer science and functional concepts, but to also encourage you to spend your own time to gain further insights into the Domain Driven, Test-Driven concepts we introduce you to.

If you want to program with a language that has computer science at its heart and want to future proof your learning then this course is for you.

What are the requirements?

  • For this course we advise that you already have F# installed and ready to go.
  • Before taking this course ensure you understand F# syntax.

What am I going to get from this course?

  • Drive out functionality with unit tests
  • Implement algorithms to solve some of the requirements of the project.
  • Deploy functional techniques in you code to enhance usability and readability
  • Create usable, easy-to-read domains from specification using the F# type system

Who is the target audience?

  • This course is for developers that see the benefits of F# and want to learn how to use the techniques in real projects.
  • Take this course to learn how harness the F# type system by turning specifications into easy-to-read F# code.
  • Utilise Test Driven Development (TDD) so that you can assist the type system while creating F# code to represent a problem domain.
  • This course is not aimed at advanced users that are already using F# in their day jobs, it is designed to cover general aspects of F# type system and TDD.

What you get with this course?

Not for you? No problem.
30 day money back guarantee.

Forever yours.
Lifetime access.

Learn on the go.
Desktop, iOS and Android.

Get rewarded.
Certificate of completion.


Section 1: Modelling a domain with F#

In this lecture we introduce the course and describe the topics you are going to encounter.


In this lecture we start creating the concept of a card using F# code.


Now we have the concept of a card underpinned we can start constructing a full deck of cards.


In this video we examine what is required to deal a card from the deck, learning about the restrictions we should enforce on how we call the deal function.


We have a deal function and now we can begin to test the function to ensure it is behaving as we desire.


After highlighting some shortcomings in the method we have chosen to deal cards, we go over the code and refactor it and come out with a complete function that can deal a card properly.


To ensure we are going to be able to create a game of cards that can be played fairly we need to know how to shuffle the deck of cards to add an element of unpredictability. In this lecture we create a shuffler.


In this video we learn how we can utilise the type system to create a deal function that is fully functioning and prevents predictability.


In this video we will fix the failures we caused in our test by introducing a new type; 'ShuffledDeck'


This lecture demonstrates how to benchmark your algorithms to help you have a better intuition for implementing algorithms of your own.


Final steps to clean up the domain file Cards.fs, in this video we compact the file and demonstrate how the entire domain can be represented on a single page.


Well done for completing the course, you have learned how to successfully and effectively turn poorly written specifications into beautiful, concise and readable F# code.

Students Who Viewed This Course Also Viewed

  • Loading
  • Loading
  • Loading

Instructor Biography

I have been a passionate software engineer since 2002 and have worked for companies such as The AA, Volkswagen Financial Services and Compare the Market, to name but a few.

I discovered programming when I was 18 and taught myself web development and Java and then moved into the .NET world in 2003. I now run the Cambridge F# User Group and co-organise the Cambridge DDD Nights User Group, both meet on a monthly basis.

My love of programming has given me the opportunity to experience various programming languages but I have happily settled on F# and I am now a proud sustaining member of the F# Software Foundation.

Ready to start learning?
Take This Course