Modern Development with Java

12 november 2019 3 dagen

12, 13, 14 november 2019
3 dagen, 9:30-16:30
€ 1.890,- per persoon (incl. lunch, excl. btw)


A three day training course bringing students up to date with the latest in Java 8 and beyond. This course covers the key features around functional programming with Java 8 over the first two days. You then build upon this theory by refactoring a project using different modern concurrency techniques including promises using Java 8’s CompletableFuture, actors using Akka and reactive streams using RxJava. You’ll learn the good, the bad and the ugly between these approaches in terms of compositionality, testability and simplicity. Hands on exercises will also be provided in order to help students fully solidify their knowledge.


Day 1
Lambda Expressions

  • Why Java 8?
  • behaviour parameterisation
  • More flexible code
  • Anonymous classes
  • What is a lambda?
  • Syntax
  • Functional interfaces: where to use lambda expressions?
  • java.util.function
  • Refactoring/putting together exercise
  • Method references: firstclass
  • functions in Java 8
  • Method references recipes
  • Type checking
  • Type inference
  • Using local variables


  • Collection Processing
  • What is a Stream?
  • Stream operations and patterns
  • Filtering
  • Mapping
  • Finding and Matching
  • Reducing
  • minBy/maxBy
  • Stream Optimization
  • the reduce pattern
  • Eager vs Lazy
  • Shortcircuiting and Loop Fusion

Exercise: financial data processing (part 1)


  • Grouping and partitioning
  • Collection Operations
  • Collecting to lists and sets
  • Flexible Collection
  • Arithmetic collectors
  • Max/Min
  • Average/Count/Sum
  • Summary statistics
  • Advanced Queries
  • Beyond grouping and partitioning
  • Downstream collectors

Exercise: financial data processing (part 2)

Mutable Reduction

  • Extending the reduce pattern
  • Reducing collector

Day 2
Easy Data Parallelism

  • What is Data Parallelism?
  • Why is this important?
  • Parallelising your streams
  • Parallel Gotchas
  • Misuse of reduce
  • Don’t use Locks
  • Danger of mutability
  • Decomposing performance

Testing & Debugging Lambda Expressions

  • Unit testing lambda expressions
  • Debugging with laziness
  • Stack traces

Practical: Hands on Debugging

Default and static methods on interfaces

  • Motivation for default methods
  • Static methods in interface
  • Useful default methods
  • Patterns for default methods
  • Resolution rules

Enhanced Design with Lambdas

  • Execute around: resource handling
  • Deferred execution: Logging
  • Design patterns
  • Command
  • Strategy
  • Observer
  • Template
  • Factory
  • Processing pipeline

Date & Time in Java 8

  • The problem with existing date and time libraries
  • The core classes: LocalDate/LocalTime
  • Common API Patterns

Optional data types

  • The problem with null
  • How Optional improves upon null
  • How to use Optional in your code
  • Creating Optional objects
  • Default values and actions
  • Transforming Optionals with map
  • Chaining Optionals with flatMap
  • Rejecting values with filter

Enhanced Concurrency with Lambdas

  • Introduction to Concurrency
  • Future and ExecutorService
  • CompletableFutures

Day 3
Asynchronous vs Synchronous Programming

  • Servlets
  • Asynchronous Servlets (3.0) & Spring
  • Why use asynchronous communications?
    - Performance
    - Testability
    - Fault Tolerance
  • Timeouts

Approaches to Concurrency

  • The Reactive Manifesto and Functional Reactive Programming
  • Models of Concurrency
    - Event Based
    - Promises
    - The Actor Model
    - Reactive Streams

Promises using Completable Futures

  • Motivation
  • Composition
  • Exception handling

Alternative Promise Implementations

The Actor Model with Akka

  • What are Actors?
  • Using Akka
  • Testing actors

Alternative Actor Implementations

Reactive Streams with RxJava

  • Introducing Reactive Streams
  • Pull vs. push models
  • Using RxJava
  • Java 9 Flow API

Alternative Reactive Stream Implementations

Java 9 Modularity

  • Motivation
  • Encapsulation
  • Dependencies
  • Evolution of JDK

Modular development

  • What is a module
  • Declaring modules
  • Packaging a module
  • Using modules

Migrating to modules

  • Top­down
  • Bottom­up


If you are a Java developer with some professional programming experience, this course is for you. If you have Object Oriented experience but haven’t yet explored the functional realm that Java 8 provides, then this course is also for you!

The course is also ideal for developers who have written Java before but are returning to it as a language now after a few years in ruby/python and want to get up to speed with modern Java.

Minimale voorwaarden deelname training

  • To get the most from this course, delegates should have programming experience with Java 5 features.
  • You are requested to bring your own laptop for this course, so you learn how to develop within your own environment.

Aanmelden training: Modern Development with Java


Gegevens cursist







Richard Warburton

Richard Warburton

Software ontwikkelaar

Richard Warburton, is een empirische technoloog en oplosser van deep-dive technische problemen. Onlangs heeft hij een ...

Skills: Software Architectuur, Software ontwikkeling, Java.

Raoul-Gabriel Urma

Raoul-Gabriel Urma

Software ontwikkelaar

Raoul-Gabriel Urma heeft een PhD in Computer Science verkregen aan de Universiteit van Cambridge. Hij concentreert ...

Skills: Software Architectuur, Software ontwikkeling, Java.


Luminis Academy biedt tevens 'In Company' trainingen aan. Informeer naar de mogelijkheden.