►
From YouTube: CoffeeTalk - gx
Description
A
B
B
But
yeah
so
just
gonna
do
it
in
the
Chemex
and
not
really
talk
too
much
about
how
that's
working,
because
I've
done
this
before
and
yeah
so
GX
is,
is
a
two
letter.
Name
stands
for
absolutely
nothing:
I,
just
literally
typed.
First,
two
letters
on
the
keyboard
that
I
could
and
made
that
the
name
of
the
thing
I
was
working
and
the
reason
for
it
is
I'm.
B
Sick
and
tired
of
all
these
different
package
managers
not
quite
doing
things
the
right
way,
because
manager
really
is
like
the
base
based
thing
that
it
does
is
ok,
I've
have
a
package.
It
requires
these
other
things.
I
need
to
go,
get
those
things
and
then
I
need
to
go,
get
the
things
that
those
things
need
and
so
on,
and
that's
like
every
package
manager
does
that
and
every
package
manager
appears
to
do
it
differently
and
why
that
doesn't
make
sense.
B
So
that's
that's
kind
of
like
the
base
level
of
what
effective
manager
needs
to
do
and
I
guess
really
GX
isn't
so
much
a
package
manager
as
it
is
a
base
framework
for
content,
distribution
and
managing
up
appendices.
You
can
easily
build
a
package
manager
on
top
of
GX,
for
example,
for
go
right
now.
I've
built
GX
dash,
go
which
works
really
nicely,
because
the
way
I
design
GX
is
to
work
like
it
does
and
you're.
B
So,
if
I
have
a
go
project
and
I
use
DX
with
it,
it's
going
to
look
forward.
T
X
dash
go
by
the
node
project,
it's
gonna
end
up
doing
things,
that's
going
to
look
for
GX
dash,
know
to
call
up
a
bunch
of
like
sub
hooks,
and
anybody
who's
used
like
get
hooks,
will
know
kind
of
how
that
works
any
like
and
get
any
binary.
You
name
as
like
get
dash
some
name.
B
You
can
run
as
and
get
that
name
and
it
kind
of
like
integrated
into
the
tool
makes
it
feel
unified,
which
is
a
really
cool
feature,
and
that's
kind
of
like
what
I'm
striving
to
kind
of
take
that
same
feeling
into
a
package
manager.
So
now
the
question
is
why
why
would
I
do
this
content?
Addressing
is
really
nice?
B
It's
great
to
be
able
to
have
a
hash
that
that
says
this
package
is
exactly
the
package
you're
expecting
it
to
be,
nothing
can
possibly
be
different
unless
there's
like
transient
dependencies
done
your
OS,
which
you
can
still
like
account
for
there's
no
versioning
confusion.
You
can
say:
okay
I
depend
on
this
hash
for
this
package.
Well,
you
pretty
much
guaranteed
to
get
the
exact
same
package.
You
don't
get
the
weird
semper
crap
order.
Oh
I
did
a
minor
or
a
patch
bump
and
it
broke
everybody's
code.
B
That's
fun,
so
I'm
saying
no
December
and
we're
doing
direct.
You
know
this
is
what
you're
importing
and
so
I
hope.
That's
going
to
solve
some
problems
that
we've
had.
The
next
thing
is
that
well,
this
is
cool
file
system
thing
called
I
PFS,
and
it's
pretty
neat
it
does
like
you
know
you
can
distribute
files,
peer-to-peer
and
other
fun
stuff
like
that,
so
I'm
building
2x
on
top
of
I
PFS,
which
means
that
we
get
all
the
nice
built-in
peer-to-peer
file
transfers
on
top
of
it.
B
Look
that
lets
us
do
is
I
I
need
to
install
a
package.
Then,
if
the
person
next
to
me
has
it
I
can
install
it
from
them
instead
of
installing
it
from
the
global
servers
or
from
you
know,
some
random
CDN
somewhere,
which,
for
things
like
when
we
r
you
know
up
at
Arctic,
j/s
sitting
in
small
barred
with
you,
know,
a
small
pipe
to
the
real
world
and
somebody
off
called
runs
MPM
install.
It
won't,
kill
our
internet
that
actually
happened.
That
was
really
fun.
B
We
were
trying
to
figure
out
what
was
going
on
with
the
internet
and
our
video
call
dropped
out,
and
everybody
like
looks
right.
Who's
doing
is
using
hey
Mike
who's
using
Internet
he's
like
oh
I,
just
ran
an
NPM,
install
I,
didn't
think
anybody
would
notice.
No,
we
noticed,
but
if
you
know
if
the
NPM
packages
were
in
I
PFS,
then
he
would
have
just
fetched
them
from
you
know.
B
People
around
us,
since
the
people
that
are
thick
ge'ez,
probably
have
most
of
the
NPM
packages
in
the
world
installed
under
computers
at
some
point,
and
I
think
david
has
a
hard
drive
with
all
of
them
on
it.
If
I'm
not
mistaken,
yeah
so
yeah
plus
you
get
into
duplication,
which
is
really
great,
because
if
I
have
the
same
thing
you
know
at
two
different
places,
I
don't
have
to
sort
twice.
B
C
C
Okay,
sorry,
Oh
teaching,
the
other
corner
the
thing
that
I
PFS
select
by
using
IP
it
has,
as
the
transport
lawyer
for
GX
one
other
thing
that
we
get
for
free,
fri,
sample
package
integrity
right.
One
of
the
things
that
like
npm,
is
still
fighting
right
now
is
how
to
make
sure
that
if
we
install
a
package,
we
actually
saw
unicode
that
we
are
hoping
for
and
from,
and
you
can
like
talk
more
about
this
journey
is
the
weather,
GX
works
and
the
way
that
GX
in
South
packages
everything
gets
referenced
by
the
ash.
B
B
You
can
specify
a
a
repo
as
just
a
hack
and
I
PFS
hash
or
an
IP
NS
entry
or
it
you
know,
I
P&S,
dns
entry,
anything
that
can
be
resolved
and
all
that
is
is
that's
essentially
just
a
directory
or
an
IP
of
s,
object
where
the
links
are
named
and
they
point
to
packages
by
that
name.
And
if
you
add
a
repository
to
your
GX
config,
then
you
can
stay.
B
Gx
install
this
package
name
by
its
short
name
and
it
will
use
your
repository
is
to
resolve
that
to
the
hash
name
and
the
way
I've
set
it
up
is
that
it
can
be.
You
can
configure
global
repositories,
you
can
configure
/
environment
repository,
so
I
can
set
up
a
repository
for
go
one
for
node
one
for
linux.
You
know-
and
you
know,
depending
on
the
situation
you're
in
and
you
can
also
set
them
up
just
per
package,
so
it
can
be
in
the
package
config
that
this
is
the
repository
to
use
and
this.
B
So
this
lets
us
still
have
kind
of
like
a
nice,
pretty
name
space,
but
it
also
lets
us
avoid
the
gross
like
global
namespace
collision
crap.
So
you
won't,
you
know
you
don't
have
to
type
in
all
these
hash
names.
You
just
have
to
you
know
type
in
your
repo
name
once
and
configure
it
and
then
from
there.
You
can
use
that.
D
B
For
like
four
npm,
we
would
just
have
one
npm
hash
for
the
entire
nvm
registry
or
repo,
and
that
could
end
up
being
like
just
a
domain.
It
could
be
npm
names,
I,
BFS
or
something
like
that
or
my
BFS
name
and
you'd.
Add
that
as
your
NPM
registry
repo
and
then
anytime,
you
type
an
NPM
package
name.
It
would
go
to
that
to
look
up
the
hash
that
maps
to
IC.
D
C
Think
about
it
as
I
doing
a
shrink
wrap
on
NPM
+
F
in
package
shining,
so
you
actually
walk
down
to
a
version
and
you
warranty
integrity
of
the
package
and
once
you
install
it
the
first
time
so
imagine
like
you,
are
developing
a
new
sir
notes
and
you'll.
Do
a
GX
install
for
all
your
packages.
Now
you
ship
that
package
of
Jason
to
your
production
servers
yeah.
That
package
of
Jason
can
have
the
ashes
for
the
modules
that
you
installed
and
you
had
a
convenience
of
being
solid
by
name.
C
But
when
it
chips
to
the
pure
build
servers
to
the
production
servers,
it's
going
to
be
installed
by
the
ash.
So
the
production
server
can
actually
verify
before
running
the
code
that
it
got
the
right
package
when
it
was
right-
and
that's
like
when,
like
a
lot
of
vulnerabilities,
happen
right
like
weights
when,
like
someone
deploys
a
piece
of
code
that
like
is
fetching
from
somewhere
and
in
my
machine-
and
it
was
working
nicely
because
I
was
touching
the
right
code.
C
But
in
this
production
server,
someone
managed
to
use
one
of
the
new
and
other
tax
possible
to
ship.
Some
new
clothes
inside
a
package
that
I
had
no
way
to
validate
and
I
started
running
that
package.
On
my
production
server
on
my
life
service
and
by
using
GX
plus
I
PFS,
you
get
that
for
free
I,
you
get
to
integrity,
checks,
free
and
you
still,
you
can
still
have
the
convenience
of
using
names.
While
you
are
developing
your
app.
D
C
I
think,
like
another
thing,
that
we
can
also
read
Jim
if
you
are
talking
right
now,
muted,
so
and
so
I.
Another
thing
that
we
can
also
reference
for
GX
is
the
case
of
ulnar
ship.
The
idea
that,
like
you,
can
start
everything
like
almost
like
a
registry
instead
of
like
being
a
place
where
all
the
modules
all
the
code
is
stored,
can
be
just
our
reference
to
the
ashes
for
the
modules
X
you
might
want
to
install
and
then
the
modules
leave
on
a
network.
It's
all.
C
You
can
tell
like
to
store
everything
in
one
server
or
one
or
more
servers
across
the
planet
to
be
able
to
serve
everyone.
You
can
just
like
use
a
network
to
the
Liberty
those
packages
and
I'll
see
you
get
like
namespaces
swatch
ownership
of
free
for
a
very
long
time
like
this
is
a
battle
of
every
packet
trainer
chip
ever
especially
those
ones
that
turn
into
companies
so
that
they
have
to
provide.
C
The
service
very
well
is
out
to
create
a
private
namespace
or
just
even
a
group
of
Project,
an
organization
in
space
that
can
still
room
in
public,
but
they
want
to
have
ownership
of
that
namespace
in
the
module
name
that
we
will
publish
under
that
minister,
and
you
can
do
that
with
IPS,
which
is
also
part
of
our
chats
right.
Like
you.
C
Instead
of
just
using
raw
I
PFF
ashes,
you
can
have
decide
pns
these
mutable
links
that
beyond
to
a
PFS
network
and
that
still
get
validated
not
true
by
cryptographically
action,
the
module,
but
by
validating
the
digital
signature
on
the
record.
Let's
get
publishes
his
name
and
you
can
create
like
several
independent
names,
for
your
organization
or
for
multiple
organizations
in
the
case.
C
So
this
not
checks
but
like
this
is
almost
like
a
test
case
wash
experiment
such
warnings
from
the
thing
that
we
did
in
registry
mirror
we
were,
we
constantly
publish,
we
constantly
publish
an
IP
mls
record
with
the
basically
the
listing
of
all
the
module
names
on
at
10pm,
and
this
way
we
have
like
this
universe
like
this.
This
namespace,
which
is
nvm
with
all
the
modules
that
are
available
on
NPM
right
now,.
C
B
You
kinda,
you
killed
it
there.
The
other
thing
I
wanted
to
mention
about
GX
is
kind
of
a
little
bit
of
the
design
I
mentioned
earlier
about
how
does
like
the
get
style
call
out
to
sub
binaries.
So
the
way
that
works
is
after
everything
you
do
like,
let's
say
I
do.
Gx
install
after
every
package
is
install
or
up
every
package
is
installed.
B
Does
that
for
all
sorts
of
different
things,
and
that
way
you
know,
GX
itself
can
do
the
core
heavy
lifting
of
get
these
packages
resolve
the
dependencies,
pull
them
down,
put
them
in
the
right
place,
and
then
your
subtool
can
do
the
minimal
logic
required
to
make
it
work
for
your
language
or
for
your
environment
platform,
whatever
and
I.
Think
that's
kind
of
like
a
really
beautiful
thing
for
us
to
have
that
way.
B
Any
improvements
we
make
to
the
core
will
benefit
all
this
child
package
managers,
and
then
we
still
don't
force
a
lot
of
things
on
the
child.
You
know
all
the
different
package
managers
that
use
it
because
they
have
the
freedom
to
do
things
really.
However,
they
want
then
can
specify
where
things
are
installed
at.
They
can
specify
like
scripts
to
run
after
they're
installed.
B
You
know
binary,
install
or
even
like
have
it
select
the
dependency
and
fetch
that
dependency
base,
which
platform
you
running
and
that
way
GX
install
chrome
or
whatever,
and
it
would
go
say:
okay,
you're,
on
linux,
x86.
You
should
go
fetch
this
and
download
this
one
and
install
it
with
these
dependencies
and
just
works.
You
know,
that's
that's.
My
hope,
for
this
is
self
somic
distribution
of
like
actual
system
binaries
and
system
packages
easier,
but
yeah.
D
Nice
subscript
are
modular
enough
so
that
you
can
do
something
like
everybody's,
not
familiar
with
brew
cask.
So
home
brew
cask
is
like
this
edition
of
you
can
install
packages
but
we're
in
the
sense
of,
and
so
their
dmg
files,
usually
for
mac,
and
they
have
a
visual
installer
and
cast
as
some
magic
to
run
these
visual
and
stores,
without
actually
showing
them
to
you
so
effectively.
B
D
What
about
yeah,
yeah,
11
nasty
thing
so
there,
for
example,
if
you
install
an
anchorage
from
NPM,
buy
a
gift
or,
for
example,
cask
uses
the
official
like
download
locations
if
it
actually
downloads
the
battery,
it
doesn't
do
put
them
anywhere
else.
In
addition,
is
there
any
way
to
do
something
like
that
so
fetching
things
from
outside
of
IP
of
s,
because
things
are
just
not
there
yet,
for
example,
if
I
fetch
something
from
one
to
install
package
from
github,
it
will
not
be
a
festival.
B
Right
so
so
what
we'd
be
able
to
do
is
if
you
clone
it
down
from
github,
and
it
still
has
the
it
still
has
the
package.json
from
GX.
All
you
have
to
do
is
run
GX,
install
and
then
from
there.
It
would
go
and
grab
everything
it
needs
and
install
it
the
same
exact
way.
So
it's
got.
It
doesn't
matter
really
how
you
get
the
package
as
long
as
you
have
the
package.json,
and
it
looks
right
that
it's
going
to
be
the
same
I
think
that's
what
you
were
asking.
D
B
B
D
B
The
repo
is
underneath
my
username,
and
why
are
you
sleeping
/
GX
on
github?
Any
questions
just
go
ahead
and
file
an
issue
or
pygmy
on
IRC.
Definitely
filing
issues
is
good
and
try
it
out.
You
know
give
it
a
few
test
runs.
One
of
my
goals
this
week
is
to
use
it
for
during
I
PFS
I'm
going
to
be
pulling
lib.
Peer-To-Peer,
well-lit
peer-to-peer
is
already
pulled
out,
but
I'm
going
to
make
go
I,
PFS
use
it
as
a
GX
dependency,
and
this
is
gonna
be
fun.
C
B
B
B
B
So
that's
just
like
the
modularity
aspect
of
it,
but
I'm
going
to
try
and
figure
out
a
way
to
make
those
install
at
the
same
time,
which
would
be
nice
but
yeah,
that's
GX
and
yeah.
Any
other
questions
are
we
want
to
call
this
remember
cool.
Well,
thank
you
all
for
coming
and
see
you
next
time.
Thanks.