►
Description
In the second episode of our Whiteboard Series with NEAR, we had Anatoly Yakovenko (https://twitter.com/aeyakovenko) from Solana speaking with our Founders Alex Skidinov (https://twitter.com/AlexSkidanov) and Illia Polosukhin (https://twitter.com/ilblackdragon)
Learn more about Solona here: https://solana.com/
Download the video here: http://near.ai/solana10211
Follow the latest from NEAR Protocol on,
Discord: https://discord.gg/gBtUFKR
Medium: https://medium.com/nearprotocol
Twitter: https://twitter.com/nearprotocol
GitHub: https://github.com/nearprotocol
#FutureIsNEAR #BlockchainProtocols #TechTalk
A
B
B
Sure
so,
a
very
high
level
solana
is
based
on
this
idea
that
you
can
use
a
clock,
a
global
block
to
speed
up
a
distributed
system,
and
the
city
has
been
around
for
like
a
really
long
time.
Since
you
know
the
40s
in
our
vlog
is
permissionless.
So
it's
interesting
about
our
clock
is
that
it
actually
works
before
consensus
like
before.
You
actually
have
any
notion
an
agreement
in
the
system.
B
You
still
have
a
notion
of
time
and
that's
why
we
can
actually
leverage
that
to
speed
up
the
network,
so
that
was
kind
of
like
the
the
very
shallow
deep
dive
bench.
So
how
the?
How
does
our
clock
work
so
I?
Think
if
you
guys
have
been
following
the
space
and
the
last
year,
there's
been
kind
of
this
explosion
of
ideas
around
verifiable
delay,
functions
or
VPS.
I
actually
didn't
didn't,
know
anything
about
PDFs
when
they
came
up
with
this
I
just
had
too
much
coffee
and
I
was
up
until
4:00
in
the
morning
an.
B
Have
a
shot
256
any
cryptographic,
image,
assistant,
hash
functions,
work
and
this
thing
just
loops
over
itself
right,
so
it
keeps
going
and
going
and
going
and
everybody
you
know
X
amount
of
iterations.
You
just
take
a
sample,
so
when
I
mean
loops
over
itself,
its
output
is
the
next
input
just
beaker
solely
just
runs,
because
it's
peanut
resistant,
you
can't
any
of
the
values
that
are
going
to
occur.
You
know
like
a
hundred
million
or
eight
iterations
from
that.
You
actually
have
to
run
this
thing
in
a
single
core
single
process.
B
Without
stopping
so
you
know,
let's
say
this
is
like
you
know:
1
million
iterations
and
the
value
is
like
zero,
be
a
whatever
right.
This
is
2
million
at
least
likes
your
OCD,
and
it
just
keeps
going
forever.
So
these
samples
represent
a
data
structure
that
tells
you
that
somebody
somewhere
spent
real
time
building.
B
B
Value
here,
I
had
some
some
bytes.
It's
that
I've
inserted
here
so
now.
At
this
point,
all
the
subsequent
fascists
have
been
modified
in
an
unpredictable
way
because
it's
premature
system,
so
it
also
is
interesting
as
if
this
thing
itself
also
contained
a
reference
to
some
other
value
that
it
observed.
So
now.
This
guarantees
that
this
message
was
created.
B
After
this
point
and
before
this
point
so
now
we
have
the
status
structure
right,
but
in
codes
time,
but
also
an
order
of
events
and
the
relative
order
between
them,
as
well
as
the
the
up
relative
amount
of
time
between
them
right.
So
we
call
this
thing
proof
of
history,
because
it
gives
you
a
proof
of
this
historical
record.
B
C
B
You're
looking
at
this
data
structure
right-
and
this
is
like
the
head
pointer-
this
is
the
last
last
thing
you
see
and
somewhere
here
you
see
a
network
message
somewhere
here
you
see
a
network
message
somewhere
here.
You
see
network
messages
right.
So,
given
this
last
thing
that
you've
observed
you
can
compute
whatever
algorithm,
you
choose
the
actus
that
settles
a
network.
B
Whatever
algorithm
you
choose,
you
could
say
that
somebody
had
sent
like
a
message
once
over
the
last
two
weeks.
Right
yeah
make
sense
whatever
it
doesn't
matter.
What
it
is.
You
pick
some
algorithm
right,
but
the
point
is
that
at
this
point
this
point
in
the
in
the
lecture
right
at
this
point
in
history,
which
is
identified
by
the
count
right,
you
know,
1
billion
and
some
value,
0
X
blah
blah
blah
you've
decided
that
this
is
the
state
of
the
network.
So.
B
The
same
algorithm
will
decide
the
exact
same
state
of
the
network,
and
if
we
optimistically
assume
that
everybody's
looking
at
this
thing,
then
this
is
how
we
keep
the
two
generals
problem
right.
If
everybody
optimistically
assumes
that
they're
looking
at
this
thing,
they
construct
a
message
that
references
this
value,
but
it's
only
valid
if
it
appears
some
time
later
right
when
we
say
we
attack
right
everybody
attacks
and
if
we're
lucky
and
everyone
did
actually
observe
the
same
thing.
B
You'll
see
that
as
evidence
here
by
a
bunch
of
messages
to
indicate
the
attack
which
is
concluded
from
the
exact
same
information,
everybody
everywhere,
sir,
so
that's
fundamentally
how
our
system
works
is
that,
based
on
this
historical
record,
which
is
not
cryptographic,
it's
not
just.
You
know
time
stamps
today,
ashed
in
the
you
know
in
this
right
and
made
up,
we
can
actually
come
to
agreement
about
the
state
of
the
network
and
therefore
make
a
decision,
and
that
decision
is
consistent,
along
with
everyone
else
optimistically.
Right.
D
C
B
Know
whatever
one
hour
later,
we
decide
oh
yeah,
we
did
actually
solve
it
and
here's
the
proof
right,
because
the
system
then
has
evidence
that
it
has
come
to
agreement
here
and
it
has
multiple
confirmations
and
our
system
just
like
brew
footwork
the
deeper
this
event
occurs,
the
harder
just
a
role
yeah,
so
I
can
kind
of
like
dive
into
that.
So
you
may
have
like
a
bunch
of
forks,
but
could.
B
D
D
C
B
D
B
D
C
D
A
B
B
Same
thing,
because
every
time
you
encode
the
message,
which
is
like
a
data
packet,
you
need
to
record
the
state
and
the
counter
yeah
II
haven't
seen
before
get
paper
set
o
first
three
million.
If
you
merely
have
this
yeah,
you
might
be
more
now,
there's
a
we
haven't,
measured
it,
but
like
AMD's
thread,
Ripper
has
chapter
56,
specific
instructions
and.
D
B
B
D
B
B
B
A
trusted
group,
so
you
need
to
make
it
huge,
or
you
need
some
other
mechanism
to
create
like
Kennedy
initial
seed.
Such
you
know
that
this
wasn't
be
computed
before
I
know
for
us,
because
we're
using
sha-256
very,
very
dump,
it
is
to
somebody
that's
been
working
on
operating
systems,
it's
very
transparent.
What
it
does
their
setup
requires
this,
like
kind
of
like
you,
know,
magic
ceremony
right,
not.
D
A
B
C
B
Have
a
message
in
the
network:
we
stick
it
into
the
into
this
loop
right.
The
frequency
of
that
we
can.
We
can
make
it
work
with
whatever
function
they
do,
but
our
main
concern
here
is
a
security
concern
is,
if
you
can
bias
this
input,
you
can
potentially
generate
a
hash
function
if
that,
if
this
is
not
the
image
secure
right,
if
this
is
not
pretty
much
resistant,
when
you
do
this
message,
recording
we
want
this
part
to
be
guaranteed
to
be
secure,
especially
you
can't
like
generate
a
loop,
yeah
I
think.
B
D
B
Gonna,
do
we
do
men's
okay,
so
the
main
part
about
why
things
can
be
fast
with
a
clock
right
is
because
when
you
do
this
active
sub,
computation,
you're
doing
this
without
messaging.
Anyone
right,
you
got
this
data
structure
from
a
carrier.
Pigeon
drive.
You
don't
have
to
talk
to
me
with
anyone
else
in
the
network.
B
You
actually
do
this
computation
locally
and
that's
the
speed-up
right,
because
now
there's
no
there's
no
interactive,
but
you
mean
you
have
to
do
with
anyone
else,
since
they
optimistically
guessed
that
I've
downloaded
the
right
structure
right
and
I'm
gonna
send
it.
So
why
is
the
best
ship
Pennings
tell
you
why
it's
fast
right
sort
of
so
the
second
part
of
why
we
can
leverage
this
is
uses
that
points,
because
in
our
setup
we
have
a
single
leader
at
a
time
and
a
bunch
of
validators
that
are
receiving
this
data.
B
So
validator
just
don't
care
how
to
get
this
data
right
because
they're
deriving
everything
from
the
data
directly,
so
this
leader
can
broadcast.
You
know
one
over
and
validators
orth
of
data
to
each
one
and
then
they
exchange
it.
So
that
is
effectively
BitTorrent
and
you
can
scale
this
out
to
a
log.
You
know
tree
structure,
yeah
right,
so
the
fan.
B
Your
fan
own,
is
we
verified
this
summer
about
200?
That
means
that
in
the
second
layer
of
about
40,000
notes,
so
with
only
two
hops,
so
our
finality
grows
with
the
log
of
the
network
size,
and
this
fan
can
be
pretty
hugest
apologies
like
stabbed
Clark.
It
changes
all
the
time.
Yeah,
there's
no
like
how
you
get
placed
a
state
based
it's
a
base
in
your
state
but
effectively.
B
You
know
we're
trying
to
get
this
group
to
be
all
the
top
state
nodes
and
then
everyone
else
and
the
protocol
is
designed
such
that
you
receive
the
state
of
partially
from
the
network
and
it
spattered
of
the
race
you're
coding.
So
if
X
percentage
of
the
notes-
or
you
know
malicious
or
send
you
bad
data
or
just
don't
do
nothing
if
that
percentage
is
below
the
rest,
your
coding,
you
should
be
able
to
recover
the
full
data
set.
B
B
The
fun
part
now
things
get
interesting
cell
rotation
right,
and
this
is
your
goes
into
the
consensus
portion.
So
imagine
we
take
this
timeline
and
we
divided
up
into
slots,
and
these
are.
These
are
just
basically
counters
right.
You
know
proof
in
street
counter.
So
this
is
you
know
one
millions
is
2
million
whatever
at
every
point
and
every
slot
there's
a
single
leader
that
can
belt
think
and
transmit.
B
B
So
what
that
means
is
me,
as
a
validator
by
either
receive
a
transmission
from
this
leader
right
or
potentially,
if
I
failed
to
reassemble
the
packets,
a
generator
virtual
tick
or
a
virtual
history
yeah,
because
I
can
derive
the
history
from
the
last
point
that
I've
observed
by
simply
appending
perfect,
like
hashes,
with
no
data
to
it
right.
So
now
we
have
like
kind
of
this
protocol
where
the
network
either
receives
the
data
or
fails
to
receive
it,
but
it
doesn't
stop
so.
D
C
B
C
B
Is
the
third
one
that
spans
this
like
now
this
the
sterno
right,
but
every
time
like
every
time,
there's
a
new
leader,
a
new
slot?
They
have
a
number
of
options
to
pick
from
from
the
previous
thing
that
they've
observed,
so
the
branching
you
know
kind
of
starts
blowing
up
here
and
how
we
reduce
it
is
I,
can
kind
of
show
you
a
different
tree.
B
C
B
B
So
the
path
here
right
can
come
from
as
if
I'll
two
failed,
l2
failed
to
observe
l1
right,
so
they
chose
feet
and
I'm
free.
She
actually
saw,
like
you
know,
also
fields
of
zero,
one
LTO
and
just
T
as
well,
and
the
only
way
this
is
chosen
is
if
both
of
them
failed
to
observe
along,
so
that
make
sense,
because,
if
l2
transmits
data
and
this
this
node
observed
a
failure
for
a-1-
and
this
data
depends
on
this
one-
it
cannot
verify.
But
this
is
correct.
Okay,.
C
B
B
B
Of
them
yeah,
because
if
you
not
verify
them
thanks
eyes,
I
mean
there's
repair
happening
and
stuff
like
that.
But
the
idea
is
that,
like
this,
snow
may
actually
fail
to
receive
both
and
well
because
it
failed
to
receive
both.
Its
only
option
is
to
see
both
have
failed
right
and
what
each
note
does
is
whenever
they
observe
you
know
transmission
data
such
that
they
vote
on
it.
They
reset
their
Poh
to
start
running
from
there.
C
B
At
any
point,
the
last
thing
you
voted
on,
that's
your
kind
of
starting
point
and
you
start
producing
caches
and
you
can
overrun.
Basically
everybody
else
up
until
it's
your
turn
for
transmit
and
that
could
be
ten
slots,
it
could
be
five
slots,
it
could
be
zero
and
then
you
transmit
that
Plus
hold
the
virtual
ticks
you
you've
generated
and
then
you
just
MIT's
up
to
the
network.
So
the
now
we're
playing
receiving
your
data
can
actually
derive
it
back
to
write.
B
D
B
B
So
imagine
your
validator
right
and
we
actually,
let's
go
back
a
little
bit
to
have
consensus,
works
to
kind
of
give
a
bigger,
broader
picture.
So
you
have
this
proof.
Mystery,
ledger
and
imagine
is
just
working
kind
of
like
at
a
very
high
level.
Okay,
it's
working
all
the
time
and
have
some
votes
here
right.
B
Every
time
I
vote
each
vote
is
for
a
particular
type
of
the
ledger,
and
this
well
starts
with
a
lock-up.
Let's
say
and
say:
vote
again
now
this
voters
a
lockout
from
this
photos
to
lock
out
of
for
right,
so
I
vote
again.
This
becomes
4.
This
becomes
8.
This
becomes
2.
It
is
that
every
time
I
vote,
my
votes
exponentially
stack
that
my
lockouts
exponentially
grow.
B
So
this
kind
of
gives
us
the
same
behaviors
proof-of-work
right
we're
not
a
pbft
or
VFT
solution
right,
our
Airedale
abilities
who
are
using
kind
of
the
threshold
approach,
but
the
threshold
isn't
based
on
electricity
right.
It's
actually
based
on
time
and
fundamentally,
when
you
look
at
it,
it's
almost
like
a
drink,
but
the
trade-off
between
availability
and
consistency.
C
C
B
D
D
B
D
B
C
D
B
B
This
is
a
vote
for
this
particular
branch
and
you
voted
here
right.
Then
you
get
sloshed,
doesn't
Rosen
whatever
you're
effectively
prevented
from
voting
again
Mason.
D
B
C
B
B
B
D
B
D
C
D
D
C
B
B
B
What
actually
happens
is
you
know,
and
let's
say
this
lockup
actually
expired
here
right,
so
this
phone
is
expired,
okay,
so
Network,
you
know,
you
know
he
WS
had
like
a
sneeze
and
things
stopped.
Working
and
I
only
ended
up
floating
here.
They
actually
lockouts
are
like
a
stack
and
the
stack
is
cleared
and
then
your
lockout
is
again-
and
this
is
still
16
question.
D
B
When
this
is
a
high
C,
so
the
way
it
works,
yeah
effectively
you're
building
a
tower
like
I,
initially
called
a
block
tower,
because
if
Bob
goes,
thank
you
thing
yeah.
So
if
this
gets
White's,
this
starts
at
2
right
now
there
needs
to
be
two
and
four
right
and
then,
until
it's
fully
rebuilt,
you
don't
actually
get
to
you
know:
2
4,
8,
16
32.
The
idea
here
is
that
anytime,
you
submit
a
vote.
B
If
this
vote
is
at
a
point
that
is
past
any
of
the
lock
outs
here,
you
clear
the
whole
stack
and
you
start
over,
and
this
allows
you
to
progressively
kind
of
do
your
work.
So
when
you
vote
here-
and
you
come
into
this
branch
or
32
lockouts
you're,
saying
that
I'm
going
to
like
effectively
be
unavailable
for
X
amount
of
time
to
break
this
consistency.
C
B
B
I
will
not
I
will
not
double
my
lockup
past
32
on
this
branch,
unless
I've
served,
50%
plus
I
was
in
front
right.
Thanks,
don't
observe
this
expired
and
eventually
it
gets
totally
exponent
yeah.
So
that
is
like
effectively
how
the
nodes
in
the
network
can
force
to
be
in
the
same
branch.
It's
because
they
picked
some
branch
behind
right,
like
that's
like
at
a
expiration
of
you,
know
one
hour,
and
they
say
that
they
will
not
commit
to
a
branch
and
the
network.
D
A
B
B
To
this
right,
what
I
can
do
is
I
can
actually,
with
both
my
boat
and
observe
both
l2
right,
so
I
can
observe
both
of
these.
We
can't
we
can't
there's
no
way
for
us
to
stop
those
from
doing
this.
I,
don't.
B
D
B
The
greedy
choice,
but
we
want
the
network
to
make
this
two.
If
they
have
multiple
branches
friend,
it
should
be
unlikely
because
we're
using
this
forced
away
all
right.
So
you
actually
have
all
three
generate
like
some
other
data
before
they
transmit,
but
thinking
sheet
they
can
use
a
faster
ASIC
or
this
one
could
just
be
slower
right.
No,
so
when
you
actually
observe
two
branches,
you
should
pick
the
one
that
maximizes
the
network
reward
so
maximizes.
The
lockup
I
see.
B
D
B
B
A
D
D
D
B
A
B
D
A
B
C
B
B
D
So
you
might
have
a
technical
example.
This
thing
has
like
one
vote,
which
was
never
done
because
nobody
yeah
it's
going
on
it.
While
I
hear
this
message,
even
though
it
is
published
later
yeah,
when
this
time
has
yeah
so
late,
usually
the
chain
which
has
much
transmissions
quickly
chosen
attach
exactly
yes,.
B
B
A
B
This
is
like
an
actual
censorship
attack,
yeah
right.
So
if
you're
all
four
and
you're
some
portion
of
the
steak,
you
can
potentially
just
overrun
the
previous
leader
every
time
yeah.
So
you
do
a
transmission
hear
that
everybody
yeah
kills
whatever
the
snow.
Yes
right
so
and
if
you're
clever
I
mean
you
would
include
all
the
validator
messages
except
the
one,
zero,
the
Sun
sir,
and
this
should
be
the
majority
Network.
So
this
is
like
the
actual
censorship
attack.
The
only
way
we
fight
that
is,
the
BBS
will
progressively
approach
whatever
secret
video.
B
B
So
the
rotation
is
steak
weighted
star
rated
yeah,
so
we,
the
active,
set
right,
is
computed
from
the
network.
So
whatever
it
is,
we
compute
this
and
then
we
decide.
This
is
the
new
schedule
and
you
just
rotate
all
the
leaders
and
even.
B
B
A
A
B
A
B
Yeah,
those
folks
would
have
to
actually
actively
participate
on
this.
If
they
voted
on
this,
they
cannot
move
that
that
role
is
over
yeah.
They
cannot
move
them
over,
so
they're
locked
out
right
from
for
a
better
perspective.
This
transmissions
is
a
failure
because
it
doesn't
include
their
previous
boat,
so
it's
a
purpose
it
suffered
for
so
they
can't
they
can't
switch
over
until
this
expires
right.
B
B
A
C
B
Over
but
you
can
just
you,
don't
even
have
to
do
just
tell
about
it.
If
people
agree,
though
it's
the
point
they're,
the
main
thing
so
what's
interesting
is
in
our
simulation,
if
you
have
all
of
all
the
notes,
instead,
instead
of
picking
the
branch
of
the
most
your
to
pick,
the
branch
that
the
least
reward,
but
still
not
allow,
like,
let's
say
I
think-
was
the
256
not
allowing
this
lock
up
to
be
under
50%
of
the
network.
Right
so
knows,
I
just
want
to
disrupt
the
network.
B
They
can't
actually
vote
on
branches
that
die
because
then
they
just
lock
themselves
out
from
the
network
right.
So
the
the
thing
that
they
chooses
to
continue
voting
in
a
branch
that
becomes
the
main
trunk,
but
always
had
kind
of
multiple
branches,
the
worst
one,
the
one
has
the
least
amount
of
Kannamma
canal
ax
t.
Thus
network
still
goes
forward
just
about
like
with
everybody
being
parasitic
and
moves
forward
at
about
like
ten
percent
of
the
rate,
so
that
is
a
really
cool.
B
That
means
that
if
the
harbor
is
actually
you
know,
you
know
uniform
right,
we
can
actually
run
this
thing
to
be
fairly
censorship,
resistant
and
fairly
kind
of
attack
resistant
to
parasitic
votes.
That's
like
if
everybody's
fair,
stating
financially
yeah,
it's
still
those
four
as
well
right,
yeah
versus
like
bitcoin.
If
everybody
is
voting,
you
know
if
everybody's
student.
A
B
B
B
B
Yeah
but
that
doesn't
work
because
then
everybody
is
throwing
like
32
cores
worth
of
PBS,
and
that
is
problematic.
So
for
us
we
don't
use
randomness.
What
we
actually
use
is
just
the
number
but
number
accounts
the
height
as
the
seed
to
like
see
the
random
to
just
scramble
this
active
stuff.
Actually,
so
it's
really
just
round-robin
with
a
little
bit
of
reordering
as.
B
B
A
A
D
B
B
D
D
B
So
what
use
a
thin
client?
In
fact,
this
is
what
we're
doing
for
kind
of
our
like
signing
in
play.
You
can
observe
that
X
amount
of
you
know
you
start
with
some
set
of
validators
right
as
you
trusted
validators
like
you've
observed
in
that.
Where
have
you
done
that
attestation
right?
This
is
my
set
of
senator
validators.
B
B
Of
elevators
general
meaning
this
is
weaker,
definitely
weaker
than
validating
the
time.
The
problem
here
twos
we-
what
you
need
to
do
is
like
actual
transaction
validation
right,
like
I,
sent
your
transaction,
and
you
want
to
quickly
verify
it,
and
this
appears
somewhere
here
in
the
middle
of
all
these
of
all
hashes
and
all
the
hashes.
So
what
we
need
to
do
is
actually
pointers
back
up
here.
You're
like
Emeril
cheat
each.
D
B
B
A
B
B
D
Pee
you
right
so
here
we
have
them
so
so,
let's
haven't
come
through.
So
let's
say
like
I
was
the
leader
and
I
was
like
this?
Is
my
your
swamp
yeah
and
then
they
try.
This
one
is
my
historia.
Another
show
is
in
industry
yeah,
but
then
perhaps
for
else
you
have
sometimes
action
yeah
right,
and
so
this
is
my
yeah
hash.
For
so
the.
B
B
A
B
B
B
D
B
To
fix
you,
actually
we
actually
do
send
the
whole
transaction
data,
because
you
can't
do
that.
Maybe
signatures
per
second
on
CPUs,
so
we
verify
signatures
right,
yeah,
yeah,
that's
our
our
defense
against
DDoS
is
just
verifying
signatures.
You
know
many
more
signatures
per
second
than
that
we
can
actually
transmit
well
that
won't
stop
like
a
router
attack
right,
like
everybody's
splitting
away
yeah
and
what
stream
component
you
know
at
each
node
and
verify
way
more
signatures
per
second,
but
trust
me
yeah.
A
B
Transaction
is
well,
first
of
all
running
away
the
RIA,
the
extra
like
bottleneck
and
computation
is
in
CPUs
memory
right,
like
the
the
problem
with
making
things
go
fast
is
just
memory
pipelining
through
the
system
like
if
you
look
at
just
operating
systems
and
how
processes
run
like
what
you're
dealing
with
this
memory
throughput
like
caches
and
all
this
other
stuff.
So
how
do
we
make
this
fast?
Is
every
transactions
specifies
a
bunch
of
public
keys.
B
And
you
can
think
of
it
as
user
data
right,
that's
the
way
I!
Think
of
it
is
we
have
a
operating
system
with
a
single
address
space.
It
just
happens
to
be
the
size
of
public
keys
right,
so
256
bit
address
space,
but
but
also
memory
protection.
So
these
accounts
are
assigned
to
process
right.
My
process
I
mean
you
know,
there's
some
account
here
whose
data
contains
program
code.
B
And
this
code
is
just
code,
it
has
no
state.
So
this
program
code
is
a
state
transition
function
over
these
accounts
and
the
accounts
that
are
assigned
to
this.
This
is
the
only
code
they
can
modify
the
data.
So
whenever
you
doing
assignment
the
status,
bits
are
zero
and
this
code
is
the
only
thing
that
can
flip
those
bits
right.
So
every
time
you
submit
a
transaction,
it
does
some
bit
slipping
here.
So
what
else
you
can.
B
And
moves
tokens
around,
you
know
power
at
once,
and
it
can
also
pay
out
tokens
to
external
to
external
accounts.
This
is
outside
of
just
code
right.
No,
this
code
does
this
modification
and
then,
when
we,
you
know
this,
the
sectional
program
can
run
on
GPUs
right.
Our
bytecode
is
that
it's
like
very,
very
simple:
it's
culbreth
a
packet
filter,
it's
designed
for
porting
into
any
architecture
you
want,
so
we
can
actually
report
it
to
spear
five.
So
we
can
execute
all
these
programs
on
Jake
and
then
on
the
pager
who's
beta.
B
Go
fetch,
it
go
run
all
the
stuff
in
parallel,
get
them
out
of
negations
back
and
the
only
thing
or
validating
is
that
if
the
data
isn't
modified,
that
it
was
done
by
this
program
right
and
if
there's
tokens
that
have
been
around
that
tokens
going
out
where
it
moved.
You
know
that
this
program
didn't
spend
any
external
tokens
and
that
that's
a
little
somewhat
soaked
into
the
same.
B
A
B
B
B
B
Problem
is
amount,
so
we
have
a
bytecode
that
is
very
stable
right.
This
is
a
very
stable
byte
gonna
be
Unchained
forever
yeah
and
we
can
pour
it
into
whatever
architecture
happens,
to
be
the
fastest
one.
It
may
be
for
some
use
cases
that
spear
5
is
the
fastest
thing,
but
for
others
it's
not
like
x86.
So
we
want
to
really
keep
it
in
this
very
simple
to
manage
intermediate
state.
So.
B
A
B
The
same
program
code
can
execute
many
many
many
different
transactions
at
the
same
time
on
the
GPU,
because
you
have
this
like
massive
Carol
massive
amounts
of
planes
for
the
same
code.
So
if
you
had
a
cryptic
Hades
like
spike,
you
actually
don't
use
a
different
thread
per
transaction
use.
One
thread
that
goes
over
this.
B
A
C
B
B
B
So,
but
if
that's
like
the
defense,
the
popular
transaction,
that's
being
thrilled
Internet
we're
like
they're
all
the
time
you
can
leave
this
program
in
the
cash
right,
because
you
know
that,
like
hey
everybody's
flooding
in
that
work
with
these
crypto
kitties
transactions
right
cool,
those
are
like
levels
of
optimization
that
I
don't
know,
but
there's
fun
fun
to
worry
about.
So.