►
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
And
I'm
developer
at
Moya.
It's
everything
interesting
about
me
and
Moya
is
a
ride.
Sharing
service.
We
write
like
we
drive
this
big
golden
ones.
Probably
you've
never
seen
them
because
right
now
they
are
only
driving
in
Hamburg
and
Conor,
but
we
also
have
an
office
in
Berlin
and
that's
where
I
work
and
that's
where
you
can
work
also.
A
And
our
thing
is
what
I'm
going
to
talk
about.
It
should
have
mentioned
it
earlier.
We
are
using
rust
with
Scala
inside
the
same
application
together
in
one
server,
and
we
are
quite
happy
about
it
and
in
general
our
problem
is,
we
do
optimization
of
brakes,
which
is
an
NP
card
problem
and
the
main
part
about
it
it's
hard
and
which
means
you
can
find
the
solution.
There
are
many
feasible
Solutions
and
we
found
one.
A
A
It's
a
open
source,
Java
solver
and
when
we're
only
creating
this
Optimizer
we're
using
up
the
planner,
and
it
was
quite
nice
because
we
could
start
quite
fast
and
it
did
all
the
hard
part
about
for
us,
and
all
we
needed
is
to
make
a
normal
service
with
all
the
domain
logic
around
it
later.
This
OCTA
planner
became
a
problem
because
it's
one
black
box,
we
just
throw
a
problem
into
it
and
it
gives
us
some
solution.
A
A
So
we
just
try
to
follow
and
there's
a
problem.
If
your
writing
takes
time,
you
write
in
big
things
takes
a
lot
of
time
and
if
we
look
at
our
optimization
service,
our
consumers
don't
think
in
terms
of
optimization
problem.
You
don't
need
to
read
everything.
It's
quite
boring,
but
the
thing
is
the
optimizer
to
think
that
octoplaner
did
it's
like
one,
this
box
in
the
middle.
Before
this
we
get
some
requests.
We
consume
some
domain
events
from
another
other
services.
We
could
make
synchronous
call
to
external
Services.
We
get
something
from
database.
A
We
aggregate
everything
we
kind
of
map
it
to
the
problem,
and
it's
also
not
that
easy.
We
have
a
decision
tree
inside
I'm
not
going
to
talk
about
it.
Then
we
call
Optimizer,
it
solves
something
we
get
a
response
and
then
we
map
everything
back
again
because
our
consumers
don't
think
in
the
terms
of
optimization
solution
and
we
send
events.
We
write
something
to
the
database
and
so
on,
and
it's
a
lot
of
code
rewriting
this
one
box
will
provide
us
a
lot
of
business
value.
We
can
get
a
better
solver.
We
are
happy.
A
We
write
in
everything
else.
It's
useless.
A
We
wanted
to
rewrite
only
this
one
box
and
we
wanted
to
avoid
HTTP
calls
within
so
basically
rust
and
Scala
within
one
application.
Is
it
possible?
The
title
of
the
talk
is
already
a
spoiler.
Yes,
it's
possible.
We
didn't
know
about
this.
So
finding
this
answer
took
us
about
five
minutes
of
Googling.
A
The
original
schema
looks
like
this.
You
have
a
bunch
of
color
code,
you
compile
it
and
you
don't
only
get
the
Java
application.
You
also
create
the
header
file
like
C
header
file,
for
which
you
can
then
create
an
implementation
with
COC
plus,
compile
everything
together,
and
you
will
have
a
c
plus
or
Library
created
to
support
jni
and
all
this
thing
can
go.
A
A
Basically,
if
Java
application
thinks
that
something
is
created
to
support
gni,
it
doesn't
need
to
know
that
it's
not
C
and
rust
provides
a
few
libraries
to
create
a
giant
with
macros
to
create
libraries
that
support
gni.
We
picked
Robusta
j9
because
it
doesn't
depend
on
this
header
file.
Instead,
you
need
to
match
the
class
name
and
function
names
manually,
but
that's
okay.
You
need
to
do
this
one
and
then
just
hope
it
works
fine.
It
also
provides
some
boilerplate.
You
need
to
copy
paste
lifetimes
and
some
micro
calls,
but
is
fine.
A
Well,
the
main
thing
is:
you
need
to
match
the
package
names
and
struct
name
with
class
name
and
have
the
same
function.
Definitions
also
Robusta
gni
allows
you
to
have
some
to
store
some
data
in
this
truck
so
to
keep
the
state
between
between
I
calls.
We
don't
need
it
and
yeah
you
have.
We
just
provide
one
function
with
one
string
argument:
it
will
be
important
later
and
one
string,
a
response
which
is
gni
result
of
string.
A
So
we
can
do
this,
we
can
call
gni.
The
next
thing
is:
how
do
we
connect
this
Optimizer
with
coordinator
coordinator?
Is
a
nice
name
for
everything
in
the
application
except
optimizer,
yeah
and
yeah?
It's
quite
a
dilemma,
because
we
want
to
store
Optimizer
and
coordinator
in
different
depositories.
Basically,
it's
two
different
programming
languages.
Having
in
one
repository,
it
will
be
not
nice
but
another.
The
thing
is,
we
want
to
have
rust
and
skull
interface
of
Optimizer.
A
A
A
In
the
optimizer
repository,
we
also
have
a
very
small
scalar
library
that
provides
the
same
interface
as
optimizer
and
all
it
does
is
loads,
the
optimizer
and
forwards
the
request
optimizer
and
then
during
the
deployment
we
compile
Optimizer
in
mac
and
Linux,
builds
then
just
copy
it
to
the
Scala
resort,
to
the
resources
of
the
Scala
Library
and
park.
Everything
in
SBT
and
it
from
outside.
It
looks
like
another
Scala
library
and
coordinator
thinks
it's
another
scholar
Library,
it
doesn't
know,
there's
a
rust
inside
and
yeah.
It
works
pretty
nice
next
thing
is
passing
data.
A
The
problem
is,
here's
a
mapping
chart.
How
can
we
turn
rust
and
Java
types
between
Robusta
gni
also
does
some
objects,
but
yeah.
We
have
a
huge
structure
with
arrays
and
the
Norms
inside,
and
it's
nested
and
doing
this
mapping
would
be
quite
a
tedious
task
and
then
we
need
to
do
everything
about
the
response
and
our
solution
about
this
is
to
use
protobuf,
because
this
is
spread
above
everywhere
else.
Why
not
here?
A
So,
in
the
same
repository
with
Optimizer,
we
also
have
brought
above
definitions,
and
we
generate
rust
code
from
them
and
scalar
code
from
them.
They
are
all
in
the
same
repository
everything
nice.
So
our
rubber
library
takes
response
serializes
into
a
string
and
then
calls
Optimizer
with
a
single
string
and
Optimizer
this
realizes
it
and
uses
everything
else,
so
it
also
works
nice.
A
A
It's
a
pop
culture,
reference
yeah,
and
that
was
surprisingly
easy.
Well,
except
wrapping
everything
in
try,
because
we
all
already
get
the
type
it
request,
with
all
the
validation
done
on
the
scholar
side
and
because
our
last
part
doesn't
call
any
external
Services.
It's
just
a
function,
then
the
most
reasons
for
panicking
a
gun,
and
we
can
just
do
it
like
this
and
another
thing
is
we
return
gni
result
type
which
can
be
success
and
which
can
be
an
error
message,
and
if
a
booster
jni
receives
an
error,
it
just
throws
a
job
exception.
A
We
can
handle
on
Java
site
and
it's
also
fine
another
thing
observability.
One
of
the
reasons
of
for
your
writing
was.
We
want
to
know,
what's
happening
and
it's
if
it's
just
a
function,
that's
a
black
box
and
we
don't
know
what's
happening,
and
it
was
all
wrong
and
yeah.
Basically,
the
solution
is
the
picture.
You
shouldn't
look
at
it
so
closely.
A
This
solution,
it
also
remembers
Matrix
and
re
returns
them
together
with
solution
and
Scala
application
can
record
them
as
it
wants
so
observability
also
solved,
and
one
Southern
nice
thing
that
the
change
was
even
smaller,
because
with
this
thing
we
could
run
two
optimizers
in
parallel,
which
is
not
like
pick
the
best
solution.
Also,
we
know
that
switching
something
introduces
bugs
and
because
of
this
we
could
rewrite
Optimizer
and
run
it
in
the
shadow
mode
and
compare
results
and
fix
the
Box.
A
We
found
some
the
Robux
and
then
we
did
the
real
switch
only
one
we
were
confident
enough
and
when
we
did
a
switch,
no
one
else
in
the
company
noticed
it,
which
was
quite
great
yeah.
So
there's
a
result.
It
works
for
about
a
year.
Now
it
works
good.
We
had
no
problems
after
the
initial
deployment
good
is
we
get
the
best
from
the
both
languages,
but
as
we
have
to
know
both
languages,
we
just
easy
for
us
right
now,
because
everyone
in
the
gym
knows
them,
it
makes
hiring
harder
and
the
thing
is.
A
B
So
you've
mentioned
that,
like
one
of
the
main
reasons
is
that
you
want
to
solve
bottlenecks
in
your
current
jvm
architecture.
So
so
have
you
tried,
for
example,
measuring
that
with
implementing
in
the
like
in
the
services
themselves?
I
don't
know
like
a
distributed
tracing
solution
to
see
how
that
optimized,
and
would
it
work
with
rust
being
in
that
context
in
jvm
or
interacting
with
jvm
like?
How
would
you,
for
example,
like
how
would
you
measure
the
efficiency
of
whatever
resources
you're
using
from
rust.
A
Yeah
quite
hard
like
comparing,
because
we
also
changed
the
algorithm
and
one
result
is
we
looked
at
metrics
and
we
could
find
good
Solutions
like
several
times
faster
and
for
us.
It
matters
a
lot
because
we
are
called
synchronously
and
finding
great
Solutions
fast
is
nice
and
yeah.
Because
of
rewriting.
We
could
also
get
the
conditions
when
we
exit
earlier,
which
was
also
fine
and
yeah.
We
could
just
check
the
number
of
steps
and
mutations
per
second
and
with
rust.
C
Thank
you
for
the
talk.
You've
explained
how
for
integrating
rust.
In
this
way,
you
had
to
use
Photo
Buster,
you
had
to
like
write
the
function,
headers
and
so
on.
Have
you
weighed
converting
to
remote
remote
procedure,
calls
and
then
having
the
Scala
Parts
integrate
with
rust
in
that
way,
I
wonder
what
what
were
the
advantages
and
disadvantages
of
both
approaches?
C
F
F
A
A
D
A
We
don't
have
such
a
problem
like
we
need
to
coordinate
the
fleet,
and
you
cannot
do
this
from
within
one
vehicle
because
you
need
to
know
where.