►
From YouTube: Feb 3, 2022 - Ortelius Architecture
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Okay,
so
actually
a
lot
has
happened
in
the
last
a
couple
weeks,
so
the
I've
had
a
couple
discussions
with
utkarsh
about
doing
a
3d
graph.
Let
me
show
you
what
we're
and,
if
anybody's
interested
in
helping
him
out,
let
me
know,
and
we
can
get
you
hooked
up
with
that
part
of
it.
It's
going
to
be,
there's
going
to
be
a
front
end
piece
and
a
back
end
piece,
so
we're
actually
going
to
implement
this
3d
graphing.
A
So
what
we're
going
to
do
here
is
across
one
access
is
going
to
be
your
application
versions,
and
then
the
the
vertical
axis
will
be.
The
number
of
component
revisions
like
this
green
column
here
will
be
like
the
shopping
cart
service
and
then
the
next
row
would
be
like
the
red
ones
would
be
the
payment
service
and
what
we'll
do
is
so
each
column.
A
Each
row
here
will
be
a
service
and
how
many
versions
of
that
service
over
time
as
we
go
through
the
deployments
process,
and
then
each
one
will
have
its
own.
Each
component
version
will
have
its
own
row
as
part
of
that
process,
so
what
it
will
show
us
is,
if
you
look
at
it
kind
of
like
from
this
point
of
view,
is
which
services
are
changing
and
which
ones
aren't
changing
as
part
of
your
progression
through
time
for
how
things
are
changing.
A
So
what
we're
going
to
need
to
do
is
the
the
front
end
for
doing
with
the
layout
here,
as
well
as
a
new
back-end
microservice
in
python,
so
to
grab
the
data
if
you're
interested,
let
me
know
and
I'll
get
you
hooked
up,
and
I
can
dive
into
deeper
on
that
front.
So
that's
going
to
be
happening,
we
do
have
the
hierarchical
edge
bundle
that
is
kind
of
in
place.
We're
just
going
to
need
to
get
some
data
into
it.
So
we
can
kind
of
show
the
nice
story
at
this
level.
A
What
this
one
is
is
the
ability
to
show
relationships,
a
lot
of
relationships
between
the
different
services,
so
this
is
this
is
showing
the
relationships
between
all
of
java
classes
and
how
one
one
class
calls
a
method
in
another
class.
So
this
will
map
out
the
same
way
with
with
services,
and
this
will
will
render
at
the
application
version
level
as
well.
So
that's
that's
when
that
one's
in
place,
but
we
need
to
get
some
good
data
behind
it.
A
On
that
aspect,
other
things
that
I've
in
the
last
couple
weeks
is
there's
another
open
source
project
called
cubesec.io
that
they
will
go
out
and
scan
a
kubernetes
cluster
and
tell
you
where
all
your
vulnerabilities
are
they'll.
Do
it
at
all
different
levels
and
on
that
front
they
have
a.
A
A
way
to
scan
the
cluster
and
kick
out
a
json
file
that
we
can
actually
bring
in
at
that
level.
So
that
may
be
something
that
we
want
to
look
at
as
well,
and
this
will
allow
us
to
mirror
up
data
from
running
environments
to
the
microservices
and
the
application
that
are
in
those
environments,
and
some
of
the
things
like
that'll
find
is
whether
you
have
like
a
rooted
container.
A
You
know,
so
you
have
a
security
vulnerability
in
a
container
that
you're
running
maybe
has
some
r
back
messed
up
for
a
particular
pod,
or
something
like
that.
So
that's
something
that
we
can
actually
look
at.
There's
a
lot
of
data
there
that
we
may
need
to
do
some
investigation
on
and
how
which
which
pieces
we
want
to
pull
out
of
there
same
thing
with
aspen
rash.
A
I've
been
talking
to
them
this
past
couple
weeks
and
they're,
basically,
a
commercial
version
of
istio,
and
with
that
they
are,
they
can
report
on
the
security
and
the
routes
so
chrome.
This
is.
This
is
a
similar
to
the
open
telemetry
that
you
looked
at,
that
we
could
probably
start
looking
at
a
way
to
start
bringing
in
that
that
telemetry
data
as
well
another
one
that
folks
are
looking
for
is
kind
of
value
stream.
A
And
like
number
of
deployments.
A
If
I
can
type
here
those
types
of
value
stream
data,
you
know
number
of
rollbacks.
A
That
type
of
value
stream,
a
lot
of
it's
gonna,
come
from
a
mix
between
the
git
what's
coming
out
of
the
development
side
and
where
it's
being
hit
on
the
deployment
side,
so
kind
of
matching
up
the
data
on
that
front.
If
anybody
wants
like
a
little
simple
project,
what
we
need
is
the
the
we
need
to
get
connect
the
git
command,
to
figure
out
the
timestamp
for
a
commit.
A
So
if
anybody
has
any
time
to
poke
around
with
git
commands
so
given
any
commit,
we
basically
need
to
know
what
the
the
the
time
stamp
is
for
that
commit
as
part
of
that
process.
Again
we
have
the
cookie
cutter.
This
is
kind
of
the
front
end
of
the
services.
A
When
some
we
can
have
somebody
register
a
service
and
then,
in
the
background
we
go
out
and
create
the
jenkins
temp
jenkins
files
to
get
repo
kind
of
helping
onboard
projects
into
into
a
new
microservice
world,
and
then
there's
one
other
thing
on
the
data
I'll
think
of
it
here,
oh
we'll
get
to
that.
We
need
to
work
on
the
the
dashboard
or
our
reporting
for
this
data.
B
A
To
be
working
with
sergio
to
clean
up
the
issues
and
get
that
kind
of
going,
and
also
last
time
we
talked
about
the
code
pairing
sessions,
I
did
talk
to
brad
mccoy
down
in
australia
with
that
working
group
and
they're
on
board
as
well
to
start
doing.
Those
first
thing
we
need
to
do
is
get
the
issues
cleaned
up
and
then
go
ahead
and
start
tackling
the
co
co-coding
pairing
sessions,
and
then
we
have
some
testing.
A
Oh
so
this
is
our
test.
Cases
were
written
in
java,
so,
if
you're
interested
in
in
helping
automate
the
test
cases,
you
can
work
work
with
boujara
and
he
can
get
you
going
on
that
front
on
how
to
set
up
the
automated
testing.
A
So
that's
kind
of
what
I
had
on
the
the
list.
Let
me
bring
up
the.
A
A
So
one
of
the
things
that
we
have
is
like
the
value
stream,
so
the
value
stream
we
kind
of
want
to
show
like
a
compliance
score
card
of
you
know
where
things
are
at
the
from
a
compliance
perspective
for
an
application.
So
what
I
was
kind
of
thinking
was
right.
Now
we
have
kind
of
like
a
a
list
view
of
the
oh.
I
know
why
that's
because
I
logged
in
the
wrong
id,
so
we
have
all
the
you
know
the
version,
the
the
domain.
A
You
know
all
that
information
and
what
I'm
thinking
for
like
a
value
stream,
because
the
value
stream
is
going
to
be
kind
of
this
is
where
it
gets
hard
because
tied
to
an
application
based
version
and
not
necessarily
like
an
application
version,
so
things
like
the
the
hierarchical
edge
bundle
would
be
viewed
over
for
a
particular
version
of
a
mic
of
an
application.
A
But
things
like
the
3d
chart,
the
value
stream
data.
You
know
the
compliance
scorecard
is
going
to
be
at
the
application
based
version.
As
part
of
that,
so
I'm
not
sure
if
we
should
do
a
reporting
tab
over
here
or
if
we
just
rework
and
add
like
in
a
new
menu
item
here,
to
kind
of
change.
The
view
to
give
that
that
data
like
when
we
bring
up
this.
A
This
data
will
be
launched
into
a
new
page
as
as
part
of
the
implementation.
So
we're
not
going
to
embed
it
into
here.
So
just
want
to
get
everybody's
thoughts
on
that
some
ideas
and
how
we
can
kind
of
navigate
to
this.
In
the
this
data
that
we're
starting
to
gather
and
then,
of
course,
we'll
have
we'll
have
arvin's
ml
and
his
data
coming
in
as
well.
That
will
be
at
a
higher
level
when
we
start
looking
at
that
and
that'll
probably
be
at
a
application.
A
So
they're,
just
bringing
up
the
speed
ukarsh
is
going
to
start
working
on
our
3d
graph.
So
what
this
will
be
is
given
application
based
version.
A
B
A
Where
the
shipping
is
getting
updated,
all
the
time.
A
A
A
Oh
cool:
did
you
ping
it
in
a
discord
or.
A
Okay,
let
me
let
me
grab
it
real,
quick
before
I
lose
it
right.
D
A
B
So
I
guess
the
question
is
so
I
think
that,
for
example,
on
that
graph,
that
you
just
showed,
that
has
to
do
with
components
right
and
the
changes
in
components.
A
This
graph
is
going
to
be.
You
can
kind
of
envision
this
from
looking
at
an
application
in
whole,
so
not
just
the.
B
A
B
Why
would
we
go
if
we're
looking
at
the
application
at
the
hole?
Wouldn't
we
keep
it
for
every
we'd
have
to
keep
it
for
every
version
of
the
application
right.
A
Because
each
one
of
these
is
going
to
be
the
way
you
calculate
the
differences
is
based
on
the
comparing
version,
one
of
the
application
to
version
two
version,
two
to
version
three
of
the
application
version.
Four,
you
know
so
that's
where
you
get
your
figure
out
the
differences
in
the
components.
B
Yeah,
so
we
had
a,
I
had
a
question
from
somebody
that
I
was
chatting
with
about
having
so,
for
example,
we
have
all
of
this
listed
in
one
big
list,
and
they
didn't
think
it
was
that
useful.
What
they
thought
was
is
that
they,
you
would
have
just
in
the
list.
You
would
just
have
the
base
component,
and
once
you
went
to
the
base
component,
it
would
have
all
the
information,
including
a
list
within
that
of
the
different
versions
of
the
of
the
component
that
you
could
select
into.
B
So
you
would
have
the
high
level
component
information.
B
B
No,
no,
you
should
you
can
keep
sharing.
I
was
just
gonna,
I
guess
it's
gonna
walk
you
through
what
he
now
this
may
have
been
that
I
was
having.
It
was
the
day
we
were
having
some
trouble
and
I
couldn't
show
him
a
clear
list
of
from
the
component
view.
So
he
wanted
to
go
just
go
to
the
component
and
then
it'll
make
sense
for
an
application.
I
think
all
right.
A
Well,
that's
what
we're
running
into
in
general
is
when
you
start
collecting
this
history,
especially
when
you're
in
a
ci
cd
pipeline.
B
Yeah,
that's
what
he
said.
He
goes.
You're
gonna
have
too
much.
It's
gonna,
there's
too
much
data
in
here
and
that's
why
I
said:
well,
you
can
filter
it.
He
he
suggested
for
usability
that
it
would
be
easier
to
conceptualize
it.
If
you
only
showed
the
base
component
to
select
and
then
once
you
went
into
the
base
component,
you
might
have
a
sub
list
or
you
would
have
so
go
back
to
yeah.
So
what
he
thought
was.
I.
A
B
B
Base
version,
so
he
thought
that
everything
in
the
in
this
list
should
just
be
the
base
version
and
not
the
iterations,
and
then
he
his
point
was,
for
the
most
part.
Isn't
this
all
this
data
redundant
for
each
one,
and
I
said
well,
the
upper
the
the
upper
two
squares
are,
but
not
necessarily
the
readme,
the
swagger
and
all
of
that.
A
Yeah
and
this
will
actually
change
so
if
we
go
into
another
component.
B
Well
anyway,
so
you
thought
we
should
have
stat
anything,
that's
static
or
associated
at
all
of
them
to
be
in
one
area,
and
then
you
could
select
from
a
list
which
version
you
want
to
see
and
it
shows
the
changes.
So
if
we
did
that
we
could
put
any
we.
If
we
did
something
similar
at
the
application
level,
then
we
could
add
the
graph
at
the
common
level.
B
A
But
yeah,
so
it
would
be
mostly
this.
The
full
domain
would
probably
probably
stay
the
same.
A
Number
this
stuff
would
would
be
the
same:
the
name
the
build
id
bureau
container
registry.
The
container
registry
may
be
not
changed,
but
it
has
the
potential
to
change,
but.
A
Right,
but
you
want
to
know
from
if
we,
if
we
switch
from
docker
hub
to
quay
halfway
through
our
components,
it's
not
going
to
be
the
same.
Do
I
mean
you're
not
going
to
go
back
well.
B
You
know
we
got
to
go
to
the
80
20
rule,
that's
if
somebody
switches
containers
at
a
different
version.
What
you're
saying
is
that
it
would
it
would
update
it
for
everything
now
that
container
is
stored
in
quay
instead
of
hub.
A
B
A
B
Anyways
that
was
that
was
his.
That
was
his
suggestion
because
he
felt
that
there
was
a
lot
of
data
on
here
and
he
did.
He
felt
that
there
was
some
that
was
redundant
and
the
other
screen.
He
thought
that
the
list
was
going
to
be
too
big,
so
it
should
just
be
all
of
the
component
all
of
the
base
components,
and
then
you
go
into
the
base
components
and
from
there
you
could
see
you
could
look
at
environments
and
you
could
see
for
that.
B
A
B
And
then
this
brings
me
to
the
other
conversation
that
we've
been
having
with
the
discussion
around
slos,
because
I
think
people
are
going
to
see
slos
based
on
the
higher
order.
The
higher
level
component
we're
going
to
be
they're,
going
to
be
tracking
slos,
not
based
on
every
single
version
of
a
component.
But
the
component.
A
A
A
B
B
B
Yes,
so
what
he
thought
was
at
the
very
top.
You
would
have
everything
common
for
that.
So
it's
really
clean
and
there's
not
a
lot
of
data
on
the
screen
and
underneath
that
that,
underneath
that
the
common
information
you
have
another,
you
have
the
exact
list
that
you
we
just
saw.
That
has
the
environment
the
parrot
all
that
and
it
shows
all
of
the
different
versions
and
then,
when
you
click
on
that
it
populates
the
bottom.
For
that
got
it.
B
A
Okay,
I
think
I
know
what
you're
what
you
mean
that
yeah.
I
think
that
could
work
for
us
to
load
in
more
of
the
high
level
data
to
be
able
to
represent
that.
B
Yeah
when
he
said
you
know
when
he
when
he
brought
it
up,
I
realized
that
that
at
first
I
thought
it
was
more
clicks.
But
after
I,
after
we
I
talked
to
him
about
it
was
like
okay
yeah.
That
does
make
sense
because
he's
like
what,
if
I
just
want
to
go,
look
at
the
swagger
detail
for
one
and
then
go
to
look
at
the
swagger
detail,
the
other.
I
have
to
keep
going
back
out
then
looking
at
the
list,
finding
it
and
then
coming
back
in.
A
Right
now
for
like
a
the
compliance
scorecard
with
that
be,
would
you
want
to
see
a
compliance
scorecard
across
all
applications
at
once,
or
would
it
be
okay
to
go
into
an
application
and
see
the
compliance
scorecard?
I.
A
B
If
so,
it
probably
would
be
something
we
just
want
to
add
to
it.
Maybe
we're
gonna
have
to
start
a
reports
or
something.
B
B
I
know
that
the
texas,
a
g,
wants
something
like
that
that
compliance
scorecard
that
says
how
you
know
how
mature
that
application
is,
but
I
feel
like
right
now
what's
more
important,
is
we
do
something
with
cookie
cutter
so
that
we
can
encourage
the
adoption
yeah.
A
Okay,
because
if
we
do
it
at
the,
if
we
do
the
compliance
scorecard
at
the
individual
application
level,
that
the
idea
that
you're
talking
about
would
actually
work
well
at
that
level,
and
if
we
need
to
roll
up
later
that
we
could
do
that
right,
because
the
other
thing
on
the
roll
up
that
we're
going
to
have
is
rolling
up.
All
the
oh.
This
is
the
other.
Other
thing
that
came
up
is.
A
If
I
don't
know,
if
I
have
it
in
the
data
here,
but
maybe
so
we
did
the
work
around
gathering
the
the
licenses
and
the
cves.
A
So
here
we
have
what
we're
dependent
upon
so
let's
say,
there's
a
vulnerability
and
click,
and
we
want
to
be
able
to
find
all
the
applications
and
microservices
that
are
using
click,
so
we
can
go
fix
them.
How
would
we
want
to
do
that?
Navigation
at
that
level,
because
this
is
like
this
is
like
a
dependency
of
this
is
package
dependencies
of
of
microservice,
so
we
kind
of
need
to
flip
it
totally
upside
down.
B
Yeah,
I
think
that
we're
going
to
get
to
a
point
where
we're
going
to
want
to
have
a
place
for
people
to
generate
reports
where
it's
you
know
they
have
to
enter
their
parameters
and
it's
more
like
a
you
know,
they're
querying
the
database.
B
A
All
right
we'll
have
to
figure
that
part
out
on
as
well,
if
we're
gonna
for
cookie
cutter,
if
we
at
the
component
level,
if
we
have
a
cookie
cutter,
template
drop
down
or
something
or
how
that's
going
to
be
utilized.
A
It's
a
path
it
was
written
in
python,
but
it
spans
across
multiple
languages.
So
the
idea
behind
it
is
to
create
a
template
process
where
you
can
kind
of
go
off
and
do
use
these
templates
to
go.
Do
things
in
the
back.
Let's
do
search
here.
A
Like
if
we
want
to
do
an
android
app
with
maven.
A
Yeah,
oh
sorry,
let's
stop
sharing
where'd.
It
go.
B
A
Yeah,
so
let
me
go
back.
A
So
the
cookie
cutter
templating
project
gives
us
a
way
to
kind
of
take
one
of
these
templates
and
it
will
then
go
ahead
and
like
hear
fast
api
for
what
we
use,
that
it's
going
to
go
ahead
and
if
we
implement
this,
that
template
will,
in
the
background,
go
generate
a
bunch
of
stuff
for
us
and
with
that
it'll
give
us
the
ability
to
help
folks
kind
of
bootstrap
their
projects
as
part
of
that
process.
A
So
this
is
one
of
those
things
that
we
need
to
look
at
to
kind
of.
When
somebody
registers
a
service,
they
can
pick
what
type
or
which
template
they
want
to
use,
and
then
we
go
ahead
and
get
everything
up
and
going
for
them.
A
And
it
looks
like
there's
a
you
know:
it's
gonna
be
just
a
bunch
of
command
line.
You
know,
because
it's
written
in
python,
we'll
just
interact
with
the
the
command
line
grab,
grab
the
information
that
we
need
to
apply
to
the
the
template
and
kind
of
get
going
there.
So
you
can
see
whether,
like
at
this
level,
when
I
create
this
fast
api
template,
am
I
gonna
connect
up
to
get
lab
or
github?
A
Am
I
going
to
be
using
postgres
or
mysql
as
part
of
that
process?
Is
it
going
to
go
out
to
kubernetes
or
not
so
that
kind
of
gives
all
that
that
base
up
and
going
redundant
stuff?
That
needs
to
happen
and
then
we'll
need
to
add
on.
I
think
you
could
probably
combine
a
couple.
A
couple
of
these
to
say
you
want
to
add
in
the
jenkins
pipeline,
for
example,
on
top
of
this.
A
A
If
this
is
a
comparable
to
backstage
that
io,
and
that
may
be
another
way
that
we
may
want
to
look
at
is
backstage.io
is
another
open
source
project
in
the
cncf.
It
came
out
of
spot,
I
think
spotify
and
we
could
leverage
their
templating
as
well.
So
we
don't
have
to
look
at
cookie
cutters
per
se,
but
a
way
to
go
ahead
and
template
and
do
that
information.
A
You
know
that
kind
of
the
onboarding
and
adoption
of
the
of
using
artelias
to
manage
your
services,
because
you
basically
we're
going
to
go
and
ask
them
everything
that
we
need
and
then
once
they
hit.
Okay,
that
we
go
off
in
the
back
end
and
generate
all
the
the
gory
details
that
you
know
the
devops
folks
have
to
set
up
manually.
We
can
do
it
through
these
templating
images
automatically.
A
A
So
if
you
want
to
say,
I
want
a
fast
api,
I
want
to
deploy
to
kubernetes
and
I
want
to
have
a
stackdriver
plus
prometheus
plus
some
cali
going
on
for
monitoring
that
you
can
pick
all
that
in
the
template
and
I'll
take
care
and
and
I'm
gonna
be
using
github
and
jenkins
it'll
go
through
and
piece
together,
these
predefined
pipelines
so
that
you
can
deploy
hello
world.
Your
new,
fast
api
application
out
to
your
cluster
within
a
couple
minutes,
instead
of
waiting
days
for
folks
to
settle
everything
up.
A
So
that's
the
concept
behind
it
being
able
to
onboard
new
services
really
quickly
and
kind
of
hands-free
type
of
mode,
and
I
think
cookie
cutter.
We
can
do
it
with
that.
I
think
I
have
to
look
at
their
templating
library
and,
like
I
said,
we'll,
probably
need
to
have
multiple
templates
being
used
to
get
what
we
want.
As
an
end
result
so
think
about
that
one,
we
need
to
do
some
investigation
on
that.
A
So
what
is
it?
Tracy's
idea
that
and
other
folks
that
she
was
working
with?
Does
that
make
sense
from
kind
of
like
the
navigation
side
of
things
as
the
next
direction.
C
C
C
Right
and
what
we
can
do
is
that,
like
for
the
time
being
like
it's,
what
we
can
do
is
that
if
we
have
the
applications
present
instead
of
showing
that,
on
the
main
application
page
inside
the
base
version,
we
can
show
show
them
as
a
drag
down,
and
in
that
case
we
can
select
the
select
the
which
one
someone
wants
to
see,
and
then
we
can
reload
the
complete
page
for
that.
In
that
case,.
A
C
A
Yeah
and
I
think
from
a
coding
perspective
on
the
the
the
javascript
so
bossam
just
to
let
you
know
the
our
front
end
is
written
in
javascript.
There
is
no
framework
library
that
it's
not
like
a
a
reactor
view
or
anything
like
that.
So
it's
pure
jquery
with
a
bunch
of
javascript.
It's
not
not
the
prettiest
thing
in
the
world,
but
it
gets
us
through
okay,
so
the
guys
that
originally
wrote
it
were
not
ui
guys.
So,
okay.
A
Be
updated,
but
it
it's
one
of
those
that
I
think
the
changes
aren't
going
to
be
that
bad
to
move
stuff
around
to
make
that
to
make
that
happen
sure.
But
if
you're
interested,
I
can
help
set
you
up
and
get
you
going,
we
we
actually
use
for
our
monolith.
We
use
eclipse,
as
the
editor
yeah
is.
Is
that
something
that
you
you
use?
Yes,.
E
Yes,
yes,
I
use
yeah,
intelligent
or
eclipse
both
are
available
for
me.
Okay
well,
but
yeah.
I've
seen
them
yeah
on
the
page.
During
the
deadline,
there
is
like
a
guide
to
to
set
up
eclipse
and
the
environment
in
eclipse.
I
think.
A
Yep
yep,
that
was
there.
Let
me
if,
if
you
go
through
that
and
you
get
hung
up
anywhere,
let
me
know
because
there
may
be
some
little
things-
that
we
need
to
tweak
in
the
documentation
to
clarify
stuff.
A
All
right
everybody,
we
ran
over
a
little
bit.
Thank
you
so
much
some
great
ideas.
Thank
you,
chrome.
For
that
time,
stamp.
I'm
gonna
add
that
in.
C
B
A
It
was
so
if
you're
gonna
measure
the
time
a
developer
makes
a
change
to
the
time
that
it
was
deployed,
which
one
would
you
use
the
the
author
date
or
the
commit
date.
What
like,
what's
the
difference.
C
That
that,
like,
if
like
in
my
current
organization,
I
use
a
direct
commit
so
like
in
that
case,
I
got
the
same
thing
but
like
when
I'm
using
like
when
I'm
going
for
a
pr.
You
should
check
it
out
once.
Okay,
like
it,
is
the
community.
If
the
community
changes,
then
definitely
I
guess,
or
we
can
have
it
look
at
once,
like
one
of
them
repo.
A
A
Think
I
think
when
you
do,
when
you
do
the
pr
you're
gonna
get
a
new
a
new
commit
hash
on
the
merge.
So
I
guess
it
would
be
when
the
pr
was
authored.
Probably
then.
A
Right
either
way
we
have
something
to
show
I'll
I'll.
Add
that
in
so
where
that's
going
to
be
added
in
is
we
have
a
a
python
library
that
fits
into
the
ci
like
into
jenkins
into
the
ci
process
and
that
python
library
is
the
one
that
kind
of
gathers
all
the
information
from
the
from
the
build?
A
So
when
the
build
happens,
we
can
gather
you
know
the
the
git
commit
the
the
like
the
github
url,
the
docker
shot,
the
docker
digest.
All
those
things
are
gathered
by
that
python
library
at
build
time,
so
we'll
modify
that
to
go
ahead
and
grab
the
commit
timestamp.
A
As
part
of
that,
I
have
to
see
what
other
requirements
we
need.
If
we
need
to
gather
anything
else,
I
think
that
may
be
the
only
thing
that
we're
missing
to
start
doing
these
calculations
of
of
things
all
right
cool.
Thank
you
again
and
we'll
talk
to
you
soon.
A
All
right,
we'll
probably
do
the
first
one,
because
what
we
want
to
show
is
is
how
old,
when,
when
a
developer,
actually
made
the
change
and
when
that
change
got
actually
deployed
to
an
environment
so
kind
of
like
when
they
started
working
on
things,
even
though
they
actually
start
coding
before
the
commit.
But
it
gives
you
at
least
a
point
in
time
to
reference.
C
A
Because
you
could,
you
know
a
person
could
work
on
a
an
issue
for
or
make
a
coding
change
that
takes
a
month
and
then
they
make
the
commit,
and
then
the
commit
goes
out
to
production
in
two
hours.
You
know
it's
not
exact
science,
but
it's
one
of
those
that'll
give
us
a
little
bit
better
time,
all
right
cool.
Thank
you.
Delicious.