Learn Git In Action

Git sebagai content-addressed database: object model, hashing, blob/tree/commit/tag, reachability, dan cara membangun commit manual dari plumbing command.

Mental model tiga tree Git: Working Tree, Index, dan HEAD; bagaimana add, commit, reset, restore, checkout, dan status benar-benar bekerja.

Commit graph, DAG, reachability, ancestry, revision ranges, and how senior engineers reason about Git history as a graph instead of a timeline.

Refs, branches, tags, HEAD, symbolic references, remote-tracking branches, packed refs, and how Git names mutable positions in an immutable object graph.

Deep dive into Git object types: blob, tree, commit, and tag; how they encode snapshots, identity, filenames, modes, ancestry, and release names.

Deep dive into Git index as staging area, cache, conflict holder, tree construction boundary, and performance structure.

Memahami Git command layer sebagai komposisi porcelain dan plumbing: command user-facing, primitive object/index/ref operation, scriptability, debugging, dan workflow automation.

Cara membaca state repository Git secara deterministic: working tree, index, HEAD, refs, upstream, conflict, object, graph, dan remote relation sebelum melakukan operasi berisiko.

Commit sebagai unit perubahan yang bisa dipahami, direview, diaudit, di-bisect, di-revert, dan dipakai sebagai bukti teknis dalam engineering workflow yang serius.

Atomic commit bukan sekadar commit kecil, tetapi commit dengan batas intent yang benar sehingga mudah direview, diuji, di-revert, di-backport, dan dipakai sebagai unit reasoning.

Commit message bukan catatan kosmetik; ia adalah interface debugging masa depan, audit trail, review contract, dan decision log untuk engineer yang belum hadir hari ini.

Patch shaping adalah teknik membentuk staged diff secara surgical supaya satu working tree yang kacau bisa dipecah menjadi commit yang atomic, reviewable, dan aman di-revert.

Amend, fixup, squash, dan autosquash adalah teknik membentuk patch series lokal sebelum menjadi history publik yang stabil, reviewable, dan aman diintegrasikan.

git range-diff membandingkan dua versi patch series sehingga rewrite, rebase, amend, dan autosquash bisa direview tanpa kehilangan konteks perubahan antar versi.

Cherry-pick sebagai operasi graph surgery untuk memindahkan patch antar branch tanpa merge topology, termasuk backport, hotfix, conflict handling, duplicate patch, dan risiko release.

Revert sebagai mekanisme kompensasi perubahan untuk shared/public history, termasuk revert commit biasa, revert merge commit, no-commit revert, revert-of-revert, dan release rollback strategy.

Branch sebagai pointer management, bukan folder copy; mencakup local branch, remote-tracking branch, upstream, refspec mental model, branch lifecycle, divergence, worktree, dan policy untuk team workflow.

Merge-base sebagai matematika integrasi Git; mencakup best common ancestor, reachability, two-dot vs three-dot, fork-point, criss-cross merge, conflict reasoning, dan decision framework sebelum merge/rebase.

Fast-forward, non-fast-forward, --no-ff, --ff-only, dan cara memilih model integrasi yang benar untuk engineering workflow nyata.

Merge strategy, ort, recursive ancestry, three-way merge, conflict model, AUTO_MERGE, dan cara memahami conflict sebagai keputusan domain.

Conflict resolution sebagai keputusan domain, bukan sekadar menghapus marker sampai Git diam.

Menggunakan git rerere untuk mengingat resolusi conflict berulang tanpa mengorbankan correctness dan reviewability.

Memahami rebase sebagai replay patch di atas base baru, lengkap dengan graph semantics, safety boundary, conflict behavior, dan workflow operasional.

Menggunakan interactive rebase untuk membentuk patch series yang reviewable, bisectable, auditable, dan aman sebelum masuk shared history.

Memahami rebase yang mempertahankan topology merge, kapan ia berguna, kapan berbahaya, dan bagaimana menggunakannya tanpa merusak konteks integrasi.

Framework praktis untuk memilih merge atau rebase berdasarkan graph semantics, collaboration model, release risk, auditability, dan operational safety.

Framework operasional untuk memilih reset, restore, checkout, dan revert berdasarkan tree yang disentuh, apakah history sudah public, dan risiko kehilangan data.

Reflog sebagai local time machine untuk memulihkan branch, commit yang hilang, bad reset, bad rebase, detached HEAD, dan force-push mistake.

Deep dive tentang git fsck, lost-found, dangling object, unreachable object, object recovery, dan repository integrity check untuk incident recovery.

Deep dive tentang git stash internals, struktur commit stash, apply vs pop, conflict handling, partial stash, recovery, dan safe usage di workflow engineering.

Cleaning working tree safely tanpa kehilangan perubahan penting, dengan mental model tracked/untracked/ignored, dry-run discipline, dan playbook operasional.

Force push recovery dan protokol tim untuk rewrite shared branch secara aman, termasuk force-with-lease, reflog, backup refs, dan incident handling.

Incident playbook saat main/master rusak: freeze, triage, isolate, revert, verify, communicate, dan reopen dengan audit trail yang defensible.

Incident playbook saat release tag salah: klasifikasi dampak, immutable release policy, retagging risk, consumer impact, dan remediation yang aman.

Remote repository, refspec, remote-tracking branch, upstream branch, fetch/push mapping, pruning, deletion, dan workflow multi-remote yang aman.

Apa yang terjadi saat Git fetch: ref advertisement, negotiation, wants/haves, packfile transfer, shallow/partial clone, tags, FETCH_HEAD, dan failure mode CI.

Git pull bukan command ajaib. Pull adalah fetch plus integration: merge, rebase, squash, atau fast-forward-only tergantung policy dan konfigurasi.

Git push sebagai operasi update remote refs: refspec, fast-forward rule, non-fast-forward rejection, force-with-lease, delete, tags, hooks, dan recovery workflow.

Fork topology, upstream synchronization, PR branch hygiene, contribution safety, and operational guardrails for working across forks.

Multi-remote Git workflows for enterprise mirrors, vendor upstreams, customer-specific branches, regulated delivery, migration, and air-gapped synchronization.

Production-grade use of Git submodules: gitlink semantics, .gitmodules, detached HEAD, recursive clone, update strategies, CI, release pinning, security, and operational failure modes.

Decision framework for subtree, submodule, and monorepo strategies: dependency ownership, history, tooling, release coupling, CI, review, and migration trade-offs.

Pull request sebagai integration contract: kontrak perubahan dari branch kerja menuju protected line, termasuk diff semantics, checks, review, merge policy, dan failure mode organisasi.

Mendesain branch yang reviewable: scope, commit series, dependency chain, branch lifetime, naming, update policy, dan failure mode agar PR kecil, jelas, dan aman diintegrasikan.

Stacked branches dan dependent changes sebagai teknik memecah perubahan besar menjadi rangkaian PR kecil yang tetap bisa direview, diuji, dan diintegrasikan tanpa kehilangan konteks.

Code review diff mechanics: memahami two-dot, three-dot, merge-base, patch generation, rename detection, whitespace, merge commits, dan failure mode diff review.

Protected branches dan merge queues sebagai kontrol integrasi: required checks, required reviews, stale branch handling, queue semantics, dan race avoidance.

Decision framework linear history policy vs merge commit policy: auditability, bisectability, revertability, topology preservation, squash, rebase merge, dan first-parent history.

Ownership, CODEOWNERS, review routing, escalation, ownership decay, dan desain review topology untuk repository skala tim maupun enterprise.

Human factors dalam Git workflow: safe defaults, cognitive load, aliases, guardrails, documentation, onboarding, dan desain sistem yang mengurangi kesalahan manusia.

Release branching models dalam Git: trunk-based, release train, maintenance branch, hotfix branch, GitFlow-like, support branch, dan decision framework untuk release yang auditable.

Version tags dan release identity dalam Git: lightweight vs annotated tags, signed tags, protected tags, immutable release policy, SemVer naming, provenance, dan artifact traceability.

Hotfix, backport, dan forward-port dalam Git: memilih patch, menjaga konsistensi lintas maintenance branch, menghindari duplicate fixes, dan membangun audit trail release.

Cherry-pick trains untuk maintenance branches: memilih patch series, mengurutkan dependency, mengelola conflict berulang, menjaga audit trail, dan memverifikasi release-line coverage.

Release Candidate Flow sebagai mekanisme stabilisasi release berbasis commit identity, protected branch, tag immutable, test gates, dan audit evidence.

Revert Strategy dalam release management: kapan revert-first, kapan fix-forward, cara revert merge commit, dan bagaimana menjaga auditability production release.

SemVer dan Git history boundaries: bagaimana version number, tag, commit range, release branch, dan artifact identity harus disusun agar release bisa dipahami, diaudit, dan dipulihkan.

Build reproducibility dan commit pinning: cara memastikan artifact, source commit, tag, dependency, build environment, dan runtime metadata membentuk rantai identitas yang bisa diverifikasi.

Anatomi direktori .git sebagai control plane dan database lokal Git: object store, refs, index, reflog, hooks, state files, worktree layout, dan cara inspeksi aman saat debugging.

Loose objects dan object storage Git: format object, header, zlib compression, path berdasarkan object ID, hash-object, cat-file, tree/commit plumbing, corruption model, dan debugging object database.

Packfiles, index files, delta compression, and the storage/performance mechanics behind Git object transfer and repository compaction.

Commit-graph files, generation numbers, changed-path Bloom filters, and how Git accelerates ancestry and history queries in large repositories.

Multi-pack-index, reachability bitmaps, reverse indexes, cruft packs, and how Git accelerates object lookup and reachability queries in large repositories.

Ref storage internals: loose refs, packed-refs, symbolic refs, reftable, transactional updates, reflogs, and ref scalability in large repositories.

Menguasai revision syntax dan revset Git sebagai bahasa untuk memilih object, commit set, ancestry, range, dan boundary perubahan secara presisi.

Menguasai pathspec, ignore matching, exclude rules, tracked vs untracked behavior, dan teknik membatasi operasi Git ke path yang tepat tanpa merusak repository.

Menguasai .gitattributes, text normalization, EOL policy, filters, diff drivers, merge drivers, archive attributes, dan failure mode konfigurasi file-level Git.

Menguasai arsitektur Git hooks, lifecycle client/server hooks, policy boundary, bypass risk, safe hook design, server enforcement, dan automation guardrails.