Carane Git gumawa sajrone njerone?

Question

Accepted Answer

Sajrone njerone, Git minangka **content-addressable object store** — nyimpan kabeh minangka **objects** (blobs, trees, commits, tags) sing diidentifikasi dening **SHA-1 hash** saben. Ngerteni model iki ngilangake misteri Git lan nerangake kenapa operasi-operasi Git tumindak kaya mangkono.

## Git minangka content-addressable object store

```text
Git stores 4 types of OBJECTS, each identified by the SHA-1 HASH of its content:
  BLOB   → file CONTENTS (just the data, no filename)
  TREE   → a directory: maps names → blobs (files) and trees (subdirs) + permissions
  COMMIT → a snapshot: points to a TREE (the root) + parent commit(s) + author/message
  TAG    → an annotated tag object (points to a commit, with metadata)
→ Content-addressable: an object's ID IS the hash of its content (same content = same hash).
```

## A commit minangka snapshot, dudu diff

```text
→ Each COMMIT points to a complete TREE (the full state of the project at that point)
→ Git stores SNAPSHOTS, not diffs (though it compresses/deduplicates internally):
  unchanged files → the commit's tree just REUSES the same blob (same hash) → efficient
→ Diffs you see are COMPUTED between snapshots, not stored.
```

## Carane iku uwal-uwalan

```text
Branch (e.g. main) → a pointer (a ref) to a COMMIT
HEAD → points to the current branch (or commit)
Commit → tree → blobs (the snapshot)
Commit → parent → parent → ... (the history chain)
→ Branches/tags are just small files containing a commit hash (cheap pointers).
  That's WHY branching is so lightweight.
```

## Kenapa iki nerangake kelakuan Git

```text
✓ Branches are cheap → they're just a 40-char hash in a file (not file copies)
✓ Integrity → content-addressing means corruption/changes are detectable (hash mismatch)
✓ Commits are immutable → changing anything = a new hash = a new commit (why rebase
  creates NEW commits, why history rewriting changes hashes)
✓ Deduplication → identical content stored once (shared blobs)
```

## Kenapa iki penting

Ngerteni carane Git gumawa sajrone njerone minangka katrangan sing berharga kanggo level senior amarga **ngilangake misteri Git** lan nerangake *kenapa* operasi-operasi Git tumindak kaya mangkono, tambah jaya ing kemampuan kanggo mikiraken lan nggunakake Git kanthi percaya diri.

Model inti — Git minangka **content-addressable object store** kanthi papat jenis object (blobs kanggo isi file, trees kanggo direktori, commits kanggo snapshots, tags) saben diidentifikasi dening **hash saka isiné** — minangka fondasyon sing kabeh liya-liyane kuwat.

Ngerteni yen **commit minangka snapshot, dudu diff** (saben commit nuding menyang tree lengkap sing mewakili status proyèk lengkap, kanthi file sing ora ganti kanthi efisien nggunakake blob sing padha, lan diffs dihitung ketimbang disimpan) ngoreksi kapercayan salah sing umum lan nerangake model snapshot-based Git.

Ndeleng **carane iku uwal-uwalan** (branches lan tags minangka pointer murah/refs menyang commits, HEAD nuding branch saiki, commits kaluwung sajrone parents) bukake kesederhanaan sing elegan ing ngisor.

Paling penting, ngerteni iki **nerangake kelakuan Git sing bisa diamati**: kenapa **branches iku murah** (mung hash ing file cilik, dudu salinan file — nerangake kenapa branching dadi cepet), kenapa Git duwe **integritas** (content-addressing ndeteksi karusakan sambil hash mismatch), kenapa **commits ora bisa diroba** lan operasi penulisan-ulang riwayat kayata rebase gawe **commits anyar kanthi hashes anyar** (ngebah apa wae isi ngebah hash), lan kenapa Git **deduplikasi** (isi padha disimpan sapisan).

Model sing lebih jujur iki ngroba Git saka sakumpulan perintah sing kudu dieling dadi sistem sing bisa dimangerteni, nggawe panalaran percaya diri babagan operasi sing kompleks.

Amarga ngerteni model object internal nerangake kenapa Git tumindak kaya apa sing ditandheske (branches murah, commits ora bisa diroba, perubahan hash pas nulisake meneh, integritas) lan naik saka nggunakake Git dadi bener-bener ngerteni, ngerteni Git internals minangka katrangan penting level senior — topik sing ngrefleksikan jujur sing dikarepake kanggo peran senior lan nyedhiyakake model mental kanggo mikiraken Git kanthi percaya diri, ngilangake misteri kelakuané lan gawe operasi maju-maju minangka ngerti ketimbang aneh.