►
From YouTube: Rust Cologne: hyperjson
Description
During a recent Python Hackathon in Düsseldorf, Matthias somehow managed to sneak in some Rust code while writing a fast, safe Python module for encoding and decoding JSON. It passes (most of) the Python test suite for the json module and was unreasonably pleasant to write. Listen carefully as he tells the story of a little side-project that got out of hand and how Rust can help speed up even the most boring, highly-optimized tasks like parsing file formats in the future.
Matthias Endler
A
Hyper
chasin,
that's
the
name
thing
I'm
gonna
talk
about
today
and
before
we
start,
I
would
like
to
mention
Pascal
who
came
up
with
an
alternative
project
name
for
it.
He
wanted
to
call
it
hydro,
Jason!
Well,
if
you
don't
get
this
reference,
simple,
you're,
probably
too
old,
but
this
is
fast
cars
project.
So
it's
not
my
project.
My
project
is
called
hyper
Jason
and
before
we
even
continue,
I
want
to
tell
you
that
I
want
to
know
your
expectations
a
bit.
So
probably
what
you're
expecting
is
this?
But
I
will?
What
I
will
deliver?
A
Is
this?
Because
this
is
a
meet-up
talk?
This
is
not
a
conference
talk,
I,
don't
get
paid
for
it.
I
didn't
have
time
to
prepare
much.
You
will
see
later
on
when
the
slides
get
less
and
less
and
less
attention
and
the
formatting
breaks
apart
and
then
everything
goes.
It
goes
to
hell,
so
be
warned
if
you
have
something
better
to
do
then
yeah,
probably
that's
a
good
good
time.
A
Hi
Patricia
I'm
Matthias
I
work
in
Dusseldorf
I
come
from
Bavaria
I
do
rust,
since
2015
I've
been
involved
in
many
projects,
but
yeah,
not
too
many.
You
might
know
of,
probably
maybe
if
at
all
then
hello
rust,
which
is
a
YouTube
channel
about
the
rust
programming
language
and
from
time
to
time.
I
make
weird
experiments
with
rust
and
I.
Try
my
best
to
come
up
with
something
that
nobody
is
ever
trying
to
use
and
just
to
have
some
fun,
and
this
is
one
of
those
projects.
A
A
Tell
somebody
I
write
a
JSON
encoder,
that's
usually
how
they
look
like,
because
there's
tons
of
them
and
also
why,
because
parsing
JSON
is
so
simple,
this
is
the
entire
JSON
spec.
That
is
all
you
need
to
implement
your
own
incoherent
decoder.
I
mean
how
hard
can
is
P.
You
have
objects,
you
have
arrays,
you
have
strings
as
basic
types.
You
have
numbers
as
basic
types.
The
word
is
so
easy
M.
A
What
is
Chaisson
by
the
way?
It's
a
subset
of
JavaScript
and
I.
Think
that
salsa,
while
became
so
popular,
because
a
lot
of
browsers
already
had
implementations
for
trace
on
interpreters,
and
so
you
already
had
parses
for
it
when
we
got
started,
and
so
this
is
why
we
are
still
using
it
until
this
time.
But
this
is
theory.
A
This
is
more
like
the
reality.
When
you're
parsing
JSON
it's
a
minefield
and
I
literally
mean
it.
There's
an
article
from
somebody
saying
JSON
is
a
minefield.
That's
the
title
of
the
article
and
I
love
it.
You
cannot
read
that,
but
the
green
stuff.
This
is
where
we
are
fine,
the
rest
not
so
much.
The
blue
stuff
is
undefined
behavior.
So
this
is,
this:
are
gaps
in
the
trace
on
definition,
at
the
definition
that
I
showed
you
before
has
a
lot
of
edge
cases
and
that's
undefined
how
to
handle
this
case.
A
Some
browser
vendors
handle
this
way.
Some
others
handle
it.
That
way,
which
is
the
correct
way.
Nobody
knows
there
is
no
correct
way,
but
what
should
never
happen
is
that
your
encoder
or
decoder
crashes,
because
then
you
have
a
problem
that
can
cause
a
lot
of
issues,
including
security
problems,
and
this
is
when
there
you
have
anything
in
this
grid.
That
is
not
blue
or
green.
Those
are
the
issues
so
on
the
top.
You
can
read
it,
but
they
are
from
left
to
right.
A
A
You
might
say
how
the
hell
can
something
crash
in
your
face.
But
then
you
look
at
those
examples
ahead.
I
guess
you
can
get
a
feeling
of
what
it
means
to
write
a
proper
trace
on
encoder,
so
those
are
the
tests
that
are
running
and
there's
everything
in
there
from
bite,
encoding
to
array,
encoding,
weird
formatting,
big
and
small,
floats
escaping
nested,
arrays,
and
so
on.
A
Now
a
lot
of
people
might
say,
but
in
practice
that's
not
really
a
problem.
Well,
for
example,
this
is
a
buck
report
for
the
child.
Json
encoder
in
Python
JSON
is
a
standard
library
module
in
Python.
You
can
import
it.
It's
been
there
since
ages,
20
years
I,
don't
know
and
that's
from
2014,
it's
already
closed,
but
you
could
access
arbitrary
process
memory
from
the
JSON
module
so
and
the
tech
vector
would
be.
You
create
a
JSON
payload
which
is
invaluable.
You
send
it
over
to
this
back-end
application.
A
Another
example
search
for
stack,
overflow
segmentation
fault
entries.
You
will
get
an
entire
list
of
things
that
can
go
wrong.
Lots
of
people
come
complain
about
invalid
memory,
access
about
SEC,
folds,
about
dangling
pointers
and
so
on.
In
fact,
it's
so
bad
that
when
you
google
for
JSON
segmentation
for
Python,
you
get
80,000
results
in
0.37
seconds.
It's
like
saying,
yeah,
you
messed
up.
A
But
on
my
own
of
course
it's
super
easy
to
write
a
JSON
encoder
and
there
was
a
Python
hackathon
at
trivago
not
too
long
ago,
where
I
was
super
bored
I
had
no
other
thing
to
do,
and
I
said
I'm
gonna
give
it
a
shot.
I'm
gonna,
try
it.
It
was
April,
14,
2018
and
I
started.
I
started
hacking
on
this
thing.
This
is
me
hacking.
So
this
is.
This
is
an
actual
recording
when
it
happened.
A
A
You
start
up
your
Python
interpreter
you
import,
hyper
JSON,
and
then
you
can
load
a
string
one
you
get
one
back,
which
is
a
Python
object.
If
you
put
in
not
a
number,
you
get
not
a
number
in
the
Python
object,
and
if
you
have
a
list
of
things
of
different
types,
then
this
should
also
give
you
an
error,
because
it's
not
a
string
or
a
bite
or
a
byte
array,
so
you
can
see,
I
add
quotes
around
it
and
then
it
will
compile
into
the
proper
Python
object.
A
So
this
is
what
I
had
after
the
first
day
and
yeah,
you
can
see
it's
been
a
while,
because
I
use
this
old
computer
for
it.
It's
definitely
not
something
that
I
just
hacked
together
on
my
Mac
real,
quick,
nice,
oh
by
the
way,
yeah
I
wrote
this
in
rust.
I
should
have
told
you,
maybe
it's
a
rust
meetup
and
the
reason
why
I
wrote
this
in
rust
is
two
reasons.
First,
I
wanted
to
avoid
segmentation
faults,
dangling
pointers.
A
Second,
I
wanted
to
use
the
power
of
rust
when
it
comes
to
performance,
so
I
wanted
almost
zero
overhead
I
wanted
to
hook
into
the
Python
interpreter
without
a
garbage
collector
I
wanted
nice
bindings
similar
to
C
I,
wanted
to
deploy
that
to
the
PI
P,
which
is
the
Python
package
index,
so
that
you
can
download
it
without
even
knowing
that
it's
written
in
rust
all
of
the
kind
of
stuff
after
this
prototype
was
running.
That
project
set
idle
for
a
moment
and
then
something
magical
happened
because
new
people
came
in.
A
That
was
just
me
on
in
the
beginning
of
the
project
working
on
my
own
and
then
all
of
a
sudden
somebody
else
came
which
was
a
Chinese
developer,
helping
me
out
with
with
some
Python
stuff.
He
also
wrote
a
talk
about
it
and
then
some
more
people
came
in
and
yeah
it's
it's
growing
organically
I'm,
not
saying
that
it's
growing
quickly,
but
at
least
there's
some
traction,
and
that
was
me
just
recording
this
video,
because
I
didn't
know
how
course
works.
A
One
of
the
reasons
why
I
got
new
contributors
was
that
I
announced
this
project
on
the
rust
reddit
forum
got
some
traction
there,
some
very
nice
ideas
from
the
users.
Some
comments,
I
just
explained
what
I
wanted
to
build
and
why
and
then
we
talked
about
how
to
make
chase
and
encoding
and
decoding
even
faster
than
C,
and
one
of
the
years,
for
example,
would
be.
You
could
use
Cindy
for
some
parts
of
chase
and
encoding.
If
you
have
a
big
Cindy
is
stands
for
a
single
instruction,
multiple
data.
A
I'm
not
saying
you
should
do
that,
but
at
least
rust
allows
you
to
do
that
is
you
can
use
a
parallel
execution
to
convert
JSON
into
Python
because
well,
if
you
have
a
nested
array
or
array
of
sup
arrays,
then
you
can
convert
each
sub
array
separately
and
then
merge
the
result
together
and
theoretically,
you
should
be
faster
than
the
C
version,
because
I
have
not
seen
a
C
Chaisson
encoder
that
is
using
any
threats
or
any
parallel
execution
in
rust.
You
could
even
have
that
as
a
separate
crate.
A
A
There's
a
github
repository
couple
stars
not
to
much
traction
right
now
busy
with
other
stuff
but
I.
Guess
it's
it's
nice
to
to
have
a
baseline
for
it.
I
will
show
you
later
on
how
it
it
looks
like
in
terms
of
performance,
but
first
this
is
roughly
the
number
of
lines
of
code
and
from
this
list
you
can
already
see
that
we
put
a
very,
very
big
focus
on
compatibility
with
other
trace
on
libraries.
A
So
hyper
JSON
now
supports
all
methods
that
JSON
also
supports
in
Python
3.6
and
before,
and
you
can
see
we
have
I
can
even
count
it
is
it
a
million
or
ten
million,
it's
a
million
and
eighty
seven
thousand
lines
of
JSON,
and
all
of
this
is
possible
with
roughly
five
hundred
lines
of
frost.
So
you
might
be
surprised
to
might
be
saying:
wait.
You
wrote
this
encoder
yourself
in
500
lines
and
it's
it
should
be
safer
than
the
other
ones.
A
Well,
no
of
course
not
yeah
I'm
using
34
conversion,
so
it's
just
a
thin
wrapper
around
30
and
the
wrapper
itself
is
also
not
written
by
me.
It's
pi,
o
3,
which
is
a
library
for
converting
Python
types
to
Russ
types.
So
all
of
this
cannot
be
simpler
from
my
side,
but
I
like
that.
You
can
combine
those
two
and
have
something
metrical,
so
imagine
doing
the
same
thing
in
C.
A
You
don't
have
a
package
manager,
so
you
have
to
kind
of
have
a
get
sub
module
for
the
34,
the
serialization
part,
and
then
you
have
getting
sub
module
for
the
Python
conversion
part.
So
it
would
be
a
total
ball
of
mud
unmaintainable
in
in
rust.
It's
super
easy.
You
have
a
car
botamo,
yet
those
two
things
you're
done.
A
How
does
a
Python
module?
Look
like
that?
You
write
in
rust,
you
might
ask.
Well
I,
was
thinking
about
showing
you
the
entirety
of
the
hyper
trace
and
source
codes,
but
probably
you
would
not
learn
much
because
it's
a
bit
overwhelming.
If,
if
you
want
to
learn
all
this
while
I
scrolled
by
so
instead
I
want
to
show
you
two
simple
slides
that
already
implement
an
entire
Python
module
from
scratch,
and
it's
usable
by
you
right
now
from
the
Python
side.
A
Let's
say
you
have
a
module
called
Len
RS.
It's
an
implementation
of
the
length
function
in
rust.
Len
RS
can
compute
the
length
of
a
string,
for
example
5
in
this
case
for
hello,
and
it
can
also
return
the
length
of
a
list
and
it
cannot
convert
this
into
something
that
is
a
length
because
what
is
the
length
of
one?
So
it
will
give
you
a
type
error,
and
that
is
the
entire
functionality
of
length
to
build
this
in
rust.
You
don't
need
much
code.
It
fits
on
one
slide.
A
Let's
go
through
this
one
by
one.
First,
you
need
nightly
rust,
because
piyo
three
uses
a
few
features
like
procedural
macros.
Those
are
the
hashes
in
front
of
your.
You
know:
function
names
there.
They
are
just
not
available
yet
in
stable
rest,
then
you
can
define
a
module
name
even
with
the
newer
versions.
This
is
not
even
needed
anymore,
so
it
will
use
the
crate
name
by
default.
I
guess,
then
you
define
a
function,
name,
let's
say
length,
and
then
you
only
write
rust
code.
A
So,
by
definition,
the
only
thing
that
is
not
boilerplate
here
is
our
length
function,
because
this
init
wrapper,
that
is
just
a
convention
for
Python
on
how
modules
are
structured.
Every
module
has
an
init
and
in
it
you
have
the
functions,
see
what
I
did
there
no
beautiful
and
they
have
one
length
function
here.
It
takes
two
arguments
in
our
case.
First
is
high,
which
is
add
an
instance
of
Python,
which
is
the
Python
runtime.
The
way
this
works
is
in
piyo
3.
The
objects
always
belong
to
Python.
A
So
with
that,
you
solve
an
ownership
problem,
because
you
don't
really
move
things
around.
You
keep
it
on
the
Python
side,
but
you
sometimes
only
hook
in
when
you
want
to
create
a
rust
object
when
you
want
to
convert
stuff
all
of
those
problems
with
borrowing
lifetimes
ownership.
That
goes
away
if
you
just
have
Python
as
your
source
of
truth,
and
the
second
thing
that
we
need
is
an
object.
A
That
is
just
a
convention.
You
can
also
have
a
string
whatever,
but
if
you
want
to
be
very
generic
and
you
want
to
accept
any
type,
then
you
want
the
pie
object
here,
because
everything
in
Python
is
an
object,
even
a
number
I'm,
not
sure
about
the
numbers,
probably
a
lot
of
people
who
screen
now,
like.
Oh,
my
god,
he
said,
numbers
are
objects
but,
for
example,
strings
are
objects
and
so
on,
and
you
always
return
a
pie
result.
A
pie
result
is
just
a
wrapper
around
a
runtime
in
which
takes
your
rust
thing.
A
Your
rust
object
that
you
created
and
converts
it
back
to
Python,
and
if
that
conversion
fails,
then
you
get
an
error,
but
otherwise
you
get
a
pie
of
check
back
which
the
Python
interpreter
can
handle
without
dropping
a
bit.
You
can
see
that
I'm
using
a
nice
pattern
here,
the
if
let
okay,
if
I,
can
convert
the
object
on
the
right
side
to
a
string.
Then
I
return
the
string
length.
This
is
what
those
two
lines
mean.
Can
you
see
my
pointer?
A
You
know
I,
probably
you
can
see
it
in
the
video
but
those
two
lines.
They're
quite
interesting.
We
match
on
the
object,
types
that
we
get
in
and
if
it
we
can
extract
the
string
from
it.
Then
we
return
the
string
length
string.
Length
is
just
a
rust
function
and
we
convert
it
to
object,
because
why
do
we
need
to
convert
it
to
an
object?
Well,
because
objects
and
Python
are
ref
counted
in
our
string
is
not,
and
the
second
case
is:
if
the
object
is
a
vector
of
strings,
then
we
return
the
victor
length.
A
We
could
now
add
more
types.
This
list
is
maybe
not
complete.
For
example,
we
did
not
cover
dictionaries,
sets
your
objects,
we
could
talk
about
other
things
on
and
on,
and
usually
this
is
the
thing
that
I
dealt
with
most
in
hyper
JSON
edge
cases
in
this
case,
whenever
it's
not
a
string
or
a
vector,
we
just
return
a
type
error.
We
just
say
it's
not
supported.
So
at
least
we
stay
compatible
with
length
of
the
Python
standard
lib
and
we
returned
and
okay.
That
means
the
initialization
was
correct.
A
That's
it
that's
the
entire
Python
module
to
get
started,
and
you
can
now
write
Python
extensions.
If
that
was
a
bit
too
fast,
I
even
have
an
episode
of
hello
rust
on
the
web.
Episode
number
eight,
where
I
explain
that
to
you
and
you
can
follow
a
long
while
I
built
this
module,
we
will
run
every
well
compile
it.
This
is
me
programming.
I
totally
did
not
insert
this
screenshot.
While
we
were
on
the
train,
so
Cologne
it.
This
is
not
a
loading
screen.
A
A
A
We
are
around
since
April,
so
we
have
some
gap
to
catch
up,
but
we
will
get
there
in
the
end,
at
least
we
have
the
30
core
developer,
also
working
on
it,
so
it
could
be
worse.
Sometimes,
though,
we
are
faster,
especially
with
with
simple
types
like
we
have.
These
are
not
256
doubles
in
an
array
these
are
256
arrays
with
doubles
those
tests.
They
come
from
micro,
Jason
itself.
We
just
converted
it
to
PI
test,
which
makes
benchmarking
really
high
dramatic,
really
fast.
A
Those
tests
will
be
running
multiple
times
on
a
worm
cache
and
you
get
the
standard
deviation.
You'd
get
a
mean
you
get
a
median.
So
scientifically
is
correct.
We
just
use
those
weird
graphs,
because
people
focus
a
lot
on
benchmarks
and
they
think
that
those
are
hard
numbers,
but
in
fact
everybody
knows
that
this
can
fluctuate
a
bit
based
on
your
machine,
so
take
that
with
a
grain
of
salt.
But
it's
just
a
rough
comparison
on
one
test
machine
on
my
Mac
and
yeah.
Sometimes
we
are
fast.
A
A
Yeah,
most
of
the
things
you've
already
seen:
piyo
3
I'm
using
sir
D
for
the
choice
on
conversion.
As
I
told
you,
then
we're
using
nightly
rust.
You
can
see
that
from
the
features
that
we
need
to
use
here.
We
are
using
failures
for
failures
and
then
we
convert
it
to
Python
types,
which
is
quite
nice
because
you
get
the
best
of
both
worlds.
Error
handling
is
very
nice
in
this
case
yeah.
A
But
the
basic
implementation
is
this:
you
try
to
match
on
different
types
in
rust.
You
say:
extract
the
string
from
it.
If
we
can
extract
the
string,
then
deserialize
it
to
a
Python
object,
otherwise
convert
some
special
floats.
For
example,
Python
knows
not
a
number
or
minus
infinity
and
plus
infinity,
which
is
definitely
not
in
the
trace
on
standard
but
Python
in
their
heavily
intuition.
They
decided
that
it's
a
good
idea
to
extend
the
standard
of
it,
and
otherwise
we
return
a
value
error.
Like
the
normal
standard
lip
module.
A
Then
we
convert
byte
arrays,
that's
for
utf-8
support
and
yeah
some
macros
for
for
conversion,
but
it's
more
or
less
the
same
thing.
We
always
use
extract
and
we
match
on
the
result,
and
if
so,
then
we
serialize
with
sorry
not
much
else
to
show
some
tests,
yeah
I
guess
we
can
run
it
once
I
was
wise
enough
to
increase
the
screen
size.
So
if
you
run
make
install
it
will
download
all
the
dependencies
from
pip
to
create
the
bindings
like
setup
rust,
rust
set
up
what
is
called
set
up.
A
A
A
Probably
this
will
be
yeah.
You
can
see
that's
testing
all
the
things
we
have
a
few
skip
tests
which
are
known
issues
but
we're
working
on
them.
I'm,
not
saying
that
we
are
free
of
segmentation
faults,
but
at
least
we
aim
very
very
hard
to
to
make
that
possible.
Apart
from
that,
that's
it
for
my
talk.
Thank
you
very
much
for
listening.
C
A
You
I
use
something
existing,
which
is
called
sturdy
trace
on
its
json
library,
for
rust,
it's
in
a
crate,
and
it
is
one
of
the
fastest
around
so
in
any
implementation
in
any
language,
and
this
is
also
the
beauty
of
it.
This
is
what
inspired
me
to
use
it,
because
it's
just
so
freakin
fast
and
just
to
piggyback
on
that
I
wrote
this
small
wrapper
around
it.
I
pass.
C
A
More
or
less
it's
the
first
so
30
will
convert
it
to
whatever
it
should
convert
to.
You
can
convert
to
many
many
different
outputs,
so
it
can
take
trace
on
and
convert
it
to
yeah
Python,
for
example,
which
in
this
case
I,
more
or
less
wrote
this
right
before,
but
yeah
internally,
so
do
is,
of
course
written
in
rust.
So
you
get
some.
A
D
So
where
would
you
see
it
in
some
performance
improvements
like
how
will
you
get
faster
than,
for
example,
micro,
J's
and
implementation?
Will
you
like
talk
to
the
cert
adjacent
people
and
make
them
may
be
aware
of
some
kind
of
performance
problems
they
could
have
well
where,
where
it
is
the
performance,
critical
point
or
the
bottleneck
right
now,
is
it
like
the
conversion
to
part
the
Python
object
or
like
the
gluco
in
between
or
yeah.
A
A
lot
of
it
just
comes
from
the
complexity
of
the
Python
interpreter.
One
of
the
bigger
things
is
utf-8
support
right
now,
utf-8
and
and
ASCII
or
supported
in
both
Python
version.
So
we
support
Python,
two
and
three:
that's
something
that
you
have
to
tackle.
Most
of
the
things
we
just
run
some
profiling.
We
see
that
we
have
a
bottleneck,
for
example,
in
the
hashmap
generation,
and
then
we
can
fix
that
iteratively.
A
But
you
can
learn
a
lot
just
by
reading
the
ultra
chase
and
implementation
because,
for
example,
some
some
things
that
they
do
are
predictive
analysis
on
what
might
be
the
next
object
that
will
be
converted
and
prioritizing
in
their
implementation
and
maybe
making
a
quick
exit.
The
air
and
some
some
hand
coded
conversion
there.
So
Saudi
is
nice,
but
if
you
really
find
a
bottle
necked
and
you
can
also
come
up
with
your
own
implementations.
A
Another
thing
is,
for
example,
for
dictionaries.
We
use
a
b-tree
map
and
maybe
that's
not
the
best,
because
as
far
as
I
remember,
it's
cryptographically
safe,
but
we
don't
really
need
that.
So
maybe
faster
hashing
algorithm
might
be
a
good
choice
to
speed
it
up.
Once
we
reach
a
certain
level
of
performance
which
we
are
happy
with
and
which
kind
of
matches
to
see
implementations.
This
is
where
the
real
fun
can
begin,
because
then
you
can
start.
A
You
can
start
parallelizing
things
you
can.
You
can
use
more
rust
features
that
you
don't
have
in
in
see
like
fearless
concurrency
like
super
out-of-the-box,
simple,
simply:
support
zero
cost,
abstractions
all
that
kind
of
stuff.
There
was
a
long
ish
discussion
on
this
subreddit
entry
for
Hyper
JSON.
So
if
you're
interested
in
that
then
checked
it
out,
there
were
a
lot
of
very
knowledgeable
people
and
a
few
also
created
issues
for
hyper
trace
on
how
to
improve
it,
had
some
own
ideas
and
so
on.
A
E
A
Yeah,
that's
a
good
point.
That's
one
thing
that
you
can
use
to
improve
the
code.
So,
instead
of
working
on
own
types
and
on
the
heap,
you
could
work
on
views
into
memory.
One
idea
is,
for
example,
using
clone
on
right
string
instead
of
a
real
own
string,
because
in
Python
you
already
have
the
string
and
when
you
use
rust,
you
already
can
access
this
memory,
but
then
we
convert
it
to
a
string
again.
A
So
we
allocate
memory
on
the
heap
and
then
we
convert
it
back
and
you
have
two
allocations
which
are
super
useless
because
you
have
to
clone
on
right.
You
you
have
to
view
on
in
memory.
It
gives
you
the
rust
guarantees,
but
without
the
overhead
of
additional
applications
and
allocations
are
one
bottleneck
right
now
for
our
performance.
We
do
a
lot
of
allocations,
as
you
can
imagine
so
those
examples
they
they
are
kind
of
extreme,
because
nobody
will
have
those
JSON
payloads.
They
are
crazy,
big.
A
So,
as
I
told
you
millions
of
lines
of
JSON
but
yeah,
it
can
happen
in
practice,
and
this
is
also
what
we
want
to
optimize
for,
if
you
have
a
small
JSON
payload
high
patrician
is
not
going
to
help
you.
The
big,
bigger
bottleneck
is
gonna,
be
your
system,
IO
and
so
on,
but
you
have
large
payloads
and
a
lot
of
payloads.
This
is
where
you
might
want
to
have
a
proper
encoder.
A
So
the
final
goal
where
I
want
to
use
it
is
a
library
of
mine
called
Kafka
in
flux,
TB,
which
connects
Kafka
with
in
flux.
To
be,
you
might
be
surprised
just
by
looking
at
the
name.
You
might
not
have
guessed
and
I'm
using
ultra
pad
trace
on
here
already,
and
you
can
see
this
is
ultra
trace
on
here
and
the
green
one
is
the
normal
trace
on
implementation
in
well.
Actually,
no,
that's
not
really
true.
This
is
for
the
conferring
consumer
in
Kafka,
but
it's
a
similar
thing.