It's the end of design patterns as we know it (and i feel fine)

It’s the end of
Design Patterns
as we know it
(and I feel fine)
Today:
Introducing Monads
Luiz Borba
http://borba.blog.br

Part 1
Deconstructing
Design Patterns

COBOL (61)
FORTRAN (57)
CLIPPER (85)
C (72)
SMALLTALK (72)
C++ (83)
PASCAL (86)
LISP (58)
PERL (87)
MS BASIC (75)
OBJECT PASCAL (95)
ML (73)
HASKELL (90)
JAVA (95) RUBY (95)
PYTHON (91)
ALGOL (58)
POWERBUILDER (92)
BASIC (64)
VISUAL BASIC (91)
SQLWINDOWS (88)
PHP (95)

COBOL (61)
FORTRAN (57)
CLIPPER (85)
C (72)
SMALLTALK (72)
C++ (83)
PASCAL (86)
LISP (58)
PERL (87)
MS BASIC (75)
OBJECT PASCAL (95)
ML (73)
HASKELL (90)
JAVA (95) RUBY (95)
PYTHON (91)
ALGOL (58)
POWERBUILDER (92)
BASIC (64)
VISUAL BASIC (91)
SQLWINDOWS (88)
DESKTOP
PHP (95)

COBOL (61)
FORTRAN (57)
CLIPPER (85)
C (72)
SMALLTALK (72)
C++ (83)
PASCAL (86)
LISP (58)
PERL (87)
MS BASIC (75)
OBJECT PASCAL (95)
ML (73)
HASKELL (90)
JAVA (95) RUBY (95)
PYTHON (91)
ALGOL (58)
POWERBUILDER (92)
BASIC (64)
VISUAL BASIC (91)
SQLWINDOWS (88)
WEB
PHP (95)

"
I always knew that one day
Smalltalk
would replace Java.
I just didn’t know
it would be called
Ruby
"
(Kent Beck)

COBOL (61)
FORTRAN (57)
CLIPPER (85)
C (72)
SMALLTALK (72)
C++ (83)
PASCAL (86)
LISP (58)
PERL (87)
MS BASIC (75)
OBJECT PASCAL (95)
ML (73)
HASKELL (90)
JAVA (95) RUBY (95)
PYTHON (91)
ALGOL (58)
POWERBUILDER (92)
BASIC (64)
VISUAL BASIC (91)
SQLWINDOWS (88)

It’s the
Mainstream,
stupid!

Are
Design Patterns
missing languages features?

Are
Design Patterns
how languages evolve?
(Jeff Atwood)

imperative languages
Java
C
Fortran
C++
add
abstractions

subtract
abstractions
Lisp
ML
Haskell
functional languages
Java
C
Fortran
C++
add
abstractions

subtract
abstractions
Lisp
ML
Haskell
functional languages
Java
C
Fortran
C++
add
abstractions
Scala
Java 8
C#
F#
hybrid languages

Haskell:
[x | x <- xs, x < 10]

Haskell:
[x | x <- xs, x < 10]
C#:
from x in xs where x < 10 select x;

Haskell:
[x | x <- xs, x < 10]
C#:
from x in xs where x < 10 select x;
Java 8:
xs.stream().filter(x -> x < 10)

Erlang
Javascript
Java 8
Swift
Objective-C
C#
C
PHP
Python
Ruby
Dart
Elixir
Coffeescript
Scala
Go
Clojure
Rust
Groovy
C++
Haskell
F#

We need to rewrite the
design patterns book

Once you understand
Monadsfor yourself
you lose the ability
to explain them to others
(Douglas Crockford)
"
"

A Monad is just
a monoid in the
category of
endofunctors

Rules
+ =
stack.push(value).top == value
stack.isEmpty == true
stack.push(value).isEmpty == false

and..
We can implement them
however we like
We can use them without
knowing their implementation

Asynchronous
programming is
becoming the norm in
modern,
connected applications"
(Anders Hejlsberg)
"

asyncCall(function(err, data1){
anotherAsyncCall(function(err2, data2){
if(err2) return calllback(err2);
oneMoreAsyncCall(function(err3, data3){
if(err3) return callback(err3);
// are we done yet?
});
});
});

asyncCall()
.then(function(data1){
// do something...
return anotherAsyncCall();
})
// do something...
return oneMoreAsyncCall();
})
// the third and final async response
})
.fail(function(err) {
// handle any error resulting from any of the above calls
})
.done();

var promise = new Promise(initialFunction)
var anotherPromise = promise.then(functionB)
var yetAnotherPromise = anotherPromise.then(functionC)
...

String version = computer
.getSoundcard()
.getUSB()
.getVersion();

String version = "UNKNOWN";
if(computer != null){
Soundcard soundcard = computer.getSoundcard();
if(soundcard != null){
USB usb = soundcard.getUSB();
if(usb != null){
version = usb.getVersion();
}
}
}

String name = Optional.of(computer)
.map(Computer::getSoundcard)
.map(Soundcard::getUSB)
.map(USB::getVersion)
.orElse("UNKNOWN");

Promises and Optional
are Monads

A Monad is a structure
that puts a value in a
computational context

Monad<B> bind(M<A> ma,
Function<A, M<B>> f)

Monad:
Value, Operations and Rules
unit(x) = Monad x
unit(x).bind(f) = Monad f(x)
unit(x).bind(f).bind(g) = Monad g(f(x))

Unit & Bind in Haskell
return :: Monad m => a -> m a
(>>=) :: Monad m => m a -> (a -> m b) -> m b
(>>) :: Monad m => m a -> m b -> m b

I/O Example
main :: IO ()
main =
putStrLn "What is your name?" >>
getLine >>=
name -> putStrLn ("Hello, " ++ name)

Sequence
main :: IO ()
main = do
putStrLn "What is your name?"
name <- getLine
putStrLn ("Hello, " ++ name)

What is that?
main :: IO ()
main = do
putStrLn "What is your name?"
name <- getLine
putStrLn ("Hello, " ++ name)

Imperative code
in functional style

PARADIGM MIX,
stupid!
It’s the

Accidental Monad
BuilderResult<Group> groupBuilder = new Builder<Group>(Group.class)
.daoContext(daoContext)
.user(loginUser)
.comments(body.getCreateComments())
.set(Field.name).with(name).validations(required(), unique())
.set(Field.owners).with(ownerIds).converting(convertToOwner())
.validations(required())
.set(Field.description).with(body.getDesc()).withoutValidation()
.build();

"Six of one or half
dozen of the other"

Set<PersistenceEventListener> result = new HashSet<>();
for (String channel: channels) {
List<PersistenceEventListener> channelListeners =
listenersPerChannel.get(channel);
if (channelListeners != null) {
result.addAll(channelListeners);
}
}
return result;
X
return listenersPerChannel.entrySet().stream()
.filter(e -> Arrays.asList(channels).contains(e.getKey()))
.map(e -> e.getValue())
.flatMap(l -> l.stream())
.collect(Collectors.toSet());

Programmers must evolve
along with the languages and
enjoy learning new things

It’s the end of Design Patterns
as we know it (and I feel fine)
Thank you!
Luiz Borba
http://borba.blog.br

It's the end of design patterns as we know it (and i feel fine)

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to It's the end of design patterns as we know it (and i feel fine)

Similar to It's the end of design patterns as we know it (and i feel fine) (20)

More from Luiz Borba

More from Luiz Borba (20)

Recently uploaded

Recently uploaded (20)

It's the end of design patterns as we know it (and i feel fine)