Contributions

Tutorial
In this video we are going to learn about the heart of the FP and OO blend. In addition to that we will start playing with implicits for the first time on this channel so be prepared for some magic and scalac bugs.
Tutorial
In this video we are going to add more functionality to Sets and generalize (not to be confused with generics) some of the existing methods to take functions as arguments instead of Sets.
Tutorial
In this video we are going to learn about the father of recursive traversals - the mighty fold.
Tutorial
In this video we will test the waters of generic programming - a type theory concept relevant for the realm of statically typed languages such as Scala. Parametric Polymorphism (aka Generics) makes a statically typed language more expressive without sacrificing type safety.
Tutorial
In this video we are going to implement our very first higher-order function on Sets which will allow us to traverse (walk through) the entire Set and apply a function to each element while doing so. Additionally we are going to learn about variable argument functions (varargs), which is a syntactical construct for implementing functions with a virtually endless amount of homogeneous arguments.
Tutorial
In this video we are going to revamp our initial implementation of Sets, since it offered no way to link elements of a Set to each other and thus prevented us from implementing methods like isSubsetOf.
Tutorial
In this video we will set up the project for our homegrown collections library and implement a very basic yet mathematically accurate version of Sets. This video is inspired by the "Functional Programming Principles in Scala" Coursera course).
Tutorial
In this video we will cover the basics of the Set Theory, just enough to finally begin writing our own collections library and the first collections being well... Sets.
Tutorial
This video is a crash course for unit testing Scala code with a library called ScalaTest. Unit testing is a concept for automatically validating programmers assumptions at a press of a button which is an invaluable tool in a professional software developers toolbox. In addition to learning the basics of writing and running unit tests with ScalaTest we will also learn how to catch certain errors at compile time with the help or Artimas SuperSafe Scala compiler plugin, generate ScalaTest HTML repo
Article
A small project to play around with the collections library just as a show case of what a well-written library has to offer.
Tutorial
This is the 3/3 part of the video series in which we are going to learn about the infamous cake pattern, which is commonly discussed in the context of dependency injection. In order to explore the intricacies of this pattern we are going to write a massively over-engineered todo app with a terminal delivery mechanism and an in-memory persistence layer.
Tutorial
This is the 2/3 part of the video series in which we are going to learn about the infamous cake pattern, which is commonly discussed in the context of dependency injection. In order to explore the intricacies of this pattern we are going to write a massively over-engineered todo app with a terminal delivery mechanism and an in-memory persistence layer.
Article
This is the 1/3 part of the video series in which we are going to learn about the infamous cake pattern, which is commonly discussed in the context of dependency injection. In order to explore the intricacies of this pattern we are going to write a massively over-engineered todo app with a terminal delivery mechanism and an in-memory persistence layer.
Article
In this video we will see how traits can be used as an alternative for packages. We will learn about self types and the differences between them and inheritance and discuss the gotchas surrounding the topic.
Tutorial
In this video we will talk about packages - a mechanism for splitting your code into modules which may reside in separate files while maintaining the precious cohesion. It is common to discuss imports together with packages, a tradition which we will honor, however we will also see that packages and imports are very flexible concepts in Scala in contrast to other popular programming languages.
Tutorial
In this video we will discuss all the possible ways to handle errors in Scala. It is mostly focused on exceptions, but also covers other interesting Techniques like Option, Either, Try, util.control.Exception.catch and friends, home baked types, external libraries and many other things. Most importantly it provides some guidance for when to use which technique.
Tutorial
After having learnt about partial functions and pattern matching it is time to dive deeper and find out how to define pattern kinds of our own. For this we will have to refresh our knowledge about tuples. Learn about a new type called Option and dig quite deep down the rabbit whole to see all the magic behind case classes and discover extractors! This video got too long so it is split into 2 parts.
Tutorial
Warning: there is so much syntactic sugar in this video that you might get diabetes! In this video we will learn what happens behind the scenes when we use (partial) function literals in Scala. We will learn about lambdas, function objects, anonymous classes, magic, partial functions and their use cases.
Article
This is the second video about objects vs data structures in which we will learn when to use which and most importantly what happens if YOU chose wrong! This video is very much related to the videos about subtype polymorphism and inversion of control. Among other things we will learn how Java lacks support for dealing with data structures whereas Scala comes prepared.
Tutorial
In the previous few videos we started exploring the object-oriented world, but maybe we should not swim too far. In this video we discuss issues that arise from programming language dependent interpretations of object-orientation. This is the first of two videos in this series, which concentrates on issues with comparing two computational objects for equality and provides an outlook to the future of Scala.
Tutorial
In this video we will learn about the majority of use cases for traits - interfaces on steroids. We will learn how to add functionality to existing classes, even the ones whose code we cannot access! We will learn how to modify behavior with the "Stackable modifications" pattern, which can also be used to intercept behavior. Most importantly we will learn about linearization - a solution for the issues which commonly arise with multiple inheritance and diamonds.
Tutorial
In this video we will learn about inheritance - a mechanism for achieving modular design which as a by product allows for code reuse even though the code reuse part is frowned upon lately. We will discuss semantic differences between inheritance and subtype polymorphism and learn about object-oriented design patterns such as the "Template method" pattern. We will also dive into visibility and inheritance modifiers.
Tutorial
In this video we will discover the primary value that Object Oriented programming has to offer: Dependency Inversion or Inversion of Control (IoC) via Subtype Polymorphism and dynamic dispatch. If you wish to be reminded of the benefits of IoC rewatch this video: https://youtu.be/Zj5AhkHDkDI which can almost be considered a prerequisite for this one. Not understanding the benefits of dependency inversion is a flaw no software developer can afford! As a by-product we will also learn how to pass o
Tutorial
Fun little project for Scala beginners.
Tutorial
In the previous video we learnt about the environment model of computation, which is necessary because Scala as most languages allows assignment to variables. In this video we combine all the knowledge we have gathered so far and use it to derive an entire programming style called message passing style. We will derive it from the environment model of computation and eventually we will see how an entire paradigm is based on it.
Tutorial
In this video we are going to start exploring the environment model of computation. We will also cover the substitution model for procedure application with both applicative- and normal-order evaluation. Furthermore we will see how the concept of garbage collection is based on the environment model of evaluation.
Tutorial
In this video we are going to learn about models of computation and why they matter. We will quickly walk through the most prominent models and in the next video we will look at two of them in depth. The models discussed in this video are: substitution (with both applicative- and normal-order evaluation), environment and stream-processing. We also take a glimpse at thread-based as well as event-based concurrency models and even mention the actor model of computation.
Tutorial
A YouTube course about learning Scala as a first programming language. It offers a fresh look at Scala from the eyes of a programming beginner in contrast to a regular Scala beginner (a probable Java refugee).

The course is ongoing. New videos are published every Sunday.