►
From YouTube: Lisbon Hack Week // P2P Testing - Mathias Buus
Description
Originally recorded during the Lisbon Hack Week from May 21-25, 2018.
A
You
get
actually
really
good
coverage
like
that,
but
then
at
some
point
it
says
it's
beautiful
here
we
want
to
do
network
stuff
and
everything
becomes
really
really
tricky,
so
basically
been
spending
a
lot
of
time
recently
trying
to
figure
out.
How
can
we
make
that
situation
better?
Basically,
all
my
testing,
where
we
still
do
network
stuff,
like
education
tests
so
and
also
I,
did
not
make
any
slides
because
I
was
fixing
a
bug.
Anyways,
so
has
anybody
ever
heard
about
mini
net
cool?
It's
one
of
those
things.
A
It's
just
like
a
way
to
basically
pretend
to
her
branch
or
network
attached
in
your
computer,
and
they
all
behave
like
normal
networks,
but
with
the
added
benefit
of
you
being
able
to
define
your
topologies
and
like
all
the
settings
for
the
network
cards
and
stuff,
like
that
so
kind
of
like
light
weight,
VM
networks
and
the
cool
thing
since
we're
on
Linux.
We
also
have
very
simple
Linux
containers,
so
we
can
count
like
composter
and
together
into
just
making
very
easy,
simple
Bowl,
just
of
all
things.
So
if
I
just.
A
Was
Amanda
I
thought
that
so
much
that's
the
only
way,
I
know
how
to
like
copy
that
thing:
I
just
search
for
anyways
and
then
Danish
flag,
emoji,
okay.
This
is
like
a
ton
of
good
data
here,
yeah.
So
it's
this
project,
basically
so
I.
Somebody
linked
me
to
this,
and
it's
like
this
is
actually
really
good
for
setting
up
virtual
networks,
which
is
actually
what
you
want
for.
A
Because
that
was
available
on
NPM
also
and
it's
node
module
that
just
in
JavaScript
that
just
writes
Python
behind
the
scenes.
So
basically
what
you
can
do
in
mini
net
is
you
can
do
cool
stuff
like
this?
Where
you
require
it
and
you
can
say,
I
want
to
get
a
switch.
You
know
like
a
normal
switch.
You
have
at
home
and
then
you
can
say:
I
want
to
create
a
host
and
a
host.
A
It's
just
a
minimap
way
of
like
a
computer,
basically
a
small
container,
and
then
you
can
do
cool
stuff
like
link
your
hosts
with
a
switch
or
a
link,
a
host
where
the
host
might
basically
build
your
topology.
Think
of
it
like
ask,
then
there
were
cables
house
to
take
go
into
things
and
then
you
can
spawn
stuff
on
the
host.
So
in
this
simple
example,
I'm
just
phoning
a
note
server
and
then
I
have
a
some
message,
passing
logic
where
you
can
send
messages,
often
on
the
server
and
react
to
it.
A
So
that
part
is
really
really
cool.
So
basically,
if
you
have
a
server
like
this
down
here,
you
can
spawn
that
into
that
container
and
it
gets
this.
You
can
require
this
mini
net
host
thing
to
message.
Your
host
script,
which
is
this
one
up
here
so
down
here,
I'll
just
spin
up
a
server
and
when
it's
listening,
Iran
I
sent
a
message
listening
and
then
in
your
host.
You
get
a
message
listening
event
that
you
can
react
to
and
there
I
just
try
to
run
curl
against
it.
That's
like
a
simple
test.
A
A
Don't
have
that
here,
here's
that
readme
did
I
not
have
the
example
here.
Oh
it's
in
the
folder!
That's
why
I'm
so
here
I
have
that
that
server
you
saw
from
before
and
that
sample
that
kind
of
orchestrates
it.
So
what
I
can
do
is
I
can
just
run
this
example
and
I'll
just
run
that
MiniMed
server
so
down
here
you
can
see
it
says
server
listening
on
10000,
because
the
server
is
printing
that
out
and
server
responding
and
thing
all
coming
together.
A
Did
this
now,
it's
like
that's
cool
and
then
I
try
to
use
it
and
what's
really
hard
because
it
turns
out
when
you
do
peer-to-peer
stuff,
you
have
a
ton
of
servers
often,
and
you
have
to
do
a
ton
of
orchestration
to
like
test
anything
and
I'd
end
up
having
like
a
ton
of
box
and
that
and
then
you
end
up
testing
your
tests,
which
is
like
the
most
useful
thing
you
can
ever
do
as
a
programmer.
So
I
started
thinking.
How
can
I
improve
this
and
I'm
a
big
fan
of
tape?
A
People
know
what
APIs
or
like
cat
in
general.
So
it's
like
a
very
simple
test:
runner
for
node.
That's
just
allows
you
to
write
like
linear
tests,
basically
with
basic
assertions,
so
I
started
thinking.
How
can
I
turn
this
into
tab
at
our
tab?
Like
experience
and
I
wrote
this
cool
module
called
tape
net
also
kumain,
because
it's
tape
for
networks
or
tab
for
networks.
So
it's
basically
a
small
module
and
it
just
uses
the.
A
Every
time
I
assume,
when
I
record
my
screen,
it
takes
forever
and
for
some
reason
it's
just
a
small
module
that
takes
the
same
idea
wraps
the
mini
net.
I
put
it
in
a
nice
little
test,
runner
interface.
So
this
is
a
very
simple
example
where
you
require
a
tape
net,
which
is
just
mini
made.
You
can
still
make
the
hosts
and
the
switches
and
you
can
link
them
together
and
then
you
can
write
a
small
little
test
here
where
you
have
a
small
description.
A
This
one
says
start
a
server
and
connect
to
it
and
then
there's
this
magic
function
called
cedar
run.
That
just
runs
the
function
on
a
virtual
instance,
so
it
actually
takes
this
function
in
serial
isis's
and
sensitive
to
a
Linux
container.
That's
running
in
an
environment
where,
based
on
a
topology
and
then
runs
that
code
and
this
this.
A
These
host
also
acts
as
magic
event,
emitters
that
you
can
use
to
embed
events
across
the
virtual
instances.
So
it's
really
easy
to
set
a
bunch
of
stuff
up.
So
what
I
do
here
is
I,
run
it
away
for
listening
event
on
the
other
host,
because
you
want
to
orchestrate
something
first
and
I'm
not
trying
to
connect
to
the
other
host
here
and
then
see
if
I
get
a
response
from
it
and
down
here.
I
spin
up
another
server
and
I
create
a
server
and
just
reply
back
right.
A
So
very
simple
example
and
the
cool
thing
about
doing
it.
This
way
is
that
if
you
have
your
server
fire
like
this,
you
can
just
run
it
and
I'll
just
run
it
as
a
normal
tape.
Test
gives
you
tape,
output
and
it's
really
easy
to
test
and
show
how
really
fast
it
is
it's
doing
a
ton
of
stuff
behind
the
scenes.
It's
like
spawning,
Python,
converting
JavaScript
or
Python,
setting
up
virtual
networks
and
like
yeah,
crazy.
It's
like
writing
8,000
global
variables
in
Python
also,
but
everything
works.
A
So
that's
really
cool
and
there's
a
ton
of
extra
fun
stuff
here,
where
typologies
all
the
sudden
turn
out
to
be
really
easy,
because
you
want
to
test
a
bunch
of
different
pathologies,
because
if
you
ever
done
anything
with
future
peer,
which
I
think
people
in
here
have
you'll
find
out
that
all
your
crazy
box
comes
from
people's
crazy,
topologies
and
topology,
because
this
is
all
software,
it's
really
easy
because
it's
just
a
JavaScript
function.
So
I
have
it
apology
here:
I
call
basic!
A
That's
just
like
make
a
switch,
make
a
bunch
of
hosts
and
link
them
together.
You
can
usually
do
that
it
just
as
a
function.
I
have
another
one
here
used
to
test
at
a
ton
where
it's
just
a
linear,
topology
or
serial
topology,
where
you
have
a
host
connected
to
a
host.
That's
connected
to
a
host
like
a
Christmas
chain
lights,
but
you
can
use
that
to
test
a
ton
of
stuff
and
what's
cool
about
the
mini
net.
Is
that
our
module
is
that.
A
So
as
an
actual
example
of
where
we
started
using
this,
a
ton
was
in
the
dead
project
which
I
work
on.
We
started
adding
a
bunch
of
integration
tests,
so
here's
one,
for
example,
that
is
very
simple:
it's
a
integration
test
that
just
tests,
multicast
DNS
and
it
just
literally
just
runs
two
instances
and
they
try
to
host
and
try
to
find
each
other
using
multicast,
enos
and
I
literally
fixed
20
bucks.
A
After
running
this
test,
because
you
find
out
that
when
you
run
an
actual
network,
things
don't
behave
as
you
expect
and
just
toss
stuff
like
that,
so
it's
really
really
easy,
so
that
was
all
I
wanted
to
share.
So,
if
you're,
if
you
want
to
try
out
setting
up
the
tests,
this
is
a
really
good
way.
The
main
downside
is
they
only
works
on
Linux,
so
be
really
cool.
If
somebody
wanted
to
help
out
to
get
this
running
in
a
dollar
container
or
something
like
that,
so
we
can
use
it
on
Mac.
That's
it!
A
Yeah
sure
yeah
you
can
it's
really
really
powerful?
It's
it's
it's
one
of
those
Linux
Fink's,
that's
really
knowing,
because
the
hardest
thing
about
MiniMed
is
installing
it
because
you
have
to
clone
a
repo
and
call
like
four
different
scripts,
and
it
turns
out
that
one
on
github,
it's
not
to
my
tag,
and
you
know
so
that's
why
you
know
a
dark
container.
Just
takes
all
that
pain
away,
so
I
use
I,
just
use
the
system.
A
Do
you
container
for
mine,
but
you
can
totally
do
that,
but
it's
actually
also
surprisingly
useful
to
run
it
without
a
net
and
just
run
it
self-contained
to
see
how
you
think
behaves
like
multicast
DNS
on
Linux
behaves
extremely
differently.
If
you
have
an
ad
or
not
for
some
reason,
that's
why
I
find
all
my
bugs
yeah
any
other
Christmas
cool.
Thank
you.