►
Description
I'm going to provide a brief overview of my journey to functional programming, and my rationale behind picking Clojure as my language of choice. I will briefly talk about my perceived advantages and disadvantages of using Clojure. I'll try to briefly and gently show core Clojure concepts, and then we'll implement a rudimentary event sourcing engine using Clojure. The engine will borrow heavily from Redux so that participants have a common ground from which to build their understanding of what we're doing. Lastly, we'll run it on Node!
This talk was recorded at the Jozi.JS meetup group on 22 August 2019.
https://www.meetup.com/Jozi-JS/events/263022807/
Disclaimer: The opinions in this talk are those of the individual and do not necessarily represent those of this channel, the meetup group, or its sponsors.
A
A
While
ago
I
was
here
to
talk
to
you
about
Redux
and
react
and
I
was
absolutely
convinced
that
that
was
the
promised
land,
hence
the
angry
cat
prior
to
doing
what
I
do
now
working
at
simply
financial
services,
I
started,
studying
at
ticks
and
I
was
quite
arrogant
about
what
constituted
software
development.
I
thought
that
JavaScript
was
something
that
neckbeards
right.
I
thought
that
web
development
was
not
for
me,
but
not
long
after
that,
I
graduated
from
University
and
got
a
job
as
a
web
developer.
A
It
was
really
exciting
times
it
was
sort
of
before
angular
came
along
came
along,
it
was
before
npm
was
a
thing
and
it
was
before.
No,
it
was
a
thing
and
in
order
to
create
classes,
essentially
we
used
to
do
these
things
called
FES,
which
are
immediately
invoked,
function,
expressions
and
using
that
and
the
parameters
that
you
pass
to
them.
You
can
ensure
that
nobody
can
modify
or
look
at
things
that
they
shouldn't
be
able
to
before
you
want
them
to
so.
A
A
A
Hence
in
our
store
we
have
these
actions
and
from
those
actions
we
send
to
our
consumers.
Something
called
an
action
creator
should
I
choose
to
add
a
to-do
to
my
list
of
two's.
I
will
call
the
action.
Creator
and
I
will
call
the
stores
dispatch
method
to
have
it
mutate
the
store
and
add
my
to-do,
where
I
need
it.
A
So
from
the
store,
we
can
pull
these
pieces
of
state
and
each
piece
of
state
is
unique
to
a
reducer
and
we
wrap
the
pulled
state
in
a
function
and
send
it
well
components
as
props.
This
is
how
we
abstract
how
we
display
things
and
how
we
modify
them.
This
is
closures
benevolent
dictator,
rich
Hickey.
A
It
took
him
about
two
years
and
eight
months
to
write
closure.
It
is
a
dialect
of
lisp,
it
is
a
dynamic
language
and
it
is
highly
opinionated
and
fun
to
work
in
so
closure
is
a
dialect
of
lisp
and
shares
with
Lisp.
The
code
is
a
philosophy
and
a
powerful
macro
system,
which
means
that
in
my
ripple,
I
can
modify
lists
and
reduce
over
them
change
properties
on
those
lists
as
I,
please
I
know
it'll
work
and
it's
just
a
great
time
once
again
dynamic
language.
So
over
here
we
look
at
closure
expressions.
A
You
start
off
your
expression
by
wrapping
it
in
parens.
Do
not
have
fear
of
parens,
don't
be
a
fop.
You
have
a
symbol
at
the
beginning,
a
number
and
another
number
and
those
are
like
your
parameters
and
you
can
chain
them
together
and
put,
and
these
functions
are
very
high
arity,
so
you
can
parse
as
many
parameters
to
them
as
you
like,
we,
since
we're
going
to
be
looking
at
closure
in
a
little
bit.
We
should
know
more
about
closure
data
structures
and
how
to
manipulate
them.
The
first
data
structure
here
is
a
list.
A
You
denote
the
list
by
wrapping
your
dates
in
brackets
and
then
adding
a
semicolon
at
the
front.
A
vector
is
the
same
thing,
but
it's
got
square
brackets.
A
set
is
unique,
but
it's
got
the
curly
braces
and
then
a
map
is
very
similar
to
a
dictionary
in
the
sense
that
you
can
index
into
it
and
modify
things
and
they're
great
for
closure.
A
So
next
thing
is
def
and
define
function,
so
I
can
declare
something
and
then
I
can
do
something
with
it
by
defining
a
function
and
the
functions
are
unique
and
we
also
have
symbols.
We
have
maps
with
nulls,
we
have
trues
and
falses.
We
have
namespaced
keywords
which
can
also
be
applied
to
symbols,
and
then
we
can
work
with
collections,
so
in
the
first
example,
I
might
earn
a
tight
rating
of
the
collection
and
adding
one
to
each
element
in
the
collection
next
I
reduce
over
that
and
one
two
three
four
gives
me
ten.
A
This
works
with
sets
and
vectors
too,
but
it's
worth
noting
that
vectors
or
sets
become
a
list.
So
what
that
means
is
that
if
you
add
something
to
the
vector
it
goes
at
the
front
because
it's
easy
to
add
things
to
the
front
of
a
list.
If
you
add
something
to
a
vector,
it
goes
at
the
end
because
you
just
eye
trait
of
it
and
you
pop
it
in
the
end,
once
again
reducing
over
one
two
three
and
four
to
get
ten,
so
I
can
concatenate
and
conjoin
collections.
A
The
first
one
is
a
vector.
So
when
I
concat
onto
the
vector
the
element
added
is
added
to
the
front
of
the
vector,
then
one
of
the
great
things
about
closure
is
the
thread.
First
macro
conventionally
known
in
languages
like
JavaScript,
with
the
use
of
rounder
and
lodash
as
a
pipe,
so
you
pipe
something
from
the
left
comes
out.
The
right
completely
changed,
I've
done
that
with
concat
and
I've
got
a
long
list
of
ten
items
and
map
over
them.
A
I
add
one
I
filter
for
the
even
ones
and
then
I
return
that
when
you
use
functions
in
closure,
the
last
thing
that
you
return
is
what
is
given
to
the
next
function.
So
I've
set
a
low
world
I've
wrapped
it
in
a
function,
I've
printed
hello,
world
and
because
I've
printed
it
I
get
a
no
back,
because
that's
Eyre
and
there's
nothing.
I
can
do
with
that.
A
So
some
things
to
know
all
of
the
data
structures
in
closure
are
immutable.
It
is
a
hosted,
dynamic,
general-purpose
language
and
you
cannot
mutate
data,
it's
very
similar
to
round
where,
if
you
add
something
to
a
map,
the
stuff
that
you
add
a
shed
and
everything
else
is
shared
with
the
other
people.
So
how
to
explain
just
memory
efficient
because
you
don't
need
to
repeat
references
fall
of
your
consumers
compared
to
JavaScript.
For
me,
it
erases
many
of
the
common
words
like
inconsistent
types.
Truth
true
and
false
inconsistency,
unintended
type,
conversions,
shallow
versus
deep
cloning.
A
So,
in
the
Redux
example
earlier,
we
had
to
spread
out
to
do's
in
order
to
create
a
new
list
of
to
do's,
so
that
our
front
end
would
know
that
something
in
that
list
had
changed.
This
is
not
an
issue
with
closure
because
of
hard
modifies
lists
and
vectors
they're,
a
huge
operator,
precedence
tables
in
JavaScript
and
there's
inconsistent
equality
checking.
A
So
for
me,
one
of
the
biggest
highlights
about
closure
and
one
of
the
best
things
is
the
ripple
with
the
ripple
you
can
pipe
stuff
together
map
them,
get
an
immediate
output,
debug
that
stuff
pop
it
into
a
file
and
make
it
part
of
a
test
for
next
time.
You
can
stream
it
to
the
front
end,
can
stream
it
wherever
you
want.
Just
it's
really
great.
So
closure
makes
life
simpler.
B
A
It
just
gets
out
of
your
way.
It
allows
you
to
be
hyper
productive.
It
allows
you
to
just
do
things
that
make
developers
sing
with
joy,
so,
on
the
subject
of
functional
programming,
I
want
to
take
a
moment
to
talk
about
event
sourcing.
If
you're
familiar
with
pub/sub,
then
you'll
be
familiar
with
the
event
sourcing.
This
is
a
model
that
we
use
at
work.
A
You
don't
have
to
worry
about
stuff
going
missing
if
you,
for
example,
have
a
store
and
you
want
to
move
stock
between
different
parts
of
the
store
you
just
say
like
I
bought
10
sheep
I
want
to
say
in
10
sheep
to
the
showroom
someone
else
bought
10
sheep,
which
means
that
I
need
to
credit.
The
account
was
like
X
amount
of
sheep
times.
10
and
I
need
to
debit.
My
account
with
the
converse.
It's
just
a
great
way
of
dealing
with
data,
so,
for
example,
the
balance
of
an
account
can
be
projected
by
summiting.
A
All
credit
and
debit
transactions
made
by
the
account
so
event
should
trace
back,
should
be
used
to
track
the
movement
of
stock
in
a
store,
I'm
using
event
sourcing
as
well
to
write
an
application
that
records
electricity.
So
you
take
the
reading
you
the
next
highest
reading,
and
you
multiply
that
by
the
cost
per
kilowatt
hour,
to
get
an
idea
of
what
you
spend
on
electricity
every
month.
A
A
A
Its
closure
script
and
then
it
builds
to
know
it.
So
that's
what
you
meant:
yeah
yeah,
yeah,
so
I'm,
just
working
with
that
with
callbacks
I.
Just
have
a
long
list
of
events
that
I
read
in
using
closures,
see
OJ's
reader,
which
reads
Eden.
It's
like
a
type
safe
data
addressed
data
structure,
for
example,
I'll
know
when
dates
updates
and
when
other
things
are
other
things.