Kapan melakukan kode?

Ketika mengerjakan suatu proyek, kode tersebut dapat dikembangkan cukup cepat dalam satu hari atau sedikit demi sedikit untuk periode berkepanjangan beberapa minggu / bulan / tahun. Karena komit kode menjadi dianggap sebagai ukuran pengembangan proyek, itu tidak benar-benar berarti memiliki lebih banyak kode yang ditulis daripada proyek yang memiliki komit lebih rendah.

Jadi pertanyaannya adalah kapan benar-benar membuat komit ke repositori sehingga komit itu dapat dibenarkan?

Sebagai tambahan: Apakah ini praktik yang tepat untuk mengukur pengembangan proyek berdasarkan komitmennya?

Anda berkomitmen ketika Anda telah mencapai status basis kode yang ingin Anda ingat. Ada banyak alasan mengapa Anda mungkin ingin mengingat status basis kode tertentu, sehingga tidak ada aturan yang sulit dan cepat tentang kapan harus melakukan. Namun, jumlah komitmen jelas bukan ukuran kualitas atau kemajuan.

Saya suka menganggap coding sebagai panjat tebing dalam konteks ini. Anda memanjat sedikit, dan kemudian Anda menaruh jangkar di batu. Jika Anda jatuh, jangkar terakhir yang Anda tanam adalah titik yang melindungi Anda, sehingga Anda tidak akan pernah jatuh lebih dari beberapa meter. Sama dengan kontrol sumber; Anda sedikit kode, dan ketika Anda mencapai posisi yang agak stabil, Anda melakukan revisi. Jika Anda gagal total, Anda selalu dapat kembali ke revisi terakhir, dan Anda tahu itu stabil.

Yang mengatakan, jika Anda bekerja di tim, itu biasa untuk memastikan apa pun yang Anda komit selesai, masuk akal, membangun dengan bersih, dan tidak merusak barang orang lain. Jika Anda perlu melakukan perubahan besar yang mungkin mengganggu pekerjaan orang lain, buat cabang sehingga Anda dapat melakukan tanpa mengganggu orang lain.

Ini juga tergantung pada sistem SCM yang Anda gunakan. Sistem terdistribusi biasanya membuat penggabungan dan forking tidak menyakitkan dan cepat, dan Anda dapat melakukan secara lokal; ini berarti Anda harus banyak melakukan, dan mendorong / menggabungkan ketika Anda telah melakukan banyak pekerjaan. Dengan sistem terpusat seperti svn atau cvs, melakukan lebih mahal, dan itu mempengaruhi semua orang. Bercabang sebagian memecahkan masalah ini, tetapi karena itu terjadi di server, itu bisa sangat lambat, dan penggabungan bisa menjadi rumit. Jadi dengan SCM terpusat, sering kali ada budaya yang lebih hati-hati, di mana Anda hanya berkomitmen setelah Anda melakukan banyak pekerjaan.

Adapun add-on: Tolong, tolong jangan lakukan itu. Baris kode, jumlah komit, jumlah bug yang ditemukan / diselesaikan, dll., Semuanya merupakan pengukuran kualitas atau bahkan kuantitas yang sangat buruk.

Jika Anda menggunakan DVCS seperti Mercurial atau Git, Anda harus berkomitmen pada repositori lokal Anda setiap kali Anda telah melakukan banyak pekerjaan. Namun, hanya dorong ke repositori bersama hanya setelah itu berfungsi, perubahan mandiri yang telah diuji.

Untuk VCS yang tidak terdistribusi (seperti misalnya. SVN) logika yang sama berlaku, alih-alih repositori lokal menggunakan cabang pribadi, alih-alih push-merge ke cabang utama.

Anda harus melakukan lebih awal dan sering.

Saya tahu orang-orang yang berkomitmen sesering setiap 90 detik. Serius. Tampaknya bekerja untuk mereka. Saya telah bereksperimen dengan melakukan setiap kali saya menyimpan file, yang mungkin lebih sering dari 90 detik. Hari ini, saya mungkin melakukan setiap 15 menit. VCS yang memungkinkan Anda untuk memeras banyak komit menjadi satu dan yang memungkinkan komit lokal (seperti git) membuat ini jauh lebih mudah.

Seberapa sering Anda harus berkomitmen? Sulit dikatakan, tetapi mungkin lebih sering daripada Anda sekarang. Teruslah melakukan komitmen lebih sering, temukan hal yang terasa terlalu aneh, dan kemudian mundur sedikit. Kemungkinannya adalah Anda akan mendapatkan sesuatu yang masuk akal.

Anda mengukur pengembangan produk berdasarkan nilai yang dikirimkan kepada penggunanya. Tidak ada pengukuran akurat lainnya.

Komit adalah blok penyusun data / kode yang dikendalikan versi apa pun. Setiap komit harus melakukan persis salah satu dari yang berikut:

• Tambahkan data atau fungsi baru
• Perbaiki satu atau lebih bug (satu komit untuk setiap perbaikan jika memungkinkan) di mana perbaikan dapat:
  • Peningkatan performa
  • Memperbaiki perilaku kode yang salah
  • Menghapus kesalahan Typographical
• Refactoring kode atau data tanpa mengubah semantik. Ini termasuk:
  • Kode penulisan ulang yang berperilaku identik dengan aslinya
  • Mengubah representasi data ke format yang berbeda
  • Memformat kode atau data untuk memenuhi pedoman pemformatan proyek
• Gabungkan perubahan dari cabang lain (baik hulu / hilir)

Juga ketika bekerja di cabang, komit harus pergi ke cabang yang lebih tepat. Dua komit seharusnya tidak memiliki pesan komit yang sama (menyiratkan perubahan serupa) tetapi di cabang yang berbeda karena membingungkan kolaborator. Cara yang lebih baik adalah komit ke cabang utama dan bergabung ke cabang fitur.

Jika penumpang mengikuti aturan di atas, itu menjadi sepele untuk:

• Kembalikan perubahan tertentu tanpa efek samping
• Identifikasi perilaku yang mengubah perubahan kode dari perubahan pemformatan kode
• Gabungkan beberapa cabang yang berbeda untuk menghindari sebagian besar konflik
• Berkolaborasi dengan pengembang lain yang dapat menarik perubahan Anda dengan mudah

Mengenai mengukur kemajuan proyek berdasarkan komitmen, dimungkinkan jika Refactoring melakukan dan komitmen perbaikan Bug tidak diperhitungkan.

Komit hanya ketika Anda telah berhasil menguji fungsi / modul / fungsi yang diberikan dan Anda cukup yakin bahwa itu siap untuk integrasi atau pengujian sistem.

Dan untuk menjawab pertanyaan tambahan Anda - TIDAK !! ukuran di mana proyek seharusnya tidak pernah ditentukan oleh jumlah komitmen ... siapa yang tahu apa yang sebenarnya telah dilakukan? Apakah sudah berhasil diuji sistem atau bahkan unit diuji. Hanya karena komitmen - bukan berarti sudah siap berproduksi.

Sebagai tambahan: Apakah ini praktik yang tepat untuk mengukur pengembangan proyek berdasarkan komitmennya?

Tidak. Ada WTF harian tentang mengapa itu adalah ide yang mengerikan.

Aturan umum saya tentang melakukan kode adalah untuk memeriksa ketika saya telah menyelesaikan sepotong kode dan mengkompilasi. Potongan tidak benar-benar didefinisikan. Jika ini adalah tugas kecil, saya mungkin tidak akan check-in sampai saya selesai. Jika lebih besar, saya mungkin check in setelah setiap bagian logis selesai.

Tetapi jangan pernah check-in jika tidak dikompilasi. Saya tahu sepertinya bodoh mengatakannya dengan keras, tetapi saya harus menjelaskannya kepada orang-orang sebelumnya.

Buat komit ketika kode siap dibagikan dengan pengguna kode lainnya - saat kode tersebut relatif stabil, aman, dan teruji dengan benar.

Dan tidak, saya tidak berpikir komit adalah metrik yang bagus untuk pengembangan proyek, karena saya tahu beberapa pengembang yang akan melakukan setiap perubahan kecil dan kecil, dan yang lain hanya akan melakukan perubahan besar besar pada fungsi. Bagaimana Anda mengukur secara kuantitatif nilai dari satu komit terhadap yang lain?

Segera setelah tugas yang sesuai selesai . Sebuah tugas adalah bagian dari cerita pengguna .

Sebuah tugas dilakukan ketika:

• unit tes lulus yang sesuai,
• kode didokumentasikan dengan benar dan
• kode diberikan.

Anda dapat memiliki definisi yang berbeda untuk dilakukan .

Saya tidak melihat nilai dalam mengukur jumlah komit. Namun, jika Anda melihat seseorang bekerja untuk waktu yang lama pada cerita pengguna yang sama (atau lebih buruk, cerita), ini bau.

Komit setiap perubahan signifikan yang menurut Anda tidak merusak sesuatu. Satu-satunya hal yang tidak boleh Anda komit adalah perubahan gaya karena mereka tidak mewujudkan perubahan logika. Tetapi sebaliknya, semakin kecil perubahan yang Anda lakukan, semakin baik.

Semakin kecil komit, semakin rinci Anda dapat mendokumentasikan proses pemikiran, yang merupakan salah satu aspek dari log komit yang baik. Peninjauan kode yang baik tidak hanya tentang hasil kode tetapi juga proses pemikiran.

Juga, memiliki banyak commit kecil membuatnya mudah untuk dibagi dua, suatu fitur yang terlalu sedikit menggunakan kontrol versi, yang menyelamatkan saya selama berjam-jam mencari bug jarum dalam basis kode tumpukan jerami.

Singkatnya membagi dua; Temukan masalah dalam basis kode saat ini. Lalu, pilih komit di changelog di mana Anda yakin masalah spesifik tidak ada. Mulailah dengan memeriksa komit tepat di tengah-tengah antara versi "baik" dan "buruk". Tes untuk melihat apakah masalah masih ada. Jika ya, Anda perlu melihat lebih jauh ke belakang, di tengah "baik" dan komit yang sebelumnya diuji. Jika masalah hilang, itu diperkenalkan setelah perubahan khusus ini, jadi Anda perlu memeriksa tengah antara "buruk" dan komit yang sebelumnya diuji. Ulangi. Akhirnya, Anda akan berakhir dengan komit yang memperkenalkan masalah. Tetapi hanya jika Anda memiliki komitmen kecil, jika tidak, Anda hanya akan tahu di mana tumpukan besar perubahan masalah muncul.

Inilah cara kerjanya dengan Git tetapi prinsipal berlaku untuk kontrol versi apa pun.

Kapan:

• itu membangun (SELALU)
• tes unit lulus
• ini berfungsi (kecuali jika ditandai dengan jelas sebagai "sedang dalam proses")
• manfaat dari menyelamatkan status kode melebihi kerumitan menjalankan tes, memikirkan pesan komit yang baik dan menyelesaikan konflik gabungan selama proses komit