►
From YouTube: Jan 19, 2023 - Ortelius Architecture Meeting
Description
In this meeting, Steve Taylor covers the new architecture for Ortelius including work with XRP Blockchain and potential integration with RedHat OCI Emporous.
A
A
To
the
artillius
January
19th
architecture
meeting,
let
me
go
ahead
and
share
my
screen.
A
Of
dive
into
this,
so
one
of
the
things
I
have
been
working
on
is
just
kind
of
pulling
together
our
architectural
design,
so
I'm
working
on
a
markdown
that
has
everything
in
it
so
kind
of
go
through
the
where
we
are
today
our
current
architecture
and
then
in
the
new
architecture.
A
A
Looking
at
the
the
functionality
that
we're
trying
to
achieve
one
of
the
things
it
would
be
to
go
ahead
and
replace
the
the
monolithic
Java.
You
know,
JSP
servlet
front
end
with
something
a
little
more
modern,
so
Joseph
Joseph
sent
me
the
the
link
to
the
Dev.
A
And
I
found
right
GS,
which
is
what
Docker
Hub
is
built
on
Joseph.
Did
you
have
a
chance
to
look
at
riot.
C
A
But
while
while
he's
trying
to
get
some
audio
working,
some
of
the
other
pieces,
I
I
just
can't
get
rid
of
Zoom
here,
it's
being
annoying
today,.
A
So
some
of
the
other
pieces
that
will
be
working
with
are
we'll
need
new
microservices
and
actually
some
of
the
existing
ones
will
have
to
change
slightly,
but
mostly
it'll
be
a
new
microservices
that
we'll
need
to
use
to
replace
the
transactions
that
we
have
in
the
monolith.
There's
not
a
lot
of
overlap,
so
it'll
be
more.
A
The
more
important
part
will
be
like
the
data
that
we
have
to
kind
of
deal
with,
and
my
thought
process
right
now
and
I
didn't
really
put
this
down
is,
instead
of
trying
to
run
the
front
end
and
the
back
end,
the
front,
the
old
Arc,
the
old
DUI
and
the
new
UI
against
the
same
database.
A
That
will
just
actually
have
a
migration
path
to
move
from
the
old
database
to
the
new
database
and
a
new
UI
kind
of
gives
us
a
clean
cut
at
that
point
and
I
think
it'll
be
easier
for
us
to
have
a
a
nice
new
UI
and
a
new
framework
as
long
along
with
new
microservices
to
deal
with
so
right
now,
looking
at
fast,
API
or
node
for
the
microservices,
it
just
really
dependent
upon
what
the
service
is
going
to
do
and
which
language
seems
the
most
appropriate
to
do
that
in
you
know
the
goal,
the
goal
being
you
know,
keeping
a
true
microservice,
where
it's
a
small
code
base
at
that
level.
A
A
The
two
that
I
have
list
up
here.
It
looks
like
their
basic
framework
implementation.
Is
you
have
like
a
a
data
access
router?
A
So
if
you
have
a
page
that
needs
data,
that
page
talks
to
the
router
and
the
router
talks
to
the
back
end,
which
which
makes
it
pretty
easy
from
a
design
perspective
to
have
everything
kind
of
in
one
place
at
that
level,
we'll
have
to
see
when
we
dive
into
those
two
Frameworks-
and
these
are
not
all
the
only
two
Frameworks.
A
If
somebody
has
a
favorite
framework
like
for
reactor
view,
we'll
take
a
look
at
that,
I
did
go
through
the
based
on
our
discussions
that
we've
been
having
in
the
proof
of
concept
pieces
around
the
database.
You
know
we're
currently
working
the
xrpl,
which
is
going
to
be
the
nft
storage
ipfs.
A
You
basically
get
this
hash
they're
based
on
location
and
not
on
name.
So
you
get
this
Sid.
That
says
this
is
where
this
data
lives,
but
you
know
nothing
about
the
data.
That's
there.
So,
with
a
combination
between
The,
Ledger
and
nfts
I
believe
we
can
build
a
searchable
cache
and
kind
of
the
idea
that
I
have
is
the.
A
All
the
data
that's
going
to
be
in
ipfs
will
be
normalized,
which
means
like
for
I
keep
on
coming
back
to
the
license
object.
So
if
you
have
a
s-bomb
that
says
this
package,
you
know,
click
for
python
is
an
Apache
2,
and
then
we
have
another
package
for
like
Fast.
Api
is
another
package
that
may
be
Apache
to
we're
only
going
to
store
the
Apache
2
license
once
in
ipfs
and
both
of
those
s-bombs
are
going
to
point
to
that.
A
So
that's
what
I
mean
by
a
normalized
database,
so
we
we
remove
duplication
as
much
as
possible.
One
of
the
things
and
what
that
allows
to
do
is
is
take
to
minimize
the
amount
of
data
that
we're
storing,
because
when
you
look
at
the
s-bombs
and
all
the
the
data
that
we're
collecting
there's
a
lot
of
repetitiveness
in
it.
So
when
you
look
at
the
Deltas,
the
Deltas
actually
are
pretty
small.
A
So
from
a
storage
perspective,
we
should
be
pretty
good,
but
in
order
for
all
this,
this
stuff
to
be
searchable,
we'll
need
to
create
an
index
of
that
data
and
I'm
thinking
using
the
Rango
database.
A
To
do
that,
it
seems
the
most
flexible
I
did
look
at
the
other
one
at
Tony
suggested,
and
they
want
more
of
a
full
on
schema
to
be
able
to
do
what
we
need
to
do
and
I
think
that's
just
going
to
be
too
restrictive
at
that
level,
and
the
idea
is
when
you
go
in
the
front.
End
needs
some
data.
It'll
go
and
search
through
the
cache.
The
cash
will
then
give
us
the
the
location.
A
Let's
say
we're
looking
for
the
details
about
an
application,
the
applic
that
will
go
ahead
and
give
us
the
the
Sid
to
the
application,
and
then
we
have
to
go
through
and
denormalize
it.
So
denormalizing
is
pulling
all
the
pieces
together
back
into
one
big
document
and
then
that
document
we
would
actually
store
in
the
Rango
DB.
So
if
we
need
to
get
to
that
application
again,
then
we're
going
to
go
ahead
and
use
the
one
as
cached
at
that
level.
A
So
that's
that's
kind
of
the
concept
behind
it
and
this
concept
will
also
be
able
to
be
applied
to
the
oci
registry
as
well.
So
the
Durango
DB
is
really
like.
You
can
think
of
as
an
ephemeral
database
which
we
go
through
and
recreate
everything
from
The
Ledger
and
the
ipfs
to
create
the
cache,
the
searchable
cache
and
then
from
there
we
kind
of
bring
things
up
as
we
need
it.
A
This
is
one
of
the
things
when
you
look
at
when
people
use
ortilius,
UI
they're,
looking
at
a
small
subset
of
all
the
data,
that's
out
there,
so
we
don't
need
to
have
everything
right
there
available
all
the
time
you
can
kind
of
think
of
it
as
like.
A
fast
disk
versus
slow,
Disk
type
of
access
and
the
caching
will
help
us
move
things
between
the
slow
and
the
fast
area.
A
Now
we've
been
meeting
with
red
hat
around
the
oci
registry,
specs
that
they're
going
to
introduce
they
don't
have
any
documentation
on
it
yet
on
what
their
new
extensions
or
plugins
are
going
to
be.
But
what
I'm
thinking
is
that
oci
registry
would
be
treated
similarly
as
the
nft
storage,
where
we
would
go
ahead
and
make
the
searchable
cache
telling
us
where
in
the
registry,
you
need
to
find
things
and
I
believe
the
registry
may
have
some
transactional
history
kind
of
late,
The
Ledger
we'll
have
to
see
on
that
front.
A
I'm,
not
100
sure
what
capabilities
are
gonna.
The
oci
is
going
to
have
to
give
us
a
transactional
history
of
how
things
evolve
over
time
for
an
object,
I'm
pretty
sure
it's
there.
We
may
have
to
do
some
extra
work
to
to
build
that
out,
but
the
same
idea
is
we'll
be
doing
the
searchable
cache
and
then
the
ephemeral
database
for
the
documents
at
that
level.
A
Both
of
these,
when
we
go
through
and
and
do
all
this
stuff
we're
going
to
actually
be
creating,
we
may
need
to
create
two
sets
of
microservices
or
two
sets
of
libraries,
one
to
be
able
to
interact
with
the
ipfs
another
one
to
interact
with
the
oci,
but
when
the
idea
is
when
we
pull
something
off
of
the
storage
that
it
gets
transformed
into
whether
it's
coming
from
oci
or
nft
ipfs
that
it
gets
transformed
into
the
same
object
and
then
that
same
object
is
pushed
back
over
to
the
front
end.
A
A
One
of
the
things
that
we
may
need
to
do
is
to
keep
a
in
interim
postgres
database
around
and
that's
basically
for
things
like
user
IDs,
Access,
Control
domain
names,
not
a
hundred
percent
sure
are
this.
This
is
gonna,
be
one
of
those
that
kind
of
plays
out
as
we
go.
A
A
Just
based
on
some
of
the
like
prototyping
I've,
been
doing
like
these
two,
where
we
have
a
service
for
creating
doing
a
create,
update
or
delete.
Then
another
service
for
the
just
for
the
read
I
think
we'll
be
able
to
combine
these
the
arango,
DB
and,
and
some
of
the
layouts
in
Python
aren't
too
big.
So
it
doesn't
look
like
we're
getting
a
huge
massive
microservice.
A
A
So
the
number
of
microservices
Will
basically
go
in
half
here.
One
of
the
things
I
did
introduce
was
tagging
a
component
tag,
an
application
tag.
I
have
not
heard
anything,
I,
don't
know.
If
he's
on
the
call
today,
if
Nick
is
here
from
Ukraine
now
it
doesn't
look
like
it,
but
we
may
need
tagging
in
order
to
do
some
of
the
additional
searching
and
UI
layout.
A
So
I
added
that
in
there,
basically,
if
you
think
of
like
Docker
Hub
or
even
like
npm
dot
org,
you
can
tag
things
and
say
this
is
a
a
login
method,
or
this
is
going
to
be
a
compression
function
that
that's
the
type
of
tagging
I'm.
Thinking
that
we
may
be
able
to
use
to
help
find
things
in
the
in
the
database
ignore
this
down
here,
because
I'm
going
to
go
over
to
another
document.
B
A
B
A
So
I
did
do
a
I,
basically
a
like
a
class
layout
of
the
objects.
So,
for
example,
we'll
go
down
to
something
a
little
more
interesting.
A
Components
here
so
some
of
the
things
that
when
we
lay
out
a
component,
this
is
mostly
this
data
structure
is
coming
from
the
postgres
database.
For
the
most
part,
I
did
take
the
opportunity
to
reorganize
some
things
slightly
to
just
make
it
a
little
more
efficient,
and
these
classes
and
objects
are
going
to
be
what
the
UI
front
end
is
going
to
consume.
A
A
That's
like
pretty
much
all
that
we
need
in
the
list.
So
this
is
like
the
example
here
where
we
have.
The
hello
world
is
the
name
and
the
in
the
domain
that
it
lives
in
there's
other
things
that
we
have
to
provide
like
the
parent
and
parent
I,
the
parent
of
the
component
version
things
like
that,
so
this
will
be
pretty
close
for
the
list
and
same
thing
like
with
the
application
version.
A
Basically,
it's
like
the
the
the
name
and
the
domain
from
there
if
we
actually
look
at
an
individual
component,
so
when
you
go
into
in
the
UI,
you
click
on
a
from
the
list
view
you
click
on
an
actual
component
version
to
dive
into
the
details
we
actually
inherit
from
the
previous
one.
So
all
that
the
name
and
stuff
like
that
comes
from
there
other
things
that
we
need
to
have
are
like
the
owner,
the
Creator,
the
type
packages,
basically
the
s-bomb
data.
A
What's
what's
the
list
of
all
the
the
s-bombs
that
are
consumed
by
this
component
version,
this
is
of
type
package.
So
it's
a
list
of
packages
and
then
we
have
like
a
list
of
vulnerabilities.
A
We
have
a
readme
the
list
of
applications
that
are
consuming
this
and
then
like.
What
is
this
component
version
provide
for
restful,
API,
endpoints
and
what
it's
consuming,
and
then
we
have
our
attributes.
Our
attributes
are
all
the
key
value
pairs
that
we
have.
One
of
the
things
on
the
audit
log
I
was
looking
at
I
think
this
is
going
to
probably
change
I
have
to.
A
We
have
to
play
it
out
because
this
will
be
coming
from
The
xrpl
Ledger,
for
example
the
audit
Trail,
so
it
may
or
may
not
be
Associated
to
this
I
have
to
look
at
that.
So
when
you
look
at
the
Json
after
it's
all
expanded
out,
you
have
your
name,
your
owner
information,
the
packages
that
you're
dependent
upon
the
vulnerabilities.
A
You
read
me
your
attributes,
all
your
attributes
and
stuff
like
that,
and
this
is
one
of
the
reason
why
I
chose
a
Rango
over
some
of
the
other
graph
databases,
because,
like
this
part
here
around
the
attributes,
it
can
be
free
form.
So,
if
we
want
to
add
in
like
the
committers
username,
we
can
add
that
into
this
list
without
having
to
go,
redefine
the
schema.
A
So
as
people
go
through
and
and
add
in
their
own
attributes,
we
can
actually
just
you
know
on
the
Fly,
not
have
to
worry
about
changing
database
schema
and
just
go
ahead
and
consume
them
at
that
level,
and
then
you'll
see
we
have
application
version.
So
I
pretty
much
all
of
the
objects
out
here
that
we
need
and
examples.
So
if
we
actually
go
over
to.
A
And
and
if
you
look
at,
let
me
jump
over
here:
real
quick,
I've
stubbed
out
a
a
little
Python
program,
so
we
have
our
our
git.
So
this
will
give
retrieve
a
list
of
all
the
component
versions.
A
A
This
all
just
is
a
the
object,
that's
coming
across
from
the
front
end
in
Json
format
and
then,
when
we
go
to
save
it
to
the
database,
we'll
transform
that
that
object
into
the
normalized
version
break
it
out
into
all
the
little
pieces
and
shove
it
into
ipfs
or
oci
in
the
right
locations
and
then
add
it
to
the
the
Rango
database
in
like
its
full
format
at
that
level.
So
if
we
look
at
the.
A
The
Swagger
for
this-
if
we
do
our
git
here,
we
can
see
that
we're
going
to
get
the
key
value
which
is
going
to
be.
You
know,
basically
a
number
a
unique
number
for
that,
and
one
of
the
things
I
was
realizing
last
night
was
the
key
actually
could
be
the
Sid
on
ipfs
at
that
level.
A
So
the
key
is
basically
a
string
and
we
may
be
able
to
use
the
ipfs
Sid
for
the
key
which
will
help
some
of
the
searching
and
things
and
simplify
some
stuff
a
little
bit
up
in
there
still.
So,
when
we
look
at
the
get,
we
can
actually
see
the
example
coming
back
of
all
the
data.
That's
going
to
be
passed
back
to
the
front
end
at
that
level,
so
I'm
going
to
go
ahead
and
build
out
the
stubs
for
the
other
restful
apis.
Like
I
said
it
doesn't
look
that
bad.
A
You
know
we
got
maybe
a
half
dozen
a
dozen
that
we
need
to
do
so.
The
one
we're
just
looking
at
is
this
combination
and
I'll
stub
it
out
for
all
the
other
main
stuff,
because
we
already
have
all
the
objects
pretty
much
defined.
A
A
Some
of
the
coding
that
we'll
need
to
do
is
actually
go
through
and
things
like
the
the
normalization
denormalization
of
the
Json,
the
right
through
cache.
Those
type
of
things
will
need
to
kind
of
manage
on
that
front.
A
A
From
that
that
perspective,
so
that's
kind
of
what
I've
been
working
on
and
giving
us
I
will
create
a
PR
for
the
architecture
here
once
I
get
a
little
bit
further
along,
hopefully
next
week
early
next
week,
I'll
have
the
pr
out
there
for
us
to
actually
approve
and
make
sure
and
comment
on,
and
things
like
that
to
make
sure
we
have
everything
covered
at
this
point.
So
that's
it
for
the
the
presentation
and
if
anybody
has
any
questions,
let
me
know
a
lot
to
cover.
B
A
So
I
dropped
into
the
into
Discord
on
the
dev
channel.
The
two
front
ends
the
Joseph
brought
the
one,
the
second
one,
the
the
riot
one.
That
is
what
Docker
Hub
uses.
A
A
The
idea
behind
Google
material
is
to
create
these
components
these
web
components,
so
you
can
think
of
as
widgets
that
you
get
to
reuse
and
stick
on
the
UI.
They
went
through
a
lot
of
research
on
the
the
component
widgets,
so
you
know
a
if
you
want
to
draw
a
box
with
curved
Corners.
They
have
spec
on
what
the
radius
of
the
curved
corner
is
supposed
to
be.
I
mean
they
went
crazy.
A
You
know
how
how
much
space
should
be
in
between
each
each
line
in
which,
in
between
each
widget
on
the
screen,
so
that
one
is
yeah.
They
went
crazy
over.
If
you
look
at
the
material
I
think
maybe
material
that
I
owe
I
can't
remember
off
the
top.
My
head.
A
A
And
now
the
other
one
is
I,
don't
know
as
much
about
Joseph
was
the
one
I
found
or
recommended
that
one.
So
we
had
to
take
a
look
at
that
as
well.
I,
don't
think
it's
component
based,
but
it
does
look
like
an
easy
framework
to
utilize.
A
A
It
has
I
believe
the
other,
both
of
them
have
like
the
concept
of
a
router
that
you
put
all
of
your
back
end
calls
in.
So
all
your
Ajax
calls
to
make
the
database
restful.
Api
calls
is
in
this
router
and
each
front-end
page
talks
to
the
router,
and
then
the
router
talks
to
the
the
back
end.
A
It
is
it's
they're,
very
angular,
react
type
of
Frameworks
and.
A
It'll
need
to
be
in
its
own
container
and
that's
where
we
could
possibly
even
containerize
it
a
little
further
down
the
road
where
we
can
container
like,
especially
with
the
riot
one.
We
can
containerize
those
individual
component
widgets.
So
if
we
want
to
go
out
and
replace
or
update
a
component,
we
can
do
it
that
way,
because
it's
it's
kind
of
more
like
on
the
Fly
I,
don't
think
it's
compiled.
C
And
why
do
you
want
to
use
a
container
for
that
I'm
going
to
ask
a
really
crazy
question
now:
okay,
I'm
glad,
because
I
know
that
you'll
give
me
a
great
answer
since
they're
all
static
files,
content
just
ran
out
of
a
bucket
with
some
smart
cloud
formation
or
a
type
of
CDN
in
front
of
it.
Yeah.
A
A
A
A
You
can
have
two
different
versions
running
at
the
same
time
and
you
can
actually
use
istio
to
pick
which
one
you
want
to
go
to,
so
the
dev
side
could
be
picking
up
the
new
version
of
the
container
with
the
new
color
of
the
component,
where
the
production
one
is
still
using
the
old
container
and
as
you
go
through
and
do
your
testing
you
can
actually
then
basically
do
a
istio
switch
on
the
virtual
routing
to
say.
Okay
now
this
is
the
new
container
I
want
you
to
use
for
production.
A
So
yeah
you're,
it's
it's
one
of
those
things
that
we
have
to
look
at
from
a
now.
How
much
are
those
widgets
gonna
change
and
how
much
are
we
going
to
be
dealing
with
that
stuff?
It's
probably
low
so
like
your
suggestion
of
dealing
with
using
a
CDN,
will
probably
be
the
the
easier
way
to
go.
C
Yeah
I
was
just
asking
because
it's
it's
obviously
cheaper
to
run,
run
it
like
that.
Right
then
running
it
in
a
kubernetes
cluster,
which
is
much
more
expensive
yeah
and
it's
just
static
files.
But.
D
F
Can
connect
you
to
Martinez
Martina
from
Roadie
she's.
D
F
D
F
A
D
So
that's
really
important.
I
want
to
start
with
the
backstage
this
time,
because
there's
a
lot
of
or
a
lot
of
a
lot
of
noise
coming
in
the
backstage,
so
I
want
to
have
some
content
on
that.
So
please,
please
circulate
some
emails,
so
we
are
up
to
19th
of
January
and
haven't
doing
any
podcasts,
so
I'm
waiting
for
some
guest,
okay.
D
A
Yeah
any
other
questions.
A
C
It's
to
get
developer,
it's
a
developer
environment,
I,
don't
know
what
is
a
good
I
call
the
tortillas
in
a
box,
but
it
doesn't
have
to
be
called
there,
because
that
doesn't
really
make
sense.
Anybody
I'm,
of
course,
you're
a
developer.
What
makes
sense
to
you
if
you
were
joining
an
open
source
project,
I'll.
C
A
I
did
at
the
just
to
give
you
an
update.
I
had
to
I
did
submit
to
GitHub
our
application,
the
contract
for
the
GitHub
sponsorship,
so
we
can
get
paid
through
GitHub
for
working
on
issues.
I
haven't
heard
back
from
them,
yet
I'm
going
to
see
if
I
can
get
some
help
from
the
Linux
foundation.
On
that
front,
it's
kind
of
a
black
box
when
you
talk
to
GitHub
as
a
small
company
yeah.
A
So
hopefully
the
Linux
Foundation,
since
they
initially
started
the
conversation
they
may
be
able
to
help
us.
C
A
And
then
I'm
gonna
also
the
xrpl
folks.
We
had
a
meeting
with
them
the
other
day
and
they
kind
of
like
a
group
meeting
and
one
of
the
things
they
asked
us.
If
there's
anything,
they
could
help
us
with
and
I
think.
A
Once
we
get
some
stuff
a
little
bit
further
along
I'm,
going
to
circle
back
around
them
to
make
sure
see
if
there's
anything,
they
can
provide
from
their
side
to
make
life
easier
for
doing
this
type
of
handling
of
the
money
for
open
source
projects.
A
B
A
A
G
No
so
Steve,
like
already
picked
up
like
three
of
the
issues
xrpl
so
I
saw
like
you,
have
created
a
couple
of
issues,
so
if
there
is
something
that
we
need
that
that
we
need
to
cover
a
Purge
on
the
Urgent
basis
right
just
let
me
know
I'll
start
working
again
will.
A
Do
I
think
that
from
the
coding
perspective,
the.
A
The
the
biggest
part
that's
going
to
be
probably
the
most
difficult,
is
going
to
be
the
transformation
from
back
and
forth
between
normalize
and
denormalized
I
think
that
is
going
to
be
either
some
node.js
or
some
python
libraries
to
be
able
to
do
those
Transformations
I
think
that's
going
to
be
where
the
most
of
our
work
is
going
to
be
at
and
things
like
once
we
get
the
the
the
the
the
full
denormalized
document
and
shoving
that
back
to
the
front
end
and
creating
the
front
end
should
be
pretty
easy.
A
If
we
do
the
back
end
work
correctly,
that's
what
I'm
hoping!
Oh
you
never
know,
but
that's
that's
the
goal.
So
I
will
once
I
get
this
architecture
document
out.
There
I'll
start
going
in
assigning
issues
to
folks,
so
people
know
what
they
can
start
work
out
or
you
know,
throw
out
a
list
for
people
to
pick
and
choose
of
what
what's
on
the
short
term
list
that
we
need
a
code.
A
B
F
There
was
a
person
I
spoke
to
on
the
on
the
xrp
breakout.
That
said,
he
had
built
a
a
a
search
for
nfts
and
ipfs
I.
Believe.
E
A
B
A
Yeah
I
found
the
the
playground.
A
And
looks
like
what
he's
doing
is
you
give
it
a
a
sid,
basically
an
nft
and
then
it'll
go
through
and
and
visualize
it
so
I,
don't
think
it
has
the
search
capability
that
we're
looking
for.
F
A
But
it
may
come
in
the
may,
help
us
with
the
when
we
get
into
The,
Ledger
and
kind
of
like,
given
a
ledger
transaction
being
able
to
to
visualize
it
or
pull
things
apart.
A
For
this
individual
trans
I
can't
tell
if
it's
a
trade
layout
is
a
trade
on,
so
it
is
a
it's
looking
at
The
Ledger
and
then
from
the
ledgers.
Looking
at
all
the
history
for
that
ledger,.
F
B
G
Yeah,
so
the
conditions
that
are
there
on
the
for
the
equating
right
essentializing
this
yeah.
A
Because
some
of
the
transactions
you
can
see
were
this
basically
xrp
coin
is
being
traded
and
all
the
transactions
along
with
it.
G
G
Why
application
name
itself
is
mutation
parser,
like
whatever
changes
happen
over
the
time?
If
this
application
is
passing
this.
B
F
Here's
the
GitHub
repository,
oh.
B
F
Well,
he
said
he'd
be
happy
to
chat
with
us
about
what
he's
doing
all
of
his
stuff
is
open
source.
If
there's
any
way,
we
he
there
his
stuff
could
help
us.
B
Yeah
we
can
looks
like
he's
written
in
PHP,
interesting.
F
A
A
At
least
at
least
for
some
of
the
transactions
I
think
you
know
we
may
not
have
every
single
object
being
pushed
back
and
forth,
but
kind
of
starting
at
the
lowest
level,
which
would
be
component.
Inversions
are
kind
of
like
the
lowest
level
objects
that
we
have,
because
then
you
know,
application
versions
consume
those.
So
that's
why
I've
been
focusing
mostly
on
component
versions.
A
But
looking
at
the
the
samples
for
like
the
orango
piece,
it
looks
like
just
a
couple
lines
of
code
to
be
able
to
to
add
something
to
the
the
database
and
fetch
it.
So
it
doesn't
look
that
complicated.
G
Yeah,
but
do
you
know
like
how
like
how
much
data
that
is
there
for
your
application,
because,
like
I,
haven't
seen,
there
is
any
concept
of
easy
pitching
there.
A
I
think
most
of
it
will
be.
Oh
there'll,
be
two
two
types
of
data
that
will
we
basically
retrieve
is
one's
a
list,
and
the
list
is
basically
like
I
said
just
just
like
name
and
domain
are
in
the
list,
and
then
we
have
the
detail.
So
it's
really
like
two
types
of
transactions
that
we
have.
Oh
and
then
the
other
one
is
gonna,
be
the
graphing.
You
know
dependency
to
dependency
graphing.
A
Those
type
of
things
is
more
of
a
you
know
the
what
they
call
them
the
edges
and
no
or
notes
I
can't
remember
the
column,
notes
or
edges
and
in
a
Ringo,
but
those
relationships
are
something
that
we
would
be
another
type
of
query.
A
And
and
data
wise
I
think
because
we're
going
to
be
using
a
Rango
as
just
a
an
ephemeral
database
that
will
kind
of
populate
on
the
fly
from
ipfs
and
The
Ledger
that
we
should
be
able
to
to
minimize
the
amount
of
data
that
we
are
going
to
store.
I,
don't
think
we're
gonna
have
to
worry
about
in
the
orango
database.
Dealing
with
like
a
terabytes
of
data,
I
think
it'll
be
relatively
low
in
the
gigabytes.
F
All
right,
I
got
I
got
most
of
that
done
yesterday.
I'll
send
everybody's
kind
of
statements.
A
I
just
had
to
push
your
website.
F
A
All
right,
cool,
I'll,
Sasha
I,
will
send
you
a
message
on
Discord.
A
I'll
give
you
full
access
to
it,
so
you
can
just
do
whatever
and
not
have
to
worry
about
the
hours.
Okay,.