►
From YouTube: Troubleshooting your Data Workflows with Noteable+Dagster-live debugging of failed jobs | PDNYC 2022
Description
A productionalized notebook integrated with an orchestration platform provides an excellent balance of reproducibility, flexibility, and intent in a way that will be quickly consumable. This tutorial is valuable to data scientists and data engineers. This setup makes it easy to take notebooks from exploratory to production, but even easier to debug and ensure quality over time. This tutorial will show how you can achieve:
Time-saving in initiating jobs: Allowing users to seamlessly transition an exploratory workflow created within a Noteable notebook, into a productionalized scheduled workflow in Dagster.
Time and Cost Saving for debugging failed runs: Allowing users to immediately dive into a live running notebook at the point of failure, with all of the in-memory state preserved. This saves the users' time, as well as saves companies' compute costs by not requiring debugging to re-execute previous steps of the workflow.
Bios:
Pierre Brunelle
Pierre Brunelle is the CEO and Co-Founder of Noteable, a collaborative data notebook that enables data-driven teams to use and visualize data, together. Prior to Noteable, Pierre led Amazon’s notebook initiatives both for internal use as well as for SageMaker. He also worked on many open source initiatives including a standard for Data Quality work and an open source collaboration between Amazon and UC Berkeley to advance AI and machine learning. Pierre helped launch the first Amazon online car leasing store in Europe. At Amazon Pierre also launched a Price Elasticity Service and pushed investments in Probabilistic Programming Frameworks. And Pierre represented Amazon on many occasions to teach Machine Learning or at conferences such as NeurIPS. Pierre also writes about Time in Organization Studies. Pierre holds an MS in Building Engineering from ESTP Paris and an MRes in Decision Sciences and Risk Management from Arts et Métiers ParisTech.
Jamie DeMaria
Jamie is a software engineer working on Dagster. She has also built data analysis tools (using Dagster!) for a robotics startup and developed software to train mission planners for the Mars Curiosity rover.
===
www.pydata.org
PyData is an educational program of NumFOCUS, a 501(c)3 non-profit organization in the United States. PyData provides a forum for the international community of users and developers of data analysis tools to share ideas and learn from each other. The global PyData network promotes discussion of best practices, new approaches, and emerging technologies for data management, processing, analytics, and visualization. PyData communities approach data science using many languages, including (but not limited to) Python, Julia, and R.
PyData conferences aim to be accessible and community-driven, with novice to advanced level presentations. PyData tutorials and talks bring attendees the latest project features along with cutting-edge use cases.
00:00 Welcome!
00:10 Help us add time stamps or captions to this video! See the description for details.
Want to help add timestamps to our YouTube videos to help with discoverability? Find out more here: https://github.com/numfocus/YouTubeVideoTimestamps
A
A
What
I'm
gonna
show
you
today,
it's
the
work
of
the
Jinky
methodology
seal
with
maintaining
and
the
pepper
mill
repo
that
maybe
you
might
be
aware
of
if
you
work
with
Jupiter
networks
and
Orchestra
Jupiter
notebooks,
so
we're
gonna
showcase
the
work
we
have
done
and
what
we
have
done
in
the
open
source
repo
as
well,
which
will
help
you
to
replicate
that
walkthrough
for
95
of
what
we're
gonna
showcase
and
five
percentages
using
our
UI
to
render
the
The
Notebook.
So
we're
gonna,
see
in
the
tutorials.
A
But
the
part
of
the
workflow
and
the
use
of
the
SDK
is
completely
open
source
engine.
You
can
Revenue
through
how
to
set
that
up
as
well
and
understand
each
step
of
what
happens
so
we're
gonna
just
have
two
or
three
slides
to
set
the
context,
but
really
jump
into
the
work.
The
workshop
as
fast
as
we
can
and
have
a
long
session
of
creating
after
questions
I
think
that's
the
best
setup.
A
A
You
have
errors,
basically
adjustment
to
debug,
and
it
can
be
very
comparison
to
debug
the
sellers
and
to
lose
time
to
have
to
re-run
your
entire
workflow,
also
quality,
to
meet
the
deadline
to
produce
a
report
or
a
dashboard,
or
someone
is
now
stuck
because
they
don't
have
the
dependency
that
they
need
for
their
own
kind
of
maybe
add
doc
analysis
or
their
own
workflow.
That
relies
on
your
on
your
on
yours.
A
So
what
we
focused
on
is
really
trying
to
think
about
That's,
a
classic
experience
that
much
usually
give
a
talk
about
when
you
demonstrate
at
Netflix,
they're,
they're,
very
difficult,
workflows
to
maintain
and
very
conversant
or
you
want
to
produce
data
that
can
be
surfacing.
Your
solution
such
as
Tableau,
you
have
so
many
technologies
that
are
involved,
and
so
many
people
want
to
maintain
this
different
parts.
A
What
we're
going
to
use
today
we're
going
to
use
gitbot,
it's
optional,
you
can
use
it
or
you
don't
have
to
use
it,
but
it's
an
easy
way
of
watching
me
to
Showcase
how
to
do
the
setup
you're
going
to
use
Daxter.
We
can
use
paper
mill,
paper,
mill,
origami
and
norigami
and
pepper
Milo,
yummy
and
origami
are
the
the
work
we
mainly
did
to
enable
the
workshop
today
and
the
collaboration
with
Jamie
here
from
naxter.
A
A
This
is
overview
of
overall
commercial
architecture
of
notable
and
Daxter
and
how
they
communicate
with
each
other
again.
Just
to
show
you
the
slide
we
can,
we
can
go
back
to
it
in
the
Q
a
but,
for
instance,
to
give
you
the
review
before
we
dive
deep
into
it.
You're
gonna
rely
on
an
API
keyboard
tracks,
version
of
a
notebook
that
is
associated
with
a
version
setup
dependency
which
we're
gonna,
be
here,
the
AdWords
image
and
the
project
files.
C
B
D
B
Doing
like
a
little
like
design
process,
we'll
kind
of
go
through
what
a
data
pipeline
is
and
we'll
go
through
designing
the
data
pipeline
that
we're
going
to
implement
and
that'll
provide
kind
of,
like
a
nice
framework
for
learning
about
two
different
paradigms
of
data
pipelines.
The
task
focused
data
Pipeline
and
the
asset
Focus
data.
B
And
then
we'll
just
kind
of
go
into
like
what
is
dagster.
How
does
that
fit
into
everything
and
we'll
learn
all
of
the
dagster
apis
and
Concepts?
That
will
be
needed,
so
we
can
just
start
off
by
defining
like
what
a
data
pipeline
is
in
Broad
terms.
So
a
data
pipeline
is
just
a
series
of
computations
that
result
in
some
deliverables
or
data
assets,
and
a
data
asset
can
be
a
lot
of
things.
It
could
be
a
table
in
a
database,
an
ml
model,
some
kind
of
like
report
you
distribute
to
people.
B
D
D
B
So,
let's
start
applying
what
we're
going
to
do
today
to
this
ETL
Ife.
So
the
first
thing
we'll
need
to
do
is
actually
like
fetch
our
Iris
data
set
and
or
something
like
this.
We
could
either
write
custom,
API,
I
called
ourselves
or
we
could
use
the
light
air
bike,
which
does
data
ingestion
without
you
having
and
for
the
sake
of
making
this
kind
of
data
pipeline
exploration
and
design
phase
a
little
more
like
the
real
world.
D
B
C
B
B
B
We
get
a
request
to
analyze,
daffodils
too,
so
we'll
add
more
code
to
the
stuff
that
purchase
the
data
or
code
to
the
step
that
does
informations
and
we'll
end
up
with
some
daffodil
data
in
our
snowflake
database
and
then
maybe
after
that,
we
get
a
request
to
analyze
roses
too.
So
we'll
go
through
that
same
process
and
add
the
rose
data.
B
D
B
B
E
B
B
D
B
So,
let's
just
do
a
quick
like
visual
comparison
between
these
two
pipelines,
there's
quite
a
bit
going
on
on
this
slide,
don't
feel
like
you
need
to
parse
all
of
it.
The
main
point
is
to
just
demonstrate
that
when
we
model
our
data
pipeline
based
on
tasks,
we
end
up
with
something
that
looks
very
different
from
when
we
model
our
pipeline
based
on
the
data
assets.
B
So
there
are
some
situations
where,
like
coach
makes
more
sense
or
it's
like
the
correct
design
decision,
but
a
doctor,
we
think
the
majority
of
data
pipelines
should
really
be
asset
focused
again.
You
know
we
sort
of
think
about
it,
like
the
point
of
your
data
pipeline
is
to
produce
this
data
and
understand
what
data
you
have
available
and
so.
B
So
when
you
want
to
add
some
new
data,
you
have
to
go
back
into
your
pipeline,
potentially
relearn.
What
it's
doing!
If
you
forgot
last
time,
you
did
some
work
before
you
can
actually
start
doing
your
job,
and
so
there's
like
some
time,
loss
there
and
just
general,
like
inability
to
like
easily
parse
and
understand.
B
Okay,
so
how
does
Dexter
fit
into
all
of
this?
So
Dexter
provides
a
framework
for
building
and
executing
this
asset.
Focused
data
Pipelines
Daxter
additionally,
does
support
task
based
data
pipelines
or,
like
other
workflows,
since
there
are
like
cases
where
those
are
needed,
but,
like
I
mentioned
before
we
sort
of
think
asset
Focus
data
pipeline.
B
C
B
B
So
the
most
important
thing
is
the
soft
set
and
dagster
we
Define
a
software-defined,
as
software
declaration
expected
to
exist,
so
just
to
remind
everyone,
a
data
asset,
a
lot
of
things,
tables
and
databases,
ml
models,
files
somewhere
in
storage
or
like
a
Jupiter
notebook,
and
when
you
go
to
write
a
software-defined
asset
in
dagster,
you
need
a
combination
of
like
three
different
things.
So
the
first
thing
you'll
need
is
the
name
of
the
asset.
So
here
we
have
the
name
of
our
assets.
It's
like
Iris
beta.
B
You
use
this
little
asset,
decorator
indexer,
to
like
held
accessories,
that
you're
writing
an
asset,
and
then
you
will
also
specify
the
names
of
any
Upstream
assets
that
it
depends
on.
So
in
this
case,
we've
created
a
dependency
which
brought
Iris
acid
data
asset
and
then
passing
it
as
a
dependency
kind
of
behind
the
scenes.
Diagster
can
do
matching
between
the
asset
name
and
the
parameters
that
other
assets.
B
B
So
the
first
thing
doctor's
going
to
do
is
raw
Irish
data
doesn't
have
any
Upstream.
It
doesn't
need
any
parameters,
so
we'll
execute
that
first,
so
I'm
going
to
run
Candace
call
return
the
value
and
then
save
that
value
in
a
persistent
location
by
default.
That's
your
local
file
system
that
you
can
set
it
up
to
be
like
ECS
or
sorry,
not
ECS,
s30
or
GCS
or
snowflake
or
all
depends
on
other
locations.
B
So
there's
no
more
like
going
into
some
bucket
of
files
and
trying
to
parse,
like
which
one
has
the
most
recent
data
data
and
then
another
benefit
of
this
is
that
we
can
also
tell
daxer
to
just
materialize
one
asset.
So
if
we
only
wanted
to
re-materialize
the
iris
beta
asset,
what
Dax
was
going
to
do
fetch
the
data
that
we've
previously
stored,
Iris
data
asset
and
then
use
that
data
in
our
function
store
the
output
again.
B
B
Work
in
your
Jupiter
notebook
and
having
to
like
copy
paste
that
into
python
functions,
you
can
just
run
the
Jupiter
notebook
as
part
of
your
data
pipeline,
and
then
you
can
also
just
like
connect
your
Jupiter
notebook
to
assets
that
are
already
in
your
pipeline.
So
you
don't
have
to
like
rewrite
like
the
fetching
or
like
data
loading
logic.
B
B
All
right
so,
like
I,
mentioned
we're
going
to
be
going
through
this
process
of
productionizing
a
future
notebook
as
part
of
our
data
pipeline
and,
more
specifically,
we're
going
to
be
doing
like
a
simplified
version
of
the
data
pipeline.
We
just
designed
design
so
we'll
only
be
creating
two
assets,
one
for
our
jupyter
notebook
and
one
for
the
iris
data
set
since
we're
working
directly
with
like
the
canonical
Iris
data.
We
just
need
to
fetch
that
data.
We
don't
need
to
do
any
like
so
that
kind
of
Skips
that
middle
step.
B
So
for
each
step
in
the
workshop,
basically
I'll
talk
through
what
we're
going
to
do.
I'll
demo
it
up
here
on
my
computer
and
then
I'll
go
back
to
a
slide
that
has
like
all
the
steps
you'll
need
to
complete
and
we
can
wait
like
three
to
five
minutes
kind
of
depending
I.
Don't
know
how
much
we're
doing
because
of
that
stuff
and
get
everyone
speed
if
you
run
into
any
issues,
just
feel
free
to
call
me
over
here
or
babies
right
there
and
we
all
sorted
out.
B
B
The
kind
of
person
who
just
wants
to
like
listen
still
wants
to
see
the
final
version
of
the
code
and
maybe
play
around
with
it
a
little
bit
you'll
be
able
to
do
that
all
right,
so
we
should
get
ourselves
set
up
with
virtual
environments,
so
we
don't
have
any
like
dependency
conflicts
or
run
into
like
I.
Don't
know
Annoying
like
python
package
issues,
so
to
do
that
I'll
be
using
the
tool
called
git
pod.
B
E
E
B
E
B
E
E
E
B
C
B
The
finished
folder
is
where
you'll
find
like
the
completed
version
of
this
project.
So
if
you
want
to
get
like
that
preview
into
what
we'll
be
doing
or
just
kind
of
see
the
final
version
of
code,
that's
where
you'll
go.
We
have
the
readme
here
that
has
all
of
the
steps.
If
you
want
to
just
like
follow
along
with
them.
There.
B
B
You
should
see
a
bunch
of
commented
out
code
and
that's
because
we're
not
going
to
be
doing
a
bunch
of
like
code
scratch.
It
falls
presenting
code
up
here
and
then
you
have
a
type
of
type.
So
instead
we're
just
gonna
be
like
uncommenting
code,
Snippets
and
I'll
be
walking
through
what
they
all
do.
So
you'll
still
get
like
a
good
understanding
of
what's
going
on
yeah,
so
you
can
get
both
of
those
files
opened
up.
B
Imagine
opening
those
won't
take
very
long,
so
I'm
just
gonna
hop
on
to
the
next
thing,
which
is
basically
I'm,
just
kind
of
like
walk
through
Jupiter,
because,
additionally,
We're
not
gonna,
be
doing
a
ton
of
work
so
kind
of,
like
I
mentioned
before
we're
just
doing
some
like
analysis
of
the
classic
Iris
data
set.
If
you're
familiar
with
the
irises
that
you
know
already
familiar
with
the
type
of
analysis
we're
doing
in
here,
but
basically
fetch
the
data
set.
B
B
C
B
B
Okay,
so
that's
our
notebook.
Let's
get
into
writing
some
actual
code,
so
we're
gonna
go
back
to
this
edit
file
that
was
in
the
assets
folder
again,
you
should
see
this
little
comment
at
the
top,
so
you're
going
you're
in
the
right
place
and
the
first
thing
we're
going
to
do
is
scroll
down
a
bit
to
where
there
is
a
two
one
con
and
all
we're
going
to
do
is
uncomment.
B
It
more
like
that
you
might
expect
to
see
a
block
of
code
like
this,
where
we
find
the
name
of
the
asset
we
give
it
that
asset
asset,
you
execute
a
bunch
of
code
in
the
function
and
we
return
our
execute
it.
The
problem
with
this
is
that
actually
executing
the
notebook
is
quite
complicated.
There's
a
lot
of
work
to
be
done,
and
so
we
created
this
helper
function
to
find
the
external
asset
to
do
it
all
for
you.
So
what
this
function
is
doing
notebook
you
want
to
execute
the
name.
B
You
want
to
give
your
asset
and
a
couple
other
parameters
we'll
talk
about
in
a
second
and
it
you
know,
creates
this
asset
and
returns.
It
I'll
leave
this
copied
up
here,
just
to
find
the
external
asset
function,
so
yeah,
the
one
parameter
so
far
that
I
haven't
talked
about
is
this
group
name,
and
this
is
just
sort
of
like
an
organizational
feature
when
we
get
into
dag
it
all,
show
it
a
little
more,
but
it
just
lets
you
group
different
assets
together,
like
these
assets,
are
related
to
each
to
each
other.
B
B
B
B
And
then
hit
enter
if
you're
using
gitpod,
it's
going
to
pop
up
this
little
dialogue
about
opening
Port
3000,
and
then
there
will
be
an
open
browser
button.
You
can
click
that,
if
you're
working
more
locally,
it
prints
out
this
blog
statement
saying
serving
app
for
three
thousand
eight
and
you
just
navigate
there
in
your
browser
to
open.
E
B
Thank
you
all
right,
so
this
is
kind
of
like
your
landing
page
for
diet.
This
is
kind
of
what
we
call
the
timeline
view.
It
will
show
you
sort
of
like
the
historical
runs
of
any
like
asset,
materialized
or
any
like
cat
based
work.
You've
done
and
show
you
whether
it's
like
succeeded
or
failed
since
we
haven't
run
anything
yet.
This
is
totally
empty.
So
if
we
go
up
here
to
this
kind
of
left,
hamburger
menu,
button
or
hamburger
menu
button
in
the
top
left
and.
C
B
B
D
B
B
Click
on
that
we
get
to
this
sort
of
asset
for
attribute
and
we
can
see
all
the
assets
that
are
parked
right
now.
We
just
have
so
from
here
click
on
this
asset
and
get
this
little
right
side
menu
after
we've
materialized
it.
This
will
be
populated
with
some
more
metadata
that
we
might
find
interesting.
C
B
So
to
actually
go
ahead
and
materialize
or
execute
this
notebook,
we'll
go
up
here
to
the
materialize
button
and
we
just
click
on
it,
and
then
this
little
alert
will
pop
up
with
a
view
button.
If
this
alert
goes
away
before
you
have
the
chance
to
click
on
it,
you
can
also
click
on
this
little
hash.
That
appears
at
the
bottom.
B
So
yeah
I
missed
it.
So
I'm
gonna
go
over
here,
and
this
will
open
up
a
new
tab
that
contains
all
the
logs
from
executing
your
notebook.
So
we
can
sit
here
and
we
can
kind
of
like
watch
everything
come
in
and
we
can
see
that
our
notebook
executes
successfully
once
we've
done
that
we
can
just
exit
out
of
this
tab
and
a
right
side
panel
for
the
asset
we
get
new
metadata
entries
and
we
actually
get
a
metadata
entry
for
click
that
button
and
The
Notebook
is
actually
and
the
reason
we
can
do.
B
That
is
because,
like
behind
the
scenes,
when
Daxter
is
executing
your
notebook,
it
isn't
like
overwriting
the
source
notebook
that
we
wrote,
It's
like
executing
that
notebook
with
paper
mill
and
then
writing
that
executed.
Notebook
to
a
new
location,
so
you
can
use
the
executed
version
of
your
notebook
and
then
still
go.
Look
at.
B
For
a
couple
of
reasons,
the
first
one
is
that
by
kind
of
like
refactoring,
the
Irish
data
set
out
of
the
notebook
it'll.
Let
us
reuse
it
in
like
future
analysis.
So
if
later
we
come
in
and
we
want
to
do-
you
know
make
a
second
notebook.
That
does
other
analysis.
We
can
reuse
that
same
Iris
asset
and
we
don't
have
to
like
rewrite
our
data
affection
logic,
and
the
second
reason
is
that
it'll
allow
us
to
use
some
of
dagsters
like
built-in
functionality
around
like
re-materializing
assets.
B
So,
let's
go
through
the
process
of
making
an
asset
for
our
Iris
data
set
and
getting
it
set
up
as
like
an
upstream
dependency
for
our
notebook.
So
to
do
that,
we're
back
in
the
init
file,
an
assets
folder
and
we're
going
to
scroll
it
to
the
top.
Where
there's
this
due
to
label
and
we're
just
going
to
uncomment
this
code
block
here
and
what's
going
on
here,
looks
a
lot
more
like
the
asset
declaration
that
we
went
over
in
the
presentation.
B
B
All
right
and
then
the
next
thing
we
need
to
do
is
actually
tell
dagster
to
use
the
iris
data
set
asset
as
input
to
our
Jupiter
notebook,
and
so,
if
you
scroll
down,
that's
where
this
ends
parameter
comes
we'll
uncomment.
This
line
and
what's
Happening
Here
is
based
space
when
Daxter
goes
to
materialize.
All
these
things
and
it's
going
to
say,
oh
I-
need
to
provide
an
input
variable
named
Iris
and.
B
B
So
the
last
thing
we
need
to
do
before
we
can
get
back
to
materializing.
This
is
update
our
jupyter
notebook
to
accept
like
an
injected
parameter
from
the
actual.
So
again,
behind
the
scenes.
Bagster
is
using
Paper,
Mill
and
paper
mill
allows
you
to
inject
external
values
into
your
tubes
and
the
way
paper
mill
does,
that
is
by
looking
for
cell
a
cell
with
the
tag
parameters
on
it.
B
It
deletes
that
cell
and
then
replaces
it
with
a
cell
that
injects
the
parameter,
and
so
what
we
want
to
do
is
instead
of
fetching
the
iris
data
set
in
our
notebook.
We
want
paper
mill
to
delete
that
cell
and
inject
a
new
cell
that
will
load
the
value
of
our
Iris
creative
set
asset
that
we
already
material.
B
So
typically,
what
you
would
do
is
you
would
go
into
your
Jupiter
notebook
editor.
You
would
just
add
a
parameter,
but
the
git
pod
editor
doesn't
let
you
add
cell
tags.
So
we
have
a
chat
or
a
cell
here
that
we've
already
tagged
with
parameters,
and
so
we're
just
going
to
cut
the
code
from
the
cell
and
put
it
in
this
cell.
D
B
B
B
B
B
B
B
All
right
here
we
go
so
our
notebook
has
executed
successfully.
If
we
go
back
here
and
we
click
on
the
executed
notebook
notebook
button,
we
can
actually
see
the
cell
that
tags
are
injected.
You
don't
need
to
understand.
What's
going
on
here,
it's
like
dragster
internal
implementation,
stuff,
basically
we're
loading
a
parameter,
Iris
and
Daxter
knows
that
that
means
it's.
The
IRS
data
set.
E
B
Cool
all
right,
so,
let's
just
like
quickly
take
a
look
at
what
we've
done
here.
We've,
basically
designed
our
data
pipeline.
We
have
our
Iris
data
set
asset
and
we're
using
that
as
input
for
inputer
Notebook
and
we're
materializing
both
of
those
and
getting
our
executed
notebook
assets
that
share
around
to
anymore.
B
C
E
B
B
Need
to
do
before
we
can
materializing
like
the
first
one
is
we
actually
need
to
get
our
notebook
notable.
So
if
you're
working
locally,
you
already
have
your
notebook
on
your
computer,
but
if
you're
in
get
pod
will
need
to
actually
like
download
The
Notebook.
So
to
do
that,
you
can
just
find
our
notebook
in
the
left
sidebar
and
if
we
right
click
on
it,
we'll
get
this
download
button.
B
When
you
open
up
notable,
you
should
have
this
sort
of
like
space
that
you
land
in.
If
you
aren't
there,
you
put
the
notable
icon
in
the
top
left
and
it'll,
bring
you
back
to
that
space
kind
of
the
default
project
that
should
be
made
for
you
is
called
my
first
project,
so
we
can
click
into
that
and
then
click
the.
B
E
B
B
D
D
D
E
E
B
Let's
move
on
okay,
so
yeah,
so
we
need
to
get
a
dragster
asset
set
up.
That
will
actually
like
execute
this
notable
notebook,
so
we'll
go
back
to
gitpod,
go
back
to
our
init
file,
where
we
find
all
of
our
other
assets
and
down
at
the
bottom.
We've
got
some
more
code
for
you
to
uncomment
and
this
time
we're
using
the
paper
mill,
origami
library,
with
The
Bagster
integration,
a
notable
like
that
Jurassic.
So
this
looks
really
similar
to
the
diagonal
asset
we
planned
before.
We
just
give
it
the
name.
B
E
B
B
Okay,
go
back
to
tag
it
again.
We
want
to
hit
the
reload
definitions
button,
so
we
can
reload
all
of
our
assets
and
we'll
see
our
notable
asset
pop
up
down
here.
So
we
want
to
materialize
the
iris
data
set
asset
and
the
kidneys
notable
notebook
asset.
So
to
do
that,
we
can
hold
down
the
shift
key
and
click
on
both
of
them,
and
then
the
materialize
selected
button
will
just
materialize
the
choosing.
D
B
Our
notebook
starts,
execute
execution,
get
a
link,
a
notable
notebook
to
watch
the
activation
happens
so
kind
of
behind
the
scenes.
Notable
similar
to
Dexter
is
like
making
a
book
and
then
executing
that.
So
you
retain
like
a
version
of
The
Source
notebook
that
you
can
go
in
and
edit
and
change
the
historical
executed.
D
B
B
E
D
B
B
So
we'll
wait
for
that
to
fail
and
then
we'll
kind
of
like
investigate
like
what
that
debugging
Globe
looks
like
so
maybe
a
more
like
real
world
example
of
this
is
like
you
might
have
this
notebook
executing
on
a
schedule
like
built-in
like
schedule
functionality.
So
maybe
you
have
this
set
up
to
run
yeah
every
hour,
every
once
a
day
or
whatever
and.
D
B
B
Yeah
and
that's
like
basically
all
we're
doing
in
the
workshop
okay,
so
we
can.
In
the
last,
like
a
couple
of
minutes,
we
had
left
what
questions
you
guys
have
and
since
we
don't
have
that
much
time,
you
have
any
like
all
feel
free
to
email
me,
freaking,
email,
Dave
or
if
you
want
to
join
the
Dr
Slack
Channel.
You
can
ask
questions
there
as.
E
B
A
B
No,
you
definitely
could
do
your
like
iterate
a
lot
of
like
your
initial,
like
development
and
duration
in
the
notebook,
like
the
whole
point.
Is
that,
like
you,
could
do
a
lot
of
your
development
in
The
Notebook,
and
then
you
set
that
into
the
factory
pipeline.
You
might
do
that
like
a
little
refactor
step.
B
A
B
B
B
You
give
it
some
values
of
like
how
often
you
want
it
to
run,
and
then
you
just
basically
like
tell
it
what
assets
you
want
to
materialize
or
like
what
other
like
tasks
you
want
to
kick
off
and
then
that
becomes
part
of
your
like
Bagster,
like
project
or
repository
this
like
collection
of
objects
and
then
in
the
did,
I
get
UI.
There's
like
a.