►
From YouTube: Apr 13, 2023 - Ortelius Archtiecture Meeting
Description
A continued discussion over the new architecture and how the team will build a platform for contributing microservices is included in this discussion.
A
B
So,
just
to
give
everybody
an
update,
I
did
take
utkarsha's
code
that
he
wrote
in
Python
and
translated
over
to
golang
and
the
reason
for
that
was.
We
needed
the
libraries
for
like
ipfs
and
nft
storage
and
things
like
that
that
were
not
available
in
the
python
world.
B
So
what
you'll
be
able
to
do
is
created
a
new
Repository
I'm,
going
to
prefix
all
the
new
repositories
with
the
scec
so
supply
chain
evidence
catalog
is
the
acronym
and
the
repository
is
that
one
it
should
be
public.
Let
me
change
that.
B
The
learning
goaling
was
wasn't
a
a
big
deal.
It's
like
a
cross
between
Python
and
C,
plus
plus.
D
B
So
that
part
went
pretty
easy
one
of
the
things
that
so
this
should
be
public
now
for
everybody
to
see,
one
of
the
things
that
I
found
was
even
though
golang
has
what
they
call
structures.
B
It
doesn't
have
a
true
object-oriented
programming
world
like
Java
does
so
in
this
example.
Here
we
have
a
user
structure
and
we
have
all
of
our
our
definitions
here
and
then,
if
you
want
to
associate
a
method
to
a
you
know,
you
could
think
of
it
as
a
class,
the
user.
What
you
have
to
do
is
you
have
to
create
a
function
with
this
type
of
definition.
B
So
this
allows
us
to
basically
self-reference
the
user
object,
and
that
is
like
the
method
now
so
like
in
Java.
Normally,
you
have
your
class
and
then
your
methods
inside
your
class
in
goaling,
you
have
to
do
a
kind
of
like
outside,
which
is
fine.
B
It's
just
the
way
it
it.
They
structure
it
now,
one
of
the
things
that
it
doesn't
have,
even
though
you
can
do
this
type
of
method
definition
is,
it
doesn't
have
one
for
a
Constructor.
So
if
you
create
a
new
user
object,
there
is
no
way
you
can
have
like
a
default.
Constructor
go
off
and
do
things
so
what
ends
up
happening
is
it
ends
up
having
to
do
two
different
calls
one
to
create
the
object
and
then
a
second
call
to
go
ahead
and
and
do
like
a
an
initialized
one.
B
Here's
an
example
one.
So
here
we
have
we're
creating
a
new
nft
object
and
after
it's
created,
we
then
whoops
one
too
big.
We
want
to
go
ahead
and
call
the
init
method
at
that
level.
So
it's
a
two-step
process.
It
works
out.
Okay,
it's
just
one
of
those
things
you
have
to
get
used
to.
So
what
I
ended
up
doing
was
I
took
every
single
object
that
we
have
and
created
a
structure
for
it,
so
you'll
see
underneath
the
model
directory
all
the
different
objects.
B
So
the
way
they
going
links
it
out
is
you
have
your
main
file?
In
our
case,
each
file
is
equivalent
to
a
a
class,
and
then
underscore
test
is
the
test
case.
That
goes
with
it.
B
So
one
of
the
things
when
I
was
going
through
and
doing
the
the
translations
was
I
realized
that
we
needed
to
do
a
custom
martial
and
on
marshaller
and
the
reason
being
is
when
we
Marshal
something
to
for
ipfs
storage.
We
need
to
exclude
the
key
and
the
the
Json
string,
so
we
really
want
just
the
raw
fields.
B
B
That's
excluding
the
key
in
the
nft
and
we're
setting
all
the
parameters
that
we
want.
So
in
this
case
for
a
user
a
user
belongs
to
a
domain
and
a
domain
has
to
be
marshaled
is
going
to
have
one
of
these
nft
marshalers
as
well.
So
that's
where
you
can
see
we
go
off
and
as
we
go,
do
the
Mark
marshalling
here
of
the
user
object
we
go
and
call
the
marshaller
of
the
domain
object
and
what
ends
up
happening.
B
Is
they
when
we
Marshal
things,
we
create
an
nft
structure
and
basically
the
nft
is
just
a
placeholder
for
the
key
itself.
B
What
we're
going
to
do
is
we're
gonna
when
we
Marshal
something
it
is
going
to
take
the
contents
of
the
of
this
structure.
B
So
somebody's
already
created
the
structure
and
filled
in
like
the
name,
the
name
and
the
email
and
the
phone
number
and
stuff
like
that,
and
when
we
Marshal
it
we're
gonna
Marshal
it
to
an
nft.
Basically,
what
we're
doing
is
we're
marshalling
it
into
a
Json
string.
Oh.
B
B
So
what
we're
doing
is
we're
converting
it
from
a
golang
structure,
this
user
structure
into
a
Json
string
that
is
going
to
conform
to
the
to
the
world
that
the
ipfs
wants
to
to
see
it
and
I'll
give
you
an
example
here
in
a
second
and
when
we
do
the
marshalling,
if
we
have
nested
objects,
we
have
to
go
and
Marshal
those
as
well
and
keep
track
of
all
that.
So
it
goes
into
this
whole
recursive
marshalling
process.
B
So
when
we
go
in
Marshall
the
domain,
we
don't
want
the
domain
as
like
Global
to
come
back.
We
want
the
the
key
that
is
going
to
be
used
to
Store
The
Domain
in
ipfs
to
come
back.
So
that's
where
the
these
OB,
the
the
I,
had
to
create
these.
These
custom
functions
to
do
to
organize
everything
that
we
needed
it
to
lay
out
in
not
only
the
ipfs
storage.
You
know
the
nft
storage,
but
also
in
our
our
Rango.
B
But
we
basically
it's
a
big
giant
data,
massaging
process
that
we
go
through
to
make
sure
that
we
have
the
the
data
and
the
right
order.
Now,
one
of
the
weird
things
is
when
you
I
found
that
you
actually
the
order
that
you
lay
out
the
fields
here
is
going
to
be
the
order
that
the
Json.
So
what
this
is.
This
is
returns
a
Json
string
of
your
structure.
B
So
one
of
the
things
that
we
need
to
do
is
to
make
sure
that
the
we
manually
sort
these
fields
so
they're
consistent.
So
if
we
go
in
and
retrieve
the
Json
from
like
a
a
node.js
program
or
python
that
the
order
is
maintained,
so
we
just
maintain
an
alphabetical
order.
B
Otherwise
you
get
a
different
hash
coming
back
because
even
though
it's
the
same
content
order
makes
a
difference
when
you
calculate
the
hashes
so
that
that
Marshall
part
is
where
we
go
in
and
take
the
structure
and
convert
it
into
basically
a
nft
Json
string.
Now
we
have
to
go
to
the
opposite
direction
as
well.
B
When
we
go
and
get
a,
we
have
a
Json
string
or
a
key.
Basically
the
ipfs
Sid.
We
have
that
and
we
want
to
go
backwards.
One
of
the
things
that
we
want
to
do
is
pull
that
back
and
turn
it
back
into
a
regular
structure.
So
this
is
going
the
other
way,
so
we
have
the
Json
or
the
Sid
and
we
want
to
go
backwards
to
the
to
the
actual
object.
This
is
the
unmarshalling
process,
so.
B
We're
making
a
converting
it
from
Json
back
into
the
the
golang
structure.
Basically,
okay,.
B
One
of
the
weird
now
one
of
the
weird
things
it
it
is,
but
it
isn't
it
it.
Actually,
it
took
a
little
bit
to
figure
out
the
the
process
and
what
we
need
to
do
and
some
of
the
limitations
of
golang.
One
of
the
things
that
golang
doesn't
have
is
a
a
method
to
do
a
deep
copy.
So
it
does
a
lot
of
things
by
pointers.
B
B
So
one
of
the
things
that
we
have
to
do
is
to
and
what
what
that
means
is
somebody
underneath
the
the
the
covers
could
go
change
like
the
real
name
and
if
they
update
the
real
name,
they're
gonna,
it's
whoever's
pointing
to
that's
going
to
get
the
copy
of
get
that
real
name
update.
So
what
we
want
to
do
is
we
want
to
make
a
deep
copy,
which
goes
and
actually
makes
a
copy
of
it.
B
Instead
of
pointer
references,
so
when
we
go
in
on
Marshall
a
nested
object,
what
we
do
is
we
set
the
the
key
of
the
which
is
the
Sid
make
that
available
and
then
on
Marshall,
like
you
see
here,
we'll
go
and
look
at
the
Sid,
that's
coming
in
off
of
the
object.
So
this
looks
for
the
the
object,
Sid
and
looks
it
up,
gets
the
the
Json
and
then
on
Marshalls
it
there.
So.
C
D
B
We
can
then
manipulate
the
the
we
can
manipulate
them,
independent
independent
of
each
other,
without
updating
them.
At
the
same
time,
yeah.
B
So
I'm
going
to
go
through
a
and
I
wrote
all
the
we're
just
jumping
over
to
another.
Let
me
go
over
to
the
user
object
first
test
case
a
little
bit
simpler.
B
So
when
we
look
at
so
I
wrote
the
test
cases
for
all
of
these
to
make
sure
that
everything
was
testing
out,
and
so
this
is
the
basically
the
the
Json
that
would
be
stored
into
the
nft
storage.
Anything
with
the
key
is
ignored,
so
you'll
see
how
we
kind
of
use
the
key.
So
this
is
this
representation.
Right
here
is
what
a
Rango
is
going
to
look
for,
so
a
Rango
has.
The
underscore
key
is
like
the
primary
key
of
the
object.
B
So
in
this
case
our
primary
key
is
this
Sid
and
then
like
in
the
domain,
object
we're
going
to
be
referencing
this
this
Sid,
which
references
that
that
that
data,
so
when
we
go
and
change
in
kind
of
manipulate
this.
B
And
we
kind
of
flatten
it
out,
and
we
changed
this
this
this
structure
of
all
the
Json
into
the
corresponding
data.
That's
going
to
be
put
into
nft
storage,
you
can
see
when
we
go
in
and
do
the
normalization
right
now
we
have
like
the
the
global
is
the
name
of
the
the
domain
that
just
gets
replaced
with
just
the
the
Sid.
B
So
this
is
where
we
get
this
pointer
process
and
when
we
get
into
more
complicated
nested
objects,
you'll
see
how
it
we
end
up
with
this
normalization
and
pointing
to
things
that
already
exist
and
not
storing
a
lot
of
data.
B
So
in
this
case
we
have
our
our
nested
domain,
which
is
just
going
to
be
the
pointed
to
the
key,
and
then
we
have
our
email
and
all
our
other
fun
data
and
then
we've
added
in
the
object
type.
So
if
we
go
look
at
the,
if
we
go
navigate
to
the
ipf
storage
and
pull
up
this
this
Sid
here,
we
can
retrieve
that
doing
just
a
a
a
curl
command.
Basically,
we
can
go
get
that
that
Json
back,
but
we
don't
know
what
type
of
Json
it
is.
C
Kind
of
that's
yeah,
just
so
yeah,
so
all
this
and
marshalling
and
marshalling
in
the
end
is
so
that
oranga
can
understand
the
data
right.
Yeah.
C
B
We'll
add
the
data
to
the
Rango
database
first,
because
that's
really
quick,
you
know
milliseconds
and
then,
when
we
add
the
data
to
the
nft
storage
that
could
take
up.
You
know
several
seconds
depending
on
how
how
big
the
data
is.
B
C
B
So,
just
to
walk
through
kind
of
the
the
test
cases.
What
we're
doing
here
is
we're
going
to
create
a
a
user
object.
B
B
Is
has
now
been
all
the
the
variables
that
have
been
populated
now.
B
It
yeah
it's
conversion
from
a
Json,
the
urango
Json
format,
into
a
a
go
laying
structure
a.
B
B
It
is
a
type
of
Json,
but
what
we
need
to
do
is
we
need
to
normalize
the
data,
so
we
want
to
replace
all
of
the
like
the
name
of
the
domain
here,
which
is
global.
It
gets
converted
into
this
pointer.
That's
of
course,
that
we
only
point
so
what
ends
up
happening
is
we
only
store
the
domain
Global
once
in
nft
store,
nft
storage
and
then
every
single
object
that
uses
the
global
domain
points
to
it.
Through
this,
this
key
the.
B
The
key,
the
key
is
basically
a
hash
that
gets
created
and.
C
B
E
B
C
B
So
I
I
have
been
thinking
about
that
as
well,
where
we,
if
we
wanted
to
and
I've,
been
reading
up
on
this,
where,
when
we
go
in,
add
things
to
the
nft
storage
that
we
actually
go
in
in
and
encrypt
these
strings
as
well.
B
We'd
have
to
see
if
we
want
to
go
that
route
and
get
into
encrypting
this
string
into
some
sort
of
like
using
an
elliptical
key
or
something
like
that
to
do
do
the
encryption
and
then
store
the
encrypted
data
on
nft
storage
right
now,
I
just
want
to
get
it
working,
and
then
we
can
get
fancier
down
the
road
yeah.
B
C
B
Yeah,
it's
just
it's
just
a
public
private
key
type
of
encryption.
B
The
one
that
seems
to
be
the
fastest
one
of
the
new
ones
is
what
is
a
Ed
195
6,
or
something
like
that.
I'd
have
to
look
it
up
again,
yeah,
but
that's
a
an
elliptical
key
pair
encryption
that
will
allow
encrypting
and
decrypting.
If
you
have
the
key.
B
B
The
curve
needs
to
be
maintained.
So
if
you
change
any
part
of
the
data
or
any
part
of
the
key,
you
get
a
different
curve
and
then
they
don't
match
up.
Okay,.
B
So
the
next
step
that
we
do
is
we
just
check
what
we
marshaled
here
and
what
we
expected
come
out
to
be
the
same.
C
A
C
B
Is
laying
all
the
groundwork
for
the
back
end
pieces
and
then
the
the
front
end
piece
is
what
this
does
is
when
you're
working
with
the
microservice,
the
nice
part,
is
the
microservice
just
needs
to
know
that
I'm
going
to
get
a
user
structure
from
the
front
end,
so
I'm
going
to
get
this
Json
passed
across
from
the
front
end.
That's
going
to
convert
into
this
user
structure.
B
There
will
be
a
micro
service
that
goes
in
front
of
this.
That
will
include
these
structures
and.
C
Almost
like
the
key
to
the
to
the
different
castles,
I
guess
right:
yeah,
okay,.
B
Now
the
reverse:
what
we
want
to
do
is
we
want
to
take
this
expected
result.
This
is
what
would
be.
This
is
what
would
be
coming
from
the
nft
storage
and
we
want
to
take
that
and
go
backwards,
so
in
this
case
we're
going
to
go
and
take
this
data
normally,
this
would
be
fetched
from
either
from
the
ipfs
storage
and
we
would
take
that
and
we
want
to
go
backwards.
B
So
one
of
the
things
that
we
need
to
do
is
to
unmarshall
that
and
you'll
see
that
there's
this.
This
basically
is
a
map
I
think
of
it
a
dictionary.
So
when
we
go
on
Marshall
things,
we
end
up
with
the
bits
and
pieces
so
like
the
domain,
because
it's
nested
we
have
to
unders,
we
have
to
save
the
domain
and
persist
that
into
the
storage,
so
this
Sid
to
Json
is
basically
a
what
the
contents
of
that
is
what
ends
up
in
I
in
the
nft
storage.
B
In
this
test
case,
what
we
do
is
we
just
create
this,
the
variable
when
we
Marshall
it
ends
up
populating
all
the
keys
into
that
that
dictionary
and
now,
when
we're
going
backwards,
we're
going
to
take
like
the
key
here
is
going
to
be
one
of
the
keys
that
we
need
to
look
up
and
the
unmarshalling
process
knows
to
go
and
look
look
for
the
key
inside
of
the
inside
of
that
dictionary
and
go
find
the
the
Json
string
and
then
go
and
do
the
recursive
on
on
marshalling.
So.
C
C
That's
sud
has
that
got
anything
to
do
with
that
domenchy
at
the
top,
or
is
it
a
completely
separate
key
type
of
key?
It's.
B
B
Okay,
so
what
ends
up
doing
it
we
end
up
doing?
Is
we
end
up
Mark
on
marshaling
it
back
into
our
user
object?
So
this
is
going
to
go
back
from
all
the
ipfs
nft
storage
formats
back
into
the
golang
structure,
and
then
what
I
do
is
I
just
go
ahead
and
to
make
sure
I
get
the
an
easy
way
to
do.
B
The
assert
is
I
just
Marshall
it
backwards,
so
I
go
forward
and
backwards
and
just
to
make
sure
that
I
end
up
with
my
expected
results,
we
could
write
an
in
an
equals
function
in
the
class,
so
in
this
class
here
we
could
write
and
is
equals
method
and
do
the
comparison.
I
just
didn't
have
the
time
to
go
to
that
length.
B
So
I'm,
literally
just
going
back
and
forwards
between
the
different
structures
to
make
my
life
easier.
That
may
be
something
we
want
to
change
down
the
road
so.
C
C
B
Is
going
to
be
the
so
it's
going
to
be
the
so
I
mix
up
terminology
here
so.
D
C
B
B
So
in
a
Rango,
we're
going
to
be
using
the
same,
the
Rango
key
is
going
to
be
the
same
key,
the
same
Sid
that
ipfs
is
using
I.
C
B
C
B
And
it'll
and
a
Wrangler
will
build
it,
build
indexes
on
its
own
as
well.
So
that's
how
the
things
will
be
tied
together.
D
B
Now,
if
you
look
at
so
I
Ran
So,
if
you
look
at
a
little
more
complex
object,
so
user
is
pretty
easy.
Now
we
go
to
a
component
version
and
you
can
see
where
it
gets
a
little
more
complicated.
So
this
is
the
the
the
Sid
of
the
whole
object,
including
all
the
nested
objects.
B
So
we
can
see
here
we
have
a
different
domain
because
we
have
a
different
domain
name:
we're
going
to
have
a
different
key
for
that
domain.
So
here's
like
the
global
domain-
and
you
can
see
how
the
Sid
was
generated-
is
different
than
this
here
because
of
the
the
data
is
different,
so
we
have
all
these.
So
we
have
a
domain
which
is
nested
object.
B
Then
we
have
owner,
which
is
a
user
object
which
has
a
domain
which
is
an
another
nested
object
and
same
thing
and
so
forth,
and
then
we
go
into
like
our
our
packages.
So
this
is
all
the
the
packages
there
are
that
were
dependent
upon
and
they
have
their
keys
in
the
key
of
the
keys
and
stuff
like
that.
So
when
we
look
at
this
whole
big
structure
for
a
component
version,
we
have
all
this
nested
data
and
when
we
flatten
it
out,
let
me
turn
on
word
wrap
here.
Whoa.
C
So
everything
here
like
the
service
owner,
has
now
got
its
own
unique
key
and
that
data
is
being
kept
unique
and
yo.
So
everything
well,
not
everything
I,
don't
I,
don't
know
what
the
right
terminology
word
to
use,
but
I'm.
Looking
at
the
the
braces
right,
yeah
and
then
I'm,
seeing
with
his
with
his
nested
data,
then
it
starts
to
get.
Then
it
gets
a
unique
key.
Yeah.
B
B
So
here's
here's
like
here's
like
the
consuming
key,
and
so
this
is
the
consuming
object
and
that's
the
key,
the
Sid
that's
going
to
be
on
on
nft
storage
and
here's
like
one
of
the
domains,
the
main
domain,
here's
our
license,
so
everything
gets
flattened
out
now.
If
we
look
at
it
from.
C
B
B
Here's
like
the
providing
list-
and
this
is
the
the
so
this
would
be.
The
key
in
nft
storage
is
Sid,
and
this
would
be
the
data
that
gets
added
to
nft
storage
and
then
here's
the
readme
file.
B
So
what
ends
up
happening
is
now
if
we
get
into
the
like
the
application.
Let's
see,
this
is
going
to
be
probably
the
highest.
C
C
C
Say:
hey
Steve,
did
you
read
my
I,
don't
know
my
readme.pdf,
for
example.
Let's
call
it
I,
don't
want
to
go
to
Steve
and
say:
hey.
Did
you
read
my
b-a-f-k-r-e-I
blob
right.
B
And
what
you
would
do
is
that's
where
the
Ledger
comes
into
play:
Because,
The,
Ledger,
in
the
metadata,
when
we
go
and
record
that
we're
adding
a
basically,
we
have
a
transaction
saying,
I'm,
adding
a
new
readme
file,
it's
going
to
record
the
date
and
time
and
who,
who
save
that
readme
file
and
then
also
it's
going
to
give
us
metadata
that
we
can
put
like
you
said
a
more
a
more
common
name
into
yep.
B
And
then
it
would
give
us
gives,
gives
us
a
place
to
put
the
the
Sid.
So
we
can
actually
go
get
the
contents
of
the
readme
file.
B
Yeah,
that's
what
the
ledgers
are
doing
when
we,
when
we
go
and
store
these
things
now.
What
you
can
see
is
when
we
look
at
the
amount
of
data
that
we're
going
to
be
storing,
because
we
are
referencing
like
the
global
domain
was
referenced
like
three
or
four
times
we're
only
gonna.
We're
only
gonna
persist
it
once
into
the
the
nft
storage,
but
each
each
object.
So
we
had
our
user
object
is
going
to
reference
this
domain
and.
B
So
we
can
follow
when
you
start
following
all
the
keys,
you
can
go
from
this
cryptic
format
back
to
this
format
that
you
can
actually
read.
D
B
So
all
what
all
the
marshalling
and
on
marshalling
is
doing
is
transforming
the
readable
data.
That's
in
the
pretty
structure
that
we
can
use
from
a
program
perspective
and
move
that
denormalize
data
into
a
normalized
format
that
we
use
for
storage
and
that's
where
the
abstract
layer,
the
data
abstraction
layer
is
going
to
come
into
play,
is
going
through
and
making
sure
that
all
the
objects
are
persisted
and
if
they're,
if
they
don't
exist
atom.
If
they
do
exist,
you
know
just
make.
You
know
all
that
that
process.
C
B
Version
of
what's
happened
over
time,
so.
C
B
That
that's
one
thing
I
haven't
figured
out.
Yet
that
we'll
need
to
address
is
if
somebody
does
a
rename.
B
History
is
there
forever
so
this
data,
the
old
data,
the
name
is
there
yeah
and
on
a
rename
we
could
tag
something
as
deleted
and
then
added.
B
So
it's
actually
like
two
transactions
in
The
Ledger,
we'll
have
to
see
when
we
get
to
that
point
how
we
want
to
handle
like
a
rename,
because
you
still
need
to
maintain
historical
point
of
view.
So
all
this
ipfs
data
doesn't
go
away.
We
just
keep
on
adding
to
it,
but
on
the
Ledger
side
we
have
to
figure
out
how
we're
going
to
track
like
a
rename.
C
B
That
look
it's
different
data,
because
it's
different
anytime,
you
change
the
data.
You
get
a
new.
C
Key
but
like
it
could
be
the
same
file,
but
it's
just
got
a
different
name
now
right,
so
it'll
create
a
whole
new
key
and
how
do
you,
oh
yo,
I,
see
what
you're
saying:
how
does
it
tie
it
back
to
what
it
was
before?
Yeah
wow?
Okay,
this
sorry
oven
then
happen
much
slang.
You
guys.
B
So
this
this
data
that
we're
looking
at
here
with
all
the
the
key
value
pairs
so
that
the
keys
on
this
side
like
this
is
gonna,
be
one
of
the
keys,
and
this
is
gonna,
be
the
value
each
one
of
these.
Basically
lines
is
going
to
be
a
what
is
going
to
be
added
to
what
they
call
a
car
file,
a
Content
addressable
archive,
so
yeah.
C
B
Is
is
towering
up
these
this
data.
B
So
a
car
file
is
you,
take
all
these
crazy
keys
and
the
corresponding
data,
and
you
call
these
going
methods
to
go
ahead
and
and
pass
in
the
data
and
once
what
ends
up
happening?
Is
you
add
each
one
of
these
Keys
into
as
a
layer
into
the
car
file
and
then
after
you've
done
all
that
you
create
a
root
key
of
all
the
keys?
B
C
Yeah,
it
feels
very
it
feels
it
does
feel
like
that
right.
It
feels
like
it
feels
like
no
what's
that
book,
1984
yeah
anyway
yeah,
it
feels
weird.
It
feels
very.
You
know
what
you
just.
B
C
C
E
B
We
will
do
some
paired
programming
on
this
stuff
as
well,
and
mine.
B
I'll
lay
out
some.
My
next
step
is
to
put
together
a
sample
microservice
that
we
can
start
with
and
then
Arvin
will
have
to
we'll
have
to
repeat
that
kind
of
copy
that
sample
microservice
into
all
the
new
repositories.
B
B
C
So
that
go
code
that
you
showed
us
would
that
be
compiled
in
a
pipeline
like
let's
take
a
like
I'm
thinking,
because
I'm
so
just
using
Maven
and
all
these
Java
projects
that
have
been
containerizing.
But
now,
if
we
were
containerizing
that
go
code,
there
would
be
some
type
of
compiling
going
on
right
to
com,
compile
that
program
and
put
it
in
a
container
rack.
B
What
ends
up
happening?
Let
me
find
the
file
sorry.
B
Go
is
going
to
you've
referenced
the
Repository,
so
all
of
the
so
go
when
you
create
your
executable
forgo
it
all
comes
from
source.
B
So
you,
you
literally
fetch
all
the
code
from
source
and
then
that
gets
compiled
into
the
executable.
So
when
we
write
our
microservice,
we'll
include
our
it's
called
the
where's,
the
package
name,
the
SEC,
so
we'll
bring
in
the
artillius
set
Commons
repo.
D
B
Yeah,
okay
and
there's
no
there's
like
no
main.
They
usually
have
like
a
main.go
as,
like
the
entry
point
to
run
the
program
from
and
because
this
is
a
reusable
package.
There
is
no
main
go
program.
E
B
No,
this
will
not
be
the
the
commons
will
not
be
a
a.
A
B
F
C
This
up
is
it:
is
it
like,
when
you're
building
a
a
like
I
know
when
I've
ripped
apart
mono
Reapers
for
a
Java
application,
I've
had
to
make
sure
that
the
Nexus
server
has
the
common
library
accessibles,
because
all
the
micro
Services
when
we
build
them,
will
look
for
that
as
the
common
you
know,
like
a
common
package
base,
yeah.
D
E
B
What
I
can
do
is
like
in
this
case,
so
this
is
like
the
the
basically
the
the
microservice
main
program
and
then
look
at
user.
B
B
B
D
C
The
V1
release
will
be
in
the
GitHub
repo,
of
course,
cool,
and
then
it's
a
different
way.
It's
different
to
I'm
so
used
to
Java
with
Maven
files
and
those
type
of.
F
B
Only
thing
that
you'll
have
is
you:
have
the
it'll
there's
a
command
go,
go
mod
tidy
that
will
go
and
update
your
dependency
file.
So
this
is
think
of
this.
As
your.
C
C
Correctly,
but
what
would
cause
us
to
the
right
way?
This
is
what
I
was
trying
to
understand,
thus
far
yeah,
it's
almost
like
package.json
in
a
way.
B
This
this
is
the
the
file
that
gets
updated
and
you
have
to
make
the
reference
to
in
the
source
code
of
what
you
want
to
use.
D
B
Some
of
the
things
that
we
will
need
is
if
we
go
back
to
our
example
here.
B
On
this
side,
when
we're
looking
at
the
the
SEC
comments,
that's
just
going
to
be
a
a
release,
a
GitHub
release.
You
know
V1
V2,
all
those
type
of
things
and
then
on
the
microservices
side,
oops
wrong.
B
F
And
one
last
question:
so
are
we
still
going
to
have
that
that
kind
of
architecture
where
we
were
you
know
triggering
one
hem
chat
and
that
was
spawning
other
ham,
charts.
C
B
There'll
be
one.
F
Just
a
thought
here,
so
that
is
like
increasing
the
complexity.
So
what
I
was
thinking?
Is
it
possible
to
avoid
that.
B
B
B
We
have
the
Automation
in
place
from
the
existing
architecture
to
automatically
create
all
of
the
help
you
know
maintain
all
the
home
charts,
including
the
parent
one.
B
So
the
next
step
is,
if
we
look
at
the.
B
When
we,
when
we
go
in
and
Marshall
and
on
Marshall
things
we're
putting
them
into
this
this
map,
this
map
is
what's
going
to
need
to
be
persisted
in
the
orango
database
as
well
as
ipfs.
B
The
Marshall
nft
may
change
slightly
to
deal
with
talking
to
the
abstraction
layer
to
go
and
get
things
for
me,
because
one
of
the
things
that
we
want
to
do
is
at
the
microservice
level.
I
can
go
from
go
from
one
structure,
one
format:
you
know
from
this
nice
pretty
structure
this
goaling
structure
into
the
appropriate
Json.
But
then
that's
all
we
want
the
microservice
to
do.
B
We
want
to
then
pass
off
that
that
data
to
the
database,
abstraction
layer
for
the
database
abstraction
layer
to
deal
with,
storing
it
in
in
a
Rango
and
storing
an
nft
storage
and
then
doing
not
only
storing
but
also
fetching
when
we
need
to
go
get
something
that
that
database
attraction
layer
should
be
the
one
that
does
all
that
back
and
forth.
C
For
us,
so
this
package
gives
microservices
the
capability
to
be
able
to
go
back
and
forth
between
in
TF
and
if
nft.
B
The
the
the
commons,
the
common
function.
D
C
B
C
Creating
a
language
work
right,
it's
kind
of
like
the
Matrix
I
need
the
Internet
helicopter
I
need
to
know
how
to
convert
the
data
so
I
just
pull
it
down
from
the
comment
package.
Full
comment
package
down,
yeah.
B
And
what
it
does
is
on
on
the
on
the
microserver
side.
It
makes
it
really
simple
to
you
know
you
know
we'll
have
like
we
could
have
a
possibly
a
database,
initialization
routine,
and
then,
let's
see
here,
this
is
where
we're
creating
like
a
new
book,
for
example
yeah.
B
This
would
be
saying:
oh
I
want
to
create
a
new
user.
These
are
the
fields
for
the
user
and
then
I'm
going
to
pass
it
off
to.
Instead
of
this,
is
talking
to
Durango,
directly
I'm,
going
to
then
talk
to
the
common
code
and
the
common
code
is
going
to
take
care
of
doing
all
the
back
end,
heavy
lifting
for
saving
the
new
user
into
the
right
places.
B
Because
the
we
we're
going
to
have
the
databases,
traction
layer,
that's
going
to
allow
us
to
do,
handle
all
that
work
for
us
now
on
a
database
extraction.
Layer,
I,
don't
know
at
this
time.
If
it's
going
to
be
able
to
be
generic,
so
there's
like
one
function:
that
does
everything
for
all
the
different
objects
or
if
each
object
has
to
have
its
own
function,
to
be
able
to
go
back
and
forth
it
doesn't
really
matter.
B
D
B
C
Steve,
why
aren't
you
incur
technical
debt
day
in
a
sense,
because
of
is
it
and
what
about
and
also
stability
in
your
application?
Now
you,
like
you,
say,
you're,
trying
to
build
this
code
or
to
accommodate
for
so
many
different
things.
That
right
is
that
the
idea
and
then
that
could
end
up
being
a
actually
a
performance
bottleneck
exactly.
B
B
You
know:
API
URL,
that
they'll
that
you'll
set
up
the
routes
for
so
each
microservice
will
have
their
their
API
URL
and
because
we're
going
to
be
including
the
common
code,
we
don't
need
to
have
a
microservice
to
microservice
transaction
I
did
look
at
that.
I
think
it's
just
going
to
be
add
to
Too
Much
complexity.
So
instead
the
common
code
will
connect
to
the
database
and
nft
storage
directly.
C
B
C
B
D
B
Have
to
go
and
rebuild
all
the
ones
that
are
dependent
upon
it
yeah,
but
that's
the
only
that's
the
downside
versus
doing
a
a
reusable
microservice
for
the
database
Handler.
So.
C
B
Easier
to
program
using
the
reusable
code
yeah,
because
you
have
all
you've
you've
accessed
all
the
structures
you
have
access
to
all
the
functions
and
methods
and
stuff
like.
D
B
C
Yeah,
there's
always
going
to
be
a
trade-off
everywhere,
so
you
have
to
just
figure
out
for
your
specific
use
case,
which
is
what
has
the
most
advantages
right
versus
disadvantages:
yep,
especially
an
open
source
project
where
you've
probably
got
people
coming
and
going
right.
You
need
to
have
something:
that's
common
all
the
time
it
makes
sense
or
any
project.
I
guess.
B
If
you
figure
out
that
it
makes
more
sense
to
do
a
microservice
for
the
database,
Handler
abstraction,
just
let
me
know-
and
it's
not
you
know
we
could
swap
it
in
and
out.
You
know
at
this
point.
C
Can
I
ask
a
kind
of
a
weird
question?
Maybe
so
could
you
make
that
comment
package
actually
into
a
microservice.
B
It's
kind
of
split
because
you
need
part
of
the
the
common
code
functionality
to
format
the
data,
so
that
the
other
side
that
you're
going
to
pass
it
off
to
the
data
is
coming
into
the
right
format.
For
the
other
side
to
deal
with,
because.
C
B
Yeah,
it's
it's
like
depends.
If
we
can
get
the
if
the
data
coming
over,
if
the
the
data
abstraction
layer
can
deal
with
generic
data,
then
we
can
kind
of
make
it
a
microservice.
F
So
there
is
this
common
application,
so
common
application
will
deal
with
the
methods
like
the
normalization,
marshalling
and
unmarshalling
of
data
right
and
behind
that
we'll
have
that
abstraction
layer
right
correct
and,
let's
suppose
we
have
one
implementation
that
says
plus
nft,
right:
okay,
so,
okay,
so
let's
Suppose
there
is
another
implementation.
So
do
you
think,
like
the
marshalling
and
unmarshling
will
make
sense
there.
B
B
The
normalized
data
isn't
going
to
change.
It's
just
going
to
be
how
it's
stored
in
the
persistence
layer.
D
C
B
Yeah
and
we'll
have
to
see
when
we
start
playing
with
like
a
Rango,
what
a
Rango
needs
in
order
to
store
stuff.
If
it's
going
to
need
a.
C
B
B
We're
gonna
have
to
have
a
whole
whole
new
set
of
basically
a
whole
new
version
of
the
application.
Yeah
yeah,
that's
true,
so
we're
not
stepping
on
top
of
each
other.
We
have
a
whole
new
front
end.
We'll
have
a
whole
new.
You
know
micro
services,
oh.
C
F
So
what
I
was
asking
so
all
the
methods
that
are
there
in
abstraction
there?
They
will
like
directly
communicate
to
orang
ODB
right
correct.
There
would
be
additional
ad
hoc,
meth
method
or
function
that
will
be
responsible
for
you
know,
polling
in
a
like
in
a
finite
intervals
and
checking
if
the
particular
data
is
being.
You
know,
persisted
right.
F
B
What
we'll
probably
need
is
well
depending
on
how
we
implement
it
and
depending
it
really
depends
on
how
big
the
code
base
gets.
But
if
the
database
database
abstraction
layer
is
in
too
large
of
a
code
base,
then
we
can
have
that
support,
nft
and
oci
at
the
same
time
and
the
same
code
base.
B
B
You
know
a
Rango
plus
nft
would
be
one
repository.
A
ranga
plus
oci
would
be
in
the
other
repository
and
depending
upon
which
one
you
want
to
use
would
be,
which,
on
the
helm,
chart
side
which
one
we're
going
to
stand
up
is
at
that
level.
C
E
B
And
a
new
cars,
if
you
could
look
into
if
the
abstraction
layer
can
be,
you
know,
take
any
generic
set
of
Json
or
data
in
in
persisted
or
if
you
have
to
have
a
a
well-defined.
You
know
go
laying
structure
to
do
the
persistence
you
have
to.
Let
me
know
on
that,
because
that
will
kind
of
depend
that'll
kind
of
dictate,
whether
we
can
do
a
database,
abstraction,
microservice
or
if
we
have
to
compile
it
in
as
part
of
the
common
code.
Library
foreign.
B
If
it,
if
it
has
to
when,
when
you
talk
to
a
Rango,
if
it
needs
to
be
a
well-defined,
go
Lane
structure
or
if
it
can
be
a
generic
Json
string
that
you
can
persist
to
a
Rango.
C
B
F
B
B
And
the
same
thing
happens
with
the
Rango:
you
have
to
have
a
connection
string
where
the
database
lives.
D
B
What
I'll
do
is
I'll
put
together
a
a
sample,
microservice
and
once
I
have
that
in
place.
Then
we
can
replicate
that
sample
into
all
the
microservices.
B
So
we
have
starting
points
for
everybody
to
start
working
on
a
the
mic.
You
know
individual
microservices.
So
if
anybody
anybody
wants
to
pick
up
a
microservices
to
work
on
they'll
have
the
data
there.
B
Yeah,
we'll
make
sure
we
do
some
pair
programming.
E
E
B
Well,
if
we
get
the
data
moving,
if
we
get
the
data
looking
good,
the
front
end
comes
together,
pretty
easy.
F
B
There
will
be
some
things
that
we
will
want
to
change
so
like
one
of
the
problems
with
the
existing
UI
is
all
the
tables
go
and
pull
all
the
data?
So
if
you
have,
you
know,
5000
rows
of
components,
you
get
all
five
thousand
coming
back,
instead
of
it
being
smart
and
bringing
back
subsets
so
I
think
that'll
be
some
of
the
one
of
the
main
changes
that
we'll
we'll
need
to
do
in
the
right.js
is
how
we
handle
big
data
for
lists.
B
Right
and
one
of
the
other
things
that
we
have
that
we
should
probably
implement,
is
you
know
how,
like
you
know
in
Docker
Hub
and
those
things
you
can
tag?
You
know
you
can
associate
a
tag
to
you
know
say
this
is
for
a
Linux
container
versus
a
Windows
container.
So
you
can
add
the
Linux
tag
versus
Windows
tag.
I,
think
we
need
to
do
that
tagging
mechanism
as
well
to
help
do
the
filtering
and
make
things
easier
to
navigate.
B
So
the
front
end's
gonna
need
some
work.
I.
Think
some
of
the
detail
screens
like
the
details
of
a
component
version,
an
application
version,
I
think
those
are
going
to
remain
pretty
close
to
what
they
are
today
with
all
the
boxes
and
stuff,
but
I
think
the
list
views
or
we're
gonna
we're
gonna
need
to
and
some
of
the
net
just
the
basic
navigation.
We
need
to
work
on.
C
B
It's
a
it's
like
yeah,
like
angular.
It
has
a
templating
engine
and.