►
From YouTube: Nix Fundamentals
Description
Presentation about fundamentals of Nix packaging tool.
Slides PDF: https://drive.google.com/file/d/1Tt5R7QOubudGiSuZIGxuFWB1OYgcThcL
A
Slights
yeah,
okay,
I
think
this
is
readable.
Okay,
so
I.
You
know,
I've
done
a
bunch
of
nicks
refactoring
recently
and
I've
managed
to
learn
a
bit
about
nicks
in
the
process
and
I
know
that
all
of
you
are
kind
of
worried
of
Nicks
and
touching
and
all
the
next
configuration
yeah,
that's
understandable,
especially
based
on
how
it
was
before,
which
was
just
a
mess
and
very
hard
to
get
through.
So
I'd
like
to
explain
to
you.
The
basics
in
this
presentation
go
over
all
the
syntax.
A
The
derivations
work,
how
we
can
make
shells
how
big's
packages
work
and
then
in
a
separate
presentation,
I'll
go
over
in
more
detail.
How
all
of
this
goes
together
and
as
they
just
react
well,
hopefully
have
some
time
at
the
end
for
questions,
but
if,
if
you
find
that
anything
is
unclear,
then
feel
free
to
interrupt
me,
although
I
would
prefer.
If,
for
the
time
being,
you
will
be
muted
because
I
am
streaming,
so
it
would
be
there
okay.
A
So,
first
of
all
what
is
Nix.
Nix
is
just
a
package
major
which
is
just
trying
to
solve
the
age-old
problem
of
dependency.
Definition
of
management
for
software
brand
also
for
the
pencil,
all
those
other
software
and
in
general,
it's
mostly
a
cyclical
graph,
with
some
small
exceptions,
and
it's
and
those
questions
usually
make
it
so
much
worse
and
there's
been
so
many
attempts
to
make
package
management
work,
there's
no
perfect
solution.
Nicks
is
just
another
one
of
them.
A
There's
some
exceptions
in
terms
of
cyclical
cyclical
elements
in
the
graphs
like
compilers
that,
for
example,
GCC
needs
GCC
to
compile
itself,
but
there's
no
def
many
examples
of
cycles
like
that,
but
in
general,
that's
what
it
was
made
for
and
it's
made
with
a
subset
of
Haskell
a
functional
programming,
language
I.
Don't
know
why,
but
that's
what
they
picked
and
essentially
spiraled
out
of
control,
and
now
it's
a
full-fledged
operating
system
and
I
think
I.
Think
it's
pretty
cool.
So,
let's
start
with
basic
syntax.
Of
course.
We
kind
of
know.
A
We
have
some
boolean
who
have
some
integers
floats.
What
have
you?
You
also
have
strengths
with
interpolation
simplex,
so
you
can
put
strings
inside
of
strengths
with
with
essentially
their
curly
brace
like
in
JavaScript.
You
have
lik
the
lists
with
mixed
types.
So
you
can
put
anything
you
want
in
there.
You
have
sets
where
keys
are
always
strings
and
the
values
can
be
any
type.
A
Syntax
were
used
twice
single
quote,
but
it's
it's
all
about
functions
right,
because
it's
a
functional
language,
so
functions
are
defined
with
the
cone.
After
your
argument-
and
it's
pretty
simple
like
let's
do
a
do,
a
wrap
or
so
it's
easier
to
explain.
I
have
to
this
is
readable
right
and
he
calls
X
next
week.
A
Thanks
to
and
to
give
me
a
form
right,
it's
just
a
single
argument:
function,
okay,
to
add
two
arguments
function
by
just
doing
like
X
y
plus
y,
to
give
me
four
right
and
similarly
in
other
functional
languages,
where
this
is
a
two
functions
rather
than
one
with
two
arguments.
There's
a
first
function
with
arguments
Y,
which
assumes
X,
is
available
and
there's
another
function,
relax
it
and
calls.
A
Why
am
I
providing
X
so
I
could
do
like
to
when
you
could
give
me
a
lambda
and
I
could
apply
the
toughing
and
then
go
added
with
another
I
might
say:
free
and
I
should
get
five
right.
The
eyes
is
the
partial
on
the
inside
about
the
first
arguments
right,
but
really
the
main
right
you
provide
your
arguments
and
Nick's
is
with
a
single
argument.
That
is
a
set,
and
the
main
advantage
of
that
is
that
you
have
the
named
arguments
which
is
easier
to
manage
and
you
have
simple
values.
A
So
we
can
rewrite
the
add
the
function
by
just
providing
a
set
with
a
different
value
of
two
and
a
treat
from
where
you
can
excellent
use
that
and
why
we
put
a
value
of
two
and
let's
do
it.
Why
right?
Are
you
trick
if
it's
a
lump
that,
because
I
need
to
give
it
an
argument?
So,
let's
give
it
an
empty
set
and
I
just
get
a
before
and
I
can
give
it
an
x
equals
three
and
I
should
get
a
fight
right.
A
Triple
thought
syntax,
which
allows
me
to
do
that
so
just
actually
also
the
default
and
and
ignore
the
a,
but
that's
very
edge
case,
usually
wouldn't
use.
Anything
like
that
and
and
sets
are
the
main
way
that
arguments
are
passed
around.
Only
small
utilities
and
libraries
use
the
positional
arguments
which
are
can
get
messy
especially
have
too
many
arguments
now
complex
expression.
So
what
files
in
Nix
are
always
an
expression?
They
can
be
function
or
they
can
be
just
a
value.
Returns
from
the
expression
are
usual,
there
are
a
function.
A
A
A
A
And
we
could
use
it
here
program
for
the
interpolation,
but
if
I
told
it
it
so
this
is
kind
of
a
weird
thing
and
in
mixes
and
shade
I,
don't
know
why
it
does
that.
But
you
have
to
keep
it
and
any
argument.
So,
let's
just
give
it
whatever
argument:
I,
don't
care
yeah
and
we
get
something
with
a
couple
like
the
default
inside
of
it.
Actually,
let's
do
LS.
A
See
another
clear
yeah,
so
we
could
add
some
more
stuff
like
a
list,
for
example,
one
two
three
four
and
then
input
so
mixed
stuff
and
we'll
get
a
list
with
default
right.
It's
wanted
to.
We
could
define
this
before
returning
them
and
it
could
return
a
set
with,
for
example,
just
a
string
nice
and
we
would
get
only
the
string,
but
this
is
important
to
do
that.
We
can
just
do
inherit
strength
and
you
could
carry
a
list
as
well
right
or
or
input
itself.
A
A
This
is
essentially
the
way
most
derivations
or
any
expressions
work.
You
have
inputs,
you
have
some
creative,
pre-prepared
variables
or
functions
that
use
and
back
to
the
current
value,
which
is
either
a
value
or
maybe
a
call
to
some
function.
That
returns,
values
way
that
now,
oh
and
there's
also
a
some
Flug.
If
you,
if
you
want
more
nice
route,
oh
we
can
specify
a
different
argument.
So,
for
example,
you
can
do
out
of
string
or
or
input
and
let's
say
whatever,
and
then
they
add
whatever
is
pulling
those
places.
A
So
you
can
get
a
patent
for
an
x
and
x
h2
to
modify
the
specific
expression
you're
working
on
now,
the
other
crucial
part
of
Nyx
languages
import.
You
can
import
another
file
into
the
file
either
as
data
or
as
a
function,
depending
on
what
the
file
contains.
Just
when
you
split
stuff.
So,
for
example,
if
you
wanted
to
put
this
list
into
separate
file,
we
could
do
separate
file
equation
X,
for
example.
You
could
take
this
list,
put
it
here
and
that's
just
left
alone,
and
you
do
a
list
import
yeah
like
this.
A
That
should
work
right.
It
does
one
because
we're
just
loading
it,
but
let's
say
what
we
did
want
to
an
input
to
be
here.
It
will
fail
because
it
doesn't
have
it
so
we'd
have
to
specify
in
two
thousand
arguments
without
equals
in
this
case,
and
this
would
fail
because
we're
not
passing
the
argument,
so
we
have
to
do
like
inherit
input
public
from
place
and
I
always
forget
cons,
yeah
and
now
it
works.
A
Now
now
the
input
is
passed
in
here
within
this
list,
but
if,
if
you're
doing
something
complex
and
you
have
multiple
files,
then
this
can
become
quite
big,
especially
when
you
have
like
multiple
additional
things
right,
so
it
becomes
very,
very,
very
bulbs
very
quickly.
So
what
you
can
do-
and
this
is
this-
is
kind
of
a
trick
that
is
used
all
around
the
necks.
You
can
create
a
new
scope
and
for
this
we'll
need
packages
so
we'll
need
to
import
packages.
Let's
do
that.
It
means
people.
Value
will
be
import.
Okay,
geez.
A
Configuration
and
we
can
do
something
like
call
actually
function
if
we
define
outside,
which
is
you
know,
scope
will
inherit
input
and
then
it
is
important
to
call
package
and
we
can
get
rid
of
this
argument.
Pension
to
work
with
a
break
of
course,
every
time,
every
time
with
a
semicolon
and
it
works
because
call
package
provides
the
arguments
by
default
through
inherit
here
in
the
new
scope
and
I
could
have
here
much
more
stuff
right.
A
So
if
I
can
I
have
the
multiple
core
packages
with
that's
required
in
scope,
it
will
be
much
central,
and
this
is
the
way
essential
packages
are
passed
around
and
Knicks
as
sure
that
you
would.
You
normally
see
you
where
it's
defined,
because
the
music's
very
used,
unless
you
really
have
a
special
case
where
even
porting
a
lot
of
files
or
something
like
that-
and
this
is
a
mainly
used
in
something
like
all
packages
and
we'll
talk
about
those
later.
A
So
let's
look
at
them
an
example
package.
You
have
a
Hello
package
which
essentially
defines
the
package
name,
the
version,
the
source
it
fetches
it
by
providing
a
set
to
a
functional,
called
fetch
URL
with
the
URL
and
Shaun
and
some
metadata,
and
that's
essentially,
all
you
need
to
press
the
M
key
derivation
to
get
a
working
hello
package
and
we'll
explain
that
in
a
second.
But
there
FP
the
division
takes
a
bunch
of
arguments.
There
is
much
more
than
then
you
would
see
in
many
derivations.
A
Of
course
you
have
the
package
name
and
version,
but
you
also
have,
for
example,
can
it
provide
multiple
sources?
You
can
provide
both
inputs.
So
if
you
have,
if
you
need
additional
tools
to
build
the
package,
you
can
configure
Flags
if
your
package
includes
the
configured
script
or
provide
a
list
of
packages,
but
you
don't
apply
and
all
of
this
gets
combined
into
a
derivation
file
or
a
drv
file
that
contains
all
of
this
information
before
the
first
search.
See
that,
let
me
just
show
you
real
quickly.
A
The
file
make
very
patient
because,
essentially
what
it
is,
it
was
just
a
function
which
is
defined
index
packages
and
that's
the
ends
of
generic,
which
takes
a
set
with
a
lot
of
arguments
like,
for
example,
building
books.
Here,
a
lot
of
arguments
and
we'll
put
some
magic
or
excuse
that
arguments
at
the
end
of
it.
It
just
calls
derivation.
It
was
just
a
wraparound
rotation
to
provide
some
additional
niceties
to
make
it
easier
to
build
packages.
A
A
A
A
It's
just
a
bunch
of
data
here
that
is
used
for
building
the
package
control
it
in
a
nicer
format
with
Linux
show
derivation
and
we'll
see
that
it
has
make
the
derivation
file
the
out
the
end.
The
cotton
ball
that
it
uses
the
the
system
target
system
version
package-
name
DMV
chooses
to
build.
So
all
of
this
essentially
and
builds
the
project.
So
what
I
did
before
is
I
build
the
package,
for
example
this
like
what
I
could
do
is
I
could
just
do
this
called
the
derivation
file
right.
A
Oh
they're,
actually
different,
because
I'm
just
here.
So
if
I
do
everything
so-
and
you
can
also
query
the
derivation
for
answer
form
for
additional
information,
like
name
or
SD,
emblems
or
SRC,
but
the
main
thing
to
understand
is
that
the
derivation
is
a
collection
of
all
of
the
impuls.
There
are
necessary
to
build
the
package.
Now,
why
is
the
hollow
being
built,
even
though
we
haven't
specified
the
things
like
GCC
or
make
well,
because
Nix
provides
something
called
the
standard
environment
nest
in
the
end
which
free
prepares,
all
of
them?
A
Most
usual
used
tools,
make
GCC
or
make
to
the
build
environment,
and
we
can
take
a
look
at
this
as
the
NFF
I.
Do
it
using
the
same
comments
to
derivations,
so
we
can
do
just
makes
sure
allocation
and
extra
babies
speedy
end
and
is
actually
there's
a
collection
of
various
tools
like
pouch
like
gzip,
like
you
make
GCC,
of
course,
and
a
bunch
of
other
stuff
like,
for
example,
the
setup
script
that
is,
he
is
to
essentially
build
everything
and
we
can
take
a
look
at
the
setup
scripts.
A
A
The
direct
build
function
is
a
function
that
calls
all
the
all
of
the
standard
phases
to
build
the
package.
So,
for
example,
it
calls
unpack
face
to
target
our
boss
touch
face
to
apply
patches
if
there
are
specified,
configure
face
to
configure
bill
to
come,
make
or
some
additional
phases
like
fix-up
phases.
If
you
want
to
patch
or
something
like
that
and
essentially
provides
the
result
in
to
the
output-
and
all
of
this
is
run
by
this
function.
A
It
essentially
runs
either
the
default
function
or
the
provided
phase
that
she's
defined
in
the
MP
derivation,
as
it
says,
the
following,
the
variable
name,
current
fight
and
if
it
exists
otherwise
functioning
translates,
and
we
can
see
here
that,
for
example,
a
look
at
the
build
phase
here
there
is
a
function
called
dual
state
and
what
built
phase
does
is
actually
just
runs,
make
with
some
additional
flags.
That's
all
adults
or
we.
A
And
that's
all
there
is
to
it:
two
tunics
go
to
section:
go
through
the
phases,
predefined
and
those
the
most
common
sense,
things
that
you
will
do
for
a
normalcy
package,
so
configure
make
make
this
whatever
and
all
of
these
phases
can
be
modified.
So,
let's
take
an
example
of
the
the
hello
package.
Hello
package
doesn't
change
any
of
these
phases.
We
look
at
the
whole
package
here,
a
little
bit
bigger.
If
you
look
up
a
whole
bunch
clear,
it
doesn't
define
any
phrases.
A
All
of
those
is
just
says
that
the
one
certain
to
check-
and
we
can
see
that-
could
you
check
just
here
and
it
verifies
that
the
check
weight
should
be
wrong,
but
everything
else
is
default.
So
if,
if
we
modify
this
package,
if
you
do,
for
example,
if
we
create
our
own
faces
like
say,
click
compute
your
faces,
we
can
do
click
configure
faces.
It
goes
with
the
fat
face
and
we
define
out
what
the
face
I'll
just
echo,
the.
A
All
right-
and
this
is
no
work,
so
let's
say
we
want
to
build
hello,
but
I
want
to
use
our
version
of
NYX
packages
from
I,
guess
homework
so
or
PPG's.
So
we've
run
this.
It
should
start
compiling
and
it's
we
see
that
it's
running
then
what
the
face
and
it's
printing,
what
the
right-
and
we
could
evoke
more
cool
stuff
here,
because
if
we
want
to,
we
can,
for
example,
change
this
to
do
something
more
useful,
like
show
us
that
their
environment
is
used
for
building
this
package.
Do
something
like
we
run
this.
A
You
can
have
it
up
here
and
we
see
yeah.
We
have,
for
example,
version
specified.
We
have
our
face
specified
FCC,
some
other
stuff
like
yeah
name,
so
it's
very
easy
to
debug
it.
Actually,
you
can
even
do
something
more
fancy
like
set
X.
If
you
want
to
see
all
of
the
comments
that
are
being
wrong
and
we'll
set
X,
if
we
run
it,
it
should
be
showing
all
the
comments
and
stop
it
yeah.
So
we
can
see,
for
example,
here
that's
running
configure
with
some
flags
like
prefix
to
specify
where
the
output
should
go.
A
So
it's
easy
to
debug
it
this
way,
and
you
can
do
this
with
every
other
face
like
if
I
wanted
to
break
the
build.
I
could
do
build
files
I'm
just
doing
one,
and
this
will
break
the
place
and
it
would
just
you
know
when
it
gets
to
it
will
go
for
the
configure
and
right
after
configure
face.
It
would
hit
their
exit
one.
A
That's
a
lot
of
configure
for
packages.
Just
prints,
hello,
world
Jesus,
all
right.
Why
did
he
do
this
yeah
there
we
go
and
go
well,
so
this
sdn
fields
provided
to
all
packages
and
you
can
modify
it,
but
in
general,
all
packages
are
built
this
standard
environment
and
we
can
explore
the
standard
environment
by
using
NYX
shell.
You
can
use
Excel
and
call
it
for
a
specific
package
in
order
to
see
that
environment
that
is
provided
by
standard
and
and
the
definition
of
your
derivation.
So
let's
go
right
now,
let's
call
as
focus
for
now.
A
A
We
can
use
type
you
can
Eric
build.
You
can
see
that
the
neck
build
is
a
function.
It's
provided
here.
I
can
call
it
if
I
want,
but
I
can
also
show
you
that
we
have
a
CD
and
just
here,
which
is
the
place
that
provides
us
the
function
because
we
consume,
but
it
is
tedious.
There
is
a
setup
script
and
that's
setup.
Script.
A
Is
the
one
we
were
just
looking
at
and
it's
sourced
before
the
Charlie
started,
so
it
makes
available
all
of
these
things
like
Bill,
and
it
makes
an
overall
other
things
like
claim
or
domain
or
version
or
our
bill
face
because,
as
you
can
see,
X
is
1
right.
So,
ok,
you
can
very
easily
debug
bills
because,
for
example,
I
could
just
a
bill
evolved
and
on
a
specific
face
like
I
could
do
it
on
configure
keep.
It
was
a
thing
or
it
is
in
this
case.
A
A
We
know
it
subpoena.
Now
it's
a
little
bit
night
bill
and
I
should
eventually
run
the
same
thing.
That
means
build
would
run,
except
in
the
show
that
I've
done
time.
I
can
stop
an
hour
or
add
additional
Commons
and
explore
what's
happening
and
the
bug
might
build
this
way,
and
this
will
result
and
essentially
the
same
binary
that
we
would
get
from
NYX
built
right
now.
If
we
look
here
hello
there,
it
is.
A
Now
this
is
cool,
because
you
can
do
the
same
thing
by
making
a
specific
shell
for
a
specific
function
because
a
derivation
doesn't
have
to
be.
You
don't
need
the
duration
to
make
a
shell.
You
can
make
a
travel
just
by
using
an
MK
shell,
which
is
provided
by
packages.
So,
let's
right
now,
let's
read
this
shells
going
to
stuff.
A
A
A
Not
the
code,
because
these
are
the
arguments
right
visit,
the
the
set-
that
is,
the
single
argument
to
the
function
that
returns
the
result
of
calling
the
function
empty,
shell
right
and
I'm
saying
that
picking
this
could
be
specified
for
am
giving
a
default,
because
just
the
default
Yukichi
serum
I
get
all
right
and
I
can
just
say
I
in
my
building
put
I'm
on
the
asteroids.
This
is
just
a
fancy
way
of
saying
like
if
you
have
more
of
that,
it's
nicer.
So
now
we
can.
Let's
go
on
excess
stuff.
A
Let's
mix
shell
mix,
I'll
have
a
neutral
you
can
do
which
I
space
have
that
straights
available
as
we
defined
right,
but
you
could
do
some
more
cool
stuff
by
using
something
called
the
shell
cook,
because
the
chef
cook
is
essentially
cold.
Whatever
the
choice
it
created,
I
can,
for
example,
I
show
a
message:
hello,
let's
recreate
the
show.
Actually
we
don't
need
to
specify
show
mix
because
the
Nick
Stahl
isn't
showing
variable.
So
it
is
correct.
A
A
Yes,
you
can
make
these
shells
for
specific
purposes
without
having
to
make
a
derivation,
but
in
reality
MK.
Shell
is
just
a
derivation,
and
let
me
show
you
okay
yeah
there.
It
is
so
this
is
the
function
of
the
vector
define.
Is
the
function
called
empty
shell
and,
as
you
can
see,
it
is
just
an
emic
innervation,
which
called
this
shell
with
phrases
set
to
a
single
phase,
which
is
no
good
phase
and
noble
phase
just
says
this:
derivation
should
not
be
dulled
and
DeSales.
A
So,
if
I
try
to
build,
the
shell
makes
if
you
mix
build,
put
fail
because
it's
not
suppose
that's
supposed
to
be
built,
and
this
is
exactly
what
we
saw
when
we
were
looking
at
set
up.
Sh
right
engineering
built.
The
phases
is
a
list
of
phrases
and
because
in
here
whispers,
quiet
fibers
are
just
one
phase.
No
both
sides,
then
just
no
don't
try
what
people
is
over
it
and
called
only
that
typical
price,
which
only
results
in
a
sec.
A
A
Two
different
sub
directories,
which
defines
specific
packages
like
in
here
we
have
different
french
functions
before
we
saw
french
where
L,
then
you
know
starfish
from
github
right.
So
if
you
look
at
the
hello
market,
if
possible,
peekaboo
change
this
tool
edge
from
the
top
right
and
we'll
do
the
same
here
and
we
define
like
on
there
reef
all
right,
no
we're
all
right
if
I
guess
anything
and
we'll
just
get
back
on
that.
Sorry
that
can
be
lookin
use
in
the
in
data
in
the
build
process
and
I
click
into
this
project.
A
It's
all
it's
there.
We
go
and
it's
just
a
huge
file
full
of
coal
package
and
we
can
find
our
own
pocket,
which
we
were
playing
with,
which
is
hello
right
here
in
just
a
coke
package
tool.
Subdirectory
applications
in
this
hello.
So
if
we
go
up
one
folder
we'll
go
to
what
the
patient's
miscellaneous
hello,
yeah,
there's
our
derivation,
which
I
was
a
fight
unnecessarily
yeah.
A
A
So
that's
essentially
all
of
the
the
basic
knowledge
you
need
to
get
started
with
mix.
All
of
this
is
kind
of
hidden
in
massive
documentation
that
is
available
at
next.
The
dork,
so
I
thought
this
would
be
a
good
primer
in
general.
I
think
mix
is
a
very
powerful
tool
because
it
provides
a
clear
way
of
defining
packages
should
be
built
and
and
the
hierarchy
of
packages
how
they
depend
on
one
another,
and
it
makes
debugging
bills
very
easy.
A
A
It's
hard
to
search
through
the
syntax
is
unfamiliar
to
anyone
that
hasn't
used,
Haskell
and
there's
kind
of
a
chaos
in
terms
of
mix
by
binary
tools
like,
for
example,
we
have
the
mix,
build
and
next
row
right,
but
there's
also
another
ballad
called
mix
which
has
subcommands
mix
shell
or
mix
build,
and
they
try
to
essentially
wrestle
that
into
order.
So
everything
is
available
and
they're
just
one
single
binary
Knicks,
but
for
now
the
functionalities
don't
fully
overlap.
So
you
kinda
have
to
switch
between
this
build
and
mix
build,
and
it's
a
bit
messy.
A
So
it's
understandable
why
it's
gonna
hard
to
get
into
it,
and
it's
and
also
discovering
libraries
essentially
consists
of
browsing
mixed
packages
and
looking
for
examples
of
how
other
people
did
things,
because
there's
no
there's
no
easy
search.
You
just
have
to
prep,
but
in
general,
I've
I
think
it's.
It
has
all
of
potential,
and
hopefully,
with
the
next
presentation
in
which
I
explain
how
all
of
this
comes
together
in
stages,
react
developers
would
be
a
bit
more
at
ease
with
with
trying
to
modify
it.
A
Here's
some
resources,
the
main
one
I,
would
recommend
that
I
should
have
put
it
at
the
top.
Is
the
next
bills
one?
It's
like
a
series
of
lessons
that
gives
you
probably
the
best
intro
into
all
of
these
things,
because
the
main
documentation
is
massive
enters
two,
these
two
videos
which
are
pretty
helpful
for
understanding
how
it
works
and
that
these
courses
is
quite
not
quite
as
usual,
people
respond
within
a
day,
so
the
communities
is
quite
active.
A
A
It
wouldn't
because
the
fingers
all
of
the
Nick
stuff
is
provided
through
Nick's.
So
essentially,
let
me
show
you
if
you
go
to
the
Knicks
site,
if
you
tried,
if
you
want
to
install
it
actually
says,
go
to
manual,
maybe
installation
what
it
does
is
it
creates
all
you
have
to
unless
you
have
permissions
to
do
it
crazy,
ass,
Nick's,
where
all
of
the
packages
are
stored
and
Nick's
once
installed,
is
just
a
sort
of
these.
A
These
tools,
like
Nick's
or
link,
build
which
don't
use
anything
from
the
underlying
system,
essentially
aside
from
the
caramel,
because
everything
is
and
there's
a
endemic
store.
So
if
we
show
derivation
for
at
the
end,
if
you
look
at
that,
for
example,
if
you
look
at
all
these
particles,
all
of
this
comes
from
from
Nick's
itself,
like
oh
the
tool.
The
tools
we
use
to
build
packages
don't
come
from
down
the
leg
system.
They
only
come
from
from
Nick's.
A
No,
no
because
essentially
Nixon
bootstrappers
itself,
because
it
has
binary
cash,
so
it
provides
all
of
their
core
utilities
necessary
to
start
building
other
things
itself
and
the
way
it
works
is
essentially
you
have
this
repository
annex.
It
is
right,
which
has
it's
just
I
get
repository
which
which
holds
history,
so
you
can,
for
example,
bind
yourself
to
a
specific
version
of
the
xpac
address
and
none
of
the
tools
you'll
be
using
for
building
will
ever
change
because
GCC
will
be
the
same.
A
A
A
In
general,
I
think
it
next
should
work
on
any
fully
fledged
Linux
or
a
Darwin
system.
I've
ever
seen
it
to
fail
on
anything
like
that.
I've
tried
NYX,
for
example,
on
that
on
multiple
architectures
like
our
arm,
and
it
does
work
Ravens,
even
it's
slow,
because
all
it
does
compile
a
lot
of
stuff,
sometimes,
but
in
general
I've
never
seen
it
fail
on
any
like
or
Darwin,
because
it's
all
free,
pretty
fine
again
and
they
told
you
starts
with-
are
also
precompiled
because
they
come
from
cache.
A
Yeah
and
in
the
track
or
Oh,
what
do
we
need
to
embed?
The
link
is
just
talking
to
other
in
this
show.
If
we
really
do,
why
is
next
and
don't
jump
to
prefix
or
other
establish,
destroy
inside
the
container
good
question.
I
actually
know
it
started
as
something
installed
on
top
of
existing
OS,
because
that
was
the
easiest
way
to
provide
it,
but
I
think
the
proper
way
is
you
just
run
it
directly
on
the
hardware.
I
run
and
XO
s
myself
like
if
you,
if
see.
A
I'm
running
mixers
right
now
and
all
of
my
pocket
is
come
from
X.
So
if
I
do
like
wait,
for
example,
sorry,
what's
wrong
current
system
and
click
troublesome
linked
to
an
X
or
next
door,
yeah
all
right
go
so
in
general,
Nix
can
run
as
its
own
system
at
the
way.
The
reason
we
run
it
as
a
subfolder
on
an
existing
systems,
because
it's
the
simplest
way
to
install
for
for
developers.
A
But
the
tools
probably
work
as
well,
if
but
it
won't
have
to
the
overhead
of
the
container
or
or
a
virtual
machine.
Yes
and
there's
like
a
series
like
patrol
and
but
I
didn't
choose
Nick's
by
himself.
I
believe
Nick's
was
proposed
by
Jared
initially,
and
it
looked
interesting.
So
that's
why
I
picked
it.
A
Oh
yeah,
the
fingers
jutsu
is
a
full
braking
system
and
Nick's
doesn't
have
to
be
a
full
operating
system
because
if
you
install
it
on
an
existing
Linux
operating
system,
you're
not
running
a
kernel,
you're
just
running
the
binaries
like
compilers
and
so
on.
So
in
general,
the
the
way
you
install
Nick's
on
an
existing
operating
system
is
much
lighter
than
if
you
use
something
like
container
it's
much
smaller,
so
yeah
any
other
questions.
A
I
will
prepare
another
presentation,
probably
next
week,
to
expand
on
that
in
terms
of
status,
react
and
what
can
go
from
there,
and
hopefully
this
will
help
the
developers
be
a
bit
scared
of
of
Nicks
and
maybe
start
modifying
it
we'll
see.
Thank
you
very
much.
Everyone
for
coming
Cheers
now
have
a
lovely
weekend.