►
Description
Stefan Baumgartner
Senior Product Architect at Dynatrace
We have all been there: The sprint’s closing, a deadline is about to arrive, and our feature needs to be shipped. Our best intentions are thrown overboard and we’re done when the compiler is happy with our work. Don’t panic! – But let’s throw a little unwrap in there, what could go wrong? Famous last words.
Rinse and repeat, and you’ll end up with winding, unwieldy functions, and kitchen sink structs, that past you wrote, but future you will have a hard time understanding. Let’s help ourselves, and all our colleagues, and refactor to something better. All we need to do is to remember some unique features of Rust, and implement the right traits for the right structs.
In this talk, we will refactor a single function with hundreds of lines of code together. We will learn to leverage expressions, define clear error boundaries, and implement standard library traits that align our code with Rust’s broader ecosystem. The result will be expressive, clear, and hopefully nothing else but beautiful.
A
A
Oh
great,
that's
a
nice
fantastic,
oh
cool,
so
we
have
very
small
Meetup
I
guess
we
have
about
10
people
Indians
or
something
like
that
to
see
that
the
people
here
know
it.
That's
that's.
That
really
means
a
lot
to
me
and
ever
since
you
know
we
started
two
years
ago,
it
was
because
we
wanted
to
learn
rust.
We
wanted
to
be,
we
were
excited.
It
was
interesting.
We
wanted
to
start
out
to
have
a
beginners
group
and
yeah.
A
Ever
since
we
we,
we
not
only
started
out
learning
it,
but
we
actually
adopted
trust.
So
the
company
I
work
for
Dyna
trees.
We
now
have
one
or
two
rust
projects
in
there
and
they're
quite
nice.
So
first
of
all,
rust
enables
us
to
do
things
that
we
didn't
think
we
were
able
to
do
before.
This
is
actually
the
project
that
we
are
working
on.
We
are
developing
our
own
JavaScript
content,
first
of
all,
cool.
A
Second,
it's
it's
very
interesting
because
it's
a
couple
of
of
use
cases
that
we
couldn't
do
otherwise.
What
we
do
here
is
that
we
get
events
from
some
Event
Source,
either
an
HTTP
event
like
a
request,
or
something
or
maybe
on
AWS,
Lambda
or
maybe
somewhere
in
some
process,
and
we
need
to
be
able
to
execute
arbitrary
JavaScript
codes
on
those
places.
Therefore,
we
create
two
modes:
one
mode
is
called
application
mode,
which
means
that
you
have
the
files
on
disk.
A
You
load
the
file
and
execute
it,
and
the
other
mode
is
called
ad
hoc
mode,
which
is
even
more
interesting
because
you
can
send
a
JavaScript
workload
to
the
runtime
indytics
executed,
so
it
doesn't
know
which
code
it
will
execute.
It
just
comes
from
an
event.
It
needs
to
be
able
to
execute
it
and
produce
a
results.
We
have
those
two
modes
and
run
into
a
work
and
the
work
is
based
on
Google
create.
They
are
really
nice
rust,
bindings
out
there
that
we
use
and
that's
about
it.
A
So
we
create
everything
in
front
and
use
the
V8
bandings
picked
there,
and
you
know
it's.
The
dinosaurs
now
has
about
1
500
developers
and
we
are
like
those
five
rust
developers
within
the
crowd,
which
is
really
really
interesting,
and
it's
also
a
little
bit
of
a
Prestige
project,
which
means
people
look
at
this
code
base
and
want
to
participate.
So,
instead
of
pack
filings,
we
get
full
requests.
This
is
really
really
nice
and
people
people
play
with
it.
A
So
once
we
changed
that
the
structure
of
how
we
load
files
from
the
disk
and
somebody
sent
us,
this
pull
requests
are
demanded
to
get
the
directories
where
the
files
are
recursively
from
a
root
directory.
They
wanted
to
make
sure
that
it
really
is
the
right
function,
so
they
did.
Of
course,
a
classic
code
comment:
get
directories
recursively
from
root
directory,
so
you
can
you
can
throw
all
your
code
comment
memes
at
me
right
now.
They
all
fit
it.
A
The
functioning
might
be
misleading,
so
close,
but
you
know
so
it's
easily
to
laugh
about
it,
but
please
don't
make
fun
about
it,
because
it's
the
first
of
all,
it's
cute,
isn't
it
so
it's
really
nice
because
I
guess
we
all
have
been
at
that
point
where
we
looked
at
code,
the
rewriting
and
realized
that
we
are
aiming
for
something
entirely
different
than
we
started
out,
and
it
was
never
more
obvious
obvious
thing
here.
So
code
is
evolving
and
this
is
a
good
thing.
A
We
start
out
with
something
totally
different
and
end
up
with
something
that
yeah
that
further
down
the
road
was
actually
what
we
were
aiming
for
and
this
change
is
inevitable,
inevitable,
inevitable,
and
especially
if
you
are
on
YouTube
programming
language
like
Russ,
so
rust
always
has
this
Monica
that
it
is
a
hard
programming,
language
or
hard
to
learn.
I,
don't
know
if
it's
hard
to
learn
with
the
programming
language
is
hard
to
learn
or
if
it's
just
your
programming,
you
just
are
not
allowed
to
cut
that
corner.
A
So,
instead
of
thinking
about
good
software
design,
when
you
start
out
with
a
programming
language
like
that,
you
will
most
likely
spend
more
time
fighting
the
plural
Checker
learn
about
those
rapid
types,
all
that
stuff
that
you
that
you
yeah
leave
those
comments
in
there
I,
don't
think
about
the
function
names
and
today,
I
want
to
go
with
you
through
a
piece
of
code
from
our
code
base
that
ended
up
very
varying
for
us.
So
it
gave
us
a
lot
of
headaches.
It
was
very
hard
to
maintain.
A
It
was
one
big
main
function
where
basically,
all
the
knowledge
was
in
there
and
we
tried
to
reflect
it
over
time
to
make
more
reason
out
of
it,
a
little
disclaimer
to
protect
the
innocent
and
also
our
our
ND
from
the
company.
The
examples
that
you
see
here
today
are
fictional,
but
they
are
rooted
in
reality,
so
the
patterns
that
I'm
going
to
show
you
the
the
starting
point
that
I'm
going
to
show
you
they
are
all
rooted
in
reality.
A
A
Actually,
it
doesn't
so
I
cut
off
a
little
version
down
at
the
end.
I,
don't
know
if
you,
if
you
realized
it,
also
I
removed
about
200
lines
of
code
monitoring
of
monitoring
code
in
there.
So
it
is
already
the
reduced
version,
and
so
one
thing:
why
would
we
want
to
refactor
that,
even
if
it's
a
behemoth
of
code-
and
even
you
see
all
the
indentation
there
and
lots
of
colors
comments
strings
whatever
I
guess
you
can
at
least
see
the
colors.
A
We
need
a
good
reason
to
change
that.
So,
if
we
don't
have
this
good
reason
to
change
it,
just
use
your
editor's
collapse,
feature
click
on
it.
Never
look
at
it,
put
a
blanket
on
it.
It's
nice
it
does
what
it
does,
but
hey
as
long
as
you
didn't,
don't
need
to
change
anything
real
good.
The
problem
is
if
we,
if
we
need
to
change
something-
and
this
was
the
main
entry
point
for
communicating
with
the
worker-
it's
called
an
event
handler.
It
takes
the
event
it
spips
up.
A
Everything
produces
nice
package,
sends
it
to
the
worker
and
gets
the
result
back.
So
this
is
what's
happening
here.
So
we
have
a
constantly
in
this
function,
all
the
time
we
will
constantly
working
with
it
and
we
faced
a
couple
of
problems
like
first,
it's
overwhelming.
So
if
you,
if
you
think
this
isn't
normal
valuing
please
come
talk
to
me
after
the
break
I
want
I
want
to
really
discuss
it
with
you.
So
there's
also
lots
of
indentation,
which
means
it's
really
hard
to
navigate.
A
So
I
I
really
have
a
hard
time
running
through
this
code
and
figuring
out,
what's
happening
as
we're
going
to
see
in
just
a
second.
They
are
very
unclear
responsibilities,
lots
of
similarities
and
it's
hard
to
keep
in
mind
what's
happening.
So
I
I
have
a
really
hard
time
to
keep
a
mental
map
of
my
code
in
my
head
and
it's
even
worse.
If
I
look
at
the
code
written
by
others,
so
the
code
needs
to
talk
to
me
and
not
I
just
do
the
code,
and
this
is
what
refactoring
is
all
about.
A
So
in
that
case,
we
really
needed
to
touch
this
piece
of
code
because
lots
of
trouble
there
lots
of
problems,
lots
of
of
panics
because
we
used
unwrapped
at
one
point
in
time
or
maybe
130
points
in
time
are
counted
so
yeah
big
problem
first
trick
to
get
into
refactoring
is
to
collapse
everything
on
the
first
level.
So
this
is
a
really
great
feature
from
your
editor.
A
You
just
click
on
the
array
on
the
left
side
and
it
collapses
everything,
and
now
we
can
at
least
figure
out
something
what's
happening
here
in
this
code
we
get
some
configuration
from
somewhere,
that's
okay,
and
then
we
have
two
modes,
so
I
told
you
about
the
application
mode
and
the
artwork
mode,
and
we
can
see
the
application
mode
in
there.
So
it's
here
on
the
line,
it
says:
Mode
app
cool.
This
is
the
application
mode.
We
can
figure
that
out
is
a
little
bit
a
little
bit
weird
where's,
the
ad
hoc
mode.
A
This
is
the
else
branch
is
at
the
elseif
branch.
So
why
do
we
need
another
condition
there?
This
is
what
I
meant
with
unclear
responsibilities.
I
assume
the
else.
If
branch
is
going
into
the
ad
hoc
mode,
because
the
elsif
branch
actually
has
more
code
than
these
Branch,
this
is
this
is
why
why
I
figured
that
out?
A
A
So,
let's
dive
in
into
the
application
mode
and
in
the
application
mode,
the
next,
if
statement
or
if
expression,
apparently
as
I
figured
out,
we
are
not
only
executing
JavaScript.
We
are
also
checking
if
our
JavaScript
application
is
healthy,
which
means
it
doesn't
produce.
Any
error,
which
is
I,
mean
it's
JavaScript.
We
could
argue
that
this
function
could
be
deleted
at
this
part
of
it
could
be
deleted
anyways,
because
errors
are
very
typically
in
JavaScript.
A
So
we
have
this
health
endpoint
and
there's
also
a
lot
of
code
in
there
and
I.
Just
look
at
the
first
thing
that
I
kind
of
the
kind
of
seems
odd
to
me-
and
this
is
this
part
here:
I
hope
you
can
see
it
all
the
way
in
the
back
attract
my
best
to
make
it
as
big
as
possible.
But
here
we
are
calling
the
evaluate
function
from
a
worker.
So
apparently
we
can
evaluate
coder.
This
is
what
we
learn
and
then
we
look
if
the
worker
result
has
an
error.
A
So
what
it
does
is
we
Loop
through
a
bunch
of
files?
We
will
evaluate
them
and
if
there
is
an
error,
we
just
return
the
error
and
break
break
the
evaluation.
So
we
found
an
error.
Let's
just
call
it
a
day
and
what
sweet
is
we
check?
If
it
is
an
error?
And
then
we
unwrap
the
error,
then
we
convert
the
error
and
then
we
pack
it
in
again.
So
this
is
all,
but
this
you
know
if
you're
not
used
to
error
types
in
Rust.
A
This
is
what
you
end
up
with
you're,
just
using
rust
analyzer.
You
talked
as
much
as
long
as
it's
the
rust
doesn't,
doesn't
give
you
any
errors
anymore
or
any
compilation.
Errors
and
that's
why
you
end
up
with
structs
like
that,
especially
if
you
don't
know
things
like,
for
example,
the
question
mark
operator,
which
takes
what
you
have
here
and
you
bubble
it
up.
It
does
the
same
thing
it.
A
It
converts
the
area
that
we
have
in
the
era
that
we
describe
the
buff,
which
is
the
sketch
all
error
that
we
had
here
and
suddenly
it
becomes
a
little
bit
smaller
and
much
much
clearer
what's
happening.
So
you
start
looking
for
those
question
marks,
because
this
is
an
operation
that
might
error
and
you
just
bubble
it
up
down
there.
We
have
the
response,
it
kind
of
looks
like
like
HTTP,
so
we
have
a
status
code
which
is
okay.
It's
your
16.
fine.
There
are
no
headers.
A
There
is
nobody,
but
this
is
the
struct
that
we
are
returning.
We
see
it
for
the
first
time.
One
thing
that
is
also
is
that
especially
this
struct
with
a
status
code.
Okay
with
nobody,
no
header
like
this
instance
of
structure,
is
repeated
over
and
over
again,
this
function,
so
every
three
times
maybe
four
times,
and
it's
always
in
cases
where
we
think
okay,
I
did
my
task.
I
just
want
you
to
know,
I'm
ready,
I'm
done,
there's
nothing
that
happened
in
particular
it's
just
that
I
finished
my
operation.
A
This
sounds
to
me
like
a
default.
This
sounds
to
me
like
something
that
should
happen
in
the
default
case.
That's
why
I
take
this
default.
Trade
and
I
implement
it
for
the
Handler
result.
It's
it's
the
same
thing.
So
the
destructive
free
return
is
just
the
same,
but
we
wrap
it
in
a
default
trade
and
now,
instead
of
that,
we
can
write,
100
result
default.
So,
okay,
it
avoids
redundancy.
We
are
abstracting
something
away,
but
we
could
use
functions
for
that.
A
Well,
I,
don't
know
something
that
we
convert
from
into
it
doesn't
matter
why
we
are
using
the
default.
Trade
is
has
a
reason.
The
reason
is
that
we
want
to
communicate
intent.
The
default
trade
says
that
we
think
this
is
our
default
State.
This
is
what
should
happen
if
nothing
extra
or
particularly
different
happens,
and
we
have
three
of
locations
where
this
default
rate
is
necessary,
and
this
is
actually
what
the
abstraction
is
all
about.
It's
not
only
to
reduce
code
in
the
void
redundancy,
but
we
want
to
provide
semantics
and
context.
A
A
We
are
not
done
with
the
function
yet.
There's
still,
these
parts
will
be
load
the
code
from
a
file.
It's
it's
a
path
buff,
and
then
we
need
the
file
name.
So
this
is.
This
is
a
V8
thing,
the
JavaScript
engine
that
we
use
underneath
it
needs
to
work
on
files
and
that's
why
we
need
to
provide
a
file
name
even
though
it's
just
we
just
came
up
with
it.
It
can
be
any
name,
even
it's
a
virtual
file,
but
it
needs
it
needs
a
name.
So
what
we
do
is
we.
A
A
We
map
that
to
a
real
string
and
then
we
hope
that
this
operation
was
okay
and
produced
a
result
like
we
have
an
unwrap,
it
totally
failed,
and
then
we
call
two
string
again
to
get
an
on
string
because
we
need
to
pass
it
to
the
worker
first
thing.
First,
this
made
the
error,
even
though
you
think
this
might
be
a
safe
operation,
because
it
never
errors.
This
might
error,
let's
at
least
provide
a
default
or
some
other
some
other
name,
instead
of
just
unwrapping
it.
A
But
then
again,
this
code
also
comes
up
over
and
over
and
over
again
in
our
code
base
in
the
health
check
in
the
actual
execution,
even
in
the
AirTrack
function,
because
you
know
in
the
other
function,
we
also
need
to
provide
a
file,
even
though
we
just
have
a
workload
from
somewhere.
We
don't
have
a
real
physical
file,
so
this
is
a
process
where
we
have
a
certain
set
of
semantics
that
we
want
to
do
with
this
particular
string.
A
It
suddenly
it's
not
just
a
string
anymore,
but
it
is
to
us
a
file
name
and
for
me
this
sounds
like
a
very
important
detail,
which
why
I
introduce
a
struct
for
it.
So
I
introduced
this
file,
name
struct,
it's
a
tool
construct.
It
just
contains
one
value:
it's
just
here
to
wrap
this
value
that
I
originally
had.
Instead
of
having
a
primitive
type.
Now
I
have
my
own
type.
It
says
something
so
now,
I'm
not
only
dealing
with
file
names,
but
I
can
also
say
well.
A
A
So
we
separate
the
knowledge
a
little
bit
on
not
only
on
the
variable
name,
but
also
on
the
file
name
and
what's
with
the
implementation,
so
first
we
create
the
conversion
implementation
from
path
buff
to
file
name.
So
for
me
this
is
really
beautiful
because
it
reads
like
English:
how
do
I
come
from
a
path
buff
to
a
file
name?
A
A
Because
this
is
what
they
need
in
the
runtime
and
with
those
trades
again,
I
communicate
intent,
I
communicate
what
I
want
to
achieve
with
that,
and
the
file
name
in
particular
becomes
something
from
my
domain,
something
from
my
semantics
and
for
the
outer
case,
I
can
Implement
default
again.
I
can
say
so
in
all
other
cases.
Please
use
that,
that's
okay,
so
we
have
this
thing
we
can
reduce
this
part.
Our
health
check
now
is
super
small
five
lines.
A
So
what
did
we
achieve?
We
introduced
defaults.
We
made
good
use
of
error
boundaries
with
question
mark
operator
and
we
introduced
our
own
type,
but
that's
more
of
our
refactoring
story.
We
learned
we
learned
that
we
need
to
focus
files
in
code.
We
learned
that
we
can
send
HTTP
responses
back
and
we
learned
that
errors
can
happening.
So
we
learned
a
little
bit
about
the
domain
of
the
function
and
we
can
apply
this
knowledge
to
all
the
other
parts.
A
Speaking
of
creating
our
own
types.
This
is
something
in
the
configuration
section
that
happens
over
and
over
and
over
again
we
have
a
hash
map.
We
look
in
this
hash
map.
If
a
certain
key
exists,
if
it
exists,
we
get
it
and
we
convert
it
to
something
that
can
be
on,
so
we
can
add
it
to
some
configuration
over
and
over
and
over
again,
and
the
problem
is
that
you
know
a
hashmap
requires
us
to
take
those
steps
to
get
to
this.
A
This
content-
and
this
is
lots
of
extra
information
that
we
also
might
want
to
abstract
away
for
us,
it's
not
necessary
to
understand
what's
going
on,
then.
If
you
want
to
make
changes,
we
would
need
to
make
those
changes
everywhere
and
everywhere
again
so
again,
I
introduce
my
own
type
again
to
abstract.
This
first
I
create
a
header
error,
because
it
can
error
interval
to
have
my
own
error
to
make
sure
that
the
notebook
was
wrong.
I
had
errors
are
pretty
easy
to
to
implement,
create
a
struct.
A
It
can
be
empty
at
the
deeper
trade
on
top
of
your
Dr
trade,
on
top
of
it,
the
display
trade
off
top
of
it.
Then
you
have
your
error,
your
own
error
and
then
I
create
again
a
struct
like
a
triple
struck
before
it
contains
my
hashmap
I
create
the
new
one
and
then
I
have
two
functions,
get
required
header
and
get
optional
header
two
methods
on
this
track
and
to
tell
me
exactly
what's
happening,
it's
a
required
header,
so
you
can
produce
a
result.
It
can
fail.
A
It
can
error,
it's
an
optional
head,
so
well
it
can
be
absent,
but
it
also
might
be
possible
that
you
have
some
and
just
with
filing,
we
added
our
own
semantics
on
top
of
a
standard
data
type,
the
characteristics
of
the
data
type
move
to
the
back
and
our
own
domain
moves
forward.
Our
goals
move
forward
again:
abstraction
hide
the
unnecessary
parts
and
provide
information
for
the
necessary
parts.
A
A
Actually,
it
would
be
nice
if
hmap,
for
example,
would
have
this
feature
at
this
characteristic,
but
then
I
say
it
is
straight
so
I,
instead
of
creating
a
header,
struct
I
create
the
header
straight
and
then
implement
the
header
straight
for
detachment
the
same
functions
just
within
my
scope.
I
can
now
treat
the
hashmip
like
headers
and
if
I
want
to
change
the
implementation
of
headers,
like
not
the
hashmap
anymore,
but
something
other
super
fancy
I
can't
just
do
it
by
code.
A
Just
stays
the
same
because
I'm
communicating
with
headers
not
with
the
hashmap,
and
this
is
how
I
use
it
so,
instead
of
instead
of
having
all
those
ifs
and
unwrapped
and
mappings
I
just
get
required.
Headers
with
the
question
mark
operator,
error,
propagation,
again
or
I,
get
optional
heads
again,
I
understand.
What's
going
on
there,
I
talk
in
my
own
domain,
I
talk
within
the
knowledge
of
my
application
and
not
handle
around
some
arbitrary
data
types
that
I
think
you
need
okie
dokie
now
for
the
main
Act,
let's
get
to
the
big
one.
A
A
We
have
to
find
him
out
yeah
and
again.
Finally,
we
already
had
that
we
can
use
our
own
struct
for
that,
so
we
can
use
that
one
to
use
the
file
name
struck
now,
a
little
bit
more
comes
into
Scorpio
next.
Here
this
is
where
we
have
an
option
value
and
we
map
it
to
another
option
value.
If
you
use
the
right
apis
from
the
option
struct,
we
can
reduce
this
to
one
line
instead
of
four.
This
is
also
nice
and
now
something
comes
into
scope,
which
is
a
default
enter
results.
A
We
also
have
a
struct
for
that.
We
can
call
Handler
a
result,
colon
colon
default,
and
we
reduce
that
as
well
and
now
I
think.
Oh
no!
Now
we
have
two
more
things.
We
have
two
very
interesting
functions,
so
we
have
a
worker
that
is
executed
and
then
we
have
two
mapping
functions.
First
of
all,
we
have
the
mapping
function.
If
the
case
is
okay
and
then
we
have
the
mapping
function.
A
If
we
have
an
error
and
since
we
use
good
error
propagation,
we
just
can
reduce
the
whole
mapping,
use
proper
error
propagation
like
bubble
up
the
error
and
work
with
the
happy
path.
So
this
is
what
error
propagation
and
the
error
trade
is
all
about.
If
we
had
a
question
mark,
you
can't
just
work
like
you
would
always
work
with
no
errors
and
just
propagate
the
errors
to
somebody
else.
Somebody
else
will
take
care
of
that.
That's
fine,
but
you
can
work
like
there
will
be
no
errors
and
now
it
fits
on
a
slide.
A
A
There
are
some
things
that
we
can
figure
out
like
there's
a
clear
distinction
between
an
error
and
the
result
within
the
worker
result,
but
it's
not
an
actual
error
or
an
actual
result.
This
is
because,
in
an
Network
execution,
you
can
have
a
JavaScript
piece
that
produces
a
result,
but
also
produces
errors.
It's
it's
JavaScript.
This
can
happen,
so
you
can
still
run
it
even
though
you
log
an
error
somewhere,
and
this
is
what
we
want
to
communicate.
This
is
by
in
the
UK
case.
A
They
have
a
piece
of
code
INE,
they
work
with
the
payload
and
once
they
are
done
with
the
execution,
they
need
to
pass
the
result
and,
if
I
look
at
from
that
perspective,
this
hacks
back
some
memories.
From
my
computer
science
case.
We
have
the
same
preconditions.
We
have
the
same
properties,
but
they
executed
only
slightly
differently,
and
this
is
also
the
presumption
of
a
strategy
pattern
so
question
to
the
audience
who
knows
about
the
design
patterns
of
object,
oriented
designed
by
the
gang
of
okay?
Okay,
that's
that
slot.
That's
great!
A
So
me
too,
I
learned
it
in
computer
science,
cars
and
I
tried
to
avoid
it
for
decades,
basically,
because
I
had
so
such
bad
memories
and
such
bad
experiences
with
from
Mostly
tropical
places
where
you
try
to
get
every
design
pattern
somehow
framed
in,
but
actually
in
Rust
I
have
the
feeling
that
they
are
really
really
nice
and
to
work
really
really
well,
because
they
were
designed
for
composition
of
inheritance.
Composition
is
great
and
last
inheritance,
not
so
much,
and
we
just
seen
it
with
Raffles.
A
Okay
also
used
the
Builder
pattern
over
and
over
again,
which
is
a
really
good
pattern
for
those
kind
of
things.
So
I
want
to
create
a
strategy
at
the
mercy.
I
have
this
execute.
They
just
take
scattered
the
right
things
are
executed,
but
they
can
rely
on
different
strategies,
calling
event
strategies
so
I
modeled
my
event
strategy
and
look
at
that.
It's
what
do
I
have
here.
I
have
a
file
name:
I,
have
the
code
I
get
a
payload
and
I
can
pass
the
result.
A
A
The
methods
speak
to
me
and
understand
that
if
I
call
the
file
name,
method,
I
get
a
file
name
and
it
I
will
always
get
a
file
name,
because
it's
not
wrapped
in
a
result
during
an
option
or
something
like
that,
I
can
be
sure
that
I
get
a
filing
I
can't
be
sure
that
I
get
a
code.
This
might
error,
but
if
I
get
a
code,
it's
of
type
spring,
so
suddenly
I
understand
a
lot
lot
more
about.
A
What's
going
on
in
both
strategies
without
needing
to
pass
every
line
of
code,
let's
try
to
implement
the
attack
strategy
so
I'm
trying
to
to
take
a
look
at
the
Watch.
What
it
does
it
takes
a
handle
event.
This
is
what
I
get
in
and
tries
to
create
an
ad
hoc
task
out
of
it.
This
is
a
structure
they
already
had
I,
really
don't
care
about
what
I
get
in
and
what
what
it's
towards
I
care?
More
about
that
I
have
a
try
from
trade.
A
Well,
I
can
tell
well
I
tried
to
generate
this
struct
for
you
I
try
to
establish
this
strategy
for
you,
it
might
fail,
but
if
it
doesn't
fail,
I
have
a
strategy.
I
can
work
with.
So
this
is
where
I
do
all
the
passing
for
those
two
elements
for
code
and
for
the
I
guess
for
the
payload
and
then
I
have
the
implementation
of
the
trade
itself
of
the
event
strategy,
trade
and
look
at
that.
A
So
almost
every
every
method
here
is
a
one-liner
except
the
one
where
I
passed
the
result,
but
it
got
contents
so
much
that
they
can
finally
figure
out
what's
happening
there
and
the
same
goes
for
for
the
app
strategy
or
application
strategy
a
testimony
because
it
doesn't
fit
on
the
slide
now.
I
understand
that
each
part
in
my
code
what's
happening,
I
implement
the
executor.
The
executor
takes
an
event
strategy
and
what
it
does
look
at
it.
A
It
gets
a
file
name,
it
gets
some
code,
it
gets
a
payload
and
then
it
calls
the
executor
and
once
the
executed
it's
done,
it
passes
the
result.
So
suddenly
all
those
steps
and
all
those
three
conditions
that
I
need
are
clear.
I
can
read
them.
It's
very,
very
clear
what
I
expect
you
know
what
that
is.
A
It's
so
great,
and-
and
it's
now
a
lot
lot
clearer,
what's
happening,
I'm,
creating
a
configuration,
that's
nice!
It
actually
doesn't
look
that
different.
It
just
got
reduced,
but
it's
nice
I
understand
that
the
configuration
is
happening
here
then,
based
on
some
input.
I,
don't
even
need
to
care
which
input
it
is
I,
create
the
strategy,
identification
strategy
or
network
strategy,
and
now
look
at
that.
There's.
No.
A
If
else,
if
else
Branch
anymore
I
have
a
match
statement,
I
take
care
of
every
mode
in
my
enum,
which
means
that
if
I
add
a
mode
or
remove
the
mode,
I
get
an
error
here.
This
is
nice
and
if
they
have
the
error
case,
I
just
propagate
the
errors
up,
I
don't
need
to
handle
the
error
explicitly
anymore.
This
is
what's
Happening
Here,
so
I
create
a
strategy.
This
is
great,
what's
happening.
A
Next,
I
feel
the
executor
with
the
strategy
and
if
I
have
this
health,
endpoint
I
evaluate
the
code,
otherwise
I
execute
the
code.
This
function
is
not
totally
clear,
what's
happening.
I
can
give
this
to
somebody
along,
of
course,
with
the
domain
knowledge
of
my
application,
and
they
can
understand.
What's
going
on
there
best
thing
is
we
won't
change
this
function
anymore?
You
know,
I,
know
famous
last
words.
We
definitely
we
changed
it,
but
not
that
often
anymore.
A
If
you
want
to
create
new
features
or
introduce
new
stuff
in
it,
we
can
do
it
in
all
the
other
parts
of
our
application.
So
hey,
what's
it
worth
it
so
I
think.
Yes,
first
of
all,
we've
got
a
rate
of
all
potential
panics.
This
is
great
and
we
have
prop
error
propagation.
Let
somebody
else
take
care
of
your
error.
A
We
can
change
things
where
they
belong,
so
we
have
much
faster
iterations.
If
we
introduce
typescript
support
which
we
do,
then
we
change
the
code
part
in
our
strategies.
If
we
want
to
change
where
we
pick
files
in
the
application
strategy,
we
can
take
the
get
directories,
recursively
function
and
put
it
in
the
code
base
a
code
part
of
the
application
strategy.
A
Also
great.
We
can
now
test
all
our
features
in
isolation.
We
can
test
the
strategies
in
isolation.
We
can
test
the
executor
with
mock
strategies.
This
is
also
possible
and
contributions
are
much
much
easier
because
the
code
communicates
clearly
if
you
know
what
we
try
to
do
and
maybe
see
an
architecture
diagram.
Well,
maybe
just
talk
to
to
this
person
at
the
coffee
machine
who
works
at
the
company
for
five
years
and
has
done
all
that
you'll
know
what
we
are
up
to
there's
still
a
lot
to
do
so.
A
Well,
you've
seen
a
couple
of
RCs
here
and
there
you
may
be
have
seen
that
I
use
trade
objects
which
I
question.
If
we
need
that,
but
that
that
our
optimizations
and
we
also
have
a
couple
of
clones
in
there,
but
those
are
all
optimizations
that
we
can
do
later.
We
can
figure
out
our
ownership.
We
can
figure
out
all
those
parts,
but
it's
much
much
easier
to
figure
out
now
that
we
have
a
clear
code
base
and
something
where
we
actually
see
what's
happening.
A
So
is
it
better
I
think
so?
Is
it
the
best
solution?
I,
don't
I
don't
know.
So
this
is
something
that
I
came
up
with.
Folks
from
my
team
came
up
with
something
different
but
with
the
same
effect,
so
many
ways
lead
to
Rome,
and
this
was
just
one
way
where
I
guess
yeah
I
guess
we
made
it.
We
made
it
a
little
better,
so
main
takeaways
have
proper
error
handling
right
for
the
happy
path.
This
is
what
you
want
work
with
defaulting
conversion,
trades
to
communicate
intent.