Boost your-oop-with-fp

How to boost your
OOP with FP
Uberto Barbini
@ramtop

Saturday, November 19, 11

About me
Uberto Barbini
Software artisan
Agile enthusiast.

Hobby:
photography and the game of Go.
http://www.ﬂickr.com/photos/uberto

Team leader and Architect for Vodafone
editorial and backend products.

What if OOP was wrong?

http://www.ﬂickr.com/photos/mbshane


OOP is only a tool,
we need to keep it sharp
we need to learn other tools



OOP is only a tool,
we need to keep it sharp
we need to learn other tools

Caution, this presentation can
contain trace of Philosophy

I would like to
pay my tribute to

for their contribution to
Software Engineering
growing-object-oriented-software@googlegroups.com

Bugs

http://www.ﬂickr.com/photos/staﬂo/


Bugs
• cause of delays and frustration
• many are easy to fix
• some cause big problems
• the worst ones are caused by...
http://www.flickr.com/photos/staflo/


State
• Foundation of
behavior
• Hidden from outside
• Should be defended
like a castle


Where is the
state?
Easy to
understand what
it does.
Hard to
understand why
it does it.

http://fractalforge.cvs.sourceforge.net/viewvc/fractalforge/fractalforge/Mandelbrot.pas?view=markup


The new procedural

public class NameAction extends Action {
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
String target = new String("success");
if (form != null) {
// Use the NameForm to get the request parameters
NameForm nameForm = (NameForm) form;
String name = nameForm.getName();
}
// if no mane supplied Set the target to failure
if (name == null) {
target = new String("failure");
} else {
request.setAttribute("NAME", name);
}
return (mapping.findForward(target));
}
}


The new procedural

public class NameAction extends Action {
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
String target = new String("success");
if (form != null) {
// Use the NameForm to get the request parameters
NameForm nameForm = (NameForm) form;
String name = nameForm.getName();
}
// if no mane supplied Set the target to failure
if (name == null) {
target = new String("failure");
} else {
request.setAttribute("NAME", name);
}
return (mapping.findForward(target));
}
}

Frameworks make easy to keep writing procedural
code in OO fashion

Procedural paradigm


Procedural paradigm

• Easy to write
• Hard to understand
• Global state


http://www.ﬂickr.com/photos/hatm


Recipe:
“We are pragmatic
about code quality”

http://www.ﬂickr.com/photos/hatm


John
McCarthy


John
McCarthy
• LISt Processing
aka
Lots of Irritating Superﬂuous Parenthesis

• S-Expressions
func(x,y) => (func, x, y)
• Homoiconic
(metaprogramming++)
• Laziness parameter
evaluation

Homoiconic John
“Clojure macro example: AND”
(defmacro and
([] true)
McCarthy
([x] x)
([x & rest] •
LISt Processing
`(let [and# ~x] aka
Lots of Irritating Superﬂuous Parenthesis
(if and# (and ~@rest) and#))))
• S-Expressions
func(x,y) => (func, x, y)
• Homoiconic
(metaprogramming++)
• Laziness parameter
evaluation

Clojure the modern Lisp
(ns bowling-game
(:use clojure.contrib.seq-utils))

(defn strike? [rolls]
(= 10 (first rolls)))

(defn spare? [rolls]
(= 10 (apply + (take 2 rolls))))

(defn balls-to-score
"How many balls contribute to this frame's score?"
[rolls]
(cond
(strike? rolls) 3
(spare? rolls) 3
:else 2))

(defn frame-advance
"How many rolls should be consumed to advance to the next frame?"
[rolls]
(if (strike? rolls) 1 2))

(defn frames
"Converts a sequence of rolls to a sequence of frames"
[rolls]
(when-let [rolls (seq rolls)]
(lazy-seq (cons (take (balls-to-score rolls) rolls)
(frames (drop (frame-advance rolls) rolls))))))

(defn score-frame
[frame]
(reduce + frame))

(defn score-game
"Score a bowling game, passed as a sequence of rolls."
[rolls]
(reduce + (map score-frame (take 10 (frames rolls)))))


Alan Kay


Alan Kay

• The best way to predict the future is to invent it.

• Possibly the only real object-oriented system in working order. (About Internet)

• The greatest single programming language ever designed. (About Lisp programming
language)


bonusFrame
^self spare or: [self strike] Smalltalk
strike
^self roll1 = 10

an elegant
spare
^self roll1 < 10 and: [ self roll1 + self roll2 = 10].

weapon
roll1
^rolls at: frameStart

for a more
roll2
^rolls at: frameStart + 1

civilized
roll3
^rolls at: frameStart + 2

age
frameScore
| frameScore |
frameScore := self roll1 + self roll2.
self bonusFrame ifTrue: [ frameScore := frameScore + self roll3 ].
^frameScore

updateFrameStart
self strike
ifTrue: [ frameStart := frameStart + 1]
ifFalse: [ frameStart := frameStart + 2]

score
10 timesRepeat:
[score := score + self frameScore.
self updateFrameStart].
^score

initialize
rolls := OrderedCollection new.
score := 0.
frameStart := 1.
^self


What is OOP?

Basically, an object type looks like a
record type with additional fields
including procedure fields and also
optional keywords which indicate the
scope of the fields.


What is OOP?

Basically, an object type looks like a
record type with additional fields
including procedure fields and also
optional keywords which indicate the
scope of the fields.

Lazarus (Object Pascal) wiki


What is OOP?
Object-oriented programming (OOP) is a programming
paradigm using "objects" – data structures consisting of
data ﬁelds and methods together with their interactions – to
design applications and computer programs. Programming
techniques may include features such as data abstraction,
encapsulation, messaging, modularity, polymorphism, and
inheritance.


Edsger W.
Dijkstra


Edsger W.
Dijkstra
It is practically
impossible to teach
good programming to
students that have had a
prior exposure to
BASIC: as potential
programmers they are
mentally mutilated
beyond hope of
regeneration. - 1975


Edsger W.
Dijkstra
Object-oriented
programming is an
exceptionally bad idea
which could only have
originated in California.


Edsger W.
Dijkstra
Object-oriented
programming is an
exceptionally bad idea
which could only have
originated in California.
I don't know how many of you have ever met Dijkstra,
but you probably know that arrogance in computer science
is measured in nano-Dijkstras. Alan Kay.

Alan Kay
OOP to me means only messaging, local retention and
protection and hiding of state-process, and extreme late-
binding of all things. It can be done in Smalltalk and in LISP.
There are possibly other systems in which this is possible, but
I'm not aware of them. (email 23/07/2003)

http://www.ﬂickr.com/photos/marcospiller


Alan Kay
OOP to me means only messaging, local retention and
protection and hiding of state-process, and extreme late-
binding of all things. It can be done in Smalltalk and in LISP.
There are possibly other systems in which this is possible, but
I'm not aware of them. (email 23/07/2003)

I thought of objects being like biological cells and/or individual
computers on a network, only able to communicate with
messages (so messaging came at the very beginning -- it took
a while to see how to do messaging in a programming
language efficiently enough to be useful). http://www.ﬂickr.com/photos/marcospiller


The venerable master Qc Na was walking with his student, Anton. Hoping to
prompt the master into a discussion, Anton said "Master, I have heard that
objects are a very good thing - is this true?" Qc Na looked pityingly at
his student and replied, "Foolish pupil - objects are merely a poor man's
closures."

Chastised, Anton took his leave from his master and returned to his cell,
intent on studying closures. He carefully read the entire "Lambda: The
Ultimate..." series of papers and its cousins, and implemented a small
Scheme interpreter with a closure-based object system. He learned much, and
looked forward to informing his master of his progress.

On his next walk with Qc Na, Anton attempted to impress his master by
saying "Master, I have diligently studied the matter, and now understand
that objects are truly a poor man's closures." Qc Na responded by hitting
Anton with his stick, saying "When will you learn? Closures are a poor man's
object." At that moment, Anton became enlightened.


The venerable master Qc Na was walking with his student, Anton. Hoping to
prompt the master into a discussion, Anton said "Master, I have heard that
objects are a very good thing - is this true?" Qc Na looked pityingly at
his student and replied, "Foolish pupil - objects are merely a poor man's
closures."

Chastised, Anton took his leave from his master and returned to his cell,
intent on studying closures. He carefully read the entire "Lambda: The
Ultimate..." series of papers and its cousins, and implemented a small
Scheme interpreter with a closure-based object system. He learned much, and
looked forward to informing his master of his progress.

On his next walk with Qc Na, Anton attempted to impress his master by
saying "Master, I have diligently studied the matter, and now understand
that objects are truly a poor man's closures." Qc Na responded by hitting
Anton with his stick, saying "When will you learn? Closures are a poor man's
object." At that moment, Anton became enlightened.

Anton van Straaten 4 June 2003


Yun Tung Lao - The Art of Objects - Addison Wesley


Bruce Eckel - Thinking in Java
The object-oriented approach goes a step further by providing tools
for the programmer to represent elements in the problem space.
This representation is general enough that the programmer is not
constrained to any particular type of problem. We refer to the
elements in the problem space and their representations in
the solution space as “objects.”
(You will also need other objects that don’t have problem-space
analogs.) The idea is that the program is allowed to adapt itself to
the lingo of the problem by adding new types of objects, so when you
read the code describing the solution, you’re reading words that also
express the problem. This is a more flexible and powerful language
abstraction than what we’ve had before.
Thus, OOP allows you to describe the problem in terms of
the problem, rather than in terms of the computer where the
solution will run.


An object has state, behavior,
and identity - Grady Booch


An object has state, behavior,
and identity - Grady Booch

OOP fundamentals:
Ignorance Apathy Selfishness
Kevlin Henney (Will The Real Oop Please Stand Up)


Half presentation check
Summary so far:
1. The worst bugs are related to state
2. Procedural paradigm doesn’t care much
3. Functional paradigm expel state from
functions
4. OOP (the real one) encapsule state in
Objects


Do I smell spaghetti?


Why singleton?


Why singleton?
Strategy without DI
is pointless


Why singleton?
Strategy without DI
is pointless

This is worse than procedural!

the real
problem is
that many
Why singleton? people
believe this is
Strategy without DIOOP
good
is pointless because
there are
many
objects,
interfaces,
patterns.
This is worse than procedural!

DDD
Eric Evans

• Many objects are not fundamentally deﬁned by their attributes but
rather by a thread of continuity and identity An object deﬁned
primarily by its identity is called an ENTITY. p.91

• When you care only about the attributes of an element of the model,
classify it as a value object. Threat the VALUE OBJECT as
immutable. Don’t give it any identity and avoid the design
complexities necessary to maintain ENTITIES. p.97

• Place as much of the logic of the program as possible in functions,
operation that returns results with no observable side effects. p. 251


The most significant part of the full citation is as follows: computational linguistics. Fortran remains one of the most
' . . . Backus headed a small IBM group in New York City widely used programming languages in the world. Almost all
during the early 1950s. The earliest product of this group's programming languages are now described with some type of
efforts was a high-level language for scientific and technical corn- formal syntactic definition.' "

Can Programming Be Liberated from the von
Neumann Style? A Functional Style and Its
Algebra of Programs
John Backus
IBM Research Laboratory, San Jose

Conventional programming languages are growing
ever more enormous, but not stronger. Inherent defects
at the most basic level cause them to be both fat and
weak: their primitive word-at-a-time style of program-
ming inherited from their common ancestor--the von
Neumann computer, their close coupling of semantics to
state transitions, their division of programming into a
world of expressions and a world of statements, their
inability to effectively use powerful combining forms for
building new programs from existing ones, and their lack
of useful mathematical properties for reasoning about
programs.
An alternative functional style of programming is
General permission to make fair use in teaching or research of all founded on the use of combining forms for creating
or part of this material is granted to individual readers and to nonprofit
libraries acting for them provided that ACM's copyright notice is given programs. Functional programs deal with structured
and that reference is made to the publication, to its date of issue, and data, are often nonrepetitive and nonrecursive, are hier-
to the fact that reprinting privileges were granted by permission of the archically constructed, do not name their arguments, and
Association for Computing Machinery. To otherwise reprint a figure,
table, other substantial excerpt, or the entire work requires specific do not require the complex machinery of procedure
permission as does republication, or systematic or multiple reproduc- declarations to become generally applicable. Combining
tion. forms can use high level programs to build still higher
Author's address: 91 Saint Germain Ave., San Francisco, CA
94114. level ones in a style not possible in conventional lan-
© 1978 ACM 0001-0782/78/0800-0613 $00.75 guages.

613 Communications August 1978
of Volume 2 i
the ACM Number 8


Mark Needham
I’m beginning to think that the combination of
functional and object oriented programming
actually results in code which I think is more
expressive and easy to work with than code
written only with an object oriented approach
in mind.

The functional mindset seems to be more about
considering the problem as a whole and then
working out how we can simplify that problem
from the outside in which is a bit of a paradigm
shift. I don’t think I’ve completely made but it can
certainly lead to solutions which are much easier
to understand. - blog April 2009


http://www.ﬂickr.com/photos/dirtyf


The Functional eye



The Functional eye

• Immutable structured values (messages)
• Never unready or null objects (a keyword)
• Use of pure functions (no side effect)
• Closures to decouple (or inner classes)


The ObjectOriented eye


The ObjectOriented eye

• Dependency Injection
• No getters for mutable state
• Interfaces for collaborators (Liskov)
• Simpler aggregates (Demeter)
• Meaningful name convention

Just an example:
protected void processRequest(HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse) throws IOException {

log.info("Processing request " + httpServletRequest.getRequestURI());
HttpCallClock clock = new HttpCallClock();

MyRequest request = createRequest(httpServletRequest);

MyResponse response = prepareResponse(getContentService(), request);

translateResponse(response, httpServletResponse);

long elapsed = clock.getElapsedTime();
log.info("Processed in " + elapsed + " ms. " +
httpServletRequest.getRequestURI());
accessLog.info(AccessLog.getRequestLog(httpServletRequest, elapsed,
response.getStatus(), response.getResponseContentLength()));

}


Another example:
protected MyResponse prepareResponse(MyRequestConfiguration myConfiguration) {
String opco = myConfiguration.getOpco();
Device device = VIRTUAL_DEVICE;

if (myConfiguration.isTacPresent()) {
DeviceResponse devicesResponse = getDeviceResponse(opco,
myConfiguration.getPublishType());
if (devicesResponse.isErrorResponse()) {
return new ResponseWithError(devicesResponse.getHttpStatusCode(),
devicesResponse.getMessage());
}

if (!devicesResponse.isDevicePresentByTac(myConfiguration.getTac())) {
return new ResponseWithError(SC_NOT_FOUND, "device with tac code: " +
myConfiguration.getTac() + " not found");
}
device = devicesResponse.getDeviceByTac();
}

DatastoreResponse responseFromDatastore = getDashboards(device,
myConfiguration.getPublishType(), opco);
if (responseFromDatastore.isErrorResponse())
{
return new ResponseWithError(responseFromDatastore.getHttpStatusCode(),
responseFromDatastore.getMessage());
}

return retrieveResponseAccordingUrl(myConfiguration,
responseFromDatastore.getDashboards());
}

Object Design Rebecca Wirfs-Brock

Control
• Centralized
• Dispersed
• Delegated


Centralized
Invoice
Customer
Invoice

Printer
Manager


Centralized
Invoice
Customer
Invoice

Martin Fowler: (http://martinfowler.com/bliki/
AnemicDomainModel.html)
The basic symptom of an Anemic Domain Model is that Printer
at ﬁrst blush it looks like the real thing. [...] The catch
Manager
comes when you look at the behavior, and you realize
that there is hardly any behavior on these objects,
making them little more than bags of getters and setters.
[...] The key point here is that the Service Layer is thin -
all the key logic lies in the domain layer.


Dispersed

Customer Items

Invoice
Printer

Popular with Zombie objects
(aka Hibernated beans)

Logic
Delegated
Entity
Identity
CustomerFetcher
Value
InvoiceFetcher Immutable
Customer No Id

Invoice
Printer
InvoicePrinter


The valley
of comfort

http://www.ﬂickr.com/photos/lviggiano


The valley
Elegance and familiarity are orthogonal

of comfort
Rich Hickey on #Clojure



The valley

of comfort

A Conversation with Ward Cunningham, Part III (5 January 2004)

The Accidental Architecture
I like the notion of working the program, like an artist works a lump of
clay. An artist wants to make a sculpture, but before she makes the
sculpture, she just massages the clay.
[...] In a sense we get the architecture without really trying. All the
decisions in the context of the other decisions simply gel into an
architecture.



The valley

of comfort
There are two ways of constructing a
software design.
One way is to make it so simple that there are
obviously no deﬁciencies.
And the other way is to make it so
A Conversation with Ward Cunningham, Part III (5 January 2004)
complicated that there are no obvious
deﬁciencies.
The Accidental Architecture
[C.A.R. Hoare]

I like the notion of working the program, like an artist works a lump of
clay. An artist wants to make a sculpture, but before she makes the
sculpture, she just massages the clay.
[...] In a sense we get the architecture without really trying. All the
decisions in the context of the other decisions simply gel into an
architecture.



The journey
to the valley
• What about domain
• What about tests
• What about mocks
• What about
refactoring
http://www.ﬂickr.com/photos/bobcatnorth


Open questions

• Do we need a yet another new language?

• Can we have Architects?

• How to teach design?


Boost your-oop-with-fp

Recomendados

Recomendados

Más contenido relacionado

Similar a Boost your-oop-with-fp

Similar a Boost your-oop-with-fp (11)

Más de Uberto Barbini

Más de Uberto Barbini (9)

Último

Último (20)

Boost your-oop-with-fp