Kapan melakukan kode?

59

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?

agas
sumber
9
Sebagian besar hal yang mudah dikuantifikasi adalah metrik buruk karena terlalu disederhanakan atau dapat dengan mudah dimainkan agar berkinerja baik terhadap pengukuran tertentu.
unholysampler
Terima kasih atas masukannya. Ada banyak alasan yang sah untuk membuat komitmen yang didistribusikan atas jawaban, dan saya tidak dapat menerima beberapa jawaban, saya menerima jawaban dengan suara tertinggi hingga sekarang. Tapi saya menerima semua jawaban Anda.

Jawaban:

79

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.

Neil Butterworth
sumber
10
Saya setuju, dengan tambahan bahwa bagasi adalah cerita yang berbeda. Untuk memeriksa bagasi di tim saya misalnya, ia harus a) membangun dengan benar, dan b) menyelesaikan sesuatu. Setiap anggota tim bebas untuk membuat cabang dan itu bisa dalam keadaan apa pun yang mereka inginkan.
Edward Strange
34

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.

tammmer
sumber
Saya kira hal yang sama berlaku untuk cabang baru, di mana semua pengembangan baru dilakukan ke cabang Anda sendiri, yang kemudian akan Anda dorong ketika fitur sudah siap? Yaitu. Anda mungkin melakukan banyak kode tidak lengkap ke cabang pribadi Anda.
Juha Untinen
Ya, tetapi pada tingkat yang lebih rendah, karena (lihat jawaban asli) Anda tidak akan mengganggu siapa pun secara langsung. Bergantung pada SCM yang dimaksud, biasanya dianggap praktik yang baik untuk membersihkan riwayat komit Anda sebelum menggabungkan upstream (misalnya git rebase -i).
Pelaku
13

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.

vartec
sumber
+1 Kagum ini tidak ter-upgrade lagi. Itulah pikiran pertama saya - dvcs atau vcs
Michael Durrant
9

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.

Rein Henrichs
sumber
1
+1. Saat Anda menggabungkan BDD-As-If-You-Mean-It, Refactor Till You Drop, Atomic Coding, dan bahasa yang sangat ekspresif, 90 detik bisa menjadi waktu yang lama tanpa komit.
Jörg W Mittag
8

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.

justjkk
sumber
Saya pikir jawaban ini pasti jawaban yang diterima, tetapi mungkin si penanya mencari penjelasan yang lebih sederhana :)
Behnam Rasooli
7

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.

Catchops
sumber
5
Itu akan benar jika Anda berkomitmen ke trunk, tetapi jika Anda berkomitmen ke cabang fitur atau ke cabang pribadi, tidak perlu untuk siap untuk integrasi.
Neil Butterworth
1
@Neil Butterworth: ... kecuali ada pengembang lain yang bekerja di cabang yang sama dengan beberapa dependensi pada kode Anda.
FrustratedWithFormsDesigner
@Frustrated Dalam kasus itu tentu harus dikompilasi, tetapi saya tidak melihat bahwa itu harus siap untuk integrasi dan pengujian sistem.
Neil Butterworth
1
Dikotomi yang menarik di sini antara vcs terdistribusi dan terpusat. Dengan vcs yang terdistribusi, ini tidak akan pernah menjadi masalah karena Anda dapat berkomitmen untuk menampilkan cabang secara lokal dan menghindari para pengembang lainnya.
George Mauer
2
@ George - Ini adalah dikotomi palsu. Dikotomi yang sebenarnya adalah antara penggunaan cabang pribadi (per pengembang), atau publik (dibagikan oleh beberapa pengembang). Ini ortogonal terhadap apakah Anda menggunakan VCS terdistribusi yang terpusat (namun, DVCS mendorong cabang pribadi, karena cabang mulai sebagai pribadi hingga Anda menerbitkannya).
Stephen C. Steel
6

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.

Tyanna
sumber
1
+1 untuk kompilasi peringatan. Kami memiliki celengan di kantor tempat setiap orang harus membayar biaya setiap kali dia melakukan sesuatu yang membuat bangunan gagal. Sayangnya kami mendapat cukup uang dengan cara ini, setidaknya pada awalnya :)
Ray
@ Ray - di tempat terakhir saya, denda masuk ke dana lotre. Sayangnya, kami tidak pernah berhasil kaya karena kebiasaan buruk ini. : P
Tyanna
1

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?

FrustratedWithFormsDesigner
sumber
Ingat bahwa dengan sistem terdistribusi, komit! = Bagikan. Anda harus mendorong ketika Anda memiliki sesuatu yang siap dibagikan.
Rein Henrichs
@Rein Henrichs: Poin bagus, meskipun kendali sumber di sini di tempat kerja tidak memiliki fungsi itu (setidaknya sejauh yang saya tahu). Ketika sesuatu dilakukan, semua orang di proyek dapat melihat dan menyinkronkan ulang (dan biasanya mereka melakukannya, kadang-kadang secara membabi buta).
FrustratedWithFormsDesigner
Yang mungkin merupakan indikasi bahwa Anda dapat memanfaatkan alat yang lebih baik. Apa pun yang mencegah sering melakukan adalah penghalang yang tidak perlu.
Rein Henrichs
@Rein Henrichs: Saya tidak akan membantah !!
FrustratedWithFormsDesigner
1

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.


sumber
1

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.

Jasper Kennis
sumber
ini tampaknya tidak menawarkan sesuatu yang substansial atas poin yang dibuat dan dijelaskan dalam 10 jawaban sebelumnya. Selain itu, paragraf terakhir tampaknya merujuk ke fitur spesifik git sementara pertanyaannya tampaknya bukan tentang git
gnat
Membagi dua tidak spesifik git. Hal ini dapat dilakukan dengan semua jenis kontrol versi, ini hanya sebuah contoh karena saya sadar Git telah membangunnya.
Jasper Kennis
-1

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
quant_dev
sumber
Terpilih untuk ini adalah praktik terbaik kami.
jersoft