Kuliah Ramadhan

Mari mengenal Git, Github dan Heroku

Kanal #ubuntu-indonesia
Server freenode.net
http://webchat.freenode.net/?channels=ubuntu-indonesia

Dibawakan oleh :
-Taufiqur-

Twitter : @iman_orang_aceh
imanulyaqin.blogspot.com

Git

Version Control

Version control adalah sebuah sistem yang mencatat setiap perubahan terhadap sebuah
berkas atau kumpulan berkas sehingga pada suatu saat a nda dapat kembali kepada salah satu
versi dari berkas tersebut.
Sistem ini memungkinkan anda untuk mengembalikan berkas anda pada kondisi/keadaan sebelumnya,
mengembalikan seluruh proyek pada keadaan sebelumnya, membandingkan perubahan setiap saat,
melihat siapa yang terakhir melakukan perubahan terbaru pada suatu objek sehingga berpotensi
menimbulkan masalah, siapa yang menerbitkan isu, dan lainnya. Dengan menggunakan VCS dapat
berarti jika anda telah mengacaukan atau kehilangan berkas, anda dapat dengan mudah
mengembalikannya. Ditambah lagi, anda mendapatkan semua ini dengan overhead yang sangat
sedikit.

Version Kontrol Sistem Lokal

Version kontrol lokal adalah sebuah basis data sederhana untuk menyimpan semua perubahan pada
berkas yang berada dalam cakupan revision kontrol

Version Kontrol Terpusat

Jenis ini memiliki sebuah server untuk menyimpan setiap versi berkas dan beberapa klien yang dapat
melakukan check out berkas dari server pusat.

Sistem ini memiliki beberapa kelebihan misalnya setiap orang pada tingkat tertentu mengetahui apa
yang orang lain lakukan pada proyek. Administrator memiliki lebih bayak kendali dan lebih mudah
menangani file dan berkas dibanding sistem lokal.

Version Kontrol Terdistribusi

Contoh sistem ini seperti git yang akan kita bahas, mercurial, bazaar atau darcs. Pada sistem ini
klient tidak hanya melakukan checkout untuk snapshot terakhir setiap berkas, namun mereka
memiliki salinan penuh dari repository tersebut. Jadi jika server mati dan sistem berkolaborasi
melalui server tersebut, maka klient manapun dapat mengirimkan salinan repositori tersebut kembali
ke server. Setiap chekout pada dvcs merupakan sebuah backup dari keseluruhan data.

Sejarah Git.
Pada awalnya untuk mempermudah kolaborasi pengembangan kernel linux, mereka menggunakan
sebuah dvcs propertary bernama bitkeeper. Seiring waktu tim pengembang dari bitkeper retak dan
status gratis pada bit keeper dicabut. Hal ini membuat komunitas pengembang Kernel Linux (dan
khususnya Linus Torvalds, sang pencipta Linux) harus mengembangkan perkakas sendiri dengan
berbekal pengalaman yang mereka peroleh ketika menggunakan BitKeeper. Dan sistem tersebut
diharapkan dapat memenuhi beberapa hal berikut:
Kecepatan
Desain yang sederhana
Dukungan penuh untuk pengembangan non-linear (ribuan cabang paralel)
Terdistribusi secara penuh
Mampu menangani proyek besar seperti Kernel Linux secara efisien (dalam kecepatan dan ukuran
data)
Sejak kelahirannya pada tahun 2005, Git telah berkembang dan semakin mudah digunakan serta
hingga saat ini masih mempertahankan kualitasnya tersebut. Git luar biasa cepat, sangat efisien
dalam proyek besar, dan memiliki sistem pencabangan yang luar biasa untuk pengembangan nonlinear.

Snapshot pada Git

Git memiliki perbedaan dengan vcs lainya dalam hal memperlakukan datanya. Secara konsep vcs lain
menyimpan informasi sebagai sebuah daftar perubahan berkas. Sistem seperti ini (CVS, Subversion,
Bazaar, dan yang lainnya) memperlakukan informasi yang disimpannya sebagai sekumpulan berkas
dan perubahan yang terjadi pada berkas-berkas tersebut.

Git tidak bekerja seperti ini. Melainkan, Git memperlakukan datanya sebagai sebuah kumpulan
snapshot dari sebuah miniatur sistem berkas. Setiap kali anda melakukan commit, atau melakukan
perubahan pada proyek Git anda, pada dasarnya Git merekam gambaran keadaan berkas-berkas anda
pada saat itu dan menyimpan referensi untuk gambaran tersebut. Agar efisien, jika berkas tidak
mengalami perubahan, Git tidak akan menyimpan berkas tersebut melainkan hanya pada file yang
sama yang sebelumnya telah disimpan.

Hal ini membuat Git mempertimbangkan kembali hampir setiap aspek dari version control yang oleh
kebanyakan sistem lainnya disalin dari generasi sebelumnya. Ini membuat Git lebih seperti sebuah
miniatur sistem berkas dengan beberapa tool yang luar biasa ampuh yang dibangun di atasnya,
ketimbang sekadar sebuah VCS.

Semua Operasi Dilakukan secara lokal

Git tidak membutuhkan data histori dari server untuk kemudian menampilkannya untuk anda, namun
secara sedarhana Git membaca historinya langsung dari basisdata lokal proyek tersebut. Ini berarti
anda melihat histori proyek hampir secara instant. Jika anda ingin membandingkan perubahan pada
sebuah berkas antara versi saat ini dengan versi sebulan yang lalu, Git dapat mencari berkas yang
sama pada sebulan yang lalu dan melakukan pembandingan perubahan secara lokal, bukan dengan
cara meminta remote server melakukannya atau meminta server mengirimkan berkas versi yang lebih
lama kemudian membandingkannya secara lokal.
Jika anda sedang berada dalam pesawat terbang atau sebuah kereta dan ingin melakukan pekerjaan
kecil, anda dapat melakukan commit sampai anda memperoleh koneksi internet hingga anda dapat
menguploadnya. Jika anda pulang ke rumah dan VPN client anda tidak bekerja dengan benar, anda
tetap dapat bekerja.

Integritas
Segala sesuatu pada Git akan melalui proses checksum terlebih dahulu sebelum disimpan yang
kemudian direferensikan oleh hasil checksum tersebut. Hal ini berarti tidak mungkin melakukan
perubahan terhadap berkas manapun tanpa diketahui oleh Git. Fungsionalitas ini dimiliki oleh Git
pada level terendahnya dan ini merupakan bagian tak terpisahkan dari filosofi Git. Anda tidak akan
kehilangan informasi atau mendapatkan file yang cacat tanpa diketahui oleh Git.
Mekanisme checksum yang digunakan oleh Git adalah SHA-1 hash. Ini merupakan sebuah susunan
string yang terdiri dari 40 karakter heksadesimal (0 hingga 9 dan a hingga f) dan dihitung berdasarkan
isi dari sebuah berkas atau struktur direktori pada Git. sebuah hash SHA-1 berupa seperti berikut:
24b9da6552252987aa493b52f8696cd6d3b00373

Anda akan melihat nilai seperti ini pada berbagai tempat di Git. Faktanya, Git tidak menyimpan
nama berkas pada basisdatanya, melainkan nilai hash dari isi berkas.

Git hanya menambahkan Data

Ketika anda melakukan operasi pada Git, kebanyakan dari operasi tersebut hanya menambahkan data
pada basisdata Git. It is very difficult to get the system to do anything that is not undoable or to
make it erase data in any way. Seperti pada berbagai VCS, anda dapat kehilangan atau mengacaukan
perubahan yang belum di-commit; namun jika anda melakukan commit pada Git, akan sangat sulit
kehilanngannya, terutama jika anda secara teratur melakukan push basisdata anda pada repositori
lain.
Hal ini menjadikan Git menyenangkan karena kita dapat berexperimen tanpa kehawatiran untuk
mengacaukan proyek. Untuk lebih jelas dan dalam lagi tentang bagaimana Git menyimpan datanya
dan bagaimana anda dapat mengembalikan yang hilang,

Tiga Keadaan
Sekarang perhatikan. Ini adalah hal utama yang harus diingat tentang Git jika anda ingin proses
belajar anda berjalan lancar. Git memiliki 3 keadaan utama dimana berkas anda dapat berada:
committed, modified dan staged. Committed berarti data telah tersimpan secara aman pada
basisdata lokal. Modified berarti anda telah melakukan perubahan pada berkas namun anda belum
melakukan commit pada basisdata. Staged berarti anda telah menandai berkas yang telah diubah
pada versi yang sedang berlangsung untuk kemudian dilakukan commit.
Ini membawa kita ke tiga bagian utama dari sebuah projek Git: direktori Git, direktori kerja, dan
staging area.

Direktori Git adalah dimana Git menyimpan metadata dan database objek untuk projek anda. Ini
adalah bahagian terpenting dari Git, dan inilah yang disalin ketika anda melakukan kloning sebuah
repository dari komputer lain.
Direktori kerja adalah sebuah checkout tunggal dari satu versi dari projek. Berkas-berkas ini
kemudian ditarik keluar dari basisdata yang terkompresi dalam direktori Git dan disimpan pada disk
untuk anda gunakan atau modifikasi.
Staging area adalah sebuah berkas sederhana, umumnya berada dalam direktori Git anda, yang
menyimpan informasi mengenai apa yang menjadi commit selanjutnya. Ini terkadang disebut sebagai
index, tetapi semakin menjadi standard untuk menyebutnya sebagai staging area.
Alur kerja dasar Git adalah seperti ini:
1.Anda mengubah berkas dalam direktori kerja anda.
2.Anda membawa berkas ke stage, menambahkan snapshotnya ke staging area.
3.Anda melakukan commit, yang mengambil berkas seperti yang ada di staging area dan
menyimpan snapshotnya secara permanen ke direktori Git anda.

Jika sebuah versi tertentu dari sebuah berkas telah ada di direktori git, ia dianggap 'committed'. Jika
berkas diubah (modified) tetapi sudah ditambahkan ke staging area, maka itu adalah 'staged'. Dan
jika berkas telah diubah sejak terakhir dilakukan checked out tetapi belum ditambahkan ke staging
area maka itu adalah 'modified'. Pada Bab 2, anda akan mempelajari lebih lanjut mengenai keadaankeadaan ini dan bagaimana anda dapat memanfaatkan keadaan-keadaan tersebut ataupun
melewatkan bagian 'staged' seluruhnya.

Menginstall git
Untuk menginstall git di ubuntu lakukan perintah seperti berikut :
$ sudo apt-get install git

di fedora dapat menggunakan perintah ini :

$ sudo yum install git-core

untuk osx bisa mendapatkan installer nya disini

http://sourceforge.net/projects/git-osx-installer/
untuk windows bisa di download di sini
http://msysgit.github.io/

File Konfigurasi Git

/etc/gitconfig
Menyimpan banyak nilai variabel untuk setiap pengguna di pc tersebut
~/.gitconfig
Menyimpan nilai-nilai variabel untuk untuk pengguna yang bersangkutan

Identitas anda
Hal pertama yang harus anda lakukan ketika menginstalkan Git adalah mengatur username dan
alamat e-mail anda. Hal ini penting karena setiap commit pada Git akan menggunakan informasi ini,
dan informasi ini akan selamanya disimpan dengan commit yang anda buat tersebut:

$ git config --global user.name "John Doe"

$ git config --global user.email [email protected]

perintah diatas hanya dilakukan sekali. Jika anda ingin menggunakan username dan email berbeda di
suatu proyek anda dapat memberikan perintah diatas tanpa parameter global

Editor
Git menggunakan editor default vi atau vim. Jika anda ingin mengganti dengan editor lain dapat
dilakukan dengan menggunakan perintah
$ git config --global core.editor emacs

Perkakas diff
Jika ingin mengganti perkakas diff bisa dilakukan dengan menggunakan perintah
$ git config --global merge.tool vimdiff

Mengecek setingan anda

Untuk mengecek setingan anda dapat menggunakan perintah seperti berikut :

$ git config list

untuk spesifik setingan dengan perintah berikut
$ git config user.name

Menu bantuan
Ada 3 jenis perintah untuk menampilkan menu bantuan
$ git help <nama>
$ git <nama> --help
$ man git-<nama>

contoh penerapan
$ git help config
$ git commit --help
$ man git-archive

Memulai Git
Ada 2 cara memulai git. Yaitu dengan mulai memantau direktori proyek, yang kedua dengan
melakukan kloning dari repository proyek git.

Memulai di direktori tersedia.

Misalkan anda akan membuat sebuah proyek, yang pertama harus anda lakukan adalah membuat
direktori tersebut dan menjalankan perintah git init.
$ git init
Git akan membuat sebuah subdirektori baru bernama .git yang akan berisi semua berkas penting dari
repositori Anda, yaitu kerangka repositori dari Git. Pada titik ini, belum ada apapun dari proyek Anda
yang dipantau.
Jika Anda ingin mulai mengendalikan versi dari berkas tersedia (bukan direktori kosong), Anda lebih
baik mulai memantau berkas tersebut dengan melakukan commit awal. Caranya adalah dengan
beberapa perintah git add untuk merumuskan berkas yang ingin anda pantau, diikuti dengan sebuah
commit:
$ git add *.c
$ git add README
$ git commit m 'versi awal proyek'

Kita akan membahas apa yang dilakukan perintahperintah di atas sebentar lagi. Pada saat ini, Anda
sudah memiliki sebuah repositori Git berisi filefile terpantau dan sebuah commit awal.

Duplikasi Repositori Tersedia

Jika Anda ingin membuat salinan dari repositori Git yang sudah tersedia misalnya, dari sebuah
proyek yang Anda ingin ikut berkontribusi di dalamnya perintah yang Anda butuhkan adalah git
clone .

Git menerima salinan dari hampir semua data yang server miliki. Setiap versi dari setiap
berkas yang tercatat dalam sejarah dari proyek tersebut akan ditarik ketika Anda
menjalankan git clone . Bahkan, ketika cakram di server Anda rusak, Anda masih dapat
menggunakan hasil duplikasi di klien untuk mengembalikan server Anda ke keadaan
tepat pada saat duplikasi dibuat.
Anda menduplikasi sebuah repositori menggunakan perintah git clone [url] . Sebagai
contoh, jika Anda ingin menduplikasi pustaka Git Ruby yang disebut Grit, Anda dapat
melakukannya sebagai berikut:
$ git clone git://github.com/schacon/grit.git

Perintah ini akan membuat sebuah direktori yang dinamakan "grit", menata awal sebuah
direktori .git di dalamnya, menarik semua data dari repositori, dan checkout versi
mutakhir dari salinan kerja. Jika Anda masuk ke dalam direktori grit tersebut, Anda
akan melihat berkasberkas proyek sudah ada di sana, siap untuk digunakan. Jika Anda
ingin membuat duplikasi dari repositori tersebut ke direktori yang tidak dinamakan grit,
Anda harus merumuskan namanya sebagai opsi di perintah di atas:
$ git clone git://github.com/schacon/grit.git mygrit

Merekam Perubahan ke dalam Repositori

Anda sudah memiliki repositori Git yang bonafide dan sebuah salinan kerja dari semua
berkas untuk proyek tersebut. Anda harus membuat beberapa perubahan dan commit
perubahan tersebut ke dalam repositori setiap saat proyek mencapai sebuah keadaan
yang ingin Anda rekam.
Ingat bahwa setiap berkas di dalam direktori kerja Anda dapat berada di 2 keadaan:
terpantau atau tak terpantau. Berkas terpantau adalah berkas yang sebelumnya berada
di snapshot terakhir; mereka dapat berada dalam kondisi belum terubah, terubah,
ataupun staged (berada di area stage).

Cek Status Repository

Untuk mengecek status dari berkas repo anda dapat menggunakan perintah
$ git status

Memasukkan Berkas Terubah ke Dalam Area Stage

Mari kita ubah sebuah berkas yang sudah terpantau. Jika Anda mengubah berkas yang
sebelumnya terpantau bernama README dan kemudian menjalankan perintah status
lagi, Anda akan mendapatkan keluaran kurang lebih seperti ini:

Berkas README terlihat di bawah bagian yang bernama "Changes not staged for commit"
yang berarti bahwa sebuah berkas terpantau telah berubah di dalam direktori kerja
namun belum masuk ke area stage. Untuk memasukkannya ke area stage, Anda
menjalankan perintah
git add
(perintah ini adalah perintah multiguna. Anda
menggunakannya untuk mulai memantau berkas baru, untuk memasukkannya ke area
stage, dan untuk melakukan hal lain seperti menandai berkas terkonflik menjadi
terpecahkan). Mari kita sekarang jalankan git add untuk memasukkan berkas README
ke dalam area stage, dan jalankan git status lagi:

begitu seterus nya jika. Jika anda melakukan perubahan pada satu atau beberapa berkas
dan mengecek status nya anda akan melihat bahwa berkas tersebut berada di posisi
modified.

Anda bisa memberi perintah git add untuk masuk ke mode commited atau perintah git
checkout -- untuk membatalkan perubahan. Contoh ;
$ git add README
$ git checkout file1.txt

Mengabaikan Berkas

Terkadang, Anda memiliki sekumpulan berkas yang Anda tidak ingin Git tambahkan
secara otomatis atau bahkan terlihat sebagai takterpantau. Biasanya berkas hasil
keluaran seperti berkas log atau berkas yang dihasilkan oleh sistem build Anda. Dalam
kasus ini, Anda dapat membuat sebuah berkas bernama .gitignore yang berisi pola dari
berkas terabaikan. Berikut adalah sebuah contoh isi dari berkas .gitignore:
$ cat .gitignore
*.[oa]
*~

Baris pertama memberitahu Git untuk mengabaikan semua file yang berakhiran .o
atau .a berkas object dan arsip yang mungkin dihasilkan dari kompilasi kode Anda. Baris
kedua memberitahu Git untuk mengabaikan semua file yang berakhiran dengan sebuah
tilde ( ~ ), yang biasanya digunakan oleh banyak aplikasi olah-kata seperti Emacs untuk
menandai berkas sementara. Anda juga dapat memasukkan direktori log, tmp ataupun
pid; dokumentasi otomatis; dan lainnya. Menata berkas .gitignore sebelum Anda mulai
bekerja secara umum merupakan ide yang baik sehingga Anda tidak secara tak sengaja
melakukan commit terhadap berkas yang sangat tidak Anda inginkan berada di dalam
repositori Git.

Aturan untuk pola yang dapat Anda gunakan di dalam berkas .gitignore adalah sebagai
berikut:
1. Baris kosong atau baris dimulai dengan # akan diabaikan.
2. Pola glob standar dapat digunakan.
3. Anda dapat mengakhir pola dengan sebuah slash ( / ) untuk menandai sebuah
direktori.
4. Anda dapat menegasikan sebuah pola dengan memulainya menggunakan karakter
tanda seru ( ! ).
Pola Glob adalah seperti regular expression yang disederhanakan yang biasanya
digunakan di shell.
Sebuah asterisk ( * ) berarti 0 atau lebih karakter; [abc] terpasangkan dengan karakter
apapun yang ditulis dalam kurung siku (dalam hal ini a, b, atau c); sebuah tanda tanya
( ? ) terpasangkan dengan sebuah karakter; dan kurung siku yang melingkupi karakter
yang terpisahkan dengan sebuah tanda hubung( [0-9] ) terpasangkan dengan karakter
apapun yang berada diantaranya (dalam hal ini 0 hingga 9).

Berikut adalah contoh lain dari isi berkas .gitignore:

# sebuah komentar akan diabaikan
# abaikan berkas .a
*.a
# tapi pantau lib.a, walaupun Anda abaikan berkas .a di atas
!lib.a
# hanya abaikan berkas TODO yang berada di root, bukan di subdir/TODO
/TODO
# abaikan semua berkas di dalam direktori build/
build/
# abaikan doc/notes.txt, tapi bukan doc/server/arch.txt
doc/*.txt

Melihat Perubahan di Area Stage dan di luar Area Stage

Untuk melihat perubahan berkas yang lebih detail anda bisa menggunakan diff. Contoh
perintahnya :
$ git diff
$ git diff --cached

Commit Perubahan Anda

Sekarang setelah area stage Anda tertata sebagaimana yang Anda inginkan, Anda dapat
melakukan commit terhadap perubahan Anda. Ingat bahwa apapun yang masih di luar
area stage berkas apapun yang Anda telah buat atau ubah yang belum Anda jalankan git
add terhadapnya sejak terakhir Anda edit tidak akan masuk ke dalam commit ini.
Perubahan tersebut akan tetap sebagai berkas terubah di cakram Anda. Dalam hal ini,
saat terakhir Anda jalankan git status , Anda telah melihat bahwa semuanya telah
masuk ke stage, sehingga Anda siap untuk melakukan commit dari perubahan Anda. Cara
termudah untuk melakukan commit adalah dengan mengetikkan git commit :
$ git commit

Cara lainnya, Anda dapat mengetikkan pesan commit Anda sebaris denegan perintah
commit dengan mencantumkannya setelah tanda -m seperti berikut:

Ingat bahwa commit merekam snapshot yang Anda telah tata di area stage. Apapun yang
tidak Anda masukkan ke area stage akan tetap berada di tempatnya, tetap dalam
keadaan terubah; Anda dapat melakukan commit lagi untuk memasukkannya ke dalam
sejarah Anda. Setiap saat Anda melakukan sebuah commit, Anda merekamkan sebuah
snapshot dari proyek Anda yang bisa Anda kembalikan atau Anda bandingkan nantinya.
Melewatkan Area Stage

Walaupun dapat menjadi sangat berguna untuk menata commit tepat sebagaimana Anda
inginkan, area stage terkadang sedikit lebih kompleks dibandingkan apa yang Anda
butuhkan di dalam alurkerja Anda.
Jika Anda ingin melewatkan area stage, Git menyediakan sebuah jalan pintas sederhana.
Dengan memberikan opsi -a ke perintah git commit akan membuat Git secara
otomatis menempatkan setiap berkas yang telah terpantau ke area stage sebelum
melakukan commit, membuat Anda dapat melewatkan bagian git add :
$ git commit -a -m 'menambahkan snapshot terbaru'

Menghapus Berkas

Untuk menghapus sebuah berkas dari Git, Anda harus menghapusnya dari berkas
terpantau (lebih tepatnya, mengpus dari area stage) dan kemudian commit. Perintah git
rm melakukan hal tadi dan juga menghapus berkas tersebut dari direktori kerja Anda
sehingga Anda tidak melihatnya sebagai berkas yang tak terpantau nantinya.

Contoh perintahnya :
$ rm <nama file>

kemudian jalankan perintah

$ git rm <nama file>

Pada saat Anda commit nantinya, berkas tersebut akan hilang dan tidak lagi terpantau.
Jika Anda mengubah berkas tersebut dan menambahkannya lagi ke index, Anda harus
memaksa penghapusannya dengan menggunakan opsi -f . Ini adalah fitur keamanan
(safety) untuk mencegah ketidaksengajaan penghapusan terhadap data yang belum
terekam di dalam snapshot dan tak dapat dikembalikan oleh Git.

Hal berguna lain yang Anda dapat lakukan adalah untuk tetap menyimpan berkas di
direktori kerja tetapi menghapusnya dari area kerja. Dengan kata lain, Anda mungkin
ingin tetap menyimpan berkas tersebut di dalam cakram keras tetapi tidak ingin Git
untuk memantaunya lagi. Hal ini khususnya berguna jika Anda
lupa untuk menambahkan sesuaitu ke berkas .gitignore Anda dan secara taksengaja
menambahkannya, seperti sebuah berkas log yang besar, atau sekumpulan berkas hasil
kompilasi .a . Untuk melakukan ini,
gunakan opsi --cached :
$ git rm --cached <nama file>

Memindahkan Berkas

Git memiliki perintah mv . Jika Anda hendak mengubah nama

berkas di Git, Anda dapat menjalankan seperti berikut
$ git mv file_from file_to

dan itu berjalan baik. Bahkan, jika Anda menjalankannya seperti ini kemudian melihat
ke status, Anda akan melihat bahwa Git menganggapnya sebagai perintah pengubahan
nama berkas.

Sama saja dengan menjalankan perintah berikut :

$ mv file2.txt file.txt
$ git rm file2.txt
$ git add file.txt

Melihat Riwayat Commit

Bisa dilakukan dengan menggunakan perintah

$ git log

untuk membatasi hasil keluaran dengan opsi -p

Untuk melihat statistik dengan opsi --stat

Beberapa opsi log yang berguna

contoh opsi lain :

$ git log since=2.weeks

Membatalkan Apapun

Sebagai contoh, jika Anda melakukan commit dan menyadari bahwa Anda lupa untuk
memasukkan beberapa perubahan dalam sebuah berkas ke area stage dan Anda ingin
untuk menambahkan perubahan ini ke dalam commit terakhir, Anda dapat melakukannya
sebagai berikut:
$ git commit -m 'initial commit'
$ git add forgotten_file
$ git commit --amend

Ketiga perintah ini tetap akan bekerja di satu commit - commit kedua akan
menggantikan hasil dari commit pertama.

Mengeluarkan Berkas dari Area Stage

Cara mengeluarkan berkas dari area stage dengan menggunakan perintah reset head
$ git add .
$ git status
$ git reset HEAD <nama berkas>

Mengembalikan Berkas Terubah

dengan menggunakan perintah checkout

$ git checkout -- <namaberkas>

Github

Github adalah sebuah sosial media sekaligus repository terpusat untuk berbagi proyek
bersama anggota team dengan menggunakan teknologi git. Cara mendaftar akun github
sangat mudah seperti mendaftar email atau sosial media kebanyakan.

Cara membuat repository baru di github

Pada bagian kanan atas layar klik tombol + dan pilih new repository, kemudian isi sesuai
dengan repository yang akan anda buat

Cara mengirim proyek anda ke github.

Jika anda ingin mengirim (push) proyek anda ke github, baik proyek yang anda buat
dengan editor, framework generator, IDE, dst dengan cara :
1. Masuk ke direktori proyek anda berada dan jalankan perintah git init untuk membuat
repository lokal di pc anda.
$ git init

2. Memasukkan file2 / direktori kode sumber ke staging area dengan cara :

$ git add *

untuk keleluruhan kode sumber

$ git add <namafile>

untuk memasukkan satu persatu nama file

$ git add <nama direktory>/

untuk memasukkan per direktori.

3. Untuk menyimpan kode sumber ke repository dengan cara
$ git commit -m judul dari perubahan repo

4. Untuk mengakses remote repository di github adalah dengan cara

$ git remote add origin https://github.com/taufiqur-rahman/railsweb1.git

kemudian jalankan perintah

$ git push -u origin master

nanti hasilnya seperti ini https://github.com/taufiqur-rahman/railsweb1

Perintah-perintah Remote yang berguna

Ada beberapa perintah yang berguna jika kita ingin melakukan kerja remote dengan
github. Contoh2 perintah tersebut adalah :

Melihat repository remote

$ git remote

dan
$ git remote -v

Mengatur Nama Pendek

$ git remote add web1 https://github.com/taufiqur-rahman/railsweb1.git
$ git remote -v

sekarang kita bisa menggunakan nama pendek untuk mempersingkat url lengkap dari
repo git kita.

Menarik repository remote

Untuk menarik repo bisa dilakukan dengan menggunakan perintah fetch yg formatnya :
$ git fetch <nama-repo>

misalnya
$ git fetch web1

Perintah tersebut akan diteruskan ke repositori remote dan menarik semua data yang
belum Anda miliki dari sana. Setelah Anda melakukan ini, Anda akan memiliki referensi
terhadap semua cabang yang ada di repositori remote tadi, yang kemudian dapat Anda
gabungkan atau periksa kapanpun.

Mendorong repository remote

Dapat dilakukan dengan perintah

$ git push origin master

Perintah ini hanya bekerja jika Anda menduplikasi dari server dengan akses tulis terbuka
bagi Anda dan jika belum ada orang yang mendorong sebelumnya. Jika Anda dan seorang
lainnya menduplikasi secara bersamaan dan mereka mendorong ke server baru kemudian
Anda, hasil kerja Anda akan segera ditolak.
Anda perlu menarik hasil kerja mereka dahulu dan menggabungkannya dengan hasil
kerja Anda sebelum Anda diperbolehkan untuk mendorong.

Memeriksa Repository Remote

Bisa dilakukan dengan perintah

$ git remote show origin

Perintah ini akan memperlihatkan daftar URL dari repositori remote dan juga informasi
cabang remote terpantau. Perintah tersebut juga membantu Anda melihat bahwa Anda
berada di cabang master dan jika Anda menjalankan git pull , perintah tersebut akan
secara otomatis menggabungkan dari cabang master remote setelah mengambil semua
referensi dari sana. Perintah ini juga memperlihatkan daftar semua referensi yang sudah
ditarik.

Menghapus dan Mengganti Nama Repositori Remote

Jika Anda ingin mengganti nama sebuah referensi, pada Git versi baru Anda dapat
menjalankan git remote rename untuk mengganti nama pendek dari repositori remote.
Sebagai contoh, jika Anda ingin mengganti nama web1 menjadi taufiq , Anda dapat
melakukannya dengan perintah git remote rename :
$ git remote rename web1 taufiq

Heroku

Heroku adalah cloud hosting server yang menerapkan konsep pass (platform as service).
Heroku mendukung beberapa jenis bahasa pemrograman seperti PHP, Ruby, Python,
Node.js, java, dst.

Cara mendeploy aplikasi ke heroku

1. Anda harus mendaftarkan akun heroku.com

2. Anda harus menginstall heroku-toolbet dengan mengikuti petunjuknya di
https://toolbelt.herokuapp.com/
untuk di linux perintah nya :
$ sudo wget -qO- https://toolbelt.heroku.com/install-ubuntu.sh | sh

3. Login di perintah heroku

$ heroku login

Berikutnya akan diminta memasukan nama akun dan password, masukkan sesuai dengan
akun yang telah anda daftarkan

4. Mempersiapkan aplikasi yang akan di deploy ke heroku

Karna dalam hal ini penulis akan mendeploy rails, maka kali ini dengan menjalankan
bundle instal yaitu berguna untuk menginstall ulang dependencies yang dibutuhkan oleh
aplikasi rails ini.
$ bundle install

5. Atur repo git

Jika anda belum membuat direktori kerja sebagai repository git, anda harus
membuatnya sekarang dengan perintah
$ git init
$ git add .
$ git commit -m "nama dari repo bebas aja"

6. Membuat aplikasi heroku

$ heroku create namasitus

7. Mendorong aplikasi ke heroku

$ git push heroku master

dan tunggu sampai proses nya selesai.

8. Perintah untuk menjalankan aplikasi kita
$ heroku run rake db:migrate && heroku restart

nanti hasilnya seperti berikut : https://latihanubuntu.herokuapp.com/ atau

https://fossmedia.herokuapp.com/

== Sekian ==
Happy ngoprek :D

Taufiqur >_
imanulyaqin.blogspot.com
twitter.com/iman_orang_aceh

Ref :

http://git-scm.com/book/id/
https://devcenter.heroku.com/articles
https://help.github.com/index.htm