Length

3 days

Description

The training is mainly designed for two categories of participants:

• people who have experience in Java and Spring programming and want to learn in a practical way reactive programming with the above-mentioned tools,

• people who already have practical experience in reactive programming, but feel the need to become better acquainted with theory.

The first two days of the training are dominated by practical tasks (60%), but nevertheless a lot of emphasis is placed on theory at the very beginning; I know from experience that this pays off later in the class. The third day is an entirely workshop day - here we use the knowledge gained during the previous days of training.

Prerequisites

Knowledge of the Java language and the Spring framework at the intermediate level

Agenda

NOTE: This is a framework programme and can always be tailored to client needs upon request

1. Introduction to reactive programming
   • Definition
   • Reasons for introducing a reactive approach
     • Waste of resources
     • Scalability problems
   • Demo - comparison an application performance in non-reactive and reactive way
   • When not to use reactive approach

2. Reactive Streams as a specification for reactive programming
   • Components (code, tests, textual specification)
   • Interfaces
     • Publisher - sender of elements
     • Subscriber - recipient of elements
     • Subscription - connection between sender and receiver
   • Subscription flow (start, request elements, end)
   • Backpressure and unlimited subscription
   • Overview of advanced subscription rules

3. Reactor framework
   • General description
   • Mono and Flux as basic classes
   • Marble diagrams
   • Flux - a stream of multiple elements.
     • Creation from existing elements
     • Programmatic creation
   • Mono - single element stream
   • Subscription to streams
     • Via callbacks
     • Through BaseSubscriber.
   • Subscription cancellation

4. Operators
   • How operators are working
     • Plugging into the subscription chain
     • Upstream, downstream
   • Mapping
     • Synchronous (map())
     • Asynchronous (flatMap(), concatMap())
   • Filtering (filter(), take(), skip())
   • Reducing (reduce())
   • Combining streams
     • Of the same types (merge(), concat())
     • Of different types (zip())
   • Time dependencies
     • Delaying elements (delayElements())
     • Triggering one stream by another (then())
   • Creating custom operators (transform())
   • How to choose the operator you need - practical tips

5. Error handling
   • Error signalling instead of throwing an exception
   • Replacing the error signal
     • Using an element
     • Using a sequence
   • Error remapping
   • Additional action when error occurs
   • Resubscription to stream

6. Testing
   • Introducing Reactor test helper classes
   • StepVerifier - verification of data emitted by the stream
     • Creation
     • Assertions chaining
     • Running the test
     • Virtual timer
   • TestPublisher - ability to manipulate data emission to the stream
     • Creation
     • Emitting data

7. Debugging
   • Reactor callstack analysis
   • Enabling debugging mode
     • As a global hook
     • As a Java Agent
   • Checkpoints
   • Logging stream behavior using the log() operator.

8. Multithreading
   • Scheduler as an abstraction of thread selection
   • Predefined and custom schedulers
   • Changing element publication thread - publishOn() operator.
   • Changing element creation thread - subscribeOn() operator.
   • Parallel processing of data in a stream

9. Typical pitfalls of reactive programming
   • Lack of subscription
   • Too eagerly operations
   • Blocking operations in non-blocking threads
   • Excessive operators
   • Manual creation of streams

10. Spring framework - reactive approach
    • Spring reactive stack - general description
    • Reactive HTTP server - WebFlux
      • Annotation approach
      • Functional approach
      • SSE (Server-Sent-Events) technique
      • WebSockets
    • Reactive HTTP client - WebClient
      • Creation and use
      • Combining several operations

11. Workshop - implementation of MasterMind game in a reactive approach using Spring
    • Presentation of requirements, general outline of the architecture and provided tools
    • Implementation of the server part
    • Implementation of the client part

Length

2 days

Description

The training is designed for developers who want to get into the habit of writing code that is readable and understandable to others. We focus not only on clean code per se, but also show how to write programs well using the object-oriented programming paradigm. We also introduce several design patterns that improve code readability and structure.

Prerequisites

Knowledge of the Java language and the JUnit library at the basic level

Agenda

NOTE: This is a framework programme and can always be tailored to client needs upon request

1. Good code vs. bad code
   • How to define and measure code quality
   • Clinical symptoms of bad code
   • Reasons for code degradation
   • Defense against code quality deterioration
     • Code review
     • Static analysis (SonarQube)
     • Daily refactoring

2. Basic principles in the daily work of a developer
   • Boy Scout rule
   • DRY
   • Least surprise principle
   • KISS / YAGNI
   • Usage of external libraries / frameworks
   • Iterative code development

3. How to create good code
   • Naming of variables, methods, classes
   • Formatting
   • Creating readable methods
   • Creating understandable classes
   • Handling error situations; exceptions
   • Comments

4. Workshop - improving the quality of existing code
   • Creation of tests
   • Step-by-step refactoring

5. OOP best practices
   • High consistency
   • Loose coupling
   • Polymorphism instead of type checking

6. SOLID principles
   • Dependency inversion
   • Interface segregation
   • Single responsibility
   • Open (for extension) / closed (for modification) rule
   • Liskov substitution principle
     • Surprising effects with inheritance
     • Replacing inheritance with composition

7. Workshop - improving the structure of existing code using SOLID principles

8. Selected design patterns in the context of creating readable code
   • Strategy ⇒ let's do one thing in many ways
   • Decorator ⇒ let's leave the side stuff to others
   • State ⇒ let's go through the entire lifecycle of our object
   • Visitor ⇒ let's collect different fruits from one tree

9. Workshop - improving existing code using design patterns

Length

1 day

Description

The training is intended for Java developers working with version 11 (as currently the most common in commercial projects) and wishing to familiarize themselves with the new functionalities of the language introduced in versions 12 and above. Presented are those new capabilities that directly affect the shape of the code, allowing to make its writing simpler and more transparent. The conclusion of the training is a mini-workshop, during which participants put the acquired knowledge into practice.

Prerequisites

Knowledge of the Java language and the JUnit library at the intermediate level

Agenda

NOTE: This is a framework programme and can always be tailored to client needs upon request

1. Preview features
   • Reasons for introduction
   • Lifecycle
   • Usage during compilation and execution
   • Support in automatic build tools (Maven, Gradle)

2. Pattern matching for instanceof
   • Excessive casting
   • Pattern matching
   • Automatic casting with instanceof
   • Flow scope

3. switch improvements
   • switch drawbacks
   • Arrow labels
   • switch as an expression
   • yield keyword
   • Exhaustiveness

4. Pattern matching for switch
   • Types as labels
   • null handling
   • Guarded patterns

5. Records
   • Immutable object as good design pattern
   • Record as immutable object implementation
   • Declaration
   • Features
   • Instantiation (canonical and custom constructors)
   • Limitations
   • Pitfalls

6. Sealed classes
   • Encapsulation as good practice
   • Declaration
   • Definition of permitted subclasses
   • Sealed interfaces
   • Sealed classes vs records

7. Text blocks
   • Declaration and usage possibilities
   • Automatic indentation
   • New special characters

8. Other improvements
   • Teeing collector
   • Meaningful NullPointerException
   • New String built-in methods

9. Workshop - creating an application using the previously discussed functionalities

I am able to conduct any training in the field of:

• Java programming (from beginner to advanced level).
• Working with databases (including SQL).
• Web application development.
• Broadly understood good software engineering practices.

The program and scope are always adapted to the customer needs.