Saya tidak pernah yakin kapan suatu proyek cukup jauh untuk pertama-tama berkomitmen pada kontrol sumber. Saya cenderung menunda komitmen sampai proyek selesai 'kerangka kerja,' dan saya terutama melakukan fitur sejak saat itu. (Saya belum melakukan proyek pribadi yang cukup besar untuk memiliki kerangka kerja inti yang terlalu besar untuk ini.) Saya merasa ini bukan praktik terbaik, meskipun saya tidak yakin apa yang salah.

Katakanlah, misalnya, saya memiliki proyek yang terdiri dari satu file kode. Diperlukan sekitar 10 baris kode boilerplate, dan 100 baris untuk membuat proyek bekerja dengan fungsionalitas yang sangat mendasar (1 atau 2 fitur). Haruskah saya check-in lebih dulu:

1. File kosong?
2. Kode boilerplate?
3. Fitur pertama?
4. Di beberapa titik lain?

Juga, apa alasan untuk check-in pada titik tertentu?

Anda harus melakukan komitmen segera setelah Anda memiliki "unit" yang masuk akal.

Apa itu unit? Itu tergantung pada apa yang Anda lakukan; jika Anda membuat proyek Visual Studio, misalnya, lakukan solusi tepat setelah penciptaannya, bahkan jika tidak ada apa pun di dalamnya.

Dari sana, tetap komit sesering mungkin, tetapi masih komit hanya "unit" yang selesai (misalnya kelas, konfigurasi, dll); melakukan hal itu akan membuat hidup Anda lebih mudah jika terjadi kesalahan (Anda dapat mengembalikan sejumlah kecil perubahan) dan akan mengurangi kemungkinan konflik.

Sejauh yang saya ketahui, repo kontrol sumber Anda adalah bagian dari pengaturan proyek dasar, jadi saya berkomitmen tepat setelah saya menghasilkan proyek kosong saya.

Kemarin

... sebagai alternatif, jika Anda tidak dapat melakukan perjalanan waktu ...
(mungkin mobil Anda tidak dapat mencapai 88mph, atau kapasitor fluks Anda baru saja patah)

Sekarang

Proyek-proyek baru harus dilakukan di tempat berdarah, itu gila untuk tidak melakukannya, dan sistem DVCS kontemporer hanya menghapus setiap alasan yang mungkin untuk menghindari komitmen : git init . ; git add * ; git commit -m initial-commitsekarang, sebelum terlambat, seperti yang mungkin sudah terjadi.

Satu pertanyaan yang lebih masuk akal, dapat diperdebatkan, bisa saja: "Kapan saya harus menggabungkan komitmen saya ke kontrol sumber bersama pada repositori yang dikelola tim pada proyek yang sudah mapan ?" (catat kata sifat, kata sifat itu penting) Dan saya merasa sebagian besar jawaban lain sebenarnya mencoba menjawabnya.

Cabang pribadi Anda harus berkomitmen seperti orang gila , setidaknya sekali sehari , sebelum tidur. Anda mungkin baru saja bangun keesokan paginya, dan tidak tahu apa yang Anda lakukan, malam sebelumnya. VCS harus melindungi Anda dari hal itu, dan memiliki kesempatan untuk mengembalikan ke sub-versi-dari-a-versi yang sangat baru yang mengkompilasi dengan baik, berjalan dengan lancar, dan / atau lulus tes mungkin merupakan pilihan terbaik Anda.

Saya akan mengatakan komit sesegera mungkin. Tujuan utama dari kontrol sumber adalah memungkinkan Anda untuk kembali jika terjadi kesalahan, dan ini beresonansi dengan latihan "komit awal dan sering".

Secara pribadi, komit pertama saya biasanya hanya berisi file .gitignore (atau yang setara) dengan beberapa filter yang saya tahu akan diperlukan, seperti * .py [co] untuk kode Python. Setup proyek dasar dan / atau prototipe sederhana pertama adalah apa yang biasanya terjadi.

Komit pertama dapat berupa file README dengan hanya satu ringkasan baris proyek, atau informasi yang cukup tentang tonggak pertama proyek. Topik luas juga dapat mencakup:

• pengantar
• Deskripsi Proyek
• Struktur proyek
• Konvensi pengkodean
• Petunjuk tentang cara:
  • membangun
  • uji
  • menyebarkan
• Masalah dan solusi yang diketahui
• daftar todo
• Syarat Penggunaan

Praktik memperbarui README sebelum membuat perubahan pada sebuah proyek juga disebut sebagai Readme Driven Development dan memungkinkan Anda untuk memikirkan perubahan sebelum menginvestasikan waktu dalam membuat perubahan tersebut.

Siapa pun yang ingin berkontribusi atau menggunakan perangkat lunak ini kemudian akan mulai dengan README.

Jika Anda telah melakukan pekerjaan yang tidak ingin Anda hilangkan, itu harus ada dalam sistem kontrol sumber Anda.

Ini tentu berlaku untuk sistem terdistribusi seperti Git. Jika Anda menggunakan sistem terpusat, dan satu-satunya cara untuk memeriksa sesuatu adalah membuatnya terlihat oleh semua orang , Anda mungkin ingin menunda - atau Anda mungkin mempertimbangkan untuk menyiapkan repositori git lokal Anda sendiri, dan mengirimkan ke pusat sistem ketika Anda siap.

Aturan praktis saya adalah untuk memeriksa setelah file solusi saya (atau potongan skrip build lainnya) selesai, bahkan jika itu berisi beberapa file yang kosong. Ini praktik yang baik ketika lebih dari satu orang mengerjakan proyek. File itu cenderung memiliki masalah penggabungan terburuk pada awalnya karena orang menambahkan hal-hal pada proyek sehingga perlu dilakukan lebih awal dan sering.

Bahkan jika Anda adalah satu-satunya yang mengerjakan proyek dan hanya punya satu file, saya merasa lebih mudah untuk mengikuti alur kerja yang sama dan menyimpan pemikiran untuk masalah yang ada.

Tidak yakin apakah itu disebutkan.

Tetapi pastikan bahwa apa yang Anda komit menjalankan / kompilasi! Jadi tidak ada kesalahan sintaks, dll.

Tidak ada yang lebih membuat frustrasi daripada kode checkout yang rusak.

Pandangan lain yang lebih terkait dengan pengujian perangkat lunak (pendekatan TDD) akan dilakukan segera setelah Anda memiliki kasus pengujian baru berwarna hijau. Ini berarti Anda telah menyelesaikan "unit" kode.

Tepat sebelum Anda melakukan sesuatu yang konyol.

Bagi kita yang tidak memiliki kekuatan magis, itu berarti sedikit dan sering.

Jika Anda bekerja sendiri, lakukan setiap kali Anda minum, atau apa pun.

Jika Anda bekerja dalam tim, Anda mungkin perlu memastikan bahwa hal itu dikompilasi, sehingga jika orang lain mendapatkan yang terbaru, mereka tidak akan mendapatkan sekumpulan kesalahan. Tapi selain itu, sebisa mungkin.

Sekitar 2 ~ 3 jam ke dalam proyek.

Hanya bercanda. Tidak ada satu jawaban yang cocok untuk semua situasi. Pertama-tama, jika Anda memiliki sistem kontrol versi terdistribusi (seperti git atau Mercurial) maka komit ke repo lokal Anda tidak akan melindungi data Anda jika terjadi kegagalan yang dahsyat. Tetapi repo jarak jauh pribadi mungkin dikenakan biaya uang, misalnya pada github. Anda akan menyimpan histori komit, tetapi dalam pengalaman saya Anda tidak akan membutuhkan itu sampai proyek Anda sedikit maju.

Anda juga mungkin tidak ingin terlalu banyak churn di awal, terutama jika Anda memindahkan file. Melakukan perubahan akan menjadi beban jika hanya perubahan kecil. Anda bahkan dapat memutuskan untuk membuang benda itu. Tetapi jika Anda kehilangan perubahan yang tidak mudah untuk direplikasi maka Anda akan kehilangan telah membuat salinan cadangan, dan sistem kontrol versi membuat sistem cadangan yang sangat berharga.

Beberapa orang saat ini menggunakan DropBox atau sejenisnya untuk menyimpan kode mereka. Ini mungkin merupakan kompromi yang baik di awal proyek karena tidak ada upaya untuk menyiapkannya. Namun kebiasaan biadab dalam pengembangan perangkat lunak yang serius, terutama jika beberapa orang menyentuh kode pada saat yang sama.

Jadi, saya cenderung mengatur kontrol versi setiap kali saya memiliki sesuatu yang berharga, yaitu tidak sepele untuk ditiru. Nilai bersifat subjektif (dan tergantung pada kapasitas seseorang) sehingga Anda harus membuat penilaian sendiri. Pada saat itu saya menyimpan repo kedua pada disk eksternal, atau pada github jika itu adalah proyek publik atau akun pembayaran saya akan menahannya.

Banyak orang sudah menjawab "Segera", dan saya 100% setuju. Saya juga suka saran Xion untuk memulai dengan pola abaikan VCS (yaitu .gitignoreatau setara).

Saya kira sudah cukup banyak disepakati bahwa tidak ada kerugian untuk komitmen awal. Saya ingin menambahkan keuntungan:

• Anda cenderung melakukan hal-hal yang Anda pilih untuk dibuang tetapi itu masih ada. Ketika saya memulai pengembangan baru, saya akan mengkodekan dan menghapus hal-hal dengan cepat, dan ketika saya melakukan nanti, ketika sudah ada banyak file, saya secara tidak sengaja melakukan hal-hal hanya untuk menghapusnya di komit berikutnya. Ini, sebagai lawan dari komit kecil, atau bahkan kosong, adalah kebisingan sejati dalam sejarah.
• Jika Anda adalah tipe yang sistematis dan memiliki langkah-langkah pertama yang khas dalam proyek Anda, menjadikannya sebagai titik komit dapat menjadi petunjuk bagi Anda atau orang lain, dan bahkan mungkin memberikan kesempatan untuk bercabang pada titik tertentu dan membuat rintisan proyek yang dapat digunakan kembali. Saya telah bekerja pada proyek berbasis Maven di mana ini berguna (karena dalam mendirikan proyek Maven, beberapa langkah kecil pertama sudah dapat mendefinisikan basis yang cukup besar, dan sementara langkah-langkah itu tidak banyak dilakukan , mereka mungkin memerlukan pemikiran yang cukup untuk menjamin dapat digunakan kembali).

Ini mungkin tergantung VCS mana yang Anda gunakan.

Dengan Git, saya melakukan direktori kosong (atau dengan file README hampir kosong). Intinya adalah bahwa saya dapat kembali dan mereset cabang saya ke keadaan kosong jika saya ingin memulai dari awal sementara saya masih awal dalam proses pengembangan (sebelum mendorong hulu). Saya kemudian akan melakukan file "dihasilkan" saya (misalnya solusi visual studio). Kemudian ketika saya benar-benar coding saya akan mulai melakukan setiap unit seperti biasa.

Dengan SVN, Anda mendorong hulu dengan setiap komit sehingga Anda benar-benar tidak mendapatkan kemewahan memulai kembali seperti yang Anda lakukan dengan Git. Dalam hal ini, mungkin tidak bermanfaat untuk melakukan komitmen lebih awal jika Anda pikir Anda akan melakukan pembenahan besar di awal proses. Itu akan tergantung pada orang yang mengkode.

Ketika saya memulai proyek baru saya biasanya memulai dengan melakukan itu sebelum kode apa pun telah ditambahkan. Aturan umum yang selalu saya ikuti adalah: jika PC Anda crash dan menghapus semua data Anda kode apa yang Anda inginkan untuk tidak harus menulis dari memori. Sepuluh tahun yang lalu sebelum TDD dan praktik pemrograman yang lebih baik, saya cukup optimis tentang apa yang dapat saya ingat. Sekarang, saya cenderung lebih berhati-hati. Seperti banyak poster lainnya katakan komit lebih awal dan komit sering. Anda tidak kehilangan apa pun dengan melakukannya.

Saya bekerja sendiri untuk sebagian besar waktu sehingga saya harus mengakui bahwa saya menjadi malas tetapi saya umumnya berkomitmen sebelum saya pulang. Dengan begitu jika saya tidak berhasil besok, maka rekan-rekan saya dapat mengambil di mana saya tinggalkan.

Saat ini saya menggunakan Tortoise / SVN di tempat kerja.

Segera lakukan proyek kosong. Teruslah berkomitmen beberapa kali per jam yang Anda habiskan untuk mengerjakan proyek. Berkomitmen bahkan jika kode tidak dikompilasi. Saya menandai komit tersebut dengan "WIP" di pijit komit untuk melacak mereka.

Saya juga memiliki skrip yang secara otomatis melakukan semua proyek saya setiap 10 menit ke repo cadangan, kalau-kalau saya lupa melakukan secara manual. Sebut saja buffer undo yang didukung cloud saya.

Lapor masuk (alias. Push ) proyek ke repo tim saat Anda membutuhkan tim Anda untuk melihat kode Anda. Yang mungkin sebelum kode Anda siap dilihat oleh tim Anda, jika Anda seperti saya.

Jika Anda ingin bersikap baik kepada tim Anda, hancurkan komitmen Anda sebelum mendorongnya ke repo tim.

Saya telah membaca semua artikel dan saya pikir kami sudah mendapatkan banyak solusi bagus tetapi saya ingin membagikan metodologi saya dengan Anda.

Saat bekerja pada pembuatan kerangka kerja (langsung dari awal) banyak perubahan akan terjadi untuk setiap modul sampai modul selesai atau diselesaikan. Jadi saya selalu memiliki 2 lokasi satu dinamai DINAMIS dan lainnya adalah STATIC. Ketika perubahan sedang terjadi dan kerangka kerja belum difinalisasi, itu sudah dilakukan di lokasi DYANMIC dan setelah selesai dan diselesaikan saya memindahkannya ke lokasi STATIC. Jadi saya punya Kontrol Sumber yang lengkap.

Terima kasih

Dengan aplikasi apa pun, Anda akan menghabiskan waktu merancang komponen. Anda harus tahu, secara kasar atau terperinci, ruang nama Anda, proyek, referensi eksternal, perpustakaan pihak ketiga dll.

Jika Anda berada di sebuah tim, saya akan menyarankan pemimpin Anda, atau siapa pun yang dipilih, untuk membuat proyek dasar, mengatur dependensi, dan memeriksa kerangka itu (fondasi tempat proyek Anda akan dibangun).

Anda juga ingin memastikan Anda memiliki tugas, rilis, trunk, dll. Cabang yang ditentukan sebelum check-in sehingga proses Anda solid.

Jika Anda sedang mengerjakan "tugas" baru untuk proyek yang sudah berjalan dan Anda berada di cabang tugas Anda sendiri, lakukan lapor masuk malam hari sehingga Anda dapat mempertahankan pekerjaan Anda.

Biasanya saya check-in setiap kali saya menambahkan sesuatu yang baru, tetapi mencoba untuk memisahkan hal-hal dalam komit diskrit.

Itu berarti, jika saya menambahkan ketergantungan baru, saya membuat perubahan sampai mereka mengkompilasi, atau mereka cukup besar sehingga akan kehilangan waktu untuk melakukannya lagi, dari awal. Jika saya memiliki tugas yang lebih besar, saya mencoba melakukan beberapa kali, ketika itu masuk akal (sekali per fungsi, setiap kali saya membuatnya kompilasi dan berjalan dengan sukses, dll).

Saya juga berkomitmen ketika saya ingin titik cadangan (yaitu "jika apa yang saya coba sekarang tidak akan berfungsi atau menjadi terlalu rumit, saya ingin kembali ke kode seperti sekarang", atau ketika seseorang meminta saya untuk meninggalkan saya apa adanya melakukan dan memperbaiki beberapa masalah mendesak).

Jika Anda menggunakan sistem kontrol sumber terpusat, Anda tidak dapat melakukan komit untuk poin cadangan, karena komit yang tidak dikompilasi / bekerja memengaruhi semua orang di tim Anda.

Biasanya ketika saya mulai menambahkan kode boilerplate (mis. Tambahkan webapp baru di situs web Django), saya melakukan setiap operasi yang saya lakukan.

Jika saya mengikuti tutorial untuk membuat / menulis kode, saya menggunakan nama langkah dalam tutorial untuk pesan komit. Dengan cara ini, saya dapat melakukan revisi dan melihat apa yang dilakukan langkah tutorial, kapan saja.

Katakanlah, misalnya, saya memiliki proyek yang terdiri dari satu file kode. Diperlukan sekitar 10 baris kode boilerplate, dan 100 baris untuk membuat proyek bekerja dengan fungsionalitas yang sangat mendasar (1 atau 2 fitur).

Itu akan tergantung pada seberapa sulit menambahkan barang itu:

• jika sepele untuk menambahkan kode pelat ketel, saya akan menambahkannya dan melakukan komit sebelum memulai pada kode lainnya (dengan cara ini, jika saya membuat kesalahan atau memperkenalkan bug aneh nanti, saya dapat dengan mudah kembali ke kode boilerplate dan mulai lagi).

• Jika kodenya non-sepele, saya akan melakukan setiap kali saya menambahkan sesuatu yang baru (di mana saja antara setiap dua baris kode berubah, menjadi sekitar seratus atau lebih).