Git Commands Cheat Sheet: 50+ Perintah Git yang Wajib Dikuasai Developer

Halo teman-teman developer! Kalau kamu udah pernah kerja sama project dengan tim atau bahkan cuma ngerjain proyek pribadi, pasti udah familiar sama yang namanya Git. Nah, tapi kadang kala kita sering lupa sama perintah-perintah Git yang penting, terutama pas lagi butuh cepat atau lagi deadline kejar-kejaran.

Git ini sebenernya adalah version control system yang udah jadi standar industri. Bayangin aja, hampir semua perusahan teknologi besar kayak Google, Facebook, sampai startup lokal kayak Gojek dan Tokopedia pasti pake Git untuk manage kode mereka. Bahkan di BuildWithAngga juga, semua materi pembelajaran dan project yang kita bikin selalu menggunakan Git sebagai tools utama.

Artikel ini bakal jadi panduan lengkap yang bisa kamu bookmark dan buka kapan aja kamu butuh. Kita bakal bahas mulai dari perintah basic sampe yang advanced, lengkap dengan contoh penggunaannya. Gak cuma teori doang, tapi juga practical banget buat dipake sehari-hari.

Kenapa sih Git ini penting banget? Pertama, Git memungkinkan kita buat tracking semua perubahan kode yang kita buat. Kedua, kita bisa collaborate dengan developer lain tanpa takut konflik atau kehilangan kode. Ketiga, kita bisa eksperimen dengan fitur baru di branch terpisah tanpa nganggu kode utama.

Yang paling keren, dengan Git kita bisa "time travel" ke versi kode sebelumnya kalau ada bug atau masalah. Imagine kalau kamu lagi ngerjain project e-commerce kayak yang sering kita buat di BuildWithAngga, trus tiba-tiba ada bug critical di production. Dengan Git, kamu bisa langsung rollback ke versi yang stabil dalam hitungan detik.

Artikel ini cocok banget buat kamu yang:

• Baru belajar Git dan butuh reference lengkap
• Udah pake Git tapi sering lupa perintah-perintahnya
• Mau improve workflow development dengan Git
• Pengen jadi lebih produktif dalam tim development

Jadi, siap-siap buat level up skill Git kamu! Mari kita mulai journey ini bersama-sama.

Basic Commands - Pondasi Wajib yang Harus Kamu Kuasai

Nah, sekarang kita masuk ke bagian yang paling fundamental nih teman-teman. Perintah dasar ini adalah pondasi dari semua yang bakal kamu lakuin dengan Git. Ibarat belajar programming, ini kayak syntax dasar yang wajib banget dikuasai sebelum lanjut ke topik yang lebih lanjut.

Percaya deh, meskipun namanya perintah dasar, tapi command-command ini adalah yang paling sering dipake dalam kehidupan sehari-hari developer. Bahkan developer senior yang udah belasan tahun kerja juga masih pake perintah-perintah ini setiap hari. Di BuildWithAngga sendiri, setiap kali kita ngerjain proyek baru atau update materi, pasti selalu mulai dari command-command dasar ini.

Git Init - Memulai Perjalanan Repository

Perintah git init adalah titik awal dari semua proyek yang menggunakan Git. Command ini pada dasarnya bikin folder biasa jadi Git repository. Pas kamu jalanin perintah ini, Git bakal bikin folder tersembunyi bernama .git yang berisi semua metadata dan konfigurasi repository.

git init

Kalau misalnya kamu lagi bikin proyek BuildWithAngga baru, kayak aplikasi e-commerce atau dashboard admin, langkah pertama yang harus dilakuin adalah:

mkdir buildwithangga-ecommerce
cd buildwithangga-ecommerce
git init

Perintah ini bakal keluarin pesan kayak "Initialized empty Git repository in /path/to/buildwithangga-ecommerce/.git/". Itu artinya repository kamu udah siap untuk dipake.

Ada juga variasi lain dari git init yang cukup berguna:

git init --bare

Command ini biasanya dipake untuk bikin repository di server yang gak ada working directory-nya. Tapi untuk development sehari-hari, jarang banget dipake.

Git Add - Staging Area adalah Kunci

Setelah repository terbentuk, langkah selanjutnya adalah nambahin file-file ke staging area. Ini adalah konsep unik dari Git yang kadang bikin bingung pemula. Staging area itu kayak "ruang tunggu" sebelum file-file kamu bener-bener di-commit.

Kenapa harus ada staging area? Karena dengan begini kamu bisa milih mana file yang mau di-commit dan mana yang engga. Misalnya kamu lagi ngerjain fitur login dan register sekaligus, tapi cuma mau commit fitur login dulu, kamu bisa selektif dalam milih file-nya.

git add filename.js

Kalau kamu mau menambahkan semua file sekaligus, bisa pake:

git add .

Atau kalau mau lebih spesifik, bisa tambahkan berdasarkan pola:

git add *.js
git add src/components/*.vue
git add buildwithangga-assets/images/*.png

Ada juga perintah yang lumayan berguna untuk menambahkan semua perubahan, termasuk file yang udah di-track sebelumnya:

git add -A

Perbedaan antara git add . dan git add -A adalah kalau git add . cuma nambahin file di direktori saat ini dan subdirectory-nya, sedangkan git add -A nambahin semua file di seluruh repository.

Untuk file yang udah pernah di-commit sebelumnya dan ada perubahan, kamu bisa langsung update staging area-nya dengan:

git add -u

Git Commit - Menyimpan Snapshot Kode

Nah, ini dia perintah yang paling penting dalam alur kerja Git. git commit adalah perintah untuk menyimpan snapshot dari kode kamu di repository. Setiap commit itu kayak titik simpan dalam game, kamu bisa balik ke kondisi itu kapan aja kamu mau.

git commit -m "Add user authentication feature"

Pesan commit ini super penting loh. Bayangkan 6 bulan kemudian kamu atau rekan tim mau nyari kapan fitur tertentu ditambahin, pasti liatnya dari pesan commit. Makanya, bikin pesan commit yang jelas dan bermakna.

Contoh pesan commit yang baik untuk proyek BuildWithAngga:

git commit -m "Implement login form validation for buildwithangga dashboard"
git commit -m "Fix responsive design issue on mobile course catalog"
git commit -m "Add payment gateway integration for course purchase"

Kalau kamu lupa menambahkan file sebelum commit, ada jalan pintas yang bisa langsung menambahkan dan commit sekaligus (khusus untuk file yang udah pernah di-track):

git commit -am "Update user profile component styling"

Kadang kala kamu perlu bikin pesan commit yang panjang dengan deskripsi detail. Untuk itu, kamu bisa pake:

git commit

Perintah ini bakal buka text editor default (biasanya vim atau nano) dimana kamu bisa nulis pesan commit yang lebih panjang dan detail.

Git Status - Mata-mata Repository Kamu

Perintah git status adalah sahabat terbaik kamu dalam development. Ini kayak dashboard yang ngasih tau kondisi terkini repository kamu. Setiap kali kamu bingung atau lupa udah ngapain aja, jalanin perintah ini.

git status

Keluaran dari git status bakal kasih informasi lengkap tentang:

• File mana aja yang udah di-stage (siap untuk di-commit)
• File mana aja yang ada perubahan tapi belum di-stage
• File baru yang belum di-track sama Git
• Branch apa yang sedang aktif
• Apakah ada commit yang belum di-push ke remote repository

Contoh keluaran yang sering kamu liat:

On branch main
Your branch is up to date with 'origin/main'.

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        modified:   src/components/LoginForm.vue
        new file:   src/assets/buildwithangga-logo.png

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   package.json

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        README.md

Ada variasi dari git status yang lebih ringkas:

git status -s

Atau

git status --short

Keluarannya bakal lebih ringkas, cocok kalau kamu udah familiar sama simbol-simbol yang dipake Git.

Tips dan Best Practice untuk Basic Commands

Sebelum kita lanjut ke perintah yang lebih lanjut, ada beberapa tips yang bakal bikin alur kerja kamu lebih efisien:

Pertama, biasain untuk selalu cek status sebelum commit. Ini mencegah kamu commit file yang gak seharusnya atau lupa commit file penting.

git status
git add .
git status
git commit -m "Your commit message"

Kedua, pake pesan commit yang konsisten. Di BuildWithAngga, kita biasanya pake format: "Action: Description". Contohnya:

• "Add: User registration form"
• "Fix: Mobile responsive issue on course page"
• "Update: API endpoint for user profile"

Ketiga, commit sesering mungkin dengan perubahan yang kecil. Lebih baik ada 10 commit kecil daripada 1 commit besar yang susah dilacak perubahannya.

Keempat, sebelum menambahkan semua file dengan git add ., selalu cek dulu file apa aja yang bakal ditambahin. Kadang ada file temporary atau data sensitif yang gak sengaja ikut masuk.

Perintah dasar ini emang keliatan sederhana, tapi penguasaan di sini bakal nentuin seberapa lancar alur kerja development kamu. Praktek terus perintah-perintah ini sampe jadi ingatan otot, karena ini adalah fondasi dari semua alur kerja Git yang lebih rumit nanti.

Branching Commands - Menguasai Cabang Pengembangan

Nah, sekarang kita masuk ke salah satu fitur paling powerful dari Git, yaitu branching. Kalau perintah dasar tadi adalah pondasi, maka branching ini adalah jantung dari kolaborasi tim dan manajemen kode yang baik. Konsep branching ini yang bikin Git jadi tools favorit developer di seluruh dunia.

Bayangkan kamu lagi ngerjain proyek BuildWithAngga yang lumayan besar, misalnya platform learning management system. Di satu waktu, kamu mungkin perlu ngerjain fitur authentication, temen kamu ngerjain payment gateway, dan ada juga yang handle UI/UX improvements. Nah, gimana caranya semua orang bisa kerja bareng tanpa bentrok? Jawabannya adalah branching.

Branch itu kayak jalur paralel dalam development. Kamu bisa eksperimen, nambah fitur baru, atau benerin bug di branch terpisah tanpa nganggu kode utama. Kalau fitur udah selesai dan aman, baru kamu gabungin ke branch utama. Konsep ini yang bikin development jadi lebih teratur dan aman.

Git Branch - Melihat dan Membuat Cabang Baru

Perintah git branch adalah starting point untuk semua aktivitas branching kamu. Command ini punya beberapa fungsi tergantung parameter yang kamu kasih.

Untuk melihat semua branch yang ada di repository:

git branch

Perintah ini bakal nampilin semua branch lokal dengan tanda asterisk (*) di branch yang sedang aktif. Contoh keluarannya:

* main
  feature/user-authentication
  feature/payment-integration
  bugfix/mobile-responsive

Untuk melihat branch remote juga, bisa pake:

git branch -a

Atau kalau cuma mau lihat branch remote aja:

git branch -r

Sekarang, untuk bikin branch baru, sintaksnya gampang banget:

git branch feature/buildwithangga-dashboard

Perintah ini bakal bikin branch baru dengan nama "feature/buildwithangga-dashboard" tapi kamu masih tetep di branch sebelumnya. Branch baru ini adalah copy persis dari branch dimana kamu lagi berada saat ini.

Kalau mau langsung pindah ke branch yang baru dibuat, ada cara yang lebih efisien:

git checkout -b feature/buildwithangga-course-catalog

Atau di Git versi terbaru, kamu bisa pake:

git switch -c feature/buildwithangga-user-profile

Kedua perintah di atas bakal bikin branch baru sekaligus pindah ke branch tersebut dalam satu langkah.

Penamaan Branch yang Baik

Sebelum lanjut ke perintah lain, penting banget buat ngebahas konvensi penamaan branch. Di BuildWithAngga, kita biasanya pake pola kayak gini:

• feature/nama-fitur untuk fitur baru
• bugfix/nama-bug untuk perbaikan bug
• hotfix/nama-masalah untuk perbaikan urgent di production
• chore/nama-tugas untuk task maintenance

Contoh penamaan yang baik:

git branch feature/buildwithangga-video-player
git branch bugfix/login-form-validation
git branch hotfix/payment-gateway-timeout
git branch chore/update-dependencies

Git Checkout - Berpindah Antar Branch

Perintah git checkout adalah cara klasik untuk berpindah antar branch. Meskipun di Git versi terbaru udah ada git switch, tapi checkout masih banyak dipake karena udah jadi kebiasaan developer.

git checkout feature/buildwithangga-dashboard

Perintah ini bakal pindahin kamu ke branch "feature/buildwithangga-dashboard". Git bakal update working directory kamu sesuai dengan kondisi terakhir di branch tersebut.

Kalau kamu mau balik ke branch utama:

git checkout main

Atau

git checkout master

Tergantung mana yang jadi branch utama di repository kamu.

Ada beberapa varian checkout yang berguna:

Untuk bikin dan langsung pindah ke branch baru:

git checkout -b feature/buildwithangga-notification-system

Untuk checkout file spesifik dari branch lain tanpa pindah branch:

git checkout feature/other-branch -- src/components/Header.vue

Untuk checkout ke commit spesifik:

git checkout abc1234

Tapi hati-hati dengan yang terakhir ini, karena kamu bakal masuk ke "detached HEAD" state yang bisa bikin bingung kalau belum familiar.

Git Switch - Cara Modern Berpindah Branch

Di Git versi 2.23 ke atas, ada perintah baru yang lebih spesifik untuk ganti branch, yaitu git switch. Perintah ini dibuat khusus untuk mengatasi kebingungan karena git checkout bisa dipake untuk banyak hal.

git switch feature/buildwithangga-search-functionality

Untuk bikin branch baru dan langsung pindah:

git switch -c feature/buildwithangga-user-settings

Untuk balik ke branch sebelumnya:

git switch -

Perintah ini mirip kayak cd - di terminal yang balik ke direktori sebelumnya.

Git Merge - Menggabungkan Perubahan

Nah, ini dia perintah yang paling crucial dalam workflow branching. git merge digunakan untuk menggabungkan perubahan dari satu branch ke branch lain. Biasanya, kita merge dari feature branch ke main branch.

Misalnya kamu udah selesai ngerjain fitur authentication di branch feature/buildwithangga-auth, dan sekarang mau gabungin ke branch main:

git checkout main
git merge feature/buildwithangga-auth

Langkah pertama adalah pindah ke branch tujuan (main), baru kemudian merge branch fitur.

Ada beberapa tipe merge yang perlu kamu tau:

Fast-Forward Merge

Ini terjadi kalau branch tujuan gak ada perubahan sejak branch fitur dibuat. Git cuma perlu "memajukan" pointer branch utama ke commit terakhir di branch fitur.

git merge feature/buildwithangga-simple-fix

Kalau mau paksa bikin merge commit meskipun bisa fast-forward:

git merge --no-ff feature/buildwithangga-simple-fix

Three-Way Merge

Ini terjadi kalau ada perubahan di kedua branch. Git bakal bikin commit merge baru yang ngegabungin perubahan dari kedua branch.

Merge dengan Pesan Custom

Kadang kamu mau kasih pesan yang lebih deskriptif untuk merge commit:

git merge feature/buildwithangga-payment -m "Merge payment gateway integration from BuildWithAngga team"

Squash Merge

Kalau kamu mau gabungin semua commit dari feature branch jadi satu commit:

git merge --squash feature/buildwithangga-multiple-commits
git commit -m "Add complete user management system"

Teknik ini berguna kalau feature branch kamu punya banyak commit kecil yang gak perlu dipertahanin di history main branch.

Mengatasi Merge Conflict

Salah satu hal yang paling bikin frustasi developer pemula adalah merge conflict. Ini terjadi kalau Git gak bisa otomatis gabungin perubahan karena ada konflik di file yang sama.

Kalau ada conflict, Git bakal kasih pesan kayak gini:

Auto-merging src/components/LoginForm.vue
CONFLICT (content): Merge conflict in src/components/LoginForm.vue
Automatic merge failed; fix conflicts and then commit the result.

File yang conflict bakal punya marker kayak gini:

// src/components/LoginForm.vue
<<<<<<< HEAD
const validateEmail = (email) => {
    return email.includes('@buildwithangga.com');
};
=======
const validateEmail = (email) => {
    return /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(email);
};
>>>>>>> feature/buildwithangga-email-validation

Bagian antara <<<<<<< HEAD dan ======= adalah kode dari branch kamu sekarang. Bagian antara ======= dan >>>>>>> branch-name adalah kode dari branch yang mau di-merge.

Untuk resolve conflict:

Buka file yang conflict, hapus marker dan pilih kode yang mau dipertahanin:

const validateEmail = (email) => {
    // Gabungin kedua validasi untuk lebih robust
    return email.includes('@buildwithangga.com') &&
           /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(email);
};

Setelah resolve semua conflict:

git add src/components/LoginForm.vue
git commit -m "Resolve merge conflict in email validation"

Tips dan Best Practice untuk Branching

Ada beberapa tips yang bakal bikin workflow branching kamu lebih smooth:

Pertama, selalu update branch utama sebelum bikin branch baru:

git checkout main
git pull origin main
git checkout -b feature/buildwithangga-new-feature

Kedua, sesering mungkin sync branch fitur kamu dengan branch utama untuk menghindari conflict besar:

git checkout feature/buildwithangga-current-feature
git merge main

Atau kalau prefer rebase:

git checkout feature/buildwithangga-current-feature
git rebase main

Ketiga, sebelum merge ke main, pastikan branch fitur kamu udah di-test dengan baik. Di BuildWithAngga, kita selalu jalanin automated testing sebelum merge.

Keempat, hapus branch yang udah gak dipake untuk menjaga kebersihan repository:

git branch -d feature/buildwithangga-completed-feature

Kalau branch udah di-push ke remote dan udah di-merge, bisa hapus remote branch juga:

git push origin --delete feature/buildwithangga-completed-feature

Kelima, gunakan merge commit untuk feature branch besar, dan squash merge untuk fix kecil atau improvement minor.

Branching ini adalah skill yang bakal bikin kamu jadi developer yang lebih profesional. Dengan menguasai branching, kamu bisa kerja dalam tim tanpa takut ngrusak kode orang lain, bisa eksperimen dengan aman, dan punya kontrol penuh terhadap development workflow kamu.

Remote Repository Commands - Menghubungkan Dunia Lokal dengan Server

Nah, sekarang kita masuk ke bagian yang benar-benar bikin Git jadi powerful untuk kolaborasi tim. Remote repository commands adalah jembatan antara kode di komputer kamu dengan kode yang ada di server, entah itu GitHub, GitLab, atau server perusahan. Tanpa perintah-perintah ini, Git cuma bakal jadi tools lokal yang gak bisa digunain untuk kerja sama tim.

Bayangkan kamu lagi ngerjain proyek BuildWithAngga bareng tim yang tersebar di berbagai kota. Ada yang di Jakarta, Surabaya, Bandung, bahkan mungkin ada yang remote dari luar negeri. Gimana caranya semua orang bisa akses kode yang sama, update fitur bareng-bareng, dan pastiin semua perubahan tersinkronisasi dengan baik? Jawabannya adalah melalui remote repository.

Remote repository itu basically adalah versi "pusat" dari proyek kamu yang disimpan di server. Setiap developer punya copy lokal di komputer masing-masing, dan mereka bisa push perubahan ke server atau pull perubahan dari server. Konsep ini yang bikin development modern bisa berjalan dengan smooth.

Di BuildWithAngga sendiri, setiap proyek pembelajaran, dari yang simple landing page sampai complex full-stack application, selalu menggunakan remote repository. Ini bukan cuma untuk backup kode, tapi juga buat collaboration, code review, dan deployment automation.

Memahami Konsep Remote Repository

Sebelum masuk ke perintah-perintah spesifik, penting banget buat ngerti dulu konsep remote repository. Dalam satu proyek, kamu bisa punya multiple remote. Yang paling umum adalah:

• origin: Ini adalah remote default, biasanya repository utama di GitHub atau GitLab
• upstream: Biasanya dipake kalau kamu fork repository orang lain
• production: Kadang dipake untuk deployment ke server production

Untuk liat remote yang udah dikonfigurasi di repository kamu:

git remote -v

Perintah ini bakal nampilin semua remote dengan URL-nya:

origin  <https://github.com/buildwithangga/ecommerce-dashboard.git> (fetch)
origin  <https://github.com/buildwithangga/ecommerce-dashboard.git> (push)
upstream <https://github.com/original-author/ecommerce-dashboard.git> (fetch)
upstream <https://github.com/original-author/ecommerce-dashboard.git> (push)

Untuk nambah remote baru:

git remote add upstream <https://github.com/buildwithangga/learning-platform.git>

Kalau mau ganti URL remote yang udah ada:

git remote set-url origin <https://github.com/buildwithangga/new-repository.git>

Git Push - Mengirim Perubahan ke Server

Perintah git push adalah cara kamu mengirim commit dari repository lokal ke remote repository. Ini adalah salah satu perintah yang paling sering dipake dalam development sehari-hari.

Sintaks dasarnya:

git push <remote> <branch>

Contoh paling umum:

git push origin main

Perintah ini bakal push commit dari branch main lokal ke branch main di remote origin.

Kalau kamu lagi di branch feature dan mau push:

git push origin feature/buildwithangga-user-authentication

Push Branch Baru

Kalau kamu baru bikin branch lokal dan mau push untuk pertama kali:

git push -u origin feature/buildwithangga-payment-integration

Flag -u (atau --set-upstream) bakal set remote tracking, jadi untuk push selanjutnya kamu cukup jalanin git push tanpa specify remote dan branch.

Setelah set upstream, push selanjutnya jadi lebih simple:

git push

Force Push - Gunakan dengan Hati-hati

Ada kalanya kamu perlu override history di remote repository. Tapi hati-hati banget sama command ini:

git push --force origin feature/buildwithangga-experimental

Force push bakal replace history di remote dengan history lokal kamu. Ini berbahaya kalau ada orang lain yang udah pull branch tersebut.

Alternatif yang lebih aman:

git push --force-with-lease origin feature/buildwithangga-experimental

Command ini cuma bakal force push kalau remote branch gak ada update yang belum kamu pull.

Push Multiple Branches

Kalau mau push semua branch sekaligus:

git push --all origin

Atau push semua tags:

git push --tags origin

Git Pull - Mengambil dan Menggabungkan Perubahan

Perintah git pull adalah kombinasi dari git fetch dan git merge. Command ini bakal download perubahan dari remote repository dan langsung merge ke branch lokal kamu.

git pull origin main

Kalau kamu udah set upstream tracking, bisa langsung:

git pull

Pull dengan Rebase

Kadang kamu mau pull tapi prefer rebase daripada merge:

git pull --rebase origin main

Ini bakal apply commit lokal kamu di atas commit terbaru dari remote, jadi history jadi lebih linear.

Kalau mau set rebase sebagai default behavior:

git config pull.rebase true

Pull dari Branch Lain

Misalnya kamu lagi di feature branch tapi mau pull perubahan dari main:

git pull origin main

Ini berguna buat keep feature branch kamu up-to-date dengan latest changes di main branch.

Git Fetch - Mengambil Tanpa Merge

Perintah git fetch cuma download perubahan dari remote repository tanpa merge ke working directory kamu. Ini berguna kalau kamu mau lihat dulu perubahan apa yang ada sebelum decide mau merge atau engga.

git fetch origin

Setelah fetch, kamu bisa lihat apa yang berubah:

git log HEAD..origin/main

Atau lihat diff:

git diff HEAD origin/main

Fetch Specific Branch

Kalau cuma mau fetch branch tertentu:

git fetch origin feature/buildwithangga-new-feature

Fetch dan Prune

Kadang ada branch di remote yang udah dihapus, tapi referensi lokalnya masih ada. Untuk bersihin:

git fetch --prune origin

Atau set sebagai default:

git config fetch.prune true

Workflow Typical dalam Tim Development

Dalam development sehari-hari di BuildWithAngga, workflow yang biasa digunain adalah:

Mulai hari dengan update main branch:

git checkout main
git pull origin main

Bikin feature branch baru:

git checkout -b feature/buildwithangga-course-progress-tracker

Kerja di feature branch, commit sesering mungkin:

git add .
git commit -m "Add progress tracking component"
git add .
git commit -m "Implement progress calculation logic"

Push feature branch ke remote:

git push -u origin feature/buildwithangga-course-progress-tracker

Sebelum merge, update feature branch dengan latest main:

git fetch origin
git merge origin/main

Atau kalau prefer rebase:

git fetch origin
git rebase origin/main

Push updated feature branch:

git push origin feature/buildwithangga-course-progress-tracker

Menangani Push Rejection

Kadang push kamu ditolak karena ada perubahan di remote yang belum kamu pull:

git push origin main
# Error: Updates were rejected because the remote contains work that you do not have locally

Solusinya adalah pull dulu, resolve conflict kalau ada, baru push lagi:

git pull origin main
# Resolve conflicts if any
git push origin main

Best Practices untuk Remote Repository

Ada beberapa best practice yang sebaiknya kamu ikutin:

Pertama, selalu pull sebelum push untuk menghindari conflict:

git pull origin main
git push origin main

Kedua, jangan pernah force push ke branch yang digunain banyak orang (main, develop, staging):

# JANGAN LAKUIN INI di shared branch
git push --force origin main

Ketiga, gunakan descriptive branch names yang include nama fitur atau tujuan:

git push origin feature/buildwithangga-user-dashboard
git push origin bugfix/login-form-validation-error
git push origin hotfix/payment-gateway-timeout

Keempat, regularl fetch untuk stay updated dengan perubahan tim:

# Jalanin ini beberapa kali sehari
git fetch origin

Kelima, cleanup local branches yang udah gak dipake:

git branch -d feature/buildwithangga-completed-feature
git remote prune origin

Troubleshooting Common Issues

Kalau kamu stuck dengan "detached HEAD" setelah checkout ke commit tertentu:

git checkout main

Kalau ada error "repository not found" saat push/pull:

git remote -v  # Check if URL is correct
git remote set-url origin <correct-url>

Kalau credentials terus ditanya:

# For HTTPS
git config credential.helper store

# Or switch to SSH
git remote set-url origin [email protected]:buildwithangga/repository.git

Remote repository commands ini adalah jantung dari collaborative development. Dengan menguasai push, pull, dan fetch, kamu udah bisa participate dalam proyek tim dengan confident. Yang penting adalah practice dan jangan takut experiment di branch terpisah.

History dan Logging Commands - Menjelajahi Jejak Perubahan Kode

Nah, sekarang kita masuk ke bagian yang super penting tapi sering diabaikan sama developer pemula - perintah history dan logging. Perintah-perintah ini adalah mata dan telinga kamu dalam menjelajahi riwayat perubahan kode. Bayangkan kamu sebagai detektif yang lagi nyari petunjuk tentang siapa yang ngubah apa, kapan, dan kenapa.

Dalam proyek nyata kayak yang sering kita kerjain di BuildWithAngga, repository bisa punya ribuan commit dari puluhan developer selama bertahun-tahun. Tanpa alat yang tepat untuk menjelajahi riwayat, kamu bakal kesulitan banget buat memahami evolusi kode, melacak bug, atau bahkan cuma mau tau siapa yang nulis function tertentu.

Perintah history ini bukan cuma buat troubleshooting aja loh. Sering kali kamu perlu memahami konteks dari perubahan tertentu, melihat pola pengembangan dari waktu ke waktu, atau bahkan belajar dari proses pengambilan keputusan yang udah dilakuin sama developer senior sebelumnya. Di BuildWithAngga, kita sering pake perintah history buat code review dan transfer pengetahuan antar tim.

Yang paling keren, dengan perintah history kamu bisa "melakukan perjalanan waktu" dalam kode. Mau tau gimana aplikasi keliatan 6 bulan yang lalu? Mudah banget. Mau cari tau kapan bug tertentu pertama kali muncul? Bisa banget. Mau lihat evolusi dari component React yang udah di-refactor berkali-kali? Gampang banget.

Git Log - Jendela Utama ke Masa Lalu

Perintah git log adalah titik awal dari semua penjelajahan riwayat. Command ini nampilin daftar commit dalam urutan kronologis dari yang terbaru ke yang terlama.

git log

Keluaran default-nya bakal nampilin informasi lengkap setiap commit:

commit abc1234567890abcdef1234567890abcdef12345
Author: John Doe <[email protected]>
Date:   Mon Jan 15 10:30:45 2024 +0700

    Implement user authentication system for BuildWithAngga platform

    - Add login and registration forms
    - Integrate with JWT token management
    - Add password hashing with bcrypt
    - Implement role-based access control

commit def2345678901bcdef2345678901bcdef23456789
Author: Jane Smith <[email protected]>
Date:   Sun Jan 14 16:20:30 2024 +0700

    Fix responsive design issues on course catalog page

Menyesuaikan Keluaran dengan Options

Git log punya puluhan pilihan yang bisa sesuaikan keluaran sesuai kebutuhan kamu:

Untuk nampilin log dalam format yang lebih ringkas:

git log --oneline

Keluarannya jadi lebih padat:

abc1234 Implement user authentication system for BuildWithAngga platform
def2345 Fix responsive design issues on course catalog page
ghi3456 Add payment gateway integration for course purchases

Untuk lihat log dengan representasi visual dari branching:

git log --graph

Atau kombinasi keduanya:

git log --oneline --graph

Untuk lihat log dari semua branch:

git log --all --graph --oneline

Membatasi Keluaran dengan Parameter

Sering kali kamu gak perlu lihat semua commit. Ada beberapa cara buat batasi keluaran:

Lihat 10 commit terakhir:

git log -10

Lihat commit dalam rentang waktu tertentu:

git log --since="2024-01-01" --until="2024-01-31"

Lihat commit dari author tertentu:

git log --author="[email protected]"

Lihat commit yang mengandung kata tertentu di pesan:

git log --grep="authentication"

Lihat commit yang mengubah file tertentu:

git log -- src/components/LoginForm.vue

Format Log Lanjutan

Untuk kustomisasi keluaran yang lebih lanjut, kamu bisa pake format string:

git log --pretty=format:"%h - %an, %ar : %s"

Keluarannya:

abc1234 - John Doe, 2 days ago : Implement user authentication system
def2345 - Jane Smith, 3 days ago : Fix responsive design issues

Beberapa format placeholder yang berguna:

• %h: Short commit hash
• %H: Full commit hash
• %an: Author name
• %ae: Author email
• %ad: Author date
• %ar: Author date relative (2 days ago)
• %s: Commit subject
• %b: Commit body

Git Show - Detail Commit Tertentu

Kalau git log nampilin daftar commit, git show nampilin detail dari commit spesifik termasuk perubahan yang dilakuin.

git show abc1234

Command ini bakal nampilin:

• Informasi commit (author, date, message)
• Diff dari semua file yang berubah
• Added/deleted lines

Untuk lihat commit tertentu tanpa diff:

git show --no-patch abc1234

Atau cuma lihat files yang berubah:

git show --name-only abc1234

Git Blame - Siapa yang Nulis Baris Ini?

Perintah git blame super berguna buat tau siapa yang nulis atau terakhir kali ngedit setiap baris dalam file.

git blame src/components/UserDashboard.vue

Keluarannya bakal nampilin setiap baris dengan informasi commit dan author:

abc12345 (John Doe     2024-01-15 10:30:45 +0700  1) <template>
abc12345 (John Doe     2024-01-15 10:30:45 +0700  2)   <div class="user-dashboard">
def23456 (Jane Smith   2024-01-16 14:20:30 +0700  3)     <h1>Welcome to BuildWithAngga Dashboard</h1>
def23456 (Jane Smith   2024-01-16 14:20:30 +0700  4)     <UserProfile :user="currentUser" />
ghi34567 (Bob Johnson  2024-01-17 09:15:20 +0700  5)     <CourseProgress :courses="userCourses" />

Untuk blame dalam rentang baris tertentu:

git blame -L 10,20 src/utils/validation.js

Git Diff - Melihat Perbedaan

Perintah git diff berguna buat melihat perbedaan antara berbagai kondisi dalam repository.

Lihat perubahan yang belum di-stage:

git diff

Lihat perubahan yang udah di-stage:

git diff --staged

Atau

git diff --cached

Lihat perbedaan antara dua commit:

git diff abc1234 def2345

Lihat perbedaan file spesifik antara dua commit:

git diff abc1234 def2345 -- src/components/PaymentForm.vue

Lihat perbedaan antara branch:

git diff main feature/buildwithangga-new-feature

Pilihan Diff Lanjutan

Untuk hasil yang lebih mudah dibaca:

git diff --word-diff

Untuk lihat diff dengan konteks yang lebih banyak:

git diff -U10

Untuk mengabaikan perubahan whitespace:

git diff --ignore-space-change

Git Reflog - Solusi Pemulihan Terakhir

Perintah git reflog adalah penyelamat kalau kamu gak sengaja menghapus commit atau merusak repository. Reflog menyimpan catatan dari semua perubahan HEAD dalam repository lokal.

git reflog

Keluarannya:

abc1234 HEAD@{0}: commit: Add user profile editing functionality
def2345 HEAD@{1}: merge feature/buildwithangga-auth: Merge made by the 'recursive' strategy
ghi3456 HEAD@{2}: checkout: moving from main to feature/buildwithangga-auth
jkl4567 HEAD@{3}: commit: Fix validation error in registration form

Kalau kamu gak sengaja reset ke commit lama dan mau pulihkan:

git reset --hard HEAD@{1}

Git Shortlog - Ringkasan berdasarkan Author

Untuk lihat ringkasan commit berdasarkan author:

git shortlog

Keluarannya:

Jane Smith (15):
      Fix responsive design issues on course catalog
      Implement mobile navigation for BuildWithAngga
      Add dark mode toggle functionality

John Doe (23):
      Initial project setup for BuildWithAngga platform
      Implement user authentication system
      Add payment gateway integration

Untuk cuma lihat jumlah commit per author:

git shortlog -sn

Pencarian dalam Riwayat

Untuk nyari commit yang nambah atau ngapus teks tertentu:

git log -S "buildwithangga-api-key"

Untuk nyari commit yang nambah atau ngapus pola regex:

git log -G "function.*authenticate"

Untuk nyari perubahan dalam function tertentu:

git log -L :functionName:src/utils/auth.js

Git Log dengan Statistik File

Untuk lihat statistik perubahan file:

git log --stat

Untuk lihat ringkasan singkat:

git log --shortstat

Untuk lihat files yang berubah tanpa detail:

git log --name-only

Menggabungkan Beberapa Pilihan

Kamu bisa gabungin beberapa pilihan untuk hasil yang lebih spesifik:

git log --oneline --graph --all --since="1 week ago" --author="buildwithangga"

Atau

git log --pretty=format:"%h %ad | %s%d [%an]" --graph --date=short

Tips Performa untuk Repository Besar

Kalau repository kamu besar dan git log jadi lambat:

Batasi kedalaman untuk riwayat branch:

git log --oneline -n 100

Lewati merge commits:

git log --no-merges

Hanya lihat first-parent untuk riwayat yang disederhanakan:

git log --first-parent

Membuat Alias yang Berguna

Untuk perintah yang sering dipake, bikin alias:

git config --global alias.lg "log --oneline --graph --all"
git config --global alias.last "log -1 HEAD"
git config --global alias.visual "log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"

Setelah set alias, kamu bisa jalanin:

git lg
git last
git visual

Perintah history dan logging ini adalah alat yang bakal bikin kamu jadi developer yang lebih efektif. Dengan memahami riwayat, kamu bisa belajar dari keputusan masa lalu, melacak masalah lebih cepat, dan berkontribusi lebih baik ke proyek tim. Praktekkan perintah-perintah ini secara teratur, karena penguasaan dalam menjelajahi riwayat adalah tanda dari developer berpengalaman.

Undo Commands - Seni Membatalkan Kesalahan dalam Git

Nah, sekarang kita masuk ke bagian yang paling menyelamatkan hidup developer - perintah undo atau pembatalan. Kalau kamu pernah ngoding, pasti udah familiar sama perasaan "Oh no, aku salah!" atau "Gimana caranya undo yang tadi?". Di Git, membatalkan perubahan itu bukan cuma sekedar Ctrl+Z biasa, tapi ada berbagai cara tergantung situasi dan kondisi repository kamu.

Bayangkan kamu lagi ngerjain proyek BuildWithAngga yang lumayan kompleks, terus tiba-tiba kamu nyadar udah ngcommit kode yang salah, atau bahkan lebih parah lagi, udah push ke repository utama dan ngrusak production. Jangan panik! Git punya berbagai mekanisme untuk membatalkan kesalahan, dari yang sederhana sampe yang lanjutan.

Yang bikin Git powerful adalah fleksibilitasnya dalam menangani operasi undo. Kamu bisa undo perubahan di working directory, staging area, atau bahkan commit history. Setiap skenario punya pendekatan yang berbeda, dan memahami kapan harus pake perintah mana adalah skill yang sangat berharga.

Di BuildWithAngga sendiri, kita sering banget pake perintah undo ini. Mulai dari developer junior yang gak sengaja commit file yang gak seharusnya, sampe developer senior yang perlu rollback fitur yang udah di-deploy tapi ternyata ada bug kritis. Memahami perintah undo dengan baik adalah perbedaan antara panik dan penyelesaian masalah yang percaya diri.

Memahami Berbagai Level Undo

Sebelum masuk ke perintah spesifik, penting banget buat memahami bahwa Git punya beberapa "level" atau area dimana perubahan bisa terjadi:

Working Directory: Ini adalah file-file yang kamu edit langsung. Perubahan di sini belum di-track sama Git.

Staging Area: File yang udah di-add tapi belum di-commit. Ini adalah "ruang tunggu" sebelum jadi bagian dari history.

Repository History: Commit yang udah tersimpan dalam repository. Ini udah jadi bagian permanen dari riwayat proyek.

Setiap level ini punya cara undo yang berbeda, dan salah pilih perintah bisa bikin situasi jadi lebih buruk. Makanya, sebelum jalanin perintah undo apa pun, pastiin kamu tau persis apa yang mau dibatalin dan di level mana.

Git Reset - Pisau Swiss Army untuk Undo

Perintah git reset adalah salah satu alat paling powerful dan sekaligus paling berbahaya dalam Git. Command ini bisa dipake untuk undo perubahan di berbagai level dengan perilaku yang beda-beda.

Soft Reset - Undo Commit tapi Keep Changes

Kalau kamu mau undo commit terakhir tapi tetep keep perubahan di staging area:

git reset --soft HEAD~1

Perintah ini bakal:

• Pindahin HEAD ke commit sebelumnya
• Keep semua perubahan di staging area
• Gak ngubah working directory

Ini berguna kalau kamu nyadar pesan commit-nya salah atau mau nambah file lagi sebelum commit ulang.

Contoh skenario: Kamu udah commit fitur login BuildWithAngga, tapi lupa nambah validation untuk password strength. Dengan soft reset, kamu bisa undo commit-nya, tambah validation, terus commit ulang dengan lebih lengkap.

# Setelah soft reset
git add src/utils/passwordValidation.js
git commit -m "Add user login with password strength validation for BuildWithAngga"

Mixed Reset - Undo Commit dan Staging

Perilaku default dari git reset (tanpa flag):

git reset HEAD~1

Atau eksplisit:

git reset --mixed HEAD~1

Perintah ini bakal:

• Undo commit terakhir
• Unstage semua perubahan
• Keep perubahan di working directory

Ini berguna kalau kamu mau benar-benar reorganisasi commit kamu. Misalnya, kamu udah commit 3 file sekaligus, tapi nyadar lebih baik dipisah jadi 2 commit terpisah.

Hard Reset - Opsi Nuclear

Ini adalah opsi paling ekstrem dan berbahaya:

git reset --hard HEAD~1

Perintah ini bakal:

• Undo commit terakhir
• Hapus semua perubahan dari staging area
• Hapus semua perubahan dari working directory

PERINGATAN: Hati-hati banget sama perintah ini! Semua perubahan yang belum di-commit bakal hilang permanen.

Gunakan hard reset cuma kalau kamu benar-benar yakin mau discard semua perubahan. Misalnya, kamu udah eksperimen dengan fitur payment gateway BuildWithAngga, tapi pendekatannya benar-benar salah dan mau start from scratch.

Reset ke Commit Spesifik

Kamu gak cuma bisa reset ke commit sebelumnya, tapi juga ke commit tertentu:

git reset --soft abc1234
git reset --mixed def5678
git reset --hard ghi9012

Untuk tau commit hash-nya, bisa pake:

git log --oneline

Git Revert - Cara Aman untuk Undo

Berbeda dengan reset yang ngubah history, git revert bikin commit baru yang membatalkan perubahan dari commit tertentu. Ini adalah cara aman untuk undo perubahan, terutama kalau commit udah di-share dengan orang lain.

git revert abc1234

Perintah ini bakal:

• Bikin commit baru yang undo perubahan dari commit abc1234
• Gak ngubah existing history
• Aman untuk digunain di shared repository

Misalnya, kamu udah push commit yang nambahin fitur notification BuildWithAngga, tapi ternyata ada bug kritis. Daripada reset (yang bakal bikin masalah buat orang yang udah pull), kamu bisa revert:

git revert HEAD

Git bakal buka editor buat pesan commit. Pesan default biasanya kayak "Revert 'Add notification system'". Kamu bisa edit sesuai kebutuhan.

Revert Multiple Commits

Kalau mau revert beberapa commit sekaligus:

git revert abc1234 def5678 ghi9012

Atau kalau commit-nya berurutan:

git revert abc1234..ghi9012

Revert Merge Commit

Revert merge commit butuh penanganan khusus:

git revert -m 1 abc1234

Flag -m 1 menentukan bahwa kamu mau revert ke parent pertama dari merge commit.

Git Checkout - Selective Undo

Perintah git checkout bisa dipake untuk undo perubahan di working directory untuk file atau direktori spesifik.

Untuk undo perubahan di file tertentu:

git checkout -- src/components/LoginForm.vue

Command ini bakal restore file ke kondisi terakhir di repository, membuang semua perubahan yang belum di-commit.

Untuk undo semua perubahan di working directory:

git checkout -- .

HATI-HATI: Command ini bakal membuang semua perubahan yang belum di-commit!

Checkout File dari Commit Tertentu

Kamu juga bisa restore file ke versi dari commit tertentu:

git checkout abc1234 -- src/utils/apiConfig.js

Ini berguna kalau kamu mau ambil versi lama dari file tertentu tanpa ngubah yang lain.

Modern Alternative: Git Restore

Di Git versi terbaru (2.23+), ada perintah baru yang lebih spesifik untuk operasi undo:

Untuk undo perubahan di working directory:

git restore src/components/UserProfile.vue

Untuk unstage file:

git restore --staged src/components/UserProfile.vue

Untuk restore file dari commit tertentu:

git restore --source=abc1234 src/utils/helpers.js

Skenario Undo yang Sering Terjadi

Mari kita lihat beberapa skenario umum dan solusinya:

Skenario 1: Salah Edit File, Belum Add

Kamu lagi edit component BuildWithAngga tapi gak sengaja ngrusak sesuatu. File belum di-add ke staging:

git checkout -- src/components/CourseCard.vue

Atau dengan git restore:

git restore src/components/CourseCard.vue

Skenario 2: Udah Add tapi Belum Commit

Kamu udah git add file tapi nyadar ada yang salah dan mau unstage:

git reset HEAD src/components/PaymentForm.vue

Atau dengan git restore:

git restore --staged src/components/PaymentForm.vue

Skenario 3: Udah Commit tapi Belum Push

Kamu udah commit tapi ada typo di pesan commit atau lupa nambah file:

git reset --soft HEAD~1
# Edit/add files
git add .
git commit -m "Correct commit message"

Skenario 4: Udah Push ke Remote

Kalau udah push dan repository di-share sama orang lain, jangan pake reset! Pake revert instead:

git revert HEAD
git push origin main

Skenario 5: Multiple Commits yang Salah

Kalau ada beberapa commit terakhir yang perlu di-undo:

git reset --soft HEAD~3
# Reorganize changes
git add .
git commit -m "Refactored BuildWithAngga dashboard with proper structure"

Advanced Undo Techniques

Interactive Rebase untuk Clean History

Kalau mau edit/remove/squash commit di history (sebelum push):

git rebase -i HEAD~5

Ini bakal buka editor dengan daftar 5 commit terakhir. Kamu bisa:

• pick: Keep commit as is
• edit: Stop to edit commit
• squash: Merge dengan commit sebelumnya
• drop: Remove commit completely

Cherry-pick untuk Selective Apply

Kalau mau apply commit spesifik dari branch lain:

git cherry-pick abc1234

Ini berguna kalau ada bug fix di feature branch yang mau di-apply ke main branch tanpa merge semua perubahan.

Reflog untuk Emergency Recovery

Kalau kamu gak sengaja nge-reset atau ngehapus commit dan panik:

git reflog

Reflog nampilin semua perubahan HEAD. Kamu bisa recovery ke kondisi sebelumnya:

git reset --hard HEAD@{2}

Best Practices untuk Undo Operations

Beberapa best practices yang sebaiknya diikutin:

Pertama, selalu backup atau bikin branch sebelum operasi undo yang besar:

git branch backup-before-reset
git reset --hard abc1234

Kedua, jangan pake force push kalau repository di-share:

# JANGAN
git push --force origin main

# LEBIH BAIK
git revert HEAD
git push origin main

Ketiga, pahami perbedaan antara reset dan revert:

• Reset: Mengubah history (berbahaya untuk shared repos)
• Revert: Bikin commit baru (aman untuk shared repos)

Keempat, kalau bekerja dengan tim, komunikasikan sebelum operasi undo besar yang mempengaruhi shared history.

Kelima, backup reguler dan pake pesan commit yang deskriptif untuk memudahkan recovery kalau diperlukan.

Perintah undo adalah jaring pengaman yang essential dalam alur kerja development. Dengan memahami kapan dan gimana pake setiap perintah, kamu bisa menangani kesalahan dengan percaya diri tanpa panik. Ingat, kesalahan adalah bagian dari proses belajar, dan Git kasih kamu alat untuk menanganinya dengan elegan.

Advanced Commands untuk Troubleshooting - Menjadi Git Detective

Nah, sekarang kita masuk ke bagian yang bener-bener menguji kemampuan kamu sebagai developer - perintah lanjutan untuk troubleshooting. Ini adalah senjata rahasia yang membedakan developer pemula dengan yang udah berpengalaman. Ketika semua orang panik karena ada bug misterius atau repository dalam kondisi kacau, kamu yang ngerti perintah troubleshooting lanjutan bakal jadi pahlawan yang nyelamatin hari.

Dalam pengalaman pengembangan nyata, terutama di proyek besar kayak yang sering kita tangani di BuildWithAngga, masalah gak selalu sederhana. Ada kalanya kamu nemuin bug yang muncul entah dari mana, atau ada konflik yang susah diselesaikan, atau bahkan repository yang entah gimana jadi rusak. Di sinilah perintah lanjutan ini jadi penyelamat.

Yang bikin troubleshooting lanjutan menantang adalah karena masalah-masalah ini sering memerlukan pemahaman yang mendalam tentang cara kerja internal Git. Kamu gak cuma jalanin perintah, tapi juga perlu analisis keluaran, memahami model objek Git, dan kadang bahkan menyelami struktur internal Git.

Di BuildWithAngga, kita sering nemuin situasi dimana developer junior stuck dengan masalah yang keliatan mustahil diselesaikan. Biasanya solusinya ada di perintah lanjutan yang memang jarang dipake sehari-hari, tapi sangat powerful ketika diperluin. Menguasai perintah troubleshooting ini bakal secara signifikan meningkatkan kepercayaan diri kamu dalam menangani masalah Git apa pun.

Git Fsck - File System Check untuk Repository

Perintah git fsck adalah pemeriksaan kesehatan untuk repository kamu. Command ini memverifikasi integritas dari semua objek dalam database Git dan mendeteksi kerusakan atau referensi yang hilang.

git fsck

Keluaran normal bakal kosong atau cuma nampilin peringatan kecil. Tapi kalau ada masalah serius, kamu bakal lihat pesan error yang detail.

Untuk keluaran yang lebih detail:

git fsck --full

Untuk memeriksa objek yang gak bisa dijangkau (orphaned commits):

git fsck --unreachable

Contoh skenario: Repository BuildWithAngga kamu tiba-tiba berkelakuan aneh, beberapa commit kayaknya hilang atau gak bisa diakses. Menjalankan fsck bisa membantu mengidentifikasi kalau ada kerusakan di database objek.

Git Gc - Garbage Collection dan Optimization

Perintah git gc (garbage collection) adalah alat pemeliharaan yang mengoptimalkan performa repository dengan membersihkan file yang gak perlu dan mengoptimalkan penyimpanan objek.

git gc

Untuk optimasi yang lebih agresif:

git gc --aggressive

Kalau mau melakukan simulasi untuk lihat apa yang bakal dibersihkan:

git gc --prune-packfiles --dry-run

Git gc secara otomatis:

• Mengemas objek loose ke dalam packfiles
• Menghapus pack yang redundan
• Menghapus objek yang gak bisa dijangkau lebih lama dari waktu default
• Mengoptimalkan struktur repository

Skenario penggunaan: Repository BuildWithAngga udah jadi sangat besar dan lambat. Menjalankan gc secara teratur membantu menjaga performa dan mengurangi penggunaan disk.

Git Prune - Cleaning Unreachable Objects

Perintah git prune menghapus objek yang gak bisa dijangkau dari referensi apa pun. Ini biasanya dijalankan secara otomatis oleh gc, tapi kadang kamu perlu kontrol manual.

git prune

Untuk menghapus objek yang lebih lama dari tanggal tertentu:

git prune --expire="2 weeks ago"

Untuk lihat apa yang bakal dihapus tanpa benar-benar melakukannya:

git prune --dry-run

PERINGATAN: Hati-hati dengan perintah prune karena mereka menghapus data secara permanen yang mungkin masih bisa dipulihkan sebelumnya.

Git Bisect - Binary Search untuk Bug Hunting

Perintah git bisect adalah salah satu alat debugging paling powerful dalam Git. Ini menggunakan algoritma binary search untuk menemukan commit tepat yang memperkenalkan bug.

Memulai sesi bisect:

git bisect start

Tandai commit saat ini sebagai buruk:

git bisect bad

Tandai commit yang diketahui baik:

git bisect good abc1234

Git bakal checkout commit di titik tengah. Test aplikasi kamu, kemudian tandai sebagai good atau bad:

git bisect good
# atau
git bisect bad

Ulangi proses sampai Git menemukan commit tepat yang memperkenalkan bug.

Akhiri sesi bisect:

git bisect reset

Contoh skenario nyata: Fitur payment gateway BuildWithAngga tiba-tiba rusak, tapi kamu gak tau persis commit mana yang merusaknya. Dengan bisect, kamu bisa secara efisien menemukan commit bermasalah di antara ratusan commit.

Automated Bisect dengan Script

Untuk debugging yang lebih efisien, kamu bisa mengotomatisasi proses bisect:

git bisect start HEAD abc1234
git bisect run npm test

Git secara otomatis menjalankan perintah test di setiap commit dan menandai sebagai good/bad berdasarkan exit code.

Git Stash - Advanced Stashing Techniques

Meskipun stash adalah perintah umum, teknik stash lanjutan sering diabaikan tapi sangat berguna untuk troubleshooting.

Buat stash dengan pesan yang deskriptif:

git stash push -m "WIP: debugging BuildWithAngga authentication issue"

Stash file tertentu saja:

git stash push -- src/components/LoginForm.vue src/utils/auth.js

Stash dengan menyertakan file yang belum di-track:

git stash push -u -m "Complete work in progress including new files"

Tampilkan semua stash dengan detail:

git stash list --stat

Tampilkan isi stash tertentu:

git stash show -p stash@{2}

Terapkan stash ke branch yang berbeda:

git checkout feature/buildwithangga-new-auth
git stash pop stash@{1}

Hapus stash tertentu:

git stash drop stash@{0}

Git Worktree - Multiple Working Directories

Perintah git worktree memungkinkan kamu punya beberapa direktori kerja untuk repository yang sama. Ini sangat berguna untuk troubleshooting ketika kamu perlu membandingkan kondisi yang berbeda atau bekerja di beberapa branch secara bersamaan.

Buat worktree baru:

git worktree add ../buildwithangga-hotfix main

Tampilkan semua worktree:

git worktree list

Hapus worktree:

git worktree remove ../buildwithangga-hotfix

Skenario troubleshooting: Ada bug kritis di production yang perlu perbaikan segera, tapi kamu lagi di tengah pengembangan fitur kompleks. Daripada stash/commit pekerjaan yang belum selesai, buat worktree untuk hotfix.

Git Cherry-pick untuk Selective Fixes

Ketika troubleshooting, sering kali kamu perlu menerapkan perbaikan spesifik dari branch yang berbeda tanpa merge semuanya.

Cherry-pick dasar:

git cherry-pick abc1234

Cherry-pick beberapa commit:

git cherry-pick abc1234 def5678 ghi9012

Cherry-pick rentang commit:

git cherry-pick abc1234..def5678

Cherry-pick tanpa auto-commit (untuk review perubahan dulu):

git cherry-pick --no-commit abc1234

Tangani konflik cherry-pick:

git cherry-pick abc1234
# Resolve conflicts manually
git add .
git cherry-pick --continue

Batalkan cherry-pick kalau ada masalah:

git cherry-pick --abort

Git Blame Advanced Usage

Meskipun blame dasar sudah dibahas sebelumnya, teknik blame lanjutan sangat berguna untuk troubleshooting mendalam.

Abaikan perubahan whitespace dalam blame:

git blame -w src/components/UserDashboard.vue

Ikuti rename file dalam blame:

git blame -C -C src/utils/apiHelper.js

Blame untuk rentang baris tertentu:

git blame -L 150,200 src/services/paymentService.js

Tampilkan blame dengan lebih banyak konteks:

git blame -s src/components/CourseCard.vue

Blame dari revisi tertentu:

git blame abc1234 -- src/utils/validation.js

Git Grep untuk Code Searching

Perintah git grep lebih powerful dari grep biasa untuk pencarian dalam repository Git.

Pencarian dasar:

git grep "buildwithangga-api-key"

Pencarian dengan case insensitive:

git grep -i "authentication"

Pencarian untuk word boundaries:

git grep -w "function"

Pencarian dengan nomor baris:

git grep -n "console.log"

Pencarian dalam tipe file tertentu:

git grep "TODO" -- "*.js" "*.vue"

Pencarian dalam commit tertentu:

git grep "deprecated" abc1234

Pencarian untuk pola regex:

git grep -E "function\\s+\\w+Auth"

Git Rev-list untuk Advanced History Analysis

Perintah git rev-list adalah perintah low-level untuk menganalisis riwayat commit dengan kriteria yang sangat spesifik.

Hitung commit antara dua titik:

git rev-list --count HEAD..origin/main

Temukan commit yang menyentuh file tertentu:

git rev-list HEAD -- src/components/PaymentForm.vue

Temukan merge commit saja:

git rev-list --merges HEAD

Temukan commit dari author tertentu dalam rentang waktu:

git rev-list --author="[email protected]" --since="1 month ago" HEAD

Git Show-branch untuk Complex Branch Analysis

Ketika menghadapi skenario branching yang kompleks, git show-branch memberikan visualisasi yang jelas tentang hubungan branch.

Tampilkan hubungan antara branch:

git show-branch main develop feature/buildwithangga-auth

Tampilkan riwayat branch dengan lebih banyak konteks:

git show-branch --all

Tampilkan jumlah commit tertentu:

git show-branch -10 main develop

Debugging Repository State Issues

Check Repository Configuration

Untuk troubleshoot masalah konfigurasi:

git config --list --show-origin

Periksa nilai config tertentu:

git config --get remote.origin.url

Analyze Object Database

Periksa informasi objek:

git cat-file -p abc1234
git cat-file -t abc1234
git cat-file -s abc1234

Tampilkan semua objek:

git cat-file --batch-all-objects --batch-check

Advanced Log Analysis

Temukan commit yang memperkenalkan/menghapus konten tertentu:

git log -S "buildwithangga-secret-key" --oneline

Temukan commit dengan pola pesan tertentu:

git log --grep="fix.*auth" --oneline

Tampilkan commit yang memodifikasi fungsi tertentu:

git log -L :authenticateUser:src/utils/auth.js

Emergency Repository Recovery

Recover Deleted Branch

Kalau gak sengaja hapus branch:

git reflog
git checkout -b recovered-branch abc1234

Recover from Hard Reset

Kalau gak sengaja hard reset:

git reflog
git reset --hard HEAD@{1}

Rebuild Index

Kalau index rusak:

rm .git/index
git reset

Performance Troubleshooting

Analyze Repository Size

Periksa apa yang menghabiskan ruang:

git count-objects -vH

Temukan file besar dalam riwayat:

git rev-list --objects --all | git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' | sed -n 's/^blob //p' | sort --numeric-sort --key=2 | tail -10

Network Troubleshooting

Debug operasi remote:

GIT_TRACE=2 git push origin main

Clone verbose untuk debugging:

git clone --verbose <https://github.com/buildwithangga/repository.git>

Perintah troubleshooting lanjutan ini adalah arsenal yang powerful untuk menangani masalah Git yang kompleks. Dengan menguasai perintah-perintah ini, kamu bakal bisa mendiagnosis dan menyelesaikan hampir semua masalah terkait Git yang ditemui dalam karir pengembangan kamu. Ingat, memahami kapan dan gimana menggunakan setiap perintah adalah kunci untuk troubleshooting yang efektif.

Penutup - Perjalanan Git Kamu Baru Dimulai

Nah, setelah kita menjelajahi berbagai perintah Git dari yang dasar sampai yang lanjutan, kamu sekarang udah punya arsenal lengkap untuk menghadapi berbagai situasi dalam pengembangan software. Git memang pada awalnya bisa terasa rumit, tapi percayalah, setelah kamu terbiasa dengan workflow Git, kamu bakal ngerasa gimana rasanya develop tanpa version control.

Yang paling penting dari semua perintah yang udah kita pelajari adalah memahami kapan harus menggunakan perintah mana. Gak semua situasi butuh solusi yang complicated. Kadang kala, perintah sederhana kayak git status dan git log udah cukup untuk menyelesaikan masalah.

Langkah Selanjutnya

Sekarang setelah kamu punya foundasi yang solid, praktekin semua perintah ini dalam proyek nyata. Bikin repository untuk proyek personal kamu dan gunakan Git dalam workflow sehari-hari. Yang penting adalah konsistensi dalam belajar dan praktek.

Kenapa Belajar di BuildWithAngga?

Kalau kamu serius mau mendalami Git dan version control dalam konteks pengembangan aplikasi modern, BuildWithAngga adalah tempat yang tepat untuk melanjutkan learning journey kamu. Di BuildWithAngga, kamu gak cuma belajar Git secara teori, tapi juga praktek langsung dalam proyek-proyek nyata.

Yang membuat BuildWithAngga special adalah:

Project-Based Learning dengan Real Collaboration - Kamu bakal participate dalam proyek tim dimana kamu benar-benar collaborate dengan developer lain, handle merge conflicts, dan manage releases - persis kayak di environment kerja nyata.

Mentorship dari Industry Experts - Access ke mentor yang udah berpengalaman handle proyek-proyek besar dan bisa kasih insight tentang gimana Git digunakan di different scenarios dalam industri.

Up-to-Date Curriculum - Materi yang selalu update dengan latest practices, integration dengan cloud platforms, CI/CD pipelines, dan modern deployment strategies.

Career Support - Bukan cuma technical skills, tapi juga career preparation, portfolio guidance, dan even job referrals.

Mulai Journey Kamu Hari Ini

Git adalah foundational skill yang bakal kamu gunakan sepanjang career programming kamu. BuildWithAngga siap ngebimbing kamu dari zero sampai jadi developer yang confident dan competent.

Jangan cuma jadi consumer of technology - jadi creator. Dan perjalanan itu dimulai dengan master the fundamentals, termasuk Git. Visit BuildWithAngga sekarang dan explore berbagai track pembelajaran yang available untuk level kamu!