Bagaimana Anda menempatkan berbagai versi perpustakaan Anda di bawah kontrol versi? Apakah Anda menggunakan tag? Atau cabang? Atau metode lain?

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?

Tag dan cabang tidak saling menguntungkan, Anda dapat (dan biasanya IMO) menggunakannya keduanya. Tag ada untuk menandai tonggak dalam pembangunan. Misalnya Anda membuka cabang untuk versi 1.2 dari produk Anda, dan Anda menandai v1.2 Beta, RC1, RC2, Final(dan kemudian, jika diperlukan, SP1dll) dengan tag pada cabang yang sama.

Saya pribadi lebih suka Metode 2 sebagai pendekatan default (walaupun saya mencoba untuk menghindari beberapa tingkat cabang, untuk menjaga hidup sesederhana mungkin). Metode 1 tidak akan berfungsi dalam kehidupan nyata - tag tidak cukup, Anda perlu cabang. Dan metode 3 tidak fleksibel karena hanya memiliki satu versi stabil setiap saat, jadi (kecuali jika Anda gabungkan dengan Metode 2), Anda tidak dapat mempertahankan beberapa versi (terbaru dan lebih lama) secara paralel. Ini diperlukan untuk hampir semua proyek dalam kehidupan nyata - saat Anda mengerjakan versi 2, Anda masih dapat menerbitkan tambalan / peningkatan untuk v1.9, dan seringkali bahkan versi yang lebih lama. Banyak tergantung pada jenis aplikasi tentunya. Kami mengembangkan aplikasi web, jadi hanya ada satu versi produksi pada suatu titik waktu tertentu, masih kami sering menyulap dengan 3 versi yang berbeda (satu dalam produksi, satu di UAT bersiap-siap untuk ditempatkan, satu adalah versi terbaru di bagasi). Ini bisa menjadi jauh lebih rumit untuk aplikasi desktop / klien dengan beberapa versi lama yang digunakan - dan dipelihara - secara paralel.

Saya memiliki folder dengan nama perpustakaan, di dalam banyak folder dengan nomor versi.

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.

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).

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.