This workshop is independently hosted by John A. De Goes

​

Functional Scala is an extensive three-day course that may be attended remotely (Pacific Time zone) or locally (San Francisco, California). The course rigorously instructs Scala developers on the most complex, confusing aspects of Scala, and shows them how to use the features of the Scala programming language to write rock-solid, bulletproof business applications that are easy to test, easy to reason about, and easy to change safely in arbitrary directions required by the business.

​

If you know Scala but are confused by concepts and techniques in functional programming, or perplexed by advanced features of Scala’s type system, then this is the course for you. You will learn how functional programming enables Scala developers to build highly-scalable, concurrent, parallel, asynchronous, testable, and modular programs. You will discover how to program passionately and fearlessly, with confidence, and build and test scalable programs that are correct-by-construction.

​

Prerequisites

 

This course assumes prior knowledge of basic programming in Scala. You should ensure that you are comfortable with the following topics to maximize your takeaway from this course:

• Case Classes

• Pattern Matching

• Basic Recursion

• Traits and Objects

• Scala Collections

• Basic Generics

 

If you are brand new to Scala, it is recommended to read a quick overview to prepare yourself for the course, like Scala for the Impatient.

​

Day 1: Functional Essentials

 

In Functional Essentials, you will learn the foundations on which all functional programming in Scala is built: function composition, algebraic data types, higher-kinded types, and type classes. These topics can be very confusing to even experienced Scala developers but properly explained, can provide a smooth gateway into the world of functional programming. By the end of the day, you’ll be confident in using ADTs and composition to solve real-world problems, know why higher-kinded types are important to code reuse and how to use them, and understand how functional programs cleanly and simply abstract over data types.

​

• Function Composition. In object-oriented programming, code can be reused, but implementation inheritance leads to the logic for an entity being scattered across a complex hierarchy. Functional programming provides a simpler, saner approach based on composition. You will learn how to use composition rather than inheritance to build larger pieces from smaller, self-similar pieces.

​

• Algebraic Data Types. Many bugs in applications are caused by invalid data, which leads to edge cases, logic errors, and runtime exceptions. Functional programming provides Algebraic Data Types (ADTs), which allow you to precisely your domain in a way that eliminates these bugs. Equipped with a knowledge of ADTs and how they improve upon the "record" types found in other programming languages like Java, you will gain an ability to craft precise models of your domain that do not allow invalid states to exist

​

• Parametric Polymorphism. In object-oriented programming, the main component of code reuse is subtyping (of which inheritance is one example). Functional programming provides parametric polymorphism, which allows both greater code reuse (by making code more generic), as well as pushing the specification of code into its type, so the Scala compiler can help check correctness at compile-time. You will learn how to use parametric polymorphism to create less tangled and more flexible code than the object-oriented equivalent.

​

• Higher-Kinded Types. In object-oriented programming, generics allow us to reuse code—for example, having a single sorting algorithm that can work with arrays of any element type. However, traditional OOP generics aren’t powerful enough to allow us to reuse higher-order logic. Functional programming provides Higher-Kinded Types (HKTs), which allow us to abstract over first-order abstractions (e.g. a collection-like data structure). You will understand why higher-kinded types are important to code reuse, and you will be able to pick apart and understand even the most complex higher-kinded type signatures.

​

• Type Classes. The traditional object-oriented habit of mandating that classes extend certain interfaces results in tangled inheritance hierarchies that are hard to understand, and impossible to force onto third-party libraries. In functional programming, Type Classes provide an alternative way of adding structure to types, one that is easier to understand and works for user-defined and third-party data types alike. You will learn how to define and implement your own type classes so you can write generic code that works across user-defined and third-party data types.

​

Day 2: Functional Abstractions

 

In Functional Abstractions, you will learn the core type classes used in functional programming, including some from abstract algebra and others from category theory. You will also learn about some of the powerful data types like lenses that help make functional programming better at stateful, effectful programs than procedural programming. By the end of the day, you’ll have a firm grasp on monads, functors, monoids, lenses, prisms, and traversals.

​

• Abstract Algebra. In object-oriented programming, many opportunities for code reuse go unnoticed, because common patterns do not come equipped with strong guarantees. In functional programming, monoids, semigroups, rings, fields, and other structures encapsulate common patterns of composition and combination, and can be used to solve many problems, especially in data processing. You will learn the basics of abstract algebra and define instances of monoids and other structures for common business data types.

​

• Functor Hierarchy. In object-oriented programming, design patterns like visitor, command, and dependency injection are used to describe common patterns. In functional programming, we can give names to common patterns and describe their behavior with structured type classes (instead of English prose) and generic laws, which lets us reuse more code and have a clearer idea of when code benefits from a certain pattern. The functor hierarchy, including everything from functor to applicative and monad and beyond, let’s us describe patterns of building data, changing data, and building programs to compute data. You will learn how to identify patterns that can benefit from various types of functors, including monads, and implement instances for practical data types.

​

• Folds & Traverses. In object-oriented programming, processing data is accomplished by writing lots of imperative loops. In functional programming, we can eliminate the duplication inherent to this style of programming, and focus strictly on the step of a loop, and its contribution toward the overall result of the iteration. This segment explores catamorphisms in the context of processing tree-like data structures, including lists, trees, and options. You will learn how to write clean, compact, and clear iterations using folds, and how to perform powerful of effectful loops using monadic traversals.

​

• Optics. In object-oriented programming, objects have getters and setters, which allow easy manipulation of data, but at the cost of local reasoning, because passing a data reference to any code anywhere means giving permanent read/write access to the data. In functional programming, a powerful construct known as optics (including lenses and prisms) allow us to preserve local reasoning and gain back not just easy data manipulation, but first-class fields, which can be passed around and stored in data structures. You will learn how to manipulate deeply nested data in a first-class, functional, and powerful way.

​

Day 3: Functional Effects

 

In Functional Effects, you will learn how to use functional effect systems like ZIO, Cats Effect, and Monix. These libraries let you do functional programming across your whole application, building leak-free Scala applications that are asynchronous and concurrent. Functional effect systems like ZIO include operations for resource safety, parallelism, and building highly concurrent, efficient code that is free of race conditions and deadlocks. By the end of the day, you will feel confident using libraries like ZIO, and will have built your own purely functional application in a graduation project that ties together everything you learn in the course.

​

• Effects. In object-oriented programming, types say nothing about the behavior of a function, and detailed exploration of code is necessary to understand behavior. Functional programming solves these problems by turning effects into ordinary values, which allows types to describe behavior, and provides powerful ways of reasoning about and composing programs. You will learn how to describe any interaction with effectful systems using monadic effect types.

​

• Asynchronicity, Concurrency & Parallelism. In object-oriented programming, asynchronicity, concurrency and parallelism are extremely painful, because of the presence of imperative callbacks and shared mutable state, which leads to callback hell, deadlocks, thread leaks, and other massive pain points. Functional programming provides a more principled, sane model of asynchronicity, concurrency and parallelism, which makes developing asynchronous, safe, scalable programs trivial. You will learn how to write efficient (asynchronous) and performant code.

​

• Resource-Safety. In object-oriented programming, the only primitive for resource safety is try / finally, which doesn’t work for asynchronous and concurrent programs, and can’t help avoiding thread-leaks. Functional programming allows us to increase the usefulness of try / finally across asynchronous and concurrent code, and across threads as well as file and socket handles. You will learn how to write programs that cannot leak resources.

​

• Real World Programming. In object-oriented programming, real world concerns include error management, thread management, and interaction with the external world. Functional programming lets us handle all these concerns, with strong benefits to type safety, modularity, reasoning, and testability. You will learn how to solve the concerns of every day programming using the tools of functional programming.

​

• Testing & Mocking. In object-oriented programming, testing effectful code is difficult, often requiring strange mocking libraries that perform bytecode rewriting. Functional programming makes testing even the most effectful code trivial, without requiring any bytecode rewriting and still being completely typesafe. You will learn how to thoroughly test effectful code with blazing fast unit tests that require no magic and are completely type safe.

​

Daily Structure

​​

• 9:00 - Begin Instruction

• 10:25 - Break

• 10:35 - Resume Instruction

• 12:00 - Lunch Break

• 13:30 - Resume Instruction

• 14:55 - Break

• 15:05 - Resume Instruction

• 16:25 - Break

• 16:35 - Resume Instruction

• 17:30 - End of Day

​

Venue

 

The training course will take place at a hotel centrally located in San Francisco (to be determined). San Francisco is a beautiful city and a tech hub on the Pacific coast, being the home to many companies using Scala in production.

​

Attendance

 

Attendance to Functional Scala is local or remote. Local attendees must arrange their own transportation and lodging to the host city, as well as meals on days of the training. Remote attendees will be provided with a link to a remote meeting session, in which they can see and hear the live workshop, ask the instructor questions, and chat with both local and remote attendees. Motivated remote attendees who participate in all exercises can expect to get nearly as much out of the training as local attendees.

​

Materials

 

Attendees will be provided with example code, a course outline, and exercises in electronic form. The workshop is not recorded and recording is strictly prohibited.

​

Price

 

See the pricing information by clicking "Register now" below. 

​

Financial Aid

 

Financial aid is available for qualified applicants. If you would like to attend the training but cannot afford the list prices, please contact the organizer for information on all available aid packages.

​