BlogtechnicalLast Workshops Of The Year With John A. De Goes

Last Workshops Of The Year With John A. De Goes

Ziverge Inc. is offering the 4 last workshops of the year with John A. De Goes

08 September 2020# scala# courses

Level up your skills with these high quality courses.

Ziverge Inc. is offering the 4 last workshops of the year with John A. De Goes.

Functional Effects (ZIO) by John A. De Goes (09/23/2020 - 09/24/2020)

Functional Design by John A. De Goes (10/20/2020 - 10/22/2020)

Functional Data Modeling by John A. De Goes (11/18/2020 - 11/19/2020)

Scala 3 for Scala 2 Developers by John A. De Goes (12/08/2020 - 12/10/2020)

Functional Effects (ZIO) by John A. De Goes

For years, actors have allowed Scala application developers to build async, concurrent, and distributed applications that are resilient, reactive, and scalable. Increasingly, however, functional effect systems are being used to create these types of applications with greater type-safety, more flexibility, and increased testability.

In this course, Scala developers will learn how to solve complex problems in asynchronous, concurrent programming using the ZIO library. Upon completion of the course, attendees will be confident using the ZIO library (and similar libraries, like Monix or Cats IO) to build modern high-performance, asynchronous, concurrent applications that don't block threads, don't deadlock, and don't leak resources; and which follow best practices regarding error management, thread management, and dependency management.

Who Should Attend

Scala developers who would like to write modern async, concurrent, and distributed applications that are robust, testable, and powerful.

Prerequisites

Good working knowledge of Scala, including familiarity with immutable data, pattern matching, and basic recursion. Developers who have attended Functional Scala Foundations will be well-prepared for this course.

Topics

  • Laziness of functional effects
  • Escaping callback hell
  • Using the compiler to help deal with errors
  • Separating recoverable errors from non-recoverable errors
  • Separating blocking code from async code
  • Safe handling of async and concurrent resources
  • Efficient concurrency and parallelism
  • Shared concurrent state without visibility issues, deadlocks, or race conditions
  • Testing functional effects
  • Retrying and repetition
  • Resource-safe, effectful, async streaming
  • Test-friendly dependency management

Functional Design by John A. De Goes

Although functional programming theory is useful, most day-to-day functional programming does not require any category theory or even any type classes. Most problems can benefit from a domain-specific model constructed using immutable data types and operators. Such functionally-oriented solutions are simple, composable, type-safe, and testable.

In this course, developers will learn how to write simple functional solutions to everyday business problems, without jargon and without type classes. Developers will learn how to construct type-safe and composable solutions to domain-specific problems, and how the single responsibility principle of object-oriented programming translates into orthogonality. When developers leave, they’ll have a newfound ability to directly benefit from functional programming techniques across their whole application, in a way that’s highly accessible to the whole team and new hires.

Who Should Attend

Scala developers who would like to apply functional programming to any code base, on any problem, without type classes or jargon.

Prerequisites

Good working knowledge of Scala, including familiarity with immutable data, pattern matching, basic recursion, and algebraic data types. Developers who have attended Functional Scala Foundations and Functional Data Modeling will be well-prepared for this course.

Topics

  • Functional domain modeling
  • The essence of composability
  • Measuring the orthogonality of operators
  • Achieving both minimalism and expressiveness
  • Using types to enforce business constraints
  • Generalized algebraic data types for advanced modeling
  • Principle of least power applied to functional design
  • Design techniques used in the ZIO library and broader ecosystem
  • Functional approaches to internal domain-specific languages
  • Translating between different domain-specific languages

Functional Data Modeling by John A. De Goes

Data modeling is a critical skill of modern application development, determining how easy it is to write application logic, how easy it is to update the application in response to changing requirements, and how many failure scenarios are caught at compile-time versus runtime. Although most Scala developers are familiar with object-oriented data modeling, many do not have a deep understanding of functional data modeling and how it differs from the former.

In this course, developers will learn how to use functional Scala to construct simple, precise, and flexible models of any business domain. Along the way, they will explore functional concepts like algebraic data types and techniques like smart constructors. Developers will leave with excellent skills for fully utilizing Scala’s functional data modeling capabilities inside their applications.

Who Should Attend

Scala developers who want to use the functional side of Scala to create simpler, more precise, and more flexible data models than traditionally possible with object-oriented data modeling.

Prerequisites

Good working knowledge of Scala, including familiarity with immutable data, pattern matching, and basic recursion. Developers who have attended Functional Scala Foundations will be well-prepared for this course.

Topics

  • Sealed traits and case classes
  • Algebraic data types
  • Polymorphic algebraic data types
  • Generalized algebraic data types
  • Smart constructors and refined types
  • Phantom types
  • Declaration-site variance
  • Existential types
  • Throwing away irrelevant details
  • Creating precise domain models
  • Making illegal states unrepresentable

Scala 3 for Scala 2 Developers by John A. De Goes

Scala 3 represents the single largest revision to the Scala programming language in more than a decade. While anticipated to be mostly backward compatible, the language is getting a host of new features, deprecating other features, and ripping out some features entirely (like Scala 2.x macros). Without knowledge of the ways in which Scala 3 is different, organizations may struggle to make forward-looking technology decisions and properly prepare for the inevitable migration to Scala 3.

In this course, developers who are already familiar with Scala 2.x will get a high-speed introduction to all the changes coming in Scala 3, including semantic changes, syntactic changes, new features, and dropped features. Upon completion of the course, developers will be empowered to make better technology decisions in the present and be comfortable with taking the first steps toward the migration of codebases to the new version of the language.

Who Should Attend

Scala developers who are anticipating working on applications that have to be maintained for longer than 12 months, and who need a quick immersion in Scala 3.

Prerequisites

Good working knowledge of Scala 2.x.

Topics

  • Enumerations
  • Intersection, union, match, and dependent function types
  • Given instances & using clauses
  • Given imports
  • Extension methods
  • Type class encoding
  • Type lambdas
  • Implicit conversions
  • Inlining, macros & staging
  • Trait parameters
  • Export
  • Syntactic changes
  • Dropped & deprecated features

About the Author

A mathematician by training but a software engineer by vocation, John A. De Goes has been professionally writing software for more than 25 years. John has contributed to dozens of open source projects written in functional programming languages, including ZIO, a library for asynchronous and concurrent programming in functional Scala. In addition to speaking at Strata, OSCON, BigData TechCon, NEScala, ScalaWorld, Scala IO, flatMap, Scalar Conf, LambdaConf, and many other conferences, John also published a variety of books on programming. Currently, John heads Ziverge Inc, a company committed to solving hard business problems using the power of functional programming.

Venue

The training course will take place online.

Attendance

Attendance to all 4 workshops is remote. Attendees will be provided with a link to a remote meeting session the day before the event, in which they can see and hear the workshop, ask the instructor questions, and chat with other 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.

Check all the courses available here.

Related Posts

14 July 2020

African Scala Development Program

African Scala Development Program We are thrilled to announce that Ziverge Inc. has launched an African Scala Development Program, in…

See More

Functional Design

Functional Design by John A. De Goes Although functional programming theory is useful, most day-to-day functional programming does not…

See More
19 April 2020

Functional Scala 2020

Functional Scala 2020 Functional Scala 2020 returns for another year of great talks, familiar and fresh faces, and positive energy around…

See More
Subscribe to our newsletter