Saya baru-baru ini mulai meletakkan kode saya di bawah kontrol versi (di lab saya bekerja, di bawah SVN, dan kode saya sendiri di github (jelas dengan git)). Sebelum menggunakan kontrol versi, saya biasa melakukan hal seperti ini. Saya memiliki folder dengan nama perpustakaan, di dalam banyak folder dengan nomor versi. Setiap kali saya ingin mulai bekerja pada versi yang lebih baru, saya akan membuat salinan dari versi terakhir, mengubah nama ke versi baru dan mulai menerapkan.
Namun ini tampaknya berlebihan ketika folder diletakkan di bawah kontrol versi. Terlepas dari redundansi, jika seseorang ingin mendapatkan versi terbaru, mereka akan mengunduh semua versi jika ia hanya imports / clones.
Sekarang saya melihat banyak cara untuk melakukan ini dengan kontrol versi, tetapi karena saya baru dalam hal ini, saya tidak tahu mana yang lebih bisa dipertahankan.
Metode 1: Menggunakan tag
Jika saya memahami tag dengan benar, Anda akan memiliki cabang utama, Anda melakukan perubahan apa pun yang Anda dapatkan dan memberi tag pada suatu versi. Kemudian, ketika Anda ingin mendapatkan salinannya, Anda mendapatkan salinan dengan tag tertentu. (koreksi saya jika saya salah)
Metode 2: Versi percabangan
Dalam metode ini, cabang utama adalah cabang pengembangan. Sesekali versi stabil dibuat (katakanlah v1.2.0), Anda membuat cabang untuk versi itu dan tidak pernah berkomitmen untuk itu. Dengan begitu, jika Anda ingin mengunduh versi tertentu, Anda mendapatkan kode dari cabang itu. Meskipun saya katakan Anda tidak pernah berkomitmen untuk itu, dimungkinkan untuk melakukan perbaikan bug dan berkomitmen untuk cabang versi lama agar versi lama tetap berjalan. Misalnya jika versi saat ini v2.0, tetapi ada orang yang ingin menggunakan v1.2, Anda bisa mendapatkan cabang lain dari v1.2, yaitu v1.2.1dan melakukan perbaikan bug, atau hanya menjaga versi yang sama v1.2dan hanya melakukan perbaikan bug.
Jadi cabang akan terlihat seperti ini:
v1.2.1 v1.2.2
/ /
v1.0.0 v1.2.0--------- v2.0.0
/ / /
-------------------------------------- dev
Dengan cara ini Anda memiliki cabang untuk setiap pembaruan versi minor. (Perhatikan bahwa pada grafik di atas, v1.2.1 dan v1.2.2 atau dibuat setelah v2.0.0 dirilis, jadi mereka bukan bagian dari pengembangan antara v1.2.0 dan v2.0.0. Anggap saja sebagai dukungan untuk versi yang lebih lama)
Metode 3: Pengembangan percabangan
Metode ini merupakan kebalikan dari sebelumnya. Cabang utama akan menjadi versi stabil terbaru. Setiap kali Anda mengerjakan versi baru, Anda membuat cabang (untuk pengembangan), bekerja pada kode Anda dan ketika stabil, gabungkan dengan cabang utama.
Dalam hal ini, cabang akan terlihat seperti ini:
________ ____ ________________ _____ dev
/ \/ \/ \/
---------------------------------- latest_version
Mungkin yang ini perlu dilakukan bersamaan dengan tag kan?
Pertanyaan!
Bagaimanapun, pertanyaan saya adalah berdasarkan pengalaman Anda, manakah dari metode ini yang terbukti lebih praktis? Adakah metode terbaik yang diketahui di luar sana (yang mungkin saya sendiri tidak tahu)? Bagaimana hal-hal ini biasa dilakukan?
Ini efektif, seperti yang Anda perhatikan, pendekatan yang salah, karena Anda sudah memiliki kontrol versi untuk ... mengontrol versi.
Sekarang, berbagai teknik yang Anda hitung tampaknya sama-sama benar. Anda dapat membaca artikel yang sangat terperinci, Kontrol Sumber Dilakukan Selesai , yang mencakup informasi tentang tag dan cabang.
sumber
Ketiga metode ini tidak eksklusif satu sama lain, dan Anda harus menggabungkan ketiganya untuk mendapatkan hasil maksimal dari kontrol versi Anda.
Untuk bagian saya, saya akan menggunakan kombinasi metode 1 dan 3 secara default, yaitu, mengembangkan di cabang fitur atau pengembangan sampai fitur siap produksi dan kemudian bergabung kembali ke bagasi. Dengan cara ini, trunk selalu mewakili keadaan saat ini dari perkembangan stabil, yang akan digunakan dan dapat dengan aman dihubungkan oleh svn: proyek eksternal. Saat Anda merilis versi, beri tag.
Aku hanya cabang pada permintaan, yaitu, ketika versi perpustakaan Anda memiliki bug yang memiliki diperbaiki. Anda dapat dengan mudah membuat cabang itu dari tag versi yang rusak. Dengan tidak bercabang secara tidak perlu, Anda menjaga jumlah cabang rendah dan memiliki ikhtisar cepat atas tepi perdarahan yang harus dipertahankan (batang dan semua cabang).
sumber
Saya akan menggunakan Metode 2 . Saya telah menggunakan ini dan menemukan ini sebagai cara yang efektif untuk mengelola dan memelihara beberapa versi sambil tetap memungkinkan pengembangan saat ini untuk bergerak maju. Anda juga dapat menggunakan tag bersamaan dengan metode ini jika Anda membutuhkannya.
Lihat jawaban saya di sini untuk informasi lebih lanjut tentang penggunaan percabangan untuk mempertahankan beberapa versi rilis.
sumber