Beta: F# in the Workplace
4.8 (5 ratings)
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.
15 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Beta: F# in the Workplace to your Wishlist.

Add to Wishlist

Beta: F# in the Workplace

Domain Modelling & TDD
4.8 (5 ratings)
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.
15 students enrolled
Created by Mark Gray
Last updated 3/2016
Price: $30
30-Day Money-Back Guarantee
  • 1 hour on-demand video
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • 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
View Curriculum
  • For this course we advise that you already have F# installed and ready to go.
  • Before taking this course ensure you understand F# syntax.

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.

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.
Compare to Other F# Courses
Curriculum For This Course
12 Lectures
Modelling a domain with F#
12 Lectures 01:11:15

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

Preview 01:45

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

Preview 06:53

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

Preview 04:11

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.

Implementing deal

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

Testing dealCard

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.

Refactoring dealCard

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.

Shuffling the deck

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

Dealing fairly

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

Fixing our tests

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

Comparing shuffle algorithms

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.

Cleaning up the code

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.

About the Instructor
Mark Gray
4.4 Average rating
206 Reviews
7,324 Students
3 Courses

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.