Do you even Function? Guiding Through Functional Interfaces

Dmitry Vinnik
@DmitryVinnik dvinnik.com
Do you even Function?
Guiding Through
Functional Interfaces

What are our goals?

Goals
Functional Programming (FP):
What, How, When and Why
Default FP Capabilities in Java
Custom Functional Solutions

Why Functional
Programming?

Because Concurrency

Multi-Core
Motivation
Microservices
CCSs

Conclusion?

Concurrency is
a New Reality

Concurrency is
a Reality

But!

What’s in it for us?

Benefits
No Idling ↑ UX
Abstraction

Only good parts, right?

Complexities
Thread
Safety
Performanc
e
Liveness
SDLC

How do we tackle it?

With Functional
Programming

Design for Functional
Programming

Design for FP
Design by
Contract
Temporal
Coupling
Immutability &
Atomicity
Lazy Evaluation
Lazy
Evaluation
No Temporal
Coupling
Immutability &
Atomicity

Design by Contract

“Require No More,
Promise No Less”
Quote from Bertrand Meyer,
“Design by Contract”

Design for FP
Design by
Contract
Temporal
Coupling
Immutability &
Atomicity
Lazy Evaluation
Lazy
Evaluation
No Temporal
Coupling
Immutability &
Atomicity
Design by
Contract
Lazy
Evaluation

Lazy Evaluation

"Lazy Evaluation is like
Filing Taxes"
Quote from Venkat Subramaniam,
“Let’s Get Lazy”

Design for FP
Design by
Contract
Temporal
Coupling
Immutability &
Atomicity
Lazy Evaluation
Lazy
Evaluation
No Temporal
Coupling
Immutability &
Atomicity
Design by
Contract
Lazy
Evaluation
Lazy
Evaluation
No Temporal
Coupling

Temporal Coupling

“When time & order
really matter”

Design for FP
Design by
Contract
Temporal
Coupling
Immutability &
Atomicity
Lazy Evaluation
Lazy
Evaluation
No Temporal
Coupling
Immutability &
Atomicity
Design by
Contract
Lazy
Evaluation
Lazy
Evaluation
No Temporal
Coupling
No Temporal
Coupling
Immutability &
Atomicity

Functional Programming

In Practice

How would we write
Functional Code?

Let’s consider two styles:
Imperative and
Declarative

Assume a Use Case:
Searching for a word
in a phrase

Imperative Style

Declarative Style

Styles Side by Side

Benefits of
Declarative Style
↑ Readability
↓ Verbosity↓ Complexity ↓ Verbosity
↑ Readability

Decreased Complexity

Benefits of
Declarative Style
↑ Readability
↑ Readability
↓ Complexity ↓ Verbosity

Decreased Verbosity

Benefits of
Declarative Style
↑ Readability
↑ Readability
↓ Complexity ↓ Verbosity↓ Verbosity
↑ Readability

Increased Readability

Changing Paradigms

FP
Changing Paradigms
Imperative
Programming
Declarative
Programming

Enough Theory!

Let’s see some FP in Java

Starting from the Base

Stream
Optional
Starting from the Base

What do we do the most?

Dealing with Data

Dealing with Collections

How do we get Functional
with Collections?

Pipeline of
Functions
Data
Mutation
Lazily
Evaluated
Data
Transformation
Streams

Streams

That’s all great

But...

What if I want to find
something?

Optional is the answer

Finding Optional Talk

Optional
Value State
Null Check
Supplement
Data
Mutation
Data
Transformation

Optional

Looks promising

But it still seems verbose

Method Reference
to the Rescue!

What is it good for?

“There are only two hard
things in Computer Science:
Cache Invalidation and
Naming Things”
Quote from Phil Karlton

Method Reference: Before

Why do we need
temporary variables?

Method Reference: After

Method Reference

Looks good

But what about
and Debugging

One Line per Statement Style

Now we have all the tools

Let’s Get Functional

High Order(HO) Functions
Functions
as First Class Entities
Functions
as Input
Functions
as Output

Why HO Functions?
↑ Abstraction
DRY by
Design
↓ Complexity ↑ Readability

Are all Functions equal?

Types of Functions
Pure
Functions
Impure
Functions

Pure Functions
Immutable Side Effects
Same
Input
Same
Output

Pure Functions

Let’s see Functions
in Action

Let’s see Functions
in Java

Single Abstract
Method
Helper
Annotation
Static
Methods
Default
Methods

High Order Functions
Out-of-the-Box
Function<T, R> Predicate<T>
Consumer<T> Supplier<T>
Predicate<T>

Function<T, R>
One OutputOne Input

Function<T, R>

Function<T, R>
Capabilities:
Functions Composition

Out-of-the-Box
Predicate<T>

Predicate<T>
Boolean
Output
One Input

Predicate<T>

Predicate<T>
Capabilities:
Logical Operators

Out-of-the-Box
Predicate<T>
Function<T, R> Predicate<T>Predicate<T>
Consumer<T>

Consumer<T>
No OutputOne Input

Consumer<T>

Consumer<T>
Capabilities:
Functions Chaining

Out-of-the-Box
Predicate<T>
Function<T, R> Predicate<T>Predicate<T>
Consumer<T>Consumer<T> Supplier<T>

Supplier<T>
One OutputNo Input

Supplier<T>

Supplier<T>
Capabilities:
Wrapped Execution

Summary

Function<T, R>
Consumer<T>
Data
Transformation
Predicate<T> Data Filtering
Data
Processing
Supplier<T>
Process
Execution

Out-of-the-Box is nice

But what about Custom
Functional Use Cases?

Let’s Build Custom
Functional Interface

What about some
Common Use Cases?

Error
Handling
Error
Passing
Multi-Dimensional
Structures
Common Use Cases
Error
Passing
Multi-Dimensional
Structures

FP: Error Handling

Let’s simplify

Error
Handling
Error
Passing
Multi-Dimensional
Structures
Common Use Cases
Error
Passing
Multi-Dimensional
Structures
Error
Handling
Error
Passing

FP: Error Passing

Error
Handling
Error
Passing
Multi-Dimensional
Structures
Common Use Cases
Error
Passing
Multi-Dimensional
Structures
Error
Handling
Error
Passing
Error
Passing
Multi-Dimensional
Structures

Multi-Dimensional
Structures: jOOQ/jOOL
Function
1...16
Consumer
1...16
Tuple
1...16
Sequences

looks great!

But is there anything to
be avoided?

Functional Programming:
Antipatterns
Overly
DRY
Early
Optimization
Impure
Functions

Call For Action
Embrace FP
Review Your
Application
Continue
Learning

About Speaker
Twitter: @DmitryVinnik
Blog: dvinnik.com
LinkedIn: in/dmitry-vinnik/
Email: dmitry@dvinnik.com

Do you even Function? Guiding Through Functional Interfaces

Recommended

Recommended

More Related Content

Similar to Do you even Function? Guiding Through Functional Interfaces

Similar to Do you even Function? Guiding Through Functional Interfaces (20)

More from Dmitry Vinnik

More from Dmitry Vinnik (13)

Recently uploaded

Recently uploaded (20)

Do you even Function? Guiding Through Functional Interfaces

Editor's Notes