top of page

Serverless Training

Portable Serverless Top-to-Bottom
November 13, 2019
9am - 5pm

Speakers: James Ward (Google),Ryan Knight (Grand Cloud), Josh Suereth (Google) and Amy Unruh (Google)

In this training, you will setup & deploy a serverless application that includes event functions, services, data streaming, and machine learning.  For event functions and services we will use the open-source Knative project on Kubernetes. For data streaming, we will use Apache Kafka. And for machine learning, we will use Kubeflow.  

All of these pieces will be weaved together through a series of hands-on exercises that create a cohesive serverless application that consumes, processes and analyzes a stream of Stack Overflow questions. You will be able to run everything on your own machine or in the cloud. The workshop exercises will use either ZIO with Scala or Java with Micronaut.


​The hands-on exercises will include three major parts:

  • Serverless Applications with Knative - Knative is an open-source project that provides a way to run serverless applications on Kubernetes with features like autoscaling, scale-to-zero, blue-green deploys, and internal services. In this phase of the workshop, we will introduce Knative, deploy a serverless app, and explore features like blue-green deploys and autoscaling.


  • Serverless Event Streaming - In this phase of the workshop we will build a Kafka adapter that consumes the data set, performs ETL of the data stream, and writes it to Kafka.


  • Serverless Machine Learning with Kubeflow - Kubeflow is an open-source machine learning stack that runs on Kubernetes. The Kubeflow project is dedicated to making deployments of ML workflows on Kubernetes simple, portable, and scalable. In this phase of the workshop, you will learn how to install and use Kubeflow, including Kubeflow Pipelines, to support an end-to-end ML workflow.


During the workshop, you'll install Kubeflow from scratch, see how to use Kubeflow's multi-user Jupyter notebook servers and other core components, and build and run Kubeflow Pipelines that support full ML workflows, using both the Pipelines UI and its SDK. 


In the process, we'll look at how you can use logging, metrics and visualizations, and metadata/artifact tracking, to support ML workflow evaluation and reproducibility.

  • 9:00 - 9:20 Intro & What is Serverless? Why Serverless? 

  • 9:20 - 9:50 Serverless Architecture 

    • Functions & Services

    • Data Streaming / CQRS

    • Data Architecture

    • Machine Learning

    • Cold starts

  • 9:50 - 10:00 Portable Platform 

    • “as a Service” or “on your own servers”

    • Can I run it while on a plane?

  • 10:00 - 10:30 - Kubernetes 

    • Setup K8s or GKE

  • 10:30 - 11:00 Break

  • 11:00 - 12:00 Knative Part 1

  • 12:00 - 13:00 Break

  • 13:00 - 14:00 Knative Part 2

  • 14:00 - 15:00 Kafka - Serverless Event Streaming 

    • Setup Kafka

    • Connect app to Kafka

  • 15:00 - 15:30 Break

  • 15:30 - 17:00 Kubeflow: Serverless ML 

    • Setup Kubeflow

    • Create & deploy a model

    • Update a model & A/B test it (monitor effectiveness)

Scale By the Bay Talk: Serverless Scala -
Functions as SuperDuperMicroServices

By James Ward and Josh Suereth, Google

Serverless is all the rage but what does it mean for Scala developers?  Can we take a plain ol' Scala function and run it on the cloud with infinite scalability?  This talk will explore how to build and deploy serverless Scala and how to avoid startup overhead.  We will also explore how to build pure serverless functions to make programs more provably correct, easier to build, test, and run.  We will use Google Cloud as a reference serverless implementation but the concepts are applicable with any provider.

Scala Workshop by Artima

Simply Scala Workshop
November 4-8, 2019

Speakers:  Bill Venners and Frank Sommers, Artima

A hands-on, intensive Scala training course
taught by Bill Venners and Frank Sommers

Scala fuses object-oriented and functional programming in a concise, high-level language applicable to a wide range of programming tasks, from enterprise applications to data science, and more.


This five-day workshop consists of a three-day fundamentals course followed by a two-day advanced course. The three-day Fundamentals Workshop will help you become more proficient and productive in Scala. The two-day Advanced Workshop will give you a deeper understanding of the more advanced features of the language. You can sign up for either course or join us for all five days!


Five days: November 4-8, 2019
San Francisco, CA (Register Here)

Part I: Fundamentals: three days, November 4-6
Groups of five or more: $1295
Regular price: $1795

Part II: Advanced: two days, November 7-8
Groups of five or more: $845
Regular price: $1195

Entire workshop (Parts I & II): five days, November 4-8
Groups of five or more: $1995
Regular price: $2595

Also available as an in-house workshop.


About the venue

For information about the location of the venue, transportation, and hotels, see: San Francisco Workshop Venue and Hotel Information



Workshops will be held the week of November 4-8 in San Francisco, CA. To register for a workshop you must either provide a purchase order or payment. You can pay with a credit card by pressing the "Add to Shopping Cart" button below or email us a purchase order at If you have any questions, please call us at (925) 394-7298 ext 109.

Refund policy


Refund policy: if you cancel within two weeks of the workshop, we will give you a 90% refund. If you cancel less than two weeks prior to the workshop, we will refund you 50% of your payment. If you cancel during the course, we, unfortunately, cannot give a refund.

Get 10% off with the code SCALEBYTHEBAY19

Functional Scala by John A. De Goes (SF Edition 2019)

Functional Scala Workshop
November 11-13, 2019

Speaker:  John A. De Goes

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.



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



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 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.



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.



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.

bottom of page