►
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
B
D
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
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
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
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
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
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
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
B
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
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
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
C
B
C
B
C
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.
C
B
E
B
C
B
C
B
B
B
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
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
B
B
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
C
C
D
C
B
C
C
B
D
B
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
C
B
B
B
C
C
C
B
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.
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
C
B
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
C
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
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
B
C
C
E
B
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
D
B
E
A
B
F
D
E
B
B
B
D
C
F
B
C
D
B
B
C
F
B
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.
D
C
B
C
B
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.
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
C
D
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
C
B
C
B
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
D
C
B
C
D
B
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
B
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.
C
F
B
D
B
B
E
E
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.