►
A
And
say:
welcome
back
to
the
everyone
can
contribute
cafe
this
time.
I
think
we
have
number
50.
So
it's
like
celebrations
and
we
are
remote
everywhere
all
over
the
world.
Hopefully
I'm
here
with
mike
gleidner
in
austria
in
mark-
and
I
know
that
nicholas
is
in
tenerife,
and
hopefully
everyone
else
also
has
a
great
time
wherever
you
are
joining
today.
Yeah
and
the
thing
we
kind
of
talked
about
or
came
about
was
dagger
or
dagger.
A
I
have
no
idea
how
to
pronounce
it,
which
which
tends
to
be
a
portable,
ci
cd
kit,
and
it
should
be
first
look.
I
know
that
meteor
has
prepared
something
to
get
us
started,
but
yeah.
The
idea
is
to
learn
together
and
ask
questions
and
figure
out
how
we
like
can
use
it
in
the
future
or
what
what
its
purpose
is.
Yeah
I
mean
to
get
started
with.
I
would
just
hand
over
the
voice
to
to
nicholas
to
maybe
kick
us
off
and
give
us
a
little
introduction.
B
Yeah
yeah
so
welcome
it
also,
since
we
have
a
live
transaction
enabled.
So
I
can
also
do
the
whole
talk
in
spanish.
So
then
we
would
see
it
in
english,
no
I'm
judging
so
my
spanish
is
not
too
fluent
for
that,
so
that
I
can
do
it,
but
it
was
mostly
when
I
started
with
data,
because
it
was
like
a
lot
of
topics
that
are
coming
around
and
I
need
to
understand
how
it
was
working.
B
That
also
was
the
reason
why
I
really
want
to
do
that
to
learn
something
new
and
for
that
what
you
want
to
do
when
I
do
today,
so
I
have
some
slides
prepared
so
to
have
like
a
little
red
dot
in
terms
of
getting
started
and
how
you
can
use
it.
We
do
like
a
simple
example.
Then
we
probably
do
also
an
advantage
example,
and
then
we
were
checking
how
much
time
is
left
and
which
questions
are
unanswered
by
the
people
yeah.
B
B
B
B
So
and
then
we
had
like
a
phase
of
where
everyone
was
building
smaller
containers
in
terms
of
like
creating
small
applications
only
for
the
users
that
it's
needed
right,
not
for
big
bloated
operating
system,
with
all
packages
for
everything
so
not
generalized,
so
really
specialized,
but
another
problem
that
also
happened.
Then
it's
mostly
is
like
when
you're
building
a
lot
of
different
containers.
B
You
get
like
the
same
like
with
lego
bricks.
So
there
are
a
lot
of
different
shapes,
a
lot
of
different
colors
and
you
need
to
stick
them
all
together
and
that's
like
a
problem
that
some
company
already
has,
and
the
next
problem
that
you
probably
also
wear
is
is
like.
We
all
do
like
the
icd
and
we
have
our
environment
and
it's
mostly
crew
running
you
can
easily
commit.
It
will
be
done.
It
will
be
executed,
probably
in
a
digital
pipeline,
but
the
problem
is,
for
example,
like
as
a
developer.
B
Like
me,
I
want
also
to
be
able
to
execute
locally
for
faster
debugging
circuits
so
that
the
feedback
loop
is
a
lot
of
faster
instead
of
waiting
on
the
pipeline.
This
waiting,
you
probably
all
know,
also
the
xkcd
comment
where
the
same
compiling
and
all
these
that's
not
compiling
anymore.
It's
mostly
waiting
on
the
pipeline.
We
can
say
pipeline
pipeline
yeah,
and
for
that
there
was
a
tool.
It
was
mostly
invented
by
the
solomon
heights
with
team
members,
and
it's
called
dagger.
So
give
me
a
second.
We
look.
B
We
need
to
first
look
a
little
bit
on
the
pictures
because
I
really
like
them
yeah.
So
we
have
like
the
main
purpose
for
dagger
is
mostly
that
you
have
like
a
unified
way
to
have
your
ci
cd
pipelines
locally
and
also
light
in
a
different
environment.
So
it
could
be
like
you
can,
try
it
on
deeplet.
You
can
run
it
on
other
platforms
or
you
can
run
it
local,
but
you
can
use
the
same
commands
everywhere.
B
B
We
have
to
know
this
unified
description,
language
and
that
will
give
us
probably
a
cruel
advantage
and
also
like
it
can
be
the
future
of
how
we
describe
our
our
pipelines.
Instead
of
that,
we,
when
we
switching
from
one
system
to
another
system,
we
need
them
to
write
new
general
syntax.
The
configuration
files
are
a
little
bit
different
and
then
you
need
to
check
it
every
time,
and
this
is
what
data
gives
us.
B
It
allows
you
that
you
don't
have
any
configuration
drift.
Another
advantage
is
like
we
don't
go.
I
need
to
write
any
more
yammer,
so
we
know,
starting,
of
course,
using
a
new
language.
It's
called
tulane.
It
was
invented
at
google
so
because
they
had
also
the
problem
with
configuration
fight
so
because
they
had
a
lot
of
difference,
so
they
have
yam
adjacent
and
so
on,
but
they
wanted
to
be
held
for
more
tight
and
more
dynamic
language.
B
In
terms
of
that,
you
can
easily
do
string,
interpolation
and
all
the
stuff
so
and
that's
the
reason
why
also
data
also
choose
q-line,
because
it
gives
us
a
lot
of
flexibility
and
it
has
some
similarities
from
other
configuration
or
package
management
system
that
we
had
before
so
before.
We
really
go
into
what
is
q
and
all
the
technical
details
on
that.
B
B
You
can
also
later
we
have
autolater
an
example
for
gitlab,
so
I
will
also
show
that
how
it
works
and
explain
it,
but
firstly,
we
need
to
start
it,
so
I
have
made,
of
course,
so
I
installed
it
with
homebrew.
It's
like
you
can
easily
do
a
brew
install
and
what
you
also
need
is
slightly
darker
and
that's
it
so
then
we
can
start
with
later.
B
Besides
that
now
coming
very
interesting
point,
as
I
said,
we
want
to
have
like
a
unified
language
instead
of
that
we're
writing.
Yaml
files
and
data
mostly
consists
of
q
files
for
the
from
maturing
language,
and
I
will
show
you
now
a
simple
example.
So
this
is
like
a
hello
world,
so
what
you
can
do
at
dagger,
so
everything
in
dagger
starts
with
a
plan,
so
this
type
of
object.
B
You
mostly
started
with-
and
probably
you
see
already
some
similarities
from
programming
language
that
you're
already
aware,
because
we
have
the
package
and
we
have
the
import.
This
is
really
transisting
to
garlic.
So
if
you
away
a
little
bit
of
darling,
it
looks
the
same.
The
reason
behind
that
is
because
q
lane
is
mostly
based
in
it's
like
a
super
set
of
json.
You
can
transform
it
to
a
little
bit
more
adjacent
syntax,
also
yummy
slightly
super
set
of
json.
B
So
that's
the
reason
why
you
can
interchange
them
and
later
you
can.
The
real
execution
of
each
action
will
be
done
by
by
a
drawling
program.
Underneath
so
that's
like
why
dagger
is
so
powerful,
so
it
gives
us
a
big
catalog
of
actions
that
we
can
do
and
each
action
just
like
you
know
a
short
benefit.
So
first
we
have
here
the
hello
action.
B
B
This
is
a
typical
system
that
you
probably
know
from
other
icd
systems
like
how
was
it
I
don't
remember:
okay,
but
that's
it
and
we
first
now
looking
into
this
example
at
all,
so
I've
prepared
already
on
my
steam.
So
okay
do
something
to
show
you
how
you
get
started,
so
we
have
here
on
the
same
file.
So
we
have
here
also
the
hello
world
view
it's
like
intended
all
the
stuff,
and
now
we
want
to
execute
it.
B
B
It's
currently
in
a
really
early
phase.
So
a
lot
of
changes
were
happening,
but
the
documentation
is
mostly
up
to
date
and
you
can
easily
get
started.
There
are
a
lot
of
more
examples
and
afterwards,
for
example,
now
we
can
type
dagger
and
we
see
we
have
only
two
commands
really
so
because
that
is
not
the
real
command.
B
It's
a
supporting
command
and
version
is,
of
course,
only
printing
reversal,
so
we
have
project,
and
we
have
a
do
so
when
you
now
type
data
due
that
you
want
to
do
something,
so
you
want
to
execute
an
action.
We
already
get
an
error,
so
it
says
here
hey.
We
need
to
initiate
the
dagger
project,
because
why
we
need
to
do
that
is
like
we
have
the
hello
world
view,
and
it
has
also
some
input,
so
we
need
also
to
import
all
the
dependencies
of
course,
and
it
currently
data
doesn't
know.
B
This
is
a
project,
so
the
first
command
will
be
with
the
hello
world.
It
will
be
start
data
project
in
it
and
then
we
starting
the
project
and
what's
happening
in
the
end
it
a
new
photo
is
here
created,
it's
called
q
mod.
This
is
like
really
similar
to
the
vendor
directory
from
goalie.
So
if
you
know
it,
this
is
like
literally
the
same
in
the
end.
Now
we
have
here
also
the
package
folder
and
this
currently
it's
really
empty.
So
let's
try
go
back
again,
just
a
question.
B
When
you're
downloading
youtube
yeah,
so
let's
yeah,
that's
the
interesting
part.
So
when
you
know
data,
do
you
still
get
an
error
because
it
says
hey,
we
cannot
find
the
dependencies
terraform
in
it
does
two
steps
in
the
end,
it's
in
it
for
crowded
and
automatic
download
dependencies,
but
data
you
need
to
do
it
in
two
commands.
B
So
and
it
says
already:
okay,
do
a
data
project
update
so
this
what
we
now
do,
we
will
do
a
data
project
update
and
that's
it.
So
now,
let's
look
again
in
the
tier
mode
so,
and
we
have
here
the
package
folder-
and
you
currently
can
see
here
that
we
this
was
empty
before
so,
when
we're
looking
a
little
bit
on
top,
it's
mostly
empty.
So
nothing
was
there
and
now.
B
I
o
and
universe
data
I
o.
These
are
the
packages
that
we
had
from
the
hello
world
view
because
they're
coming
while
it's
universal,
we're
coming
out
later
to
the
point,
but
when
you
now
go
into
the
dependency
tree
and
check
it,
for
example,
like
we're
going
to
be
universe
yeah
you
see
now
a
lot
of
more
directories
were
created.
B
For
example,
we
looked
now
in
the
I
want
to
have
a
simple
one:
an
airport,
okay
alpha-
and
you
see
also
these
packages
are
also
written
in
cuba,
so
they
are
not
written
in
a
different
language
and
you
have
like
an
importing
dependency
system
right
yet,
but
we
will
translate
it
to
the
focus.
So,
let's
start
now
with
executing
our
first
data
action.
B
B
D
B
B
This
is
what
probably
like
a
little
bit
different
to
other
bit
systems.
We
don't
execute
it
directly
on
the
system
by
itself.
We
use
docker
for
that
to
abstract
in
it
in
the
end,
so
you
can
also
see
here
that
some
debug
detected
the
build
kit
instead
computing.
You
can
see
also
here
that
the
image
was
pulled
or
the
lp3.
B
B
We
can
do
data,
do
hello
again,
and
you
see
it's
quite
fast,
so
it's
like
under
one
second
in
total,
so
it
runs
in
800
seconds,
mostly
and
800
milliseconds,
to
execute
for
command
to
execute
starting
a
container
printing
out
the
command
in
there
executing
the
command,
and
this
gives
us
for
full
flexibility.
So
we
can
have
different
type
of
actions
can
be
described
in
tuning
instead
of
writing
like
a
lot
of
docker,
composers
or
like
space
scripts,
or
something
like
that
to
start
different
containers
in
different
directions.
B
We
have
q
lane
for
that,
to
orchestrate
it
completely
or
to
unified,
and
that's
mostly
the
trick
what's
happening
there,
yes,
yeah,
so
I
would
say
we
should
make
shortly
a
stop.
And
probably
we
asked
for
questions,
because
probably
I
was
a
little
bit
too
fast
for
that
and
then
otherwise.
I
would
go
to
the
next
example
to
a
more
complex
result.
B
B
Okay,
so
when
there
are
currently
no
questions,
I
would
draw
now
a
little
bit
back
and
starting
a
short
summary
of
a
hello
world.
So
first,
it's
important
to
know
that
dagger
is
mostly
using
containers
for
executing
all
steps.
So
it's
running
every
time
in
an
isolated
environment
and
q
lane
will
be
used
for
describing
the
action,
steps
and
action
step
can
become
as
packaged
so
like,
as
also
like
as
module
way,
so
that
you
can
composite
each
to
another.
So,
for
example,
right
we
can
have
an
alpine
package.
B
We
have
a
docker
package,
we
can
have
a
terraform
package
and
all
the
stuff
on
that.
That's
quite
cool,
but
mostly,
I
think,
okay,
you
would
say
okay.
This
is
like
not
an
interesting
example
like
because
it's
like
only
one
step
and
it's
like
not
really
a
compact
system,
not
a
real
world
system
yeah,
for
that
we
should
probably
switch
to
to
a
brighter
example.
B
B
We
have
here
currently
an
to
do
application.
It's
deployed
on
netlyfly,
it's
on,
react
applications,
so
you
can
easily
add
things
to
it,
so
you
can
send
something
to
the
edit
and
you
can
delete
it
another,
of
course
so,
and
we
would
need
to
know
as
developers
now
we
want
to
deploy
it
and
typically
how
you
would
do
it
right
now
would
be
like
oh
yeah.
We
need
to
deploy
it,
so
we
need
to
write
our
eclipse,
ci
yammer.
B
C
B
So
it's
like
a
little
bit
more
complex
here
right
now.
Why?
Because
we
do
different
types
of
actions.
Probably
you
can
really
compare
data,
also
like
like
the
old
make
file
so
because
we
have
now
here
we
have
flight
for
all
javascript
for
our
nodes
application.
We
have
like
a
test
action.
We
have
a
build
action.
B
B
In
terms
of
that,
you
want
to
run
something
in
in
a
shell
script.
Here
we
want
probably
to
do
use
fenetify.
Typically,
you
know
what
what
happening
is
like.
We
would
have
like
10
different
chest
strips
that
needs
to
be
maintained
and
we
cannot
easily
composite
to
each
other.
So
we
need
to
have
like
in
a
shared
common
folder
and
with
data
we
can
also
import
them
as
dependency
and
I'm
sharing
it
with
other.
So
and
it's
like
a
really
cool
move.
B
B
So,
first
of
all,
what
we
would
probably
do
is
like
we
would
do
to
the
daily
command
to
see
which
available
actions
are
currently
there
so,
and
we
can
say
okay
what
we
should
do
now
to
to
run
it.
Oh
wait:
yeah!
Okay!
We
do
that
right.
So
it's
fine,
so
we
first
would
start
to
build
it.
So
we
would
do
a
dagger
boat
and
you
see
that's
currently
building
the
application.
B
B
B
It's
also
mostly
instant
because
it
already
attached
from
the
widget
demon
and,
if
you
remember,
basically,
probably
from
docker
when
we
started
to
use
like
multi-stage
images.
So
that's
like
now.
The
really
powerful
steps
that
coming
in
here
is
like
that.
We
can
parallelize
all
the
tasks,
because
when,
for
example,
when
I
don't
need
the
deploys
the
for
running
the
build
steps,
they
can
run
in
peril
and
this
slide
when
we
also
have
the
same
like
in
gitlab
pipelines
or
in
in
yeah.
I
like
the
normal
pipelines.
B
We
have
like
this.
This
chord
lets
you
also
a
crew
funny
fact
about
dagger.
So
here's
like
a
blueprint
and
the
blueprint
shows
the
arrows
to
which
you
can
think
about
the
whitebox
to
each
action
step
and
each
action
step
goes
into
one
direction,
but
interesting
on
this
one
you're
coming
from
the
referee,
it's
like
that.
You
not
see
any
cyprus.
B
So
when
you
are
here
at
that
point
in
the
latest
at
the
bottom,
you
cannot
turn
back
anymore,
and
this
helps
us
to
visualize
if
there
are
dependencies
between
the
jobs
and
if
they
can
be
run
in
parallel
or
not.
So
that's
also
a
reason
why
built
it
on
dagger
are
so
fast
in
the
end,
so
that
you
can
run
independent,
drops
emperor.
B
B
So
currently,
when
you
have
it
not
light
in
debug
mode
right
now
you
don't
see
so
much
stuff,
so
you
see
only
like
a
little
bit
output
what's
coming
out
of
the
budget,
so
for
that
I
would
recommend
to
use.
Currently
all
the
stuff
is
now
written
into
the
directly
to
our
local
system.
And
now
we
see
that,
like
the
netify,
build
action
was
triggered
and
now
our
app
was
deployed.
B
B
B
It
runs
right
now
so
now,
of
course,
because
for
caching
I
happen
to
change
something
on
my
javascript,
so
also
the
build
needs
to
be
new
run,
and
currently
this
step
is
more
like
synchronized,
so
you
need
to
have,
of
course,
of
the
build
before
the
deployment.
So
now
the
deployment
container
will
be
recreated
and
we
get
an
output
out
of
that.
B
B
D
B
Some
of
my
tradition
does
not
work
correctly,
except
yeah,
but
let's
see
why.
Why
is
no
way
says
it's
no
different.
So
I
have
also
data
here
in
it's
the
same
pro
project
and
I
have
also
like
set
up
the
data
pipeline
so
for
the
project.
So
we
can
look
here
on
into
the
step
and
we
have
here
also
we
deploy
netly
faster
so
and
you
can
see
what's
really
crude
on
that
is
it's
like
yeah.
B
We
have
gitlab,
of
course,
but
we
use
diplab
as
as
a
middleware,
so
we
do
like
we
doing
like
the
same
command.
So
we
do
the
data
project
updates
just
like
protection
dependencies,
and
then
we
say
innovation
we
want
to
trigger
currently
because
it's
your
multi-line
collapse,
we're
doing
like
the
data
to
deploy
and
what
we
only
need
to
have
like
available
in
the
pipeline
is
like.
B
We
need
to
have
like
v
docker
image
and
we
are
slightly
documented
so
that
we
can
use
the
docker
and
docker
to
get
access
to
the
docker
engine.
That
data
can
connect
to
it
and
then
it
will
execute
the
steps
in
the
same
way
and
I
don't
need
to
have
like
any
other,
any
other
abstractions.
So
I
don't
need
to
write
now
new
scripts.
I
can
use
the
same
of
that
and
that's
like
a
really
cruel
benefit,
and
you
also
see
here.
B
That's
all
what
I
really
like
is
that
they
have
colored
output
already,
because
it
makes
also
easily
to
see
what's
happening
there
and
what's
not
happening
so
yeah.
I
hope-
and
this
can
be
literally
done
for
every
pipeline
system,
so
I
know
that
they're
currently
people
watching
already
on
rankings
fights
already
for
azure
for
devops
and
other
stuff
so
and
we
can
have
like
a
look
in
how
complex
now
our
data
ci
pipeline
is
it's
like
that.
B
So
we
have
here
on
the
docker
image
so
that
we're
providing
the
docker
and
the
docker
service
to
it,
and
then
we
are
using
the
as
a
point
of
that,
we're
using
have
also
cache
that
we
do
like.
We
are
installing
the
data.
So
currently
it's
installed
via
a
ship
strip
because
it's
currently
the
fastest
way
and
then
we
do
like
having
like
a
re-template
of
data
to
action
and
no,
I
cannot
see
it
right.
B
B
Images
can
be
built,
but
this
is
now
a
little
bit
coming
back
to
the
theory
so
because
docker
images
are
nothing
else
like
like
a
file
like
guitar
archive
the
file
system
in
an
archive
or
like
a
zip
file
in
the
end,
and
you
then
do
mostly
the
manipulation.
So
what
you
really
need
is
when
we
are
now
drawing
back.
I
will
go
back
into
my
slides
because
I
have
like
a.
B
I
stole
the
picture
mostly
from
so
we
have
here
the
data
engine
and
then
we
need
every
time
a
docker
engine,
but
in
real
what
they're
doing
using
under
the
hood
is
like
widget,
so
you
don't
need
to
have
like
the
darker
engine.
You
can
also
use
only
build
kit
for
it,
so
this
is
like
a
more
advanced
concept
on
top
of
them,
so
because
the
main
benefit
is
why
why
you
use
endocrine
yeah,
for
example,
when
I
have
doctor
for
desktop,
there's
already
included
widgets.
B
B
So
you
do
here
literally
what
you
do
is
like
you
use
before
we,
when
we
would
use
the
alpine
package,
it
does
a
docker
build,
it
pulls
the
current
alpine
version.
This
is
now
also
what's
coming
here
from
the
strength
from
q
lane
what
you
not
have
in
yemen.
You
can
use
templates,
so
we
have
here
the
version
this
can
be
coming
outside
as
a
parameter,
so
it's
a
string
or
we
can
have
a
default
value.
B
So
this
reason,
when
you're
going
to
put
it
in
there,
so
then
would
be
version,
8,
3.5,
dot,
blah
blah
blah
and
then
typically,
what
it
does.
It
uses
a
dr
run
commander,
building
them
the
image
all
the
dependencies
that
we
need
when
we
look
back
into
the
alpine.
Well,
let
me
do
it
you
see.
Currently
the
same
step
is
like
here,
so
we
abstract
it
a
little
bit
in
the
depth
step.
We
have
here
the
alpine
bit
and
then
we
said
here
we
want
to
install
the
beyond
and
widget.
B
B
You
see
that
he's
now
really
executing
into
the
container
of
the
yarn
with
the
bash
and
fidget.
So
then
we're
using
this
container
and
using
it
on
top
on
top,
so
it's
mostly
docker
all
the
way
down.
So
that
is
also
gives
us
reflectivity
that
we
mostly
can
say
that
data
runs
on
any
ci
system
on
any
operating
system.
When
you
can
run
docker
or
anything
else,
it
will
still
work.
So
I
hope
it
answered
your
question
or
if
they
are
still
questioned
to
that,
I
must
be
free.
B
It
brings
us
the
flexibility
that
we
have
like,
so
the
question
was,
apart
from
removing
the
need
of
yammer
and
the
usage
of
q.
What
else
does
bring
us
data
to
the
table
that
we
have
like
a
unified,
a
unified
language,
a
dsl,
a
domain,
specific
language
that
we
can
use
to
describe
our
pipelines?
That,
for
example,
when
you
shift
from
from
github
actions
to
deep
lab
yammer,
you
don't
need
to
re-implement,
then
every
action
you
need
to
check?
Okay,
however,
there?
How
vds
is
at
that
topic?
B
B
Typically,
you
have
a
problem
that
you
have
like
different
logo
strips
and
different
ci
environment
strips
because
we
have
some
other
requirements
and
just
like
give
us
the
same
part
of
that
we
are
having
we
having
the
same
conformity
mostly
and
that's
the
real
big
game
changer.
I
would
say,
because
I
see
currently
here,
that
data
can
be
like
the
next
evolve.
Evolution
of
the
ground.
B
Yeah,
so
no
that's
not
true,
regarding
which
the
environments
are
currently
involved.
So
there
was
like
when
you're
going
here
to
this
discussion,
if
you
are
checking
for
ci
system,
so
I
know
that
the
cloud
piece
guys
already
worked
on
the
jenkins
integration
and
also
I
saw
already
some
involvement
on
the
discord
for
azure
devops,
where
it's
currently
working.
So
in
the
end,
you
don't
need
so
many
steps,
so
you
need
to
have
like
a
docker
and
you
need
to
have
a
cli
installed
in
your
system.
B
B
Yeah-
and
this
is
like
the
current
short
overview,
and
now
we
should
go
into
deeper
into
different
topics
in
terms
of
we
can
go
into
the
queue
lane
or
also
for
other
questions,
or
we
generally
rotate
sample
work
trip,
for
example
right
when
we
want
to
wrap
other
to
it.
So
because
nitro
already
did
write
a
proposal
of
wrapping
terraform
so
that
you
use
data
to
also
do
like
a
terraform
in
it.
To
do
a
terraform
apply
that
you
have
like
this
unified
language.
B
Yeah,
so
currently
the
demon
or
the
execute
execution
engine
is
like
build
it.
So
this
is
like
what
they're,
using
at
heart
to
execute
all
the
container
commands,
mostly
because
this
is
also
what
use
docker
under
the
hood
to
do
like
a
docker
build.
So
when
you
do
a
docker
build,
it
will
be
directly,
send
it
to
build
it
and
build
your
builds
and
with
container
because
and
controls
also
be.
We
run
c
into
continuously.
There.
B
I
think
by
default
it's
currently
run
with
root
privileges,
but
you
can
also
start
bluetooth
without
root
privileges.
That's
currently
supported,
but
currently
I
think
I
not
saw
it
that
they're
already
executing
it.
I
think
you
can.
We
will
have
it
later
so
that
you
can
run
it
also
with
without
privileges
that
you
can
be
on
ci
systems,
because
when
we're
going
to
movie
it's
coming
out
of
the
moby
budget.
B
Yeah,
okay,
yeah!
Probably-
but
you
know
all
this
mostly
because
when
you
use
docker,
you
see
that
he's
checking
and
he's
resolving,
then
he's
building
like
a
dependency
tree
and
that's
right
called
like
a
duck
currently
so
to
know
which
steps
will
be
executed
and
funny.
We
know
the
first
instructions
that
everyone
knows
already
what
bit
it
uses
so
b
to
use
as
instruction
set,
for
example,
docker
built.
So
a
docker
file
is
like
a
build
instruction
for
build
it.
How
to
execute
the
steps,
and
there
are
a
lot
of
other
important.
B
B
B
It
was
called
somewhere
motor
file
and,
just
like
the
instructions
said
so
just
like
this
instructions
understands
it,
because
it's
transporting
the
motor
file
into
the
llb.
So
just
like
the
instruction
set
for
bit
and
then
built
it
understands
it.
But
this
is
like,
I
think,
a
really
deep
topic
in
terms
of
what
you
can
do
there,
and
this
is
like
what
also
dagger
uses
under
the
hood.
B
B
A
B
B
But
you
have
here
like
the
hashes
and
each
hash
is
like
a
simple
tar
file,
so
you
can,
when
you
do
docker
export.
It's
like
multiple
layers
right
here,
because
we
have
now
here
the
base
layer.
It's
only
one
link
and
they
all
connected
to
each
other.
That's
where
the
overlay
comes
into
the
game.
It
just
like
a
union,
a
merged
view
of
a
file
system.
B
And
this
is
what
bluetooth
uses
underwood.
It
goes
into
the
tar
file
and
changes
files
or
adding
like
a
new
tar
file,
and
then
you
would
have
the
multiple
layers,
because
it's
like
every
step
or
every
execution
in
build.
It
is
also
generating
a
new
layer.
In
the
end,
it's
like
also
the
same
with
your
docker
files.
So
if
you
have
a
run
command,
it
will
generate
a
new
layer.
If
you
have
an
exit
command,
you
will
generate
a
new
layer
and
just
like
the
similar.
A
A
B
Yeah,
it
gets
sanded
the
action.
So
when
we
look
in
our
example,
we
have
here
here.
This
is
the
important
part.
This
is
for
client
and
what
it
does
we
have
here
this
this
slide
in
tulane.
Now
the
read
file
system,
it
says
secretly
send
the
current
directory.
So
that's
the
reason
why
we
have
h3
so
and
when
we
say
we
don't
want
to
read
to
read
media
the
build
file
and
patufa,
and
this
would
be
centered
as
a
tar
archive
to
bridge
it
and
then
build.
B
It
is
doing
the
execution
steps
and
next
underwater.
So
what's
coming
in
the
actions
mostly
and
then
you
can
also
say,
okay,
I
want
to
write
the
content
to
a
local
file
system
also
back
because
this
is
all
also
how
docker
is
working.
So
when
you
are
building
a
docker
image,
everything
from
your
logo
file
system
will
be
packaged
as
a
as
a
zip
file
and
will
be
send
it
to
the
docker
daemon,
and
then
he
will
execute
in
all
the
steps.
B
A
B
There
we
currently
don't
have
like
and
the
reason
why
you
should
not
worry
about
like
if
you
want
to
run,
build
it.
The
simpler
approach
is
to
run
docker
because
it's
included,
and
then
you
don't
need
to
take
up
how
you
install
bitrate
and
all
the
stuff.
That's
the
reason
why
they're
saying
use
docker
for
it,
because
it's
a
little
bit
simpler.
B
A
There's
an
interesting
question
in
the
chat:
how
new
is
dagger,
would
you
consider
production
pipeline
ready?
I
think
it's
pretty
news,
so
it
left
its
private
beta
two
weeks
ago
and
it's
in
in
rapid
development.
I
would
say
so.
I
would
wait
and
test
it
and
try
it
out,
give
feedback
to
the
developers,
open
issues,
pull
requests
and
so
on,
but
my
personal
opinion,
it's
not
it
might
it
doesn't
look
like
it's.
It
has
reached
the
general
availability
release
yet,
but
who
knows
what
the
future
will
bring.
B
Yeah,
so
I'm
here
what
you
can
see
so
I
removed
before
I
before
I
did
the
door
that
I
do
deploy
step.
I
remove
the
database
with
the
container
so
and
there
are
also
started
this
container
again
so
that
he
can
execute
the
steps.
So
you
don't
need
to
have
like
you
need
to
have.
It
could
be
also
working
with
contain
id
only
so
because
you
would
send
when
we
yeah
it
worked.
So
I
I'm
for
sure.
If
you
wrench
off
a
desktop,
I
don't
have
it
so
that's
the
reason
why
I
cannot.
C
C
B
C
B
B
Yeah
the
main
trick
as
a
not
for
metric.
So
what
you
need
to
specify
when
you
want
to
have
like
running
budget,
it
doesn't
need
to
be
run
on
your
router
machine.
You
can
specify
the
built-in
host.
This
can
be
a
container.
It
can
be
like
a
tcp
connection.
It
can
be
assorted,
it
can
be
everything
mostly,
and
this
is
how
it
connects.
It
connects
by
default
to
a
socket,
but
you
can
also
overwrite
it
and
there's
also
already
some
guidance
on
that,
and
if
I
check
that
so.
B
B
B
B
B
B
B
D
B
So
and
probably
very
interesting
question
how
you
can
also
give
your
feedback
and
involve
into
the
community.
Of
course
you
can
use
github
for
that
check
the
people
out
also
on
twitter,
and
they
have
also
like
a
discord
official
discord.
So
you
can
also
connect
to
them
and
ask
them
questions.
They
are
really
eager
to
help
there's
currently
a
lot
of
work
on
growing.
B
B
B
It's
like
the
same
idea
like
from
circles
to
evo
for
alls,
and
that's
like
a
really
cool
approach,
so
that
you
don't
need
to
reinvent
the
wheel
every
time
when
you
want
to
have
like
a
small
dedication
or
a
small
strip
and
gets
you
started
faster
and
you
can
use
it
not
only
in
ci.
You
can
also
use
all
the
same
things
on
your
local
machine,
so
that
makes
also
easier
for
us
to
debug
pipelines.
B
B
A
B
Yeah,
so
I'm
mostly
what
I
do
to
being
catched
up
with
all
the
changes
that
are
happening.
What
I
can
recommend
is
I
go
back
to
the
distro,
and
then
I
read
it
mostly
what's
currently
happening,
and
currently
people
already
have
like
newborns
new
tools,
so
I
think
for
getting
started.
This
could
be
quite
interesting.
B
What's
currently
the
problem,
so
currently
it's
not
sensitive
with
working
with
q,
because
there's
no
like
big
integration,
so
there's
a
small
vs
code
extension,
but
that's
not
like
a
lsp,
but
currently
I
was
not
sure
about
the
roadmap.
I
know
that
they're
repackaging
the
the
the
packages,
so
that
means
like
that.
They
have,
for
example,
terraform
other
small
things
like
probably
also
like
for
github.
B
It
could
be
also
that
you
use
for
github
api
through
two
on
pages
and
configure
like
for
pipeline
and
like
having
like
an
event
stream
and
also,
but
just
like
a
little
bit
more
topic.
They
are
mostly
open
for
discussions
and
I
think
the
next
interesting
what
people
can
involve,
of
course,
is
also
like.
What's
the
next
step
environment
should
be
integrated
so
because
a
lot
of
people
currently
working
on
it
and
when
you're,
probably
not
sure
if
your
ci
system
is
in
there,
I
think
that's
always
a
good
hint.
B
C
B
Would
be
okay
for
that?
I
can
actually
shortly
give
a
shot.
So
we
have
also
like
your
formatting
two
in
q
length.
So
like
growth
format,
it's
also
q
format
and
you
can
format
right
directly
find
solution
so
available.
But
you
can
also
do
like
things
that
you
you
to
evil
and
then
you
would
see
how
the
whole
fight
would
pure
look
into,
but
just
like,
I
think
this
one.
We
should
dive
this
into
next
session
dedicated
only
to
lane
and
all
its
different
kinds,
because
this
is
like
an
own
language.
D
A
B
A
Yeah
or
maybe
maybe
have
a
github
a
pre-pre-commit
talk
locally
in
my
death
environment,
for
example,
which
which
does
the
linting
or
the
syntax
checking,
or
something
like
that.
So
before
I
even
commit
things
I
can,
I
can
verify
that
automatically
yeah.
I
don't
need
to
remember
the
exact
command,
but
instead
have
it
executed
automatically.
B
Yeah
yeah,
and
also
what's
good,
sometimes
happening
so
when
you
are
being
a
little
bit
late
on
the
europe
time
so
that
the
developers
are
on
the
stage
and
developing
live
in
this
box,
so
that
you
can
see
and
probably
also
watch
what
they
are
doing.
So
that's
also
really
cool
if
you
want
to
so
last
time
I
was
a
little
bit
late
on
and
I
misplaced-
and
I
was
in
the
stage
with
solomon
heights
and
some
other
developer,
possibly
discussing
shortly
about
this
topic.
B
So
it's
yeah
it's
trying
to
crew
involvement,
yeah
and
that's
it
for
the
start.
So
if
you
have
questions,
if
you
reach
out
so
the
most
interesting
thing
could
be
probably
the
project
you
can
find
the
whole
project.
The
example
project
that
we
didn't
know
with
the
neglify
amp
is
also
on
gitlab.
It
says
the
piper
and
it
have
everything
I
described
also
a
little
bit
what
you
need
to
do
to
deploy
it
so
and
feel
free
to
do
much,
requests
and
help
us
to
build.
B
Also
more
examples-
and
we
could
probably
make
like
in
the
next
six
months
and
you
will
revisit
on
data.
What's
up
involved
what
changed
and
then
we
probably
also
a
lot
of
more
deeper
in
there,
because
it's
like
really
in
an
early
phase
right
now,
but
it's
quite
rude
to
be
like
being
an
early
adopter
here
again,
yeah.
A
B
B
D
B
A
A
B
Yeah
yeah,
I
think
there
will
be
also
be
composed.
Actions
will
coming
up,
so
a
lot
of
more
wrappers
will
come
in
future.
So
I
saw
what
I
really
found
interesting,
so
there
was
already
a
project
that
do
aws
lambda
with
dagger
already
so
the
people
who
are
working
on
that
so
that
you
don't
need
to
really
use
these
serverless
states
that
you
use
directly
data
for
deploying
number
actions
and
all
the
stuff
so
use
the.
D
D
B
Yeah,
I
think
the
main
benefits.
In
short,
I
think,
like
what
you
can
see
here,
that
we
can
have
like
different.
So
you
don't
need
to
write
the
deploys
age
script.
Then
it
will
be
looking
different.
You
have
a
simple
two
file
that
you
you
have
to
file
for
it.
Then
you
have
like
the
category.
That's
individually
grow
over
time,
probably
also
different
community
packages,
so
they
have
also
like
different
source
already,
so
universe
is
for
official
one,
so
there's
also
a
community
space.
B
It's
called
europa
there's
also
an
alpha
version,
and
you
can
have
like
your
own
modules
if
you
want
to,
but
I
mean
the
main
benefit
is
really
that
you
can
do
it
locally
on
your
machine.
You
don't
need
to
run
a
whole
ci
system
to
test
all
the
changes
that
you
do
on
your
ci
pipeline
and
to
affect
faster
feedback
instead
of
waiting
and
all
the
machines.
That's,
I
think
what
currently
breaks,
probably
so
with
really
large
workloads.
B
So,
for
example,
like
you
need
to
do
number
crunching
or
really
computing
compiling,
and
it
takes
only
cpu
if
it
won't
make
it
faster
and
darker,
because
you
need
to
have
hardware
resource
to
fix
it,
but
if
you
have
multiple
steps
and
you
need
to
orchestrate
that
could
be
like
a
good
step
that
you
draw
on
parallelization,
because
it's
like
yeah,
I
see.
Okay,
this
step
is
independent
from
that.
So
you
see
it
here
directly.
So
the
these
proof
steps
can
be
run,
apparel,
okay
and
then
the
next
step,
and
so
on.
B
A
Yeah
for
the
mod
use
and
reusability
I'm
a
little
worried
around
when
something
is
incompatible
and
you're,
using
the
same
actions
or
modules
or
whatever
is
it
is
called
then
so,
like
quality
assurance
in
in
extensions
and
modules.
This
will
be
a
thing
in
the
future
and
I'm
sure
the
developers
already
thought
about
it.
A
A
B
A
Okay:
okay,
if
there
are
no
further
questions,
I
would
like
to
say
thanks
a
lot
for
preparing
for
today.
I
you
know
I
didn't
ask
for
it,
but
I
really
appreciate
it
yeah
and
I
hope
everyone
stays
safe
and
we
might
be
meeting
in
the
future
next
month.
Topic
is
still
open.
It
will
be
in
the
week
before
kubecon.