Apa yang harus saya lakukan ketika saya sudah menunggu terlalu lama di antara komitmen?

Saya nakal ... Terlalu banyak "koboi pengkodean," tidak cukup berkomitmen. Sekarang, saya di sini dengan komitmen besar. Ya, saya seharusnya sudah melakukan selama ini, tapi sekarang sudah terlambat.

Apa yang lebih baik

1. Lakukan satu komit besar yang mendaftar semua hal yang saya ubah
2. Cobalah memecahnya menjadi komit kecil yang kemungkinan tidak akan dikompilasi, karena file memiliki beberapa perbaikan, perubahan, nama metode tambahan, dll.
3. Coba lakukan pembalikan sebagian file hanya untuk komit yang sesuai, lalu kembalikan perubahan yang baru.

Catatan: sampai sekarang saya adalah satu-satunya programmer yang mengerjakan proyek ini; satu-satunya orang yang akan melihat komentar komit ini adalah saya, setidaknya sampai kita mempekerjakan lebih banyak programmer.

By the way: Saya menggunakan SVN dan Subclipse. Saya memang membuat cabang baru sebelum melakukan perubahan ini.

Informasi lebih lanjut : Saya mengajukan pertanyaan terpisah yang berkaitan dengan bagaimana saya masuk ke situasi ini di tempat pertama: Bagaimana mempersiapkan untuk menulis ulang lem aplikasi

Untuk menjawab, Anda harus bertanya pada diri sendiri bagaimana Anda berharap untuk menggunakan hasil dari komitmen ini di masa depan. Alasan paling umum adalah:

• Untuk melihat rilis apa bug diperkenalkan.
• Untuk melihat mengapa ada baris kode tertentu.
• Untuk bergabung ke cabang lain.
• Untuk dapat memeriksa versi sebelumnya untuk pemecahan masalah, pelanggan atau penguji melihat dalam versi itu.
• Untuk dapat memasukkan atau mengecualikan bagian-bagian tertentu dari rilis.

Dua alasan pertama dapat dilayani sama baiknya dengan satu check-in besar, dengan asumsi Anda dapat membuat pesan check-in yang berlaku sama baiknya untuk setiap baris kode yang diubah. Jika Anda satu-satunya programmer, maka komitmen yang lebih kecil tidak akan membuat penggabungan Anda lebih mudah. Jika Anda tidak berencana melakukan rilis atau pengujian dengan hanya sebagian dari perubahan yang tidak terkirim, maka dua alasan terakhir tidak berlaku.

Ada alasan lain untuk membuat komitmen kecil, tetapi itu untuk sementara Anda berada di tengah-tengah perubahan, dan waktu sudah lewat. Alasan-alasan itu membuatnya lebih mudah untuk mundur dari kesalahan atau perubahan eksperimental, dan membuatnya lebih mudah untuk tetap disinkronkan dengan kolega tanpa penggabungan yang menakutkan.

Dari pemahaman saya tentang situasi Anda saat Anda menggambarkannya, tampaknya ada sedikit manfaat atau tidak untuk memisahkan komitmen Anda pada titik ini.

Saya pikir apa pun yang Anda lakukan, cobalah untuk menghindari memeriksa kode yang Anda tahu tidak akan dikompilasi.

Jika Anda berpikir opsi ketiga Anda layak, itu mungkin cara yang baik untuk melakukannya, selama Anda dapat memastikan bahwa urutan komit Anda tidak akan membuat sistem yang tidak dapat dikompilasi. Kalau tidak, lakukan saja komitmen besar. Itu jelek, tapi sederhana, cepat, dan menyelesaikannya. Ke depan, komit lebih sering .

Alasan paling penting untuk membuat komitmen yang sering, kecil, dan bermakna adalah untuk membantu pemahaman tentang sejarah kode. Secara khusus, sangat sulit untuk memahami bagaimana kode telah berubah jika sulit untuk menghasilkan perbedaan yang dapat dimengerti.

Opsi 1 mengaburkan riwayat perubahan yang telah Anda buat, tetapi sebaliknya itu tidak akan menyebabkan masalah.

Opsi 2 mengaburkan riwayat perubahan yang telah Anda buat, mungkin agak kurang dari opsi 1, tetapi bisa menyebabkan masalah lain untuk Anda atau orang lain jika mereka menganggap atau menyimpulkan bahwa komitmennya berbeda, misalnya dapat digabung ke cabang lain secara mandiri. Kecuali ada alasan praktis yang kuat mengapa ini lebih disukai daripada opsi 1, ini kurang ideal daripada itu.

Opsi 3 adalah yang terbaik, semuanya sama, tetapi jika, seperti yang telah Anda jelaskan di tempat lain, melakukannya akan membutuhkan jumlah waktu "ekstrem" atau akan menimbulkan biaya signifikan lainnya, Anda harus mempertimbangkan biaya-biaya tersebut terhadap manfaat yang diharapkan dari membuat komitmen lebih bersih.

Berdasarkan info yang Anda berikan, saya akan memilih opsi 1. Mungkin Anda harus mengatur pengingat yang meminta Anda melakukan perubahan?

Prototyping dan Penulisan Ulang

Pertimbangan lain yang perlu diingat, terutama mengingat catatan Anda tentang menjadi programmer tunggal, dan kecurigaan saya bahwa Anda sedang mengerjakan basis kode yang relatif baru, adalah bahwa mungkin baik untuk mengembangkan kebiasaan yang berbeda sehubungan dengan melakukan perubahan ketika Anda sedang membuat prototipe kode baru versus mempertahankan atau memperluas kode yang ada. Mungkin tidak ada pembagian yang sangat tajam antara keduanya, tapi saya pikir itu masih merupakan perbedaan yang berguna.

Saat Anda membuat prototipe kode baru, komit kapan pun Anda ingin menyimpan perubahan Anda, hampir pasti di cabang, tapi mungkin dalam proyek terpisah. Atau mungkin bahkan hanya bekerja di luar kendali versi sama sekali. Alih-alih, Anda bisa fokus mengumpulkan bukti tentang kelayakan berbagai hipotesis atau desain yang Anda pertimbangkan. Saya sering menulis prototipe kecil menggunakan alat yang berbeda, misalnya LINQPad bukan Visual Studio untuk kode C #.

Saat Anda telah memvalidasi hipotesis atau desain tertentu, tulis ulang di proyek utama Anda, idealnya di cabang, dan buat komitmen kecil dan bermakna yang akan membantu pemahaman orang lain (termasuk Anda di masa depan) tentang sifat perubahan Anda sedang membuat.

Meskipun satu-satunya jawaban yang masuk akal adalah tidak pernah mematahkan belalai , beberapa kali itu tidak mungkin. Sebagai contoh, svn dapat merusak komit jika Anda komit terlalu banyak (mungkin opsi, atau fitur, saya tidak yakin). Dalam kasus khusus seperti itu, cukup periksa dalam beberapa bagian. Karena Anda adalah seorang programmer tunggal itu tidak akan mengganggu siapa pun.

Karena itu, saya akan memilih opsi 1. Jika tidak memungkinkan, maka opsi 2.

Opsi 3 membutuhkan banyak usaha, dan itu tidak layak.

Cobalah memecahnya menjadi komit kecil yang kemungkinan tidak akan dikompilasi, karena file memiliki beberapa perbaikan, perubahan, nama metode tambahan, dll.

Ketika saya menemukan diri saya dalam situasi yang sama saya menggunakan teknik berikut:

1. Tambahkan hanya kode yang relevan dengan fitur tertentu: git add --patch
2. Simpan semua perubahan lainnya: git stash save --keep-index
3. Jalankan tes / coba kompilasi
4. Komit berubah jika semuanya baik-baik saja, jika tidak masuk ke 1

Saya tidak terbiasa dengan SVN, jadi saya tidak tahu apakah ini berlaku untuk situasi spesifik Anda, tetapi dasarnya harus sama - mengisolasi bagian-bagian kecil kode dan mengujinya secara individual.

Bagaimana dengan opsi 4: Cadangkan keadaan repo Anda saat ini di tempat sementara, kembalikan repo Anda ke keadaan semula, buat daftar semua perubahan yang Anda lakukan (Anda masih dapat melihat cadangan sementara), lalu reimplement secara manual (dan kompilasi secara manual dan uji!) mereka sebagai komitmen terpisah.

Ini seharusnya lebih mudah, karena Anda sudah menulis kode, itu hanya sedikit mencari tahu bagian mana yang akan disalin dan tempel dari cadangan sementara Anda.

Ketika Anda telah menerapkan kembali setiap perubahan dengan bersih, dan dengan demikian memastikan bahwa komit mandiri, kecil, dan kompilasi, Anda dapat menghapus cadangan sementara, dan semuanya akan hampir sama persis (kecuali untuk waktu / tanggal komitmen) itu akan jika Anda melakukannya sejak awal.

Anda satu-satunya programmer; lakukan saja checkin besar tunggal merinci bit penting dari apa yang Anda lakukan.

Apakah Anda cenderung untuk memutar kembali "bagian" dari apa yang Anda lakukan? Jika tidak, maka lanjutkan dengan opsi 1.

Ada beberapa alasan untuk memeriksa kode ke dalam sistem kontrol versi. Dan SEMUA dari mereka, ketika Anda satu-satunya pengembang, berputar di sekitar keselamatan - yaitu, jika Anda gagal, mesin mati atau apa pun, Anda selalu dapat kembali ke pos pemeriksaan terakhir.

Seorang programmer yang datang ke proyek nanti tidak mungkin ingin memutar kembali ke versi yang tidak dikompilasi. Jadi, IMHO, opsi 2 adalah kegilaan.

Opsi 3 terdengar seperti tenggang waktu, bahwa jika saya adalah bos Anda dan melihat Anda menghabiskan waktu berjam-jam melakukan ini, saya akan berbicara sedikit dengan Anda tentang berapa nilai waktu Anda.

Untuk mengulangi: dengan memeriksa kode Anda, Anda menutupi / menyimpan pantat Anda jika terjadi kegagalan pada mesin Anda. Yang lainnya, dalam satu tim, adalah ganti jendela.

Aturan saya adalah: Tidak ada lapor masuk tanpa tinjauan kode serius. Jika saya sendiri, saya harus meninjau kode sendiri, tetapi akan ditinjau. Tampaknya Anda memiliki sejumlah perubahan kode yang tidak dapat ditinjau oleh orang lain, oleh karena itu Anda tidak dapat memeriksanya sendiri (meninjau kode Anda sendiri lebih sulit dan membutuhkan lebih banyak disiplin, karena Anda secara otomatis membuat asumsi yang salah bahwa kode Anda sendiri benar. ).

Aturan yang benar-benar tidak dapat dipecahkan oleh semua orang adalah: Jangan pernah memeriksa kode yang bahkan tidak dibuat, dan secara serius menghindari memeriksa kode yang tidak berfungsi.

Solusi: Salin kode Anda yang diubah, kembali ke titik semula. Gabungkan satu perubahan pada satu waktu ke dalam kode asli, tinjau, uji, periksa. Dengan metode pemrograman yang Anda jelaskan, Anda pasti menemukan beberapa bug serius dengan cara itu.

Ini juga cara yang baik untuk melatih diri Anda sendiri kebiasaan pemrograman yang baik.

Saya pikir Anda terlalu khawatir. Jika Anda adalah satu-satunya programmer dan Anda tidak memiliki lembar spesifikasi untuk dikerjakan maka itu sepenuhnya terserah Anda apa yang Anda lakukan. Saya berasumsi tidak ada yang akan menghukum Anda karena membuat komit besar sehingga satu-satunya masalah yang akan Anda hadapi adalah teknologi, seperti tidak dapat mengembalikan perubahan file individual dalam komit. Karena Anda hanya mengendalikan repo pada saat ini yang seharusnya tidak menjadi perhatian besar juga.

Ada garis yang harus ditarik antara pragmatisme dan dogmatisme. Apa yang Anda lakukan tidak akan menjadi ide yang baik di tim dan mungkin tidak boleh diulang maju, tetapi dalam situasi Anda, saya hanya akan menyerahkan komit besar.

Masalahnya bukan pada penundaan yang lama di antara commit, tetapi pada kenyataan bahwa Anda menyimpan kode dalam waktu yang tidak dapat dikompilasi terlalu lama. Pertama-tama, apa definisi Anda tentang 'panjang'? Bagi sebagian orang 5 menit untuk keadaan transisi terlalu banyak tetapi beberapa dapat memoles kode mereka selama berhari-hari bahkan tanpa mencoba menjalankan kompiler.

Sebenarnya tidak masalah - yang penting adalah Anda kehilangan kendali atas kode Anda, kode Anda menjadi tidak terkelola. Ini normal, itu hanya berarti bahwa Anda memiliki hutang teknologi dan ini saatnya untuk berpikir tentang refactoring. Jadi kamu frustrasi? Kode Anda tidak dikompilasi, Anda bahkan tidak memiliki tes unit? Bagaimana Anda bisa berpikir tentang refactoring dalam kasus ini? Jangan khawatir. Selesaikan "koboi kode" dan mulailah membersihkannya. Idealnya cobalah menulis beberapa tes. Anda tidak punya waktu untuk itu? Ok, mulai dari perbaikan kecil.

Beberapa perubahan tidak memerlukan tes. Ubah nama variabel agar lebih cocok, pindahkan kode berulang ke fungsi terpisah, dll ... Anda akan mendapatkan gagasan kode yang lebih baik. Setelah itu Anda bisa melakukan perubahan yang lebih besar. Sekali lagi, cobalah menulis tes jika memungkinkan. Buat kode Anda dapat dikelola.

Setelah itu Anda akan melihat bahwa perubahan selanjutnya tidak akan membuat Anda "terlalu lama" (apa pun artinya).