►
From YouTube: Painless Serverless Function Development In Kubernetes - Ramiro Berrelleza, OktetoSDCC
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
Painless Serverless Function Development In Kubernetes - Ramiro Berrelleza, OktetoSDCC
Developing serveless functions is a pain. You either develop and test locally, and then run into a lot of integration issues, or you develop and test in production, and you end up with a workflow where most of the time you're waiting for builds or deploys to happen. Not great.
Using open source tools I will show attendees how they can launch a replicable development environment directly in Kubernetes, and use it to hot reload and connect their debugger to their OpenFaaS functions.No commits , build or deploys required. The goal of this is to reduce friction, eliminate integration issues between development and production environments, and make for a happier and faster development experience.
A
Well,
hi
everyone,
my
name
is
Amy
dome,
I'm
gonna,
be
talking
a
little
bit
about
the
deaf
experience
on
building
surveillance
functions
and
how
we
can
use
a
lot
of
open
source
tools
to
make
it
easier
for
everyone.
So
before
I
start
a
bit
about
me,
I'm
a
tomato
I'm,
one
of
the
cofounders
of
octet.
Oh,
it's
an
open
source
project
and
a
company
that
probably
over
there
and
I,
are
building
before
Chado
I
used
to
be
an
architect
Atlassian
and
before
that
I
used
to
be
part
of
the
service
bus
team.
A
Sure,
if
you
wanna,
connect
later
I'm,
our
Berryessa
Twitter
Tigra
flow
and
most
most
places
so
for
most
people
out
there,
the
surveillance,
deaf
experience
is
pretty
slow.
It's
not
easy
to
start.
It
takes
a
while.
You
still
get
a
function
up
and
running
and
there's
a
lot
of
like
layers
of
work.
You
have
to
go
through
it.
If
you
think
about
it.
A
B
A
A
You
know
30
seconds
a
minute
depending
on
your
network,
your
build
server
whatever
and
then
you're
gonna
be
able
to
finally
test
your
function
and
to
end
and
sure
you're
gonna
find
a
bug
and
yeah,
and
no
one's
excitable
intuition
bugs
they're
hard
to
figure
out
and
then
what
happens
at
that
point,
we
typically
go
back
to
our
code,
add
a
bunch
of
println
statements
or
you
know,
logs
traces
where
were
you're
using
and
then
what
happens.
Well,
you
write
a
code.
You
package,
the
function,
you
deploy
your
function.
A
You
have
to
wait
again
a
few
minutes
at
this
point:
you're
gonna,
entire
and
yeah
success.
You
figure
out
what
happened?
You
have
your
logs,
your
traces,
okay,
I
know.
What's
going
on
with
a
function
and
then
well
you
go
back.
You
write
your
code,
you
repackage
and-
and
you
see
where
I'm
going
with
this,
it
becomes
this
very,
very
slow
cycle,
full
of
full
of
friction,
and
it's
just
terrible.
This
makes
it
a
waste
time.
There's
a
lot
of
frustration.
A
You
will
start
building
side
systems
where
their
ability,
talking
and
testing
them
just
to
avoid
the
cycle,
but
there
has
to
be
a
better
way
right.
We've
been
building
Cerberus
for
a
few
years
now
and
we
need
to
evolve
on
this
model
and
the
fact
is
I
do
love
running
functions.
It's
easy
to
run.
They
scale
up
very
easy
to
maintain
very
low
overhead,
but
I
do
miss
a
fast
inner
loop.
This
is
something
where
every
time
the
building
a
function
I
do
miss.
A
This
experience
of
I
want
to
write
code
and
see
my
changes
immediately,
but
there
is-
and
this
is
what
I'm
here
to
show
you
like-
we-
there
is
a
better,
a
better
way,
there's
a
way
where
we
could
take
the
best
of
these
approaches:
the
lightweightness
of
functions,
the
ease
of
use,
the
low
overhead
of
running
them,
but
have
our
local
experience
directly
there.
So
that's
where
there
and
that's
what
I
would
hope,
Tarot
and
open
fast
together.
You
can
do
this,
something
that
oak
terrace
opened
fastest.
A
As
you
saw
earlier,
this
framework
that
Alex
wrote
and
one
of
really
cool
things
would
open
fast.
It
leverages
all
of
the
components
of
kubernetes,
so
you
have
access
to
parts
your
deployments
behind
the
scenes.
All
of
these
things
are
happening
and
let
me
start
talking
twice
wow.
This
is
one
of
the
things
where
we
saw
as
a
great
way
for
us
to
help
with
that
experience,
because
walk
shadow
from
our
side
is
an
open-source
tool
that
lets
you
deploy
dev
environment
in
kubernetes
on
demand.
A
You
run
them
on
your
cluster
and
you
develop
their
explain
later,
how
it
works,
but
high
level,
you
launch
your
deployments
a
container
and
kubernetes.
You
synchronize
local
code,
and
you
do
this
very
fast
live
coding.
So
when
we
start
talking
to
Alex,
something
we
saw
that
was
really
interesting
is
that
we
could
actually
use
all
this
stuff
with
a
million
with
a
channel
but
apply
it
in
a
serverless
manner.
Us
typically
we're
doing
this
more
first
stateful.
You
know
cloud
native
apps.
A
It
was
really
interesting
to
see
how
they
could
how
they
could
work
together
and
at
the
end
we
must
to
put
together
at
that
workflow,
where
you
can
use
open
fast
and
up
shadow
and
iterate
on
functions
as
fast
as
you
can
type.
You
no
longer
have
to
wait
for
this
push
to
happen
for
your
function
of
a
package
and
redeploy
it.
You
can
just
write
your
code,
save
it
and
see
the
results
of
it
quickly.
A
Immediate
and
just
again,
the
point
is
to
not
get
you
out
of
that
flow
out
of
that
in
ESU
of
like
typing
validate
and
repeating
that
a
hundred
times
what
I
per
day
so
yeah,
it's
it's
possible.
It
is
something
that
I'm
gonna
show
you
now
I'm
gonna
give
you
a
demo
of
this.
Everything
we're
showing
here
is
open
source
available
on
github
at
the
end,
I'll
show
some
links,
but
the
the
slicer
also
published
if
you
wanna
see,
what's
going
on
so
live
demo.
So
hopefully
things
will
work.
A
On
I
hope
you
can
see
my
screen
can't
really
see
it
from
here,
but
something
I
did
before
this
talk
is
I.
Have
a
cluster
with
open,
fast
running
and
I
deploy
a
function.
Function
is
just
a
simple
hello
world
I
configure
my
CLI
to
talk
to
open
class
and
it's
a
hello
war
function.
You
have
a
URL,
so
we're
gonna.
Take
that
and.
A
Go
to
it
and
it's
a
lovely
function.
Welcome
to
San
Diego,
some
tacos.
If
you
have
not
eaten
tacos,
please
do
it's
one
of
the
best
things
about
San
Diego
of
that
and
that
on
the
ocean,
but
anyway,
but
this
is
that
it's
a
function.
Html
very
plain:
there's
not
not
a
lot
of
interesting
things
about
this,
so
this
is
where
we're
gonna
start
using
a
potato
and
open
fast
to
to
build
something.
That's
it's
not!
Some
more
piece
has
some
some
logos,
maybe
or
something
like
that
right.
So,
typically,
how
would
this
work
now?
A
Go?
I'll,
go
to
my
code
very
simple
right
here:
I'll
modify
my
function
say
my
file
built
all
these
things
already
talked
about.
Instead
of
that,
we're
gonna,
do
it
redirecting
the
clutter.
So
we
have
our
function
running
so
I'm
going
to
now
is
and
when
I
run
a
command
oak,
taro
CLI,
already
pre-installed
and
I'm
gonna
deploy
my
dev
environment,
another
measurement
well
well,
this
runs
it's
all
described
here
on
this
manifest
is
another
channel
because
we
don't
have
enough
channels
in
the
cloud
maybe
space.
What
this
does.
A
This
tells
open
taro,
which,
where
is
your
dev
environment,
which
image
to
use
in
this
case,
because
we're
connected
will
open
fast,
we're
going
to
connect
with
with
a
function
there
and
replace
is
the
content
of
a
function
with
a
container
with
our
dev
environment,
which
in
this
case
is
gone.
It
has
a
runtime
debugger,
all
these
things
and
then
it
also
has
other
configurations
like
the
same
user,
you're
running
on
function
and
in
this
case,
CSP
trace.
A
A
Forgot
this
and
there
we
go-
and
that
is
the
washed
look
in
this
case-
sample
view
in
the
watchdog
to
just
pick
up
the
code
from
my
local
directory
and
run
the
function.
So
at
this
point,
I
go
back
to
my
browser
refresh
and
you
see
the
same
thing
as
before.
At
this
point,
we
have
a
different
measurement.
That's
going
through
the
entire
pipeline
of
open
files.
You
know
it's
an
SSL
endpoint,
it's
getting
the
request,
that's
getting
to
the
wachatis
filing
the
process.
A
So
the
same
as
before,
and
now,
let's
make
up,
let's
make
a
small
change
for
this
change.
I.
Have
it
right
here,
you
know
cooking,
show
style,
it's
gonna
uncomment
this!
It's
a
couple
of
nice
logos,
I'm,
gonna,
save
and
I'm,
going
to
restart
my
process.
I
go
back
here,
I
reload
and
now
we
have
open
fast
and
oak
shadow
down
there.
So
very
small,
it's
a
very
small
sample,
but
the
idea
with
this
is
show
you
how
you
can
iterate
on
this
function.
We
are
having
to
build
push
anything.
A
This
is
not
intended
to
replace
something
like
an
open,
fast
cloud
where
you
push
to
deploy.
The
idea
with
this
is
while
you're
developing
you
can
iterate
very
quickly
and
then
once
you're
ready,
then
you're
gonna
use
the
traditional
deployment
mechanisms,
your
CI
CD.
If
your
sentiment
like
flocks
get
ups
the
bill
get
to
build
your
image
and
deploy
it.
It
doesn't
replace
that,
but
it
does
gives
us
this
very
nice
flow.
A
While
we
are
developing
the
other
thing
that
octet
on
the
profiles
together
give
us
is,
you
saw
that
I
don't
have
to
install
anything.
My
def
environment
in
this
case
something
I
pre
created
it's
a
it's
a
docker
container
that
has
everything
I
need
for
my
function,
the
right
version
of
go
right,
tooling.
A
In
this
case,
they
lay
out
that
the
the
go
function
expects
this
is
using
one
of
the
go
HTTP
templates
and
we
were
using
all
of
this
great
concept
of
open,
fast
off,
very
simple,
reduce
templates,
just
focus
on
your
business
logic
and
don't
worry
about
anything
else,
plus
the
added
benefit
of
quick,
quick,
onboarding
use
fire.
This
up
develop
your
done.
Send
your
PR
commits,
and
finally
we
are
fooling
to
a
Tony's
environment.
So
we
know
there
are
code
working
in
the
context
of
this
function.
A
Imagine
a
more
complex
function
where
you're
calling
other
functions.
Other
api's
other
things
like
this.
That
gets
very
complex
to
do
locally
and
try
an
error,
and
with
this
you
can
just
iterate
really
quickly
and
really
really
get
it
get
it
done,
and
ship
value
super
fastest,
as
it
was
mentioned,.
A
So
how
does
all
work?
This
is
when
it
gets
a
little
more
interesting
and
I
hope
you
I
hope
you
like
it.
This
is
how
open
fast
works
internally.
When
you
launch
a
function
eventually,
a
port
will
be
launched.
That
has
is
sitting
on
port
8080
at
the
contact
that
Alex
mentioned
earlier,
it
was
going
to
receive
the
request.
A
There's
this
process
called
watchdog,
that's
waiting
on
on
port
8080,
and
when
he
gets
a
request,
it
will
launch
your
function
and
one
of
the
things
I
really
like
the
best
about
open
files
is
how
abstracted
it
is
because
this
function
is
just
a
process,
and
this
could
be
go
like
in
this
sample
could
be
Java
bash.
He
doesn't
really
matter
and
the
same
thing
with
locked
arrow.
The
environment
is
completely
tech
agnostic.
You
can
just
put
have
some
samples
with
bash
with
Python
node.
A
It
doesn't
really
matter
and
the
way
it
works
is
the
watcher
will
fork
the
process
and
then
they'll
open
a
channel,
and
we
will
forward
the
request
response
function
following
a
contract
in
the
case
of
goes
through.
A
typical
handler
in
the
case
of
bash
is
just
you
know,
input,
output
and
the
response
will
flow
that
way,
so
that
it
does
how
it
works.
Internally,
it's
how
you
were
when
you
deploy
a
function
when
you
deploy
the
function
with
an
octet
on
level
measurement.
This
is
what
happens.
A
We
keep
the
same
flow
that
we
had
before,
but
then
the
dev
environment
is
adding
extra
services,
one.
It's
adding
all
your
dev
dependencies
in
this
case
the
go
runtime
anything
else,
all
their
files
assets,
really
whatever
you
need
it's
injecting
a
synchronization
service.
So
your
the
code,
you
write
locally
again
is
getting
like
instantly
synchronized
on
your
dev
environment,
on
your
function,
in
this
case
we're
using
same
thing
and
an
open
source
like
as
well,
and
you
have
your
coder
and
then
you
modify.
A
We
modified
in
this
case
the
process
that
watchdog
is
the
starting
so
that,
instead
of
starting
the
vinery,
maybe
starts
a
whole
loader.
It
starts
a
compile
and
run
kind
of
process
like
I'm
doing
here
and
he
starts
a
function
and
then
every
time
the
function
gets
started,
you're
getting
a
fresh
version
of
your
code
in
this
sample
I'm
using
go,
but
this
works.
A
If
you
see
something
like
node
or
Python,
it's
even
quicker,
because
you're
even
have
to
restart
the
process
you're
using
the
fact
is
interpreted
and
their
own
built-in
hot
reloaders,
but
I'm
going.
You
can
do
something
as
simple
as
build
it
restart
the
process
or
in
the
in
the
case
of
the
sample.
You
can
just
do
go
run
main,
so
it
become
piles
on
the
fly
and
gets
you
the
previous
dam,
the
latest
version
of
your
code.
The
idea
with
all
of
this
is
again
it's
on
the
dev
cycle.
It's
not
to
the
press
production.
A
It's
not
we're
not
looking
for
how
to
make
it
super
efficient.
The
whole
idea
is:
how
can
you
give
you
the
experience
as
close
as
possible
to
the
local
dev
quick,
the
rate
focus
on
that,
but
you
are
in
a
function,
so
you
can
start
to
leverage
all
these
really
cool
things.
All
the
fast
execution
in
an
easier
way,
but
that
is
not
that's.
A
Not
all
one
of
the
really
cool
things
about
this
model
with
def
environments
are
remotely
is
that
you
can
also
start
using
or
reusing
I
should
say
all
the
traditional
part
of
your
toolkit.
You
know
if
you're
using
go
or
Java
for
your
function,
you
can
start
using
incremental
builds.
You
don't
have
to
wait
for
bills
to
be
from
zero.
Every
time
you
have
to
build
a
container
or
we
don't
have
to
blow
your
sip
file
in
the
case
of
lambda.
A
In
this
example,
user
on,
go,
builds
and
because
you
have
a
it's
a
it's
a
pod,
it's
there,
your
cache
can
be
their
throat
arrow.
You
can
even
catch
your
your
build
cash
across
multiple
life
environment.
In
the
case
of
Java,
you
can
get
this
very
fast
incremental
builds
and
just
build
your
the
jar
files
that
you
really
need.
A
So
in
this
case,
what
I'm
gonna
do
I'm
gonna
stop
my
function
and
what
I'm
doing
here
is
I'm
gonna
export.
This
and
VAR
f
process
is
the
M
bar
that
the
watchdog
uses
to
see
what
to
launch
when
your
function
gets
it
bugged.
So,
in
this
case,
what
I'm
going
to
do
is
I'm
going
to
tell
open
fast
to
launch
my
debugger
and
it
is
delft.
The
go
debugger,
that's
pre-installed
on
my
the
environment
already
and
have
it
listen
on
port
two,
three,
four
five.
A
One
other
thing
that
I
mentioned
before
is
that
when
you
launch
you
Devon
bottom,
is
you
locked
arrow
because
you
can
also
configure
it,
but
eclis
port
forward
a
list
of
ports
to
your
local
machine?
So
if
you
want
access
to
certain,
in
this
case
the
port
of
the
debugger
for
remote
debugging,
if
you
want
some
extra
ports
for
like
an
admin
interface,
you
can
automatically
forward
this
to
your
machines.
You
have
to
create
a
special
networks
through
an
anger
core
about
any
of
these
things.
A
At
this
point,
I'm
gonna
stir
it
again
and
now
what
I'm
gonna
do
I'm
gonna
use,
BS
code
and
BS
code
I
have
it
configuration
if
you
are
familiar
is
like
the
default
remote
go
configuration
it's
pointing
in
this
case
are
a
host.
It's
local
host
because
of
my
port
forward,
I
have
a
port,
23.5
and
I
have
a
configure
set
the
remote
pad,
so
I
can
get
code,
completion
and
follow-up
on
all
those
things.
A
So
this
point:
when
I
got
my
debugger
I'm
going
to
add
an
endpoint
and
I
click
debug,
and
if
you
go
back
to
your
dev
environment,
you'll
see
this
is
the
output
of
my
debugger
is
very
attached
to
it.
So
the
next
time
I
go
here
and
I
request
my
function,
you
see
that
is
hanging
and
you
see
that
BS
code
broke
into
the
function
of
the
request,
and
at
this
point
you
have
the
full
capabilities
of
your
of
your
debugger.
A
This
is
very
simple:
you
can
inspect
the
request,
HTML
again
I'm,
keeping
this
the
demo
simple
to
focus
more
on
the
workflow
and
the
idea
behind
this
definite,
very
much
for
functions.
You
can
imagine
how
this
can
become
very
useful,
especially
as
your
as
your
functions
get
more
and
more
and
more
complex
come
break
in
and
then,
when
you're
done,
you
just
connect.
A
And
anytime,
when
you're
done,
you
can
just
exit
your
dev
environment,
octet
or
down
to
deactivate
it,
and
this
will
restore
your
function
the
way
it
was
before
before
Hotel.
Oh,
there
we
go.
It
is
a
spot
it
recover
before
and
the
flow.
It
will
be
this
where
you
launch
you
def
function,
you
tie
you,
try
it
you
trade
on
this
code.
When
you're
done,
you
have
your
code,
you
send
your
PR
and
then,
if
you're,
using
something
like
open,
fast
cloud,
then
you
will
do
the
deployment
base
and
get
ups.
A
So,
at
the
end,
it's
all
about
how
can
we
make
it
easier
for
everyone
to
build
functions
and
to
make
it
more
efficient?
We
go
way
faster
and
it's
really
in
line
with
the
idea
that
Alex
mention
before
of
it's
about
providing
value.
It's
about
removing
all
this
friction
and
not
thinking
in
terms
of
functions,
but
thinking
in
terms
of
I
have
this
code.
I
have
this
value
that
I
need
to
deliver
to
my
customers.
How
can
I
do
it
as
quickly
as
possible
and
with
octet
on
open,
fast
you're,
not
waiting
on
bills?
A
You're,
not
waiting
you're,
not
losing
all
this
friction.
Well,
there's
not
creating
all
this
friction.
You
just
focus
on
your
code
on
the
volume
and
you
really
go
quickly
and
finally,
and
for
me
is
the
biggest
value
as
you
can.
You
can
reuse
all
those
tools
that
typically
are
lost
when
you
move
to
cloud
native
ground.
Just
when
you
move
the
server
list,
the
debugger
was
an
example,
but
even
just
being
able
to
compile
your
code
engine
of
environment,
you
are
already
on
the
network.
A
You
are
in
the
cloud
you
depend
on
me:
downloading
I'm,
going
faster
you'll,
be
spending
less
time
waiting
for
images
to
be
built.
All
of
this.
It
really
makes
you
a
lot
more
productive.
We
use
this
a
lot
internally
as
we
build
other
cloud
native
apps,
and
the
difference
is
just
great.
We
have
a
lot
of
customers
now
using
this,
not
so
many
yet
they're,
using
it
more
for
the
cognitive
experience
and
I'll
tell
oh
the
same
thing.
A
That
I
show
here
work
for
any
other
type
of
cloud
native
apps
as
long
as
their
support,
as
well
as
deployment
I'm
sure
I
can
work
with
it.
You
know
kubernetes
OpenShift,
open
fast.
Any
of
these
tools
that
are
building
as
long
as
everyone's
built
on
this
common
kubernetes
building
blocks.
It
will
work
with
each
other
and
finally,
your
dev
environment
is
integrated
from
end
to
end.
So
you
are
testing
the
entire
lifecycle
of
your
function
if
you're
using
a
load
balancer
if
you're
using
SSL.
A
If
there's
like
a
flow
of
functions,
if
you're
calling
other
third-party
services,
the
idea
is
also
to
get
you
away
from
building
all
these
marks
from
having
all
these
test
services
and
just
be
integrated,
end-to-end
all
the
time,
you're
building
functions
and
just
have
higher
degree
of
certainty
that,
when
you're
gonna
go
to
production,
everything's
gonna
work,
I
saw
someone
on
Twitter
yesterday
were
stealing
this
picture.
That
said
that
Mach
services
give
you
more
confidence,
and
it's
true,
you
don't
know
it
like
it's.
A
Your
API,
really
reflecting
like
your
mock
API,
is
really
behaving
the
way
the
service
is
gonna
behave,
I,
don't
think
so.
Having
everything
end
to
end
really
helps
build
this
confidence.
This
understanding
on
your
platform
and,
as
you
scale
your
team,
it's
easier
to
work
in
peril.
Its
way
easier
to
just
send
someone
hey,
there's
this
function,
try
it
out,
rather
than
set
up
a
local
environment
with
a
simulator
and
try
this
and
then
in
production
staging.
A
You
know
what
I'm
saying
it's:
it's
really
all
about
I'm,
going
to
make
individuals
teams
and
not
just
the
functions
themselves
more
more
efficient,
so
have
some
links
there.
Rock
tell
us
open
source,
you
can
go
there.
Please
check
it
out
star
it
for
kit,
we're
always
looking
for
more
people
in
a
community
to
come
and
help
us.
We
didn't
believe
in
this
idea
of
building
deaf
experiences
for
cloud
native
applications,
both
serverless
or
or
not.
We're
just
exploring
that
we're.
Just
starting
with
this
idea
of
how
to
develop
with
serverless
functions
and
I'm.
A
Tell
us,
oh
I
would
love
to
hear
what
you
think.
Ideas
will
be
around
all
week
or
later
through
github.
We
are
in
the
quinces
luck
as
well.
We
have
a
channel
there
and
I
would
love
to
hear
what
you
think
and
if
you
starting
using
oak
Chado
how
you're
using
it
and
this
sorry
this
sample
that
I
went
through
today,
I'm
gonna
polish,
it
on
github,
I,
think
already
there
we
can
try
it
out,
it's
all
based
on
what
we
released,
there's,
nothing,
nothing
there!
A
You
can
try
it
out
and
everything
is
open
source,
so
just
please
check
it
out
and
finally,
we
want
to
connect.
I'm
on
twitter,
twitter
/,
our
barista,
the
flights
already
on
the
on
the
side.
So
you
have
to
memorize
my
overly
long
last
name,
but
well.
That's
it!
That's
the
demo.
That's
the
talk.
I
hope
you
find
it
useful.
If
you
have
any
questions
and
now
is
the
time
where
I'll
be
around
after
the
talk,
Thanks.
C
B
A
Think
the
questions
so
I'm
I,
don't
know
at
this
point
we're
focusing
more
and
because
the
requests
got
seen
and
you
have
to
either
change
the
timeout
on
on
course,
like
it
opened
fast
or
whatever
in
this
case
know
when
you're
attached
to
it
you're
waiting
right
now,
I'm
focusing
more
on.
How
can
we
get
a
debugger
to
go
through
it
for
the
response
code
thing
you
have
to
test
it
on
the
other
side
like
on
queries,
returning
the
the
call.
A
B
C
A
It's
something
we're
starting
on,
so
something
we're
looking
into
right
now.
Is
we
just
released
a
plugin
for
a
tariff
for
BS
code
remote?
So
one
of
the
ideas
we're
pursuing
is
how
you
can
uncheck
the
environment
that
includes
the
IDE
that
really
get
attached
to
your
function
and
all
those
things
that
is
where
we
are
today
and
what
was
the
way
I
wanted
to
present
here
was
to
get
more
ideas
and
conversation.
How
can
we
improve
this
specifically
for
server
list?