Git உள்ளூரில் எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

உள்ளூரில், Git ஒரு **content-addressable object store** — இது அனைத்தையும் **objects** (blobs, trees, commits, tags) ஆக சேமிக்கிறது, அவை அவற்றின் **SHA-1 hash** மூலம் அடையாளப்படுத்தப்படுகின்றன. இந்த மாதிரியைப் புரிந்துகொள்வது Git ஐ தெளிவுபடுத்துகிறது மற்றும் அதன் செயல்பாடுகள் ஏன் இவ்வாறு செயல்படுகின்றன என்பதை விளக்குகிறது.

## Git ஒரு 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).
```

## ஒரு commit ஒரு snapshot, 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.
```

## இது எவ்வாறு ஒன்றாக பொருந்துகிறது

```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.
```

## இது 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)
```

## இது ஏன் முக்கியமானது

Git உள்ளூரில் எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொள்வது மதிப்புமிக்க senior-level அறிவு ஆகும், ஏனெனில் இது **Git ஐ தெளிவுபடுத்துகிறது** மற்றும் *ஏன்* அதன் செயல்பாடுகள் இவ்வாறு செயல்படுகின்றன என்பதை விளக்குகிறது, இது Git பற்றி தர்க்கரீதியாகச் சிந்திக்கும் மற்றும் நம்பிக்கையுடன் பயன்படுத்தும் உங்கள் திறனை ஆழப்படுத்துகிறது.

கோர் மாதிரி — Git ஒரு **content-addressable object store** நான்கு object types (file contents க்கான blobs, directories க்கான trees, snapshots க்கான commits, tags) உடன், ஒவ்வொன்றும் அதன் **content இன் hash** மூலம் அடையாளப்படுத்தப்படுகிறது — இது அனைத்தும் நம்பி இருக்கும் அடித்தளமாகும்.

**ஒரு commit ஒரு snapshot, diff அல்ல** என்பதைப் புரிந்துகொள்வது (ஒவ்வொரு commit முழு project state ஐ பிரதிநிதித்துவப்படுத்தும் ஒரு complete tree க்கு சுட்டிக்காட்டுகிறது, மாற்றப்படாத files திறமையுடன் same blobs ஐ மீண்டும் பயன்படுத்துகின்றன, மற்றும் diffs சேமிக்கப்படுவதற்குப் பதிலாக கணக்கிடப்படுகின்றன) ஒரு பொதுவான தவறான கருத்தை சரிசெய்கிறது மற்றும் Git இன் snapshot-based model ஐ விளக்குகிறது.

**இது எவ்வாறு ஒன்றாக பொருந்துகிறது** என்பதைக் கண்டறிவது (branches மற்றும் tags ஆனவை commits க்கு மலிவான pointers/refs, HEAD current branch க்கு சுட்டிக்காட்டுகிறது, commits parent ஏற்பட்ட வழங்கப்பட்டவை) அடியில் இருக்கும் elegant simplicity ஐ வெளிப்படுத்துகிறது.

மிகவும் மதிப்புமிக்க வகையில், இந்த புரிதல் **Git இன் கவனிக்கக்கூடிய நடத்தையை விளக்குகிறது**: ஏன் **branches lightweight** (ஒரு small file இல் வெறும் hash, file copies அல்ல — branching இவ்வளவு வேகம் ஆகிற காரணத்தை விளக்குகிறது), ஏன் Git **integrity** (content-addressing hash mismatches மூலம் corruption ஐ সনாক்தம் செய்கிறது), ஏன் **commits immutable** மற்றும் rebase போன்ற history-rewriting operations **new commits with new hashes** ஐ உருவாக்குகின்றன (இந்த content அதனை மாற்றுகிறது hash ஆக), மற்றும் ஏன் Git **deduplicates** (identical content ஒரு முறை சேமிக்கப்படுகிறது).

இந்த deeper model Git ஐ memorized commands ஦ சேமணையாய் இருந்து ஒரு understandable system ஆக மாற்றுகிறது, complex operations பற்றி நம்பிக்கைยะoldanauga reasoning ஐ செயல்படுத்துகிறது.

Git இன் internal object model புரிந்துகொள்வது Git ஐ ஏன் இவ்வாறு செயல்படுத்துகிறது என்பதை விளக்குகிறது (lightweight branches, immutable commits, hash changes on rewriting, integrity) மற்றும் Git ஐ பயன்படுத்துவதிலிருந்து உண்மையாக புரிந்துகொள்வதற்கு ஒருவனை உயர்த்துகிறது, Git internals ஐ புரிந்துகொள்வது மதிப்புமிக்க senior-level அறிவு ஆகும் — senior roles க்கான வீழ்ச்சி expected பதிப்பை பிரதிபலிக்கும் ஒரு topic மற்றும் Git பற்றி நம்பிக்கையுடன் reasoning செய்ய, அதன் நடத்தையை தெளிவுபடுத்தி advanced operations ஐ புதிரான ஆக மாறாக மனக்கணக்கு வழங்குகிறது மற்றும் comprehensible.