►
Description
Berlin Ethereum Meetup - 2018/12/7
A
B
B
C
B
A
B
A
B
One
change
we
did
is
we
removed
all
the
address
members
from
the
contract
member
from
the
contract
type
because
they
would
just
I
mean
you
might
have
a
function
that
is
called
transfer
on
your
contract
and
that
would
conflict
with
the
function.
That's
part
of
the
address
type,
and
so,
if
you
want
to
use
transfer,
this
is
a
little
bit
needs
a
little
bit
working
out
so
and
now
this
is
this
effect
of
whether
the
former
collector
is
payable
or
not.
That
is
lost
so
yeah.
B
The
contract
type,
so
you
have
to
convert
the
contract
to
address
first
to
use
the
transfer
function.
But
if
you
convert
it
to
address,
then
the
fact
whether
you
have
a
payable
for
by
French
or
not,
is
lost,
and
because
of
that
we
introduce
the
address
payable
type
and
so
contracts
with
the
payable
for
work
function
can
be
converted
to
have
is
payable
contracts
without
a
table
format
to
ensure
chemical
checks.
Okay,
that's
the
reason
why
we
introduced
it
and
we
did
some
testing.
B
E
E
E
E
E
B
A
B
Anyway,
even
without
these
problems,
we
can't
do
it
because
running
the
solidity
compiled
inside
the
agreement
be
kind
of
weird,
and
this
leads
to
a
situation
that
we
as
compiler
engineers,
don't
really
use
the
language
a
lot,
and
because
of
that,
we
always
are
happy
about
any
feedback
that
we
get
from
the
people
that
actually
use
it.
I
think
I
talk
too
much
right.
There
was
another
question:
what's
there.
C
B
B
Reason
for
you
is
to
be
able
to
compile,
welcome
right,
okay,
so
so
we're
preparing
for
I've
been
already
over
a
year
now
to
compile
some
identity
webassembly,
and
you
see
to
be
good
step
to
go
there
and
yeah
I
mean
if
you
say
you
will-
and
you
mean
solidity
in
that
assembly-
that
this
is
another
use
for
it,
which
allows
you
to
write
more
low-level
stuff.
That
is
not
language.
B
B
Get
impacted
on
topic
with
zero
from
zero.
We
disallowed
the
so
called
loose
dialect
of
inline
assembly
or
of
U
and
the
strict
version.
So
the
difference
between
loose
and
strict
is
that
we
lose
in
the
Neuse
version.
You
have
direct
access
to
the
stack
you
can
run
can
use
op
codes
that
manipulate
the
stack
and
in
the
strict
version
we
only
have
variables
and
function
actually,
and
this
fully
abstracts
a
way
yeah.
Whether
or
not
there
actually
is
a
step
and
whoever.
D
B
C
B
B
B
A
A
A
B
Easy
three
linearization
multiple
inheritance
model,
it's
more
like
it
will
be
more
restrictive,
so
especially
when
it
comes
to
over
writing.
So
you
can't
just
have
two
functions
in
coming
from
two
different
base:
contracts
for
function
of
the
same
name,
and
you
will
have
to
solicit
estate
whether
you
want
to
be.
D
B
D
B
C
B
B
B
B
There's
a
we
have
a
dedicated
page
in
the
documentation
that
says
these
are
the
changes,
and
this
is
what
you
have
to
do
to
your
source
code
to
update
it
to
the
compatible
zero-five-zero,
so
I
hope
that
documentation
is
enough
for
anyone.
If
not,
then
please
talk
to
us.
We
didn't
get
too
much
feedback
on
that,
yet
so
I'm
not
sure
a
particular.
At
that
time.