►
From YouTube: 2021-10-27 meeting
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
A
A
D
Paulo
for
the
agenda
did
we
still
want
to
do
a
walk
through
of
the
integration
test,
ideas
that
we
are
at
least
the
idea
that
new
relic
was
using.
C
I
I
I
think
we
should
do
that
too.
I
I
think
the
issue
that
you
found
that
you
probably
are
not
gonna
solve,
probably.
E
C
But
I
I
think
we
should
discuss
and
bounce
ideas
about
that
about
the
issue
that
found
besides
the
app
you
know
yeah.
So,
let's
give
one
more
minute.
You
usually
start
a
bit
late,
so.
D
Yeah
and
if
raj
was
able
to
to
join,
I
wonder
if
he
would
have
ideas.
C
But
he
was
looking
also
into
that
yeah,
so
yeah,
I
think
I
think
oh
zach
is
here
now
hi
zach.
F
C
I
think
we
should
start
then,
and
let's
start
with
the
thing
that
chris
found.
Basically,
they
change
a
package.
A
nuget
package
remove
a
reference
to
one
of
the
abstract
packs
packages
of
asp.net
core,
and
now
we
fail
to
load
when
we
try
to
put
that
instrumentation.
C
I
think
chris
and-
and
I
try
the
kind
of
simple
stuff
and
at
least
for
me,
nothing
worked.
I
have
to
confess
I
had
a
silly
idea
that
I
think
may
work
about
generate
a
new
get
package
in
the
same
format
as
the
old
one,
including,
but
I
think
that's
kind
of
very,
very
forced
workaround.
You
know
I
didn't
try,
but
it
should
work.
The
previous
package
was
working,
so
if
we
just
wrap
the
package
correctly,
it
should
work.
C
But
it's
interesting
that
this
way
that
the
dependencies
framework
dependencies
are
handled
for
me
is
kind
of
a
little
bit
opaque.
You
know,
okay,
they
are
supposed
to
come
on
the
framework,
but
if
you
have
application,
you
have
to
add
a
specific
hitting
group
item
group
on
the
project
to
kind
of
load
those
reference.
C
So
I
I
was
reading
some
of
the
links
that
you
put
put
decrease
and
there
is
one
thing:
that's
like:
oh
okay,
if
you
have
a
sdk
app
that
you're
building
and
you
want
a
that
reference,
you
wanna,
you
add
a
framework
reference
to
your
project
and
your
project
basically
build
with
a
different
depth
json
but
other
than
that
is
the
same
kind
of
result.
I
think.
D
Yeah
and
then
it
looks
like
there's
also
another
difference
in
way.
I
I
don't
know
that
compiler
is
the
right
term
to
you
to
use
here,
but
those
framework
references
are
treated
very
differently
than
package
references
in
that.
C
Output,
that's
I
I
didn't
test
that,
but
I
was
suspecting.
That
was
the
case,
so
I
think
there
is
some.
If
I
remember
the
expression
for
this
fingering
compiler
is
three
shaking.
I
think
there
is
some
tree
shaking
going
on
there
and
kind
of
we
are
not
using
and
remove
it
right.
So
then
we
we
don't
get
the
thing.
So
a
nuget
package
doesn't
behave
that
way
at
all.
C
You
know
right,
so
it's
very
very
likely
that
this
is
exactly
what's
going
on
and
I'm
open
to
ideas
about
how
we
work
around
this.
You
know.
D
So
I'm
continuing
to
poke
at
different
things
that
that's
kind
of
where
I'm
at
just
poking,
but
almost
flailing
yeah.
C
I
I
I
I
I'm
at
the
same,
I
probably
test
only
basic,
even
basically
stuff
than
what
you
are
trying,
but
yeah.
That's
what
I
tried
some
combinations
of
that
and
I
think
perhaps
the
best
way
you'll
be
to
understand
how
those
framework
dependents
are
really
handled
by
the
the
build
and
the
runtime.
You
know
that
you'll
be
the
best
path,
but
that
that
I
think
we
need
help
from
raj
or
somebody
that
has
the
contacts
to.
F
I'll
just
quickly
say
so.
I
know
that
in
our
datadog
one
we
still
reference
the
abstractions
in
our
own
project.
So
we
still
get
this
on
reference,
even
though
we
don't
actually
ship
the
binaries.
F
F
One,
it
is,
let's
see,
I
think
we.
F
In
okay,
because
we
also
do
mvc,
so
we
pull
in
the
mvc
obstructions,
which
then
I
think
also
in
turn
pulls
in
the
hdp
obstructions.
F
Yeah
and
so
that
that
hasn't
crashed
for
us,
so
it
should
work
for
now.
C
C
Yeah,
so
I
I
think
what
you
said
that
makes
sense,
and
perhaps
is,
is
the
way
to
go.
I.
C
Yeah,
I
I
just
wondering
if
the
fact,
because
I
tried
some
stuff
adding
a
reference
to
just
the
abstractions
in
principle-
should
be
the
same
thing
as
bringing
the
mvc,
but
I
keep
wondering
if
that
makes
something
extra
to
be
different.
You
know
kind
of
bring
something
extra
that
is
needed
and
in
the
first
case
it's
not
there,
but
this
is
definitely
something
that
we
should
try
chris
and
I,
in
our
blind
trials.
F
And
then
another
thing
we
can
do
is
just
duct
type,
all
the
asp.net
core
types.
So
that
way
we
don't
really
care
about
the
abstraction
assembly
or
or
anything
like
that.
Yeah.
D
Yeah
to
do
that,
we'd
have
to
upstream
that
into
the
sdk
project.
D
It
here,
but
also
in
sdk,
so
right
now
we're
loading
the
instrumentation
from
the
sdk,
oh
you're,
yeah,
you're,
right,
you're,
right,
okay,
and
so
that's
kind
of
what
we're
running
into
I
see
so
I
mean
technically
it.
We
could
just
write
our
own
instrumentation
and
use
duct
typing
to
handle
all
of
that.
But
at
this
point
we're
trying
to
leverage
the
sdk
for
consistency.
C
Yeah
and
it
related
to
that
idea
that
I
mentioned
of
wrapping
a
package
that
wraps
the
reference
we
could
wrap
the
the
original
asp.net
core
sdk
sdk
instrumentation,
that
we
have
on
on
their
sdk
ripple
and
do
access
stuff
is,
if
it's
needed
to
avoid
three
shake
and
things
like
this.
You
know
we
can
do
that,
it's
not
pretty,
but
in
theory
it
should
work.
You
know
yeah
until
until
we
test
no
no
nothing's
guaranteed,
but
at
least
in
principle
it
should
work
as
a
as
I
mentioned.
C
Raj
said
that
he's
gonna
also
look
into
that.
I
I
really
hope
that,
because
at
least
for
my
part
and
I
what
I
look,
I
didn't
find
a
a
very
deep
explanation
about
framework
loading
that
framework
reference.
C
I
just
find
hey
if
it's
this
case
use
this,
but
I
didn't
understand
exactly
how
it
works.
How
is
different
you
know,
so
perhaps
with
that
extra
information,
we
can
get
to
kind
of
a
better
perspective
on
exactly
what's
happening.
C
But
for
the
mongol
db
thing
you
you,
if
we
add
the
reference
directing
the
application
for
what's
needed,
it
fixes
right,
yeah,
yeah
yeah,
so
because
that
works
as
new
get
packed
resolution.
So
the
thing
works
as
we
need
it.
But
when
the
reference
is
this
framework
reference,
we
didn't
find
a
way
to
to
make
it
work.
So
even.
C
I
I
just
tested
the
asp.net
core
I
didn't
kind
of
when
that
was
failing.
I
keep
testing
that
I
didn't
try
to
test
what
comes
after.
I
was
kind
of
stuck
on
that
trying
to
fix
that.
So
I
didn't
look
to
what
comes
after.
I
don't
know
if
anybody
else
did
that
yeah.
So
I
think
chris
and
I
were
on
the
same
kind
of
hey.
We
have
this
problem
here
and
we
stuck
on
that
one.
We
didn't
try
to
look
further.
D
I
know
that
when
I
looked
at
the
depths
jason
file,
I
didn't
actually
see
any
reference
in
there
for
whatever
reason:
okay.
C
Yeah,
I
I
think
perhaps
I
need
better
control
on
that,
but
when
I
I
tried
some
different
builds,
I
remember
that
I
got
when
I
include
the
frame
work
reference.
I
get
a
depth
json.
That
has
many
more
things,
but
I
don't
recall
from
the
top
of
my
mind
if
had
that
this
this
please
the
reference
that
we
are
missing.
C
You
know
so
yeah
we
we
can
look
into
that,
but
it
does
change
the
depth.json,
but
I
actually
don't
understand
exactly,
if
just
add
all
the
reference.
If
it
does
add
the
reference
does
a
three
shake
and
then
oh,
this
is
the
set
that
you
need
or
something
like
that.
I
really
don't
know.
D
A
C
Yeah
yeah,
okay,
I
think,
for
now
we
have
a
few
ideas
to
try.
G
Sorry,
but
I
was
a
minute
late,
are
you?
Are
you
talking
specifically
about
single
file
applications.
G
C
D
Okay,
so
what
I'm
doing
is
I'm
just
running
our
proof
of
concept
application
and
when
I
run
the
app
as
it's
trying
to
load
the
asp.net
core
instrumentation,
we
are
running
into
this
file,
not
found
exception
when
trying
to
load
here
it
is
microsoft,
asp.net,
core
http
abstractions
and
it's
a
particular
version
that
is
trying
to
load,
and
so
this
version
is
coming
from
the
framework
reference
used
by
the
instrumentation
assembly.
D
D
And
I
was
just
never
able
to
get
it
to
load.
E
Use
yeah,
so
if
I
pull
that
back
up
so
let's
see.
D
D
D
No,
so
when
a
package
reference
is
used
as
a
dependency
for
something,
then
we're
able
to
add
that
craft
package
reference
to
the
sample
application
to
ensure
that
the
correct
version
of
of
a
dependency
is
going
to
get
loaded
by
the
application.
D
But
what
we're
running
into
is
when
it's
not
a
package
reference
and
you're,
relying
on
a
framework
reference
like
I
have
highlighted
here,
then
we
haven't
figured
out
a
way
to
add
something
to
the
sample
applications
project
file
to
get
the
right
version
of
a
dependency
loaded.
G
C
And
the
three
shaking
mention
came
when
we
are
saying
that
when
you
have
a
package
reference,
even
if
you
don't
actually
reference
the
code,
at
least
when
you
build
and
publish
the
whatever
imported
on
the
package
is
there,
but
with
the
framework
reference,
I
think
chris
did
some
experiment
that
if
he
was
not
referenced,
he
didn't
notice
any
difference.
That's
right.
Chris.
D
I
found
a
reference
to
it
in
stack
overflow,
where
people
were
trying
to
do
something
similar
where
they
had
to
explicitly
use
something
from
that
assembly
in
their
code.
In
order
for
that
dependency
to
ultimately
get
published
with
their
application.
G
So
this
is
not
an
area
that
I'm
an
expert
in
unfortunately,
but
if
you
the
easiest
way
like,
I
can
find
the
right
people
at
microsoft.
The
easiest
way
is,
if
you
send
me
an
email,
that's
how
we
operate
still
and
if
you
write
up
the
problem
and
send
an
email
to
me,
then
I
can
forward
it
to
the
right
people
and
hopefully
we
can
get
somebody
to
weigh
in.
D
Yeah
and
raj
said
that
he
was
also
taking
a
look
at
this
too,
so
that'll
help
as
well.
C
Unless
any
anyone
wants
to
bring
anything
else
to
add
to
our
framework
reference
space,
we
can.
E
So
let
me
know
if
you're
able,
no,
that's
not
what
I
want.
Where
is
it.
D
Okay,
are
you
able
to
see
my
windows
vm
now.
D
I'm
not
sure
if
it's
showing
my
windows
desktop,
you
should
see
visual
studio,
open,
yes,
mistakes,
okay!
Thank
you!
So
last
week
we
talked
about
integration,
test
strategies,
and
so
I
have
a
new
relics.
Integration
test
code
up
to
just
kind
of
give
a
a
walkthrough
of
how
new
relic
is
solving
some
some
of
the
problems
which
we
may
find
useful
or
we
may
not,
and
so
just
to
to
start
things
out
I'll,
probably
show
a
what
we
were
originally
doing
with
the
integration
test.
So
I'll
just
choose.
D
One
of
the
simpler
cases
where
so
we
have
a
test
fixture
and
in
here
we
kind
of
abstract
away
how
we
start
a
process
up.
That
will
then
run
a
test
application.
So
that's
handled
in
this
remote
service
fixtures
that
we
include,
and
so
what
happens
there
is
it
will.
Oh
gosh.
D
D
A
D
Okay,
so
here
what
we
do
is
we
we
end
up
copying,
so
there's
a
publish
step
for
the
application
so
that
it
builds
all
of
the
the
binaries
for
the
test
app
and
then
we
copy
those
binaries
to
some
temporary
location,
as
well
as
the
binaries
from
the
agent
or
tracer,
depending
on
which
terminology
you
want
to
use
to
a
local
folder.
D
So
this
remote
application
start
will
start
the
process.
The
environment
variables
are
in
place
so
that
it'll
be
instrumented.
We
exercise
the
application
and
then
we
should
shut
it
down.
D
But
the
way
that
we
exercise
the
the
application.
D
Yeah,
it's
done
in
the
yeah
a
lot
of
it's
done
in
the
constructor,
and
then
it
just
ensures
that
it
only
runs
once
I
I'm
not
aware
of
the
the
history
for
that,
but
that's
just
how
it
was
decided
to
be
done
so
that
the
process
just
gets
started
when
the
constructor
runs
and
then,
when
any
of
the
facts
get
run.
It's
not
going
to
kick
off
another
process.
D
And
some
of
the
things
are
cached
to
prevent
rerunning
it.
But
I
I
don't
remember
the
deals
I
I
think
that's
kind
of
the
the
less
interesting
part
of
it,
and
so
the
more
interesting
part
will
be
the
the
way
the
actions
are
are
managed.
So
I
guess
this
one's
less
interesting
in.
E
E
E
E
D
Okay,
anyways,
usually
what
happens
is
in
here
there's
another
method
that
we
pass
in,
that
defines
the
actions
to
execute
and
then
those
actions
to
execute.
That's
where
we
actually
go
and
make
http
calls
out
to
the
running
application
locally.
D
But
one
of
the
things
that
we
kept
running
into
is
that,
as
you
have
new
libraries,
that
you
want
to
test
whether
it's
a
new
database
or
different
versions
of
the
same
database,
we
had
to
keep
creating
new
test
applications
and
there
was
just
a
lot
of
boilerplate
code
that
kept
getting
added
to
the
repository
and
kept
having
to
be
maintained.
D
D
That
are
going
to
be
more
focused
to
just
contain
the
things
that
we
we
want
to
test,
and
so
this
api
calls
test
is
one
of
those
and
so
the
way
we're
handling
that
is.
D
Console
multi-function
test
application
and
we
can
queue
up
a
series
of
commands
and
these
commands
get
sent
to
the
test
application
via
standard
input,
so
they're
just
strings
and
the
test
application
can
parse
those
strings
to
determine
okay.
What
test
library
do
I
need
to
load
and
what
method
and
class
in
the
test
library
should
I
execute
to
handle
this
command,
and
so
this
is
an
example
of
one
of
those
test,
libraries,
so
in
the
command.
We
simply
say
that,
okay,
we
want
to
run
the
api,
calls
dot,
trace,
metadata.
D
So
then,
in
this
method,
we
define
the
things
that
the
logic
that
we
want
executed
in
the
test
application
in
this
case,
since
this
is
an
api
test,
we're
simply
calling
an
api
method
that
we
want
to
be
executed.
D
D
So
we
have
this
multi-function
application
helpers
projects.
B
Actual
dependencies
of
this
project,
sorry,
what
could
you
just
open
the
tree
for
dependencies?
You
just
want
to
check
all
the
dependencies
right
here.
B
D
There's
just
a
single
project
file
that
has
many
of
these
test
libraries
in
it,
but
the
vision
was
that
we
could
build
multiple
assemblies
individually,
that
we
could
load
at
runtime,
but
we
just
hadn't
gotten
to
that.
Need
yet,
and
it
looks
like
that
need
might
not
be
present
yet
but
anyways.
That
was
the
idea,
and
so
we
have
two
versions
of
this
application.
We've
got
the
net
core
version
of
the
application
and
a.net
framework
version
of
the
application.
C
So,
just
just
to
kind
of
rephrase
to
see
if
I
really
capture
the
the
the
things
covered.
So
basically
you
have
one
application
for
core
and
framework
that
kind
of
handles
the
boilerplate
stuff.
Let's
say
it's
gonna
write
the
same
information
to
extend
output
or
some
log
or
something
like
this
I'll
handle
on
the
app
and
then
you
build
right.
Now
is
one
assembly,
but
in
principle,
could
be
many
separate
assemblies
correct.
C
You
build
the
the
the
exact
steps
actions.
I
think
the
term
was
that
that
you
use
that
you
want
to
test.
D
Correct
yeah,
and
so
here
so
the.net
core
and
the.net
framework
applications
themselves,
really
simple:
it's
delegating
its
logic
into
this
multi-function
application,
which
is
a
shared
library
that
they
can
both
use,
and
if
we
go
in
here,
this
is
where
we
have
a
lot
of
that
shared
logic,
and
so
the
the
side
benefit
of
this
is
it
made
it
really
easy
for
us
to
be
able
to
just
oh,
if
you
got
a
problem
with
an
integration
test.
D
C
One
question
this
is
kind
of
tangential,
but
I
think
I
I
understood
that
you
mentioned
that.
Okay,
the
application
is
running
you,
you
run
a
test.
You
run
a
set
of
commands,
for
instance,
and
then
you
keep
the
application
running
and
you
run
another
set
of
tests,
but
this
is
for
kind
of
the
same
instrumentation
that
you're
targeting
or
you
are
doing
that
as
a
general
thing.
D
Yeah,
so
this
is
just
in
general
how
the
the
test
works.
If
I'm,
remembering
correctly,
what
happens
is
so
the
constructor
runs.
D
D
D
So
in
this
case,
one
of
the
things
that
we
look
at
is
with
these
tests
is:
it
relies
on
parsing
the
log
files
that
were
generated,
so
these
log
files
are
basically
set
to
a
verbose
mode
where
we
can
actually
see
the
payloads
that
we're
ultimately
sending
up,
and
so
it
can
read
those
in
parse
them.
And
then
you
can
run
tests
against
those
payloads
to
verify
that
we're
sending
up
the
right
data
that
that
we
expect
to
find.
D
And
so
most
of
these
test
fixtures
have
a
single
fact.
Some
of
the
test
fixtures
have
multiple
facts
in
them,
but
that's
the
general
idea
of
how
it
works.
C
So
just
because
I
I
think
I
so
where
you
have
the
facts,
you
are
going
to
typically
have
on
the
setup
when
you
are
building
the
test.
You
are
going
to
start
the
app
for
that
set
of
facts,
and
then
you
stop.
B
C
Yeah,
so
I
think
it
is
a
a
similar
model
to
data
log,
with
the
main
difference
that
you
pick
up
the
common
code
of
these
apps,
that
are,
they
start
and
this
kind
of
thing,
and
you
have
a
single
app
for
that
right.
C
One
thing
that
I'm
I'm
I'm
considering
here,
but
this
is
kind
of
is
secondary,
I
think
is,
is
not.
Is
that
in
principle
you
could
kind
of
depend
on
how
you're
going
you
organize
your
theory,
your
facts
in
the
test,
but
you
could
run
the
application
less
times
in
not
so
much
about
the
model,
but
the
way
that
you
organize
the
test.
C
I
think
right
now
and
zach
can
correct
me
if
I'm
wrong,
I
think
if
you
have
kind
of
not
configuration
because
configuration
really
needs
to
run
again,
there
is
no
escape
right
if
you
change
environment
variable.
That
is
a
configuration
you
have
to.
Unless
you
have
access
directly
to
the
types
you
have
to
to
run
again
the
application,
but
what
I'm
thinking
is
that
perhaps
this
kind
of
makes
a
bit
easier
to
have
less
runs
of
the
test
application.
C
Let's
say
if
you
have
a
not
a
configuration
in
that
case
because
of
the
reason
that
I
explained,
but
something
that
you
run
want
to
run
differently,
you
can
use
the
same
run
of
the
application.
I
think
it's
just
it.
It's
a
bit
more
invite
that
people
implement
in
that
way,
not
that
the
way
that
upstream
has
prevents
that
you
know,
but
it's
a
bit
more
kind
of,
I
think
guides
you
to
do
that
way.
D
B
E
B
One
use
case
can
crash
the
app
and
the
second
will
not
work
at
all,
and
I
don't
think
that
running
the
app
is
really
cost
like
costly.
I
think
the
most
expensive
was
building
copying.
These
applications
configure
changing
the
frameworks
on
all
of
them,
even
debugging,
finding
the
correct
application,
etc.
D
D
C
Yeah,
I
I
think
I
think
upstream
also
reduced
the
copies
that
they
were
doing.
They
they
now
share
their
profiler,
so
that
helps
a
lot
with
the
build
time
yeah.
I
I
I
like
this
model
too.
I
think
the
fact
that
you
have
kind
of
you
avoid
the
boilerplate
about
logging
and
this
kind
of
stuff
makes
consistent.
You
know,
that's,
I
think
it's
for
me.
It's
the
big
advantage.
Yeah.
D
C
That
makes
a
lot
of
sense
too.
You
are
instrumental,
I
don't
know
rapt
mq
and
then
you,
when
you
write
your
test.
You
are
just
writing
right.
D
Yes,
I
think
I've
got
a
rapid
mq
example
here,
where
yeah
here's
the
test,
so
we
just
happen
to
have
one
file
with
all
of
the
rabbitmq
actions
that
can
be
executed.
C
D
B
D
It's
because
it's
crossing
process
boundaries,
so
you
got
the
test
runner
process
and
then
you've
got
the
test
app
process
and
there
there
are
two
different
things
and
so
that
that's
why
it's
just
using
standard
input
so
that
for
simplicity
there
that
way,
you
can
still
run
the
test
application
independent
of
using
a
test
runner
or
not.
C
B
D
C
Yeah,
I
I
do
expect
that
you
do
have
to
do
some
setting
there,
but
anyway,
you
are
able
to
launch
the
app
and
debug
the
app
directly.
C
C
Yeah
yeah,
I
I
also
have
that.
I
I
always
thought
I
I
don't
know
where
I
got
that
idea.
I
always
thought
that
that
worked
with
the
command
line
tools,
and
then
I
realized
no,
it's
just
visual
studio
and
kind
of,
but
yeah
it's
very
convenient
with
visual
studio.
You
know
makes
very
easy
so.
C
I
I
would
I'd
like
thank
you
for
presenting
that.
I
think
it
it's
a
slightly
difference,
but
I
think
the
nice
thing
is
about
being
the
the
point
that
you
call
attention,
you're
being
focused
on
the
exact
instrumentation
that
you're
all
working
and
you
can
kind
of
hey.
I
already
have
the
application
that
gets
the
log
in
they
start
in
the
command
line
that
that's
the
nice
part.
You
know
so
you
saved
that
boilerplate.
C
I
I
like
the
idea,
I
think,
as
we
get
to
the
point
of
starting
to
write
and
improve
the
unit
tests,
we
should
look
at
the
model
and
perhaps
make
a
kind
of
control
consensus
between
us
here
to
some
structure
and
go
for
it.
C
A
C
C
But
but
the
profiler
should
be
generating
some
logs
anyway
right
so.
A
Yeah
it
should
it's
actually
doing
this
locally.
So
locally
everything
is
work,
so
it's
kind
of
generating
logs
and
the
docker
has
also
mapped.
Try.
B
A
B
C
But
dci
things
usually
have
a
way
to
connect
to
the
boxes
that
are
running
that
the
the
stuff.
I.
B
A
I
saw
that
they
have
some
extensions
that
enable
the
ssh
and
over
there
you
can
or
if
the
step,
let's
call
it
step
extension
is
not
working.
Then
you
can
manually
instantiate
the
ssh
session
there.
A
C
Yeah,
but
unfortunately,
this
is
the
only
way
right.
Otherwise
you
don't
have
a
ripple.
It
seems
to
be
the
only
way,
but
it
seems
a
kind
of
big
step
to
kind
of,
invest
and
and
check
that,
but,
as
far
as
I
understand
is
the
only
way
because
otherwise
you're
not
going
to
be
able
to
to
see
what's
happening.
A
F
Thing
that's
worth
checking
you
might
have
already
done.
This
is
to
just
make
sure
that
the
bitness
of
the
app
pool
and
the
profiler
match
so
maybe
adding
some
more
adding
to
the
the
webpage
or
something
that
you
hit.
Actually
now
you
already,
let's
see
actually
you're
already,
including
the
process
architecture
in
there,
nevermind
yeah.
C
All
right
I
was
going
to,
I
was
going
to
say
good
luck,
erasmus,
because
this
this
seems
a
little
bit
convoluted
to
to
kind
of
figure
out,
but
yeah.
C
All
right,
then,
if
yeah
we
are
quiet.
I
think
then
it's
time
for
us
to
end
the
meeting.