►
From YouTube: Learn How Git's Code Works - Git Merge 2022
Description
Presented by Jacob Stopak
This talk discusses the concepts and implementation of Git's very first revision (i.e. Git's initial commit), as published by Linus Torvalds in 2005. The talk explores the actual C code that Linus wrote in 2005 when he developed the initial commit of Git's codebase. Topics covered would be Git's original implementation of file compression, hash functions, Git objects (blobs, trees, commits), the current directory cache (staging area), the structure of Git's original C codebase (which amazingly is only 10 files and ~1000 lines of code), and a demo of Git's original set of commands.
About Git Merge:
Git Merge is dedicated to amplifying new voices in the Git community and showcasing the most thought-provoking projects from developers, maintainers, and teams around the world. Git Merge 2022 took place at Morgan Manufacturing in Chicago, IL on September 14th and 15th.
A
So
sort
of
in
the
spirit
of
that
today,
we're
going
to
examine
the
initial
commit
of
gits
code,
which
was
made
by
Linus
Torvalds
in
April,
2005.
and
we'll
start
by
looking
at
the
structure
of
the
initial
commits
code
base
and
then
we'll
get
into
some
code
extracts.
So
some
of
git's
core
functionalities,
but
before
we
do,
why
should
anyone
even
care
about
git's
initial
commit
so
first
of
all,
the
code
base
is
shockingly
small
and
approachable.
A
The
code
actually
works
and
it's
easily
accessible
by
running
a
git
clone
of
git
source
code,
which
you
can
find
on
GitHub
here
and
then
running.
A
git
log
reverse
to
see,
gets
initial
commit
listed
at
the
top
of
the
log
and,
almost
more
importantly,
to
see
for
yourself
how
Linus
has
just
oh
so
lovingly
nicknamed
it.
A
So
this
initial
commit
is
written
in
C
and
it's
made
up
entirely
of
these
11
files,
which
contain
just
1244
lines
and
if
you
compare
that
to
gets
current
root
directory,
so
excluding
all
subdirectories,
which
has
that
has
around
470
files
with
just
over
250
000
lines
and
obviously
that's
because
it
gets
modern
code
base.
You
know
has
17
years
of
active
development
on
top
of
the
initial
commit,
along
with
all
of
the
features
and
functionality
and
stability
that
we
get
and
expect
from
git.
But
regardless
gets
initial.
A
Commit
is
still
a
great
representation
of
some
of
its
core
functionalities,
packaged
up
in
a
super
super
small
package
that
makes
it
very
approachable
to
a
newcomer.
Like
me,
when
I
first
kind
of
stumbled
upon
gets
code
so
gets
initial,
commit
contains
a
DOT
C
source
file
for
each
of
git's,
original
Seven
commands,
and
you
can
see
those
source
files
in
the
left-hand
column
here
when
compiled
this
results
in
seven
executables
one
for
each
command.
A
You
can
see
those
here
in
the
middle
column
so,
for
example,
the
init
db.c
source
file
compiles
to
the
init
DB
executable,
which
you
can
think
of
as
like
a
predecessor
to
get
in
it
and
similarly
update.
Cache
could
be
like
a
predecessor
to
get
add
and
the
combination
of
write
tree
and
commit
tree
sort
of
together.
A
You
can
think
of
as
forming
the
original
git
commit,
and
today
we're
just
going
to
stick
to
talking
about
the
files
in
green
here,
because
I
just
don't
have
time
to
get
to
the
ones
in
red,
so
gets
original
model
implemented
three
main
components,
starting
with
objects,
and
that
includes
blobs
trees
and
commits
note
that
tags
were
not
implemented.
Yet
in
the
initial
commit.
A
A
All
right
so
now,
let's
jump
right
into
git's
code
and
see
how
it
actually
creates
an
object
database,
and
it's
actually
ridiculously
simple.
So
it's
created
when
you
run
that
init
DB
command,
which
remember,
is
like
the
original
get
init
and
the
code
just
uses
this
maker
function
in
C
to
create
a
hidden,
folder
called
dotger
cache,
which
is
just
the
original
name
of
the
dot
git,
folder
and
kind
of
a
fun
fact
about.
A
So
next,
the
code
uses
maker
again
to
create
a
subdirectory
within
durcache
called
objects,
and
then
the
code
uses
this
simple
for
Loop
to
create
256
subfolders
within
that
which
are
actually
used
for
storing
the
objects
and
when,
when
git
creates
an
object,
it
will
calculate
its
hash.
It's
shot
one
hash
and
use
the
first
two
characters
of
that
hash
to
organize
the
object
into
the
corresponding
folder.
A
So
now,
let's
see
how
gits
code
creates
a
blob
to
go
into
the
object
database
and
remember
a
blob
is
just
a
files,
binary
content
and
it's
created
when
you
run
the
command
update
cache
along
with
the
file
name,
that
you're
telling
it
to
track
and
remember.
This
is
like
a
predecessor
of
git
add
so
it
kind
of
makes
sense
that
pretty
much
the
first
thing
the
code
does.
A
Is
it
grabs
that
file
name
that
you
passed
in
as
a
command
line
argument,
and
then
it
uses
the
open
function
in
C
to
open
that
file
for
reading
and
then
uses
this
complicated,
looking
function
called
mmap,
but
it's
really
not
that
bad.
It
will
just
take
the
file's
content
and
make
it
accessible
to
gits
code
in
a
memory
location
that
is
accessible
through
that
variable
called
in
right
there.
A
A
So
next
gets
code
calculates
the
Shao
one
hash
of
the
compressed
data
using
the
openssl,
Sha
Library
and
pretty
much
all
the
work
for
this
is
done
by
the
Shawan
update
function,
which
actually
calculates
the
hash
and
show.
One
final
final
here
just
takes
that
hash
and
puts
it
somewhere
in
this
case
in
something
called
the
cache
entry
structure
which
we'll
talk
about
more
in
a
minute.
A
A
A
A
So
the
tree
starts
with
the
object's
type
and
the
size
of
the
data
followed
by
a
series
of
these
chunks,
and
each
chunk
has
three
pieces
of
information
that
should
look
super
familiar
from
the
previous
slide
as
a
part
of
a
cat,
the
three
pieces
of
information
from
a
cache
entry,
a
files
mode
or
permissions.
A
files
path,
a
name
and
shall
one
of
the
files
blob.
So
from
this
you
can
kind
of
think
of
a
tree
as
being
built
up
of
a
series
of
these
cache
entries.
A
And
lastly,
this
right,
shell
on
file
function,
takes
care
of
compressing
the
tree,
hashing
it
and
storing
it
in
the
object
database,
and
we
already
saw
how
those
three
things
work
for
a
blob.
So
we
don't
have
to
go
over
them
again
for
retrieve
so
yeah.
Finally,
we've
made
it
to
commits-
and
at
this
point
we
have
a
blob
and
a
tree
sitting
together
in
the
object
database.
So
let's
see
how
we
get
a
commit
there
too,
and
that's
created
using
the
commit
tree
command
along
with
the
hash
of
the
tree.
A
A
So
that
sort
of
completes
our
Trio
of
objects
sitting
as
kind
of
loose
objects
in
the
object
database.
So
yeah,
that's
pretty
much.
It
I
hope
that
getting
a
glimpse
at
a
few
different
parts
of
gits
code
encourages
more
git
users
and
developers
out
there
to
dive
into
the
code
themselves.
Not
only
will
this
help,
you
understand
git.
A
More
fundamentally
but
you'll
be
able
to
apply
these
Concepts
in
your
own
programs
going
forward
and
if
you're
interested
in
learning
more,
we
actually
have
a
fully
documented
version
of
gets
initial
commit
up
on
bitbucket
and
you
can
find
a
link
to
that
at
our
homepage
at
initialcommit.com.
So
thanks
a
lot
for
your
time.