Bagaimana cara nomor versi?

Perusahaan saya sedang membangun suatu produk. Ini akan diversi oleh SVN. Ini adalah webapp jadi pada dasarnya tidak akan pernah ada versi yang tidak memiliki beberapa fitur di dalamnya dan dengan demikian selalu dapat diberi label sebagai beta. Tapi karena itu akan menjadi produk perusahaan saya benar-benar tidak ingin "pengawasan tidak stabil" di sana. Jadi, bagaimana cara Anda membuat versi? Apakah 1.0 stabil? Haruskah tanggal pembuatan dalam nomor versi? Katakan apa yang kalian pikirkan!

[ mayor ]. [ minor ]. [ release ]. [ build ]

major : Benar-benar keputusan pemasaran. Apakah Anda siap untuk memanggil versi 1.0? Apakah perusahaan menganggap ini sebagai versi utama di mana pelanggan mungkin harus membayar lebih, atau apakah itu pembaruan dari versi utama saat ini yang mungkin gratis? Kurang dari keputusan R&D dan lebih banyak keputusan produk.

minor : Mulai dari 0 setiap kali jurusan bertambah. +1 untuk setiap versi yang go public.

rilis : Setiap kali Anda mencapai tonggak pengembangan dan merilis produk, bahkan secara internal (misalnya ke QA), tambahkan ini. Ini sangat penting untuk komunikasi antar tim dalam organisasi. Tak perlu dikatakan, tidak pernah merilis 'rilis' yang sama dua kali (bahkan secara internal). Atur ulang ke 0 pada minor ++ atau mayor ++.

build : Dapat menjadi revisi SVN, saya menemukan yang terbaik.

Contoh
Chrome saya saat ini: 83.0.4103.61

xyzg

kenaikan di g tidak stabil. Peningkatan (atau RC) dalam z adalah stabil dan berarti perbaikan bug.
kenaikan dalam y adalah stabil dan berarti fitur baru.
peningkatan x adalah stabil, rilis utama tanpa kompatibilitas mundur 100%.

Saya pernah menulis "panduan gaya versi" yang rumit untuk proyek besar saya. Proyek gagal terwujud, tetapi panduan gaya masih tersedia online . Itu pendapat pribadi saya, mungkin itu membantu (atau menginspirasi) bagi Anda.

Hati-hati, ini teks yang panjang, dan masuk ke versi komponen vs versi produk dan hal-hal seperti itu. Itu juga mengekspresikan pendapat yang kuat tentang beberapa skema versi yang populer di komunitas OSS, tetapi saya memilikinya, jadi saya mengungkapkannya. ;-)

Saya tidak setuju dengan menggunakan nomor revisi Subversion, misalnya. Anda mungkin ingin mempertahankan versi yang dirilis sambil melanjutkan pengembangan di TRUNK, jadi Anda akan membuat cabang pemeliharaan - dan versi nomor revisi Anda akan sia-sia.

Sunting: Sebagai ringkasan, ini membedakan antara versi sumber file, komponen, dan keseluruhan produk. Ia menggunakan sistem versailing xy yang terpisah untuk komponen dan produk, dengan saling ketergantungan yang bagus di antara keduanya yang membuat pelacakan versi komponen mana yang menjadi versi produk yang sepele. Ini juga berbicara tentang bagaimana menangani siklus alfa / beta / rilis / patch tanpa merusak sistem. Sebenarnya, ini adalah modus operandi untuk seluruh siklus pengembangan, jadi Anda mungkin ingin memilih-ceri. ;-)

Sunting 2: Karena cukup banyak orang yang menemukan artikel saya berguna untuk menjadikan ini "Jawaban yang Bagus", saya mulai mengerjakan artikel itu lagi. Versi PDF dan LaTeX sekarang tersedia, penulisan ulang lengkap termasuk bahasa yang lebih baik dan grafik penjelasan akan mengikuti segera setelah saya dapat menemukan waktu. Terima kasih untuk suaramu!

Dapatkan inspirasi dari Wikipedia: "Versi perangkat lunak"

Opsi "baru" dan "relatif populer" lainnya adalah Semantic Versioning

Ringkasan:

Diberi nomor versi MAJOR.MINOR.PATCH, menambah:

1. Versi UTAMA ketika Anda membuat perubahan API yang tidak kompatibel,
2. Versi MINOR saat Anda menambahkan fungsionalitas dengan cara yang kompatibel ke belakang, dan
3. Versi PATCH saat Anda membuat perbaikan bug yang kompatibel dengan mundur.

Label tambahan untuk pra-rilis dan metadata bangun tersedia sebagai ekstensi ke format MAJOR.MINOR.PATCH.

abcd

Penambahan: kapan
- d : perbaikan bug
- c : pemeliharaan, mis. Peningkatan kinerja
- b : fitur baru
- a : perubahan arsitektur

Wajib adalah yang paling kiri misalnya jika ada misalnya fitur baru dan bug diperbaiki maka Anda hanya perlu menambah b .

Berdasarkan pengalaman saya dengan manajemen ketergantungan tingkat platform perusahaan yang kompleks dan pelepasan versi, saya datang untuk merekomendasikan pendekatan yang saya sebut Semi-Semantic Versioning .

Pada dasarnya itu dibangun dari Semantic Versioning 2.0 tetapi tidak cukup ketat.

Segmen Versi Semi-Semantik:

<primary.release.segment>[-<pre.release.segment>][+<post.release.segment>]

Format Segmen Rilis Utama:

MARKETTING.MAJOR.MINOR.PATCH

Setiap segmen harus memungkinkan alfanumerik, tetapi numerik murni disarankan untuk perubahan inkremental logis.

Seperti SemVer, saya merekomendasikan komponen Major, Minor, dan Patch untuk mewakili tingkatan kompatibilitas terbalik, tetapi saya juga merekomendasikan untuk menambahkan komponen Pemasaran . Hal ini memungkinkan pemilik produk, epik / grup fitur, dan masalah bisnis untuk menabrak komponen utama terlepas dari masalah kompatibilitas teknis.

Tidak seperti jawaban lain, saya tidak merekomendasikan menambahkan nomor Build ke segmen utama. Alih-alih, tambahkan Segmen Pasca Rilis setelah '+' (mis: 1.1.0.0 + build.42). SemVer menyebut metadata build ini, tetapi saya pikir Segmen Pasca Rilis lebih jelas. Segmen ini bagus untuk mendeklarasikan data akhiran sebagai tidak terkait dengan info kompatibilitas di Segmen Rilis primer. Bangun integrasi kontinu Anda kemudian dapat diberi nomor rilis sebelumnya yang ditambahkan dengan nomor build tambahan yang direset setelah setiap rilis utama (mis: 1.1.0.0 -> 1.1.0.0 + build.1 -> 1.1.0.0 + build.2 -> 1.1.0.1). Beberapa orang secara bergantian suka memasukkan nomor revisi svn di sini atau git commit sha untuk membuatnya mudah untuk mengikat ke repositori kode. Pilihan lain adalah dengan menggunakan segmen pasca-rilis untuk perbaikan terbaru dan tambalan, yang mungkin layak dipertimbangkan menambahkan komponen rilis primer baru untuk itu. Itu selalu bisa turun ketika komponen tambalan bertambah, karena versi secara efektif dibariskan kiri dan diurutkan.

Selain segmen rilis dan pasca-rilis, orang sering ingin menggunakan Segmen Pra-Rilis untuk menunjukkan pra-rilis yang hampir stabil seperti alfa, beta, dan kandidat rilis. Pendekatan SemVer untuk ini berfungsi dengan baik, tetapi saya sarankan memisahkan komponen numerik dari pengklasifikasi alfa-numerik (mis: 1.2.0.0 + alpha.2 atau 1.2.0.0 + RC.2). Biasanya Anda akan menabrak segmen rilis pada saat yang sama dengan menambahkan segmen pasca-rilis dan kemudian menjatuhkan segmen pra-rilis ketika Anda berikutnya menabrak segmen rilis primer (mis .: 1.0.1.2 -> 1.2.0.0-RC.1 - > 1.2.0.0). Segmen pra-rilis ditambahkan untuk menunjukkan bahwa versi rilis akan datang, biasanya hanya seperangkat fitur tetap untuk pengujian dan berbagi yang lebih mendalam yang tidak berubah dari menit ke menit berdasarkan lebih banyak komitmen.

Keindahan dari memiliki semua ini secara semantik didefinisikan dengan cara yang mencakup hampir semua kasus penggunaan adalah bahwa Anda dapat menguraikan, mengurutkan, membandingkan dan menambahkannya dengan cara standar. Ini sangat penting ketika menggunakan sistem CI untuk aplikasi yang kompleks dengan banyak komponen kecil versi independen (seperti layanan mikro) masing-masing dengan dependensi yang dikelola sendiri.

Jika Anda tertarik, saya menulis parser semi-semantik di ruby . Saya perlu tidak hanya menggunakan pola ini tetapi dapat mengelola aplikasi lain yang menggunakannya.

"Nomor versi" adalah masalah untuk sistem kontrol versi internal Anda. Nomor rilis adalah masalah yang berbeda (dan harus berbeda KEPT).

Tetap berpegang pada sistem rilis MAJOR.MINOR sederhana (seperti v1.27), di mana MAJOR adalah tingkat kompatibilitas (versi 2.x tidak kompatibel dengan atau setidaknya sangat berbeda dari versi 1.x) dan MINOR adalah rilis bugfix atau peningkatan kecil Anda. . Selama Anda mengikuti format XY, Anda juga dapat menggunakan sistem lain seperti YEAR.MONTH (2009.12) atau YEAR.RELEASE (2009.3). Tapi sungguh Anda mungkin lebih baik berpegang teguh pada UTAMA. MUNGKIN kecuali Anda punya alasan kuat untuk tidak melakukannya.

Tentunya jangan menggunakan apa pun yang tidak sesuai dengan format XY, karena akan menyulitkan distro, situs web pengumuman, dll. Untuk bekerja dengan Anda, dan itu saja dapat secara serius mempengaruhi popularitas proyek Anda.

Gunakan cabang dan tag di sistem kontrol versi Anda (lebih baik didistribusikan) untuk menandai nomor versi internal tertentu yang berkaitan dengan masing-masing UTAMA dan MINOR.

Dan ya, 1.0 harus stabil. Semua rilis harus stabil, kecuali ditandai alfa, beta, atau RC. Gunakan Alphas untuk diketahui-rusak-dan-tidak lengkap. Beta untuk diketahui rusak. RC untuk "coba saja; Anda mungkin akan melihat hal-hal yang kami lewatkan". Apa pun tanpa salah satu dari ini harus (idealnya, tentu saja) diuji, dikenal baik, memiliki manual terkini, dll.

Belakangan ini cukup populer untuk hanya menggunakan nomor revisi Subversion.

Jika ada di SVN maka mengapa tidak menggunakan nomor revisi SVN?

Jika Anda melihat di kanan bawah halaman web ini Anda akan melihat nomor versi Stack Overflow yang merupakan nomor revisi SVN.

Versi terserah Anda; Saya akan menambahkan 1.0 pada versi pertama yang saya percayai. Anda mungkin ingin menindaklanjutinya dengan cepat dengan versi lain, karena beberapa vendor perangkat lunak telah memberi 1.0 reputasi buruk.

Anda memang menginginkan cara untuk mengikat nomor versi dengan versi yang digunakan, tetapi Anda mungkin ingin itu menjadi bagus dan sederhana untuk pengguna akhir Anda. Pertimbangkan untuk menggunakan nomor versi standar, dan menandai repositori SVN dengan menyertakan nomor versi.

Meskipun hanya berjalan dengan nomor revisi Subversion bagus dan sederhana, itu menghapus informasi dari nomor versi. Pengguna mungkin menganggap ini hal yang buruk.

Saya berasumsi bahwa webapp Anda akan memiliki semacam prosedur penyebaran, sehingga tidak setiap revisi di Subversion benar-benar diterbitkan. Karena tidak mungkin dari "luar" (dari perspektif pengguna) untuk menentukan kapan rilis dibuat, dan berapa banyak revisi kode akan menjalani di antara mereka, itu membuat angka hampir acak. Mereka akan meningkat, dan saya kira itu mungkin untuk menduga beberapa jenis jarak dari membandingkan dua revisi, tapi tidak banyak.

Nomor versi klasik cenderung "mendramatisir" rilis, sehingga pengguna dapat membangun semacam harapan. Lebih mudah untuk berpikir "Saya memiliki versi 1.0, sekarang versi 1.1 keluar menambahkan ini dan itu, itu terdengar menarik" daripada berpikir "kemarin kami menjalankan revisi SO 2587, hari ini 3233, pasti jauh lebih baik!".

Tentu saja, dramatisasi ini dapat meningkat juga, dengan perusahaan memilih nomor versi yang dimaksudkan untuk terdengar lebih menarik daripada termotivasi oleh perbedaan aktual dalam produk, saya kira akan pergi dengan angka revisi counter ini sedikit.

Skema versi: [mayor]. [Minor]. [Devrel] [mark]
[mayor]: increment jika Anda memiliki perubahan drastis dalam pengembangan.
[minor]: increment jika Anda memiliki perubahan kecil dalam pengembangan.
[devrel]: increment jika Anda memiliki perbaikan bug. Atur ulang ke nol jika mayor ++ atau minor ++.
[mark]: a, b atau rc: a adalah rilis alpha, b adalah rilis beta, dan rc adalah kandidat rilis. Perhatikan bahwa versi seperti 1.3.57a atau 1.3.57b atau 1.3.57rc ada sebelum versi 1.3.57. Mulai dari 0,0.0.

Kami telah menghabiskan terlalu banyak waktu untuk memutuskan kapan akan menambah versi utama. Beberapa toko jarang melakukannya sehingga Anda akan memiliki rilis seperti 1.25.3 dan yang lain akan melakukannya untuk rilis yang memberi Anda 15.0

Saya muak dengan itu dan meyakinkan semua orang bahwa nomor rilis utama hanya tahun dan minor hanya rilis berurutan dalam tahun itu. Para pengguna sepertinya menyukainya dan tidak perlu repot untuk membuat nomor versi berikutnya.

Year.Release.build

• tahun = tahun sekarang
• release = urutan # rilis publik dengan fungsionalitas baru - reset ke 1 setiap tahun
• build = bertambah untuk perbaikan bug dan rilis internal

EDIT

** Sekarang ini untuk aplikasi internal yang terus ditingkatkan **

Ini mungkin tidak akan berfungsi untuk aplikasi komersial di mana penting untuk memiliki rilis besar di waktu yang berbeda tahun ini untuk tujuan pemasaran dan keuangan.

Alasan mengapa pertanyaan ini ada adalah karena kami tidak memiliki satu pun cara yang disepakati untuk melakukan manajemen konfigurasi.

Cara saya suka melakukan nomor versi hanyalah integer kenaikan dari 1. Saya tidak ingin nomor versi multi-bagian yang harus saya jelaskan atau dokumentasikan. Dan saya tidak ingin menggunakan nomor rev SVN karena itu akan memerlukan penjelasan juga.

Anda memerlukan beberapa skrip rilis di atas SVN untuk mewujudkannya

Saya memiliki sedikit pengalaman di daerah tersebut. Namun, inilah yang akan saya lakukan:

1. Pilih skema penomoran revisi dan patuhi. Bersikaplah konsisten.
2. Setiap perubahan versi harus mewakili perubahan yang signifikan . Seberapa kecil perubahan itu signifikan dan tingkat perubahan yang tercermin dalam nomor versi terserah Anda.

Tentu saja, Anda bisa menggunakan nomor revisi svn --- seperti yang disarankan banyak orang lainnya !!!

Saya harap ini membantu.

Kami menggunakan sintaks major.minor.julian_date sederhana.

Dimana;

• major - Rilis pertama adalah 1 dan kemudian ketika kami memperkenalkan fitur-fitur baru atau perubahan yang begitu signifikan sehingga tidak kompatibel dengan peningkatan jumlah ini.
• minor - Rilis tonggak utama. Untuk setiap bangunan yang didorong oleh produksi, jumlah ini meningkat.
• julian_date - Hari Julian , build didorong ke QA.

Contoh rilis pertama yang didorong ke QA pada 1/15 adalah -> 1.0.015
Contoh rilis pertama yang didorong ke Produksi pada 3/4 adalah -> 1.1.063

Ini tidak sempurna, tetapi berguna karena kami mendorong build ke QA dekat setiap hari.

Beberapa info bagus di sini:

Kapan Mengubah File / Versi Perakitan

Pertama-tama, versi file dan versi perakitan tidak perlu bertepatan satu sama lain. Saya merekomendasikan bahwa versi file berubah dengan setiap build. Tapi, jangan mengubah versi perakitan dengan masing-masing build hanya agar Anda dapat mengetahui perbedaan antara dua versi file yang sama; gunakan versi file untuk itu. Memutuskan kapan untuk mengubah versi perakitan membutuhkan beberapa diskusi tentang jenis pembuatan untuk dipertimbangkan: pengiriman dan non-pengiriman.

Pembuatan Non-Pengiriman Secara umum, saya sarankan menjaga versi perakitan non-pengiriman sama antara pengiriman build. Ini menghindari masalah pemuatan perakitan yang diberi nama kuat karena ketidakcocokan versi. Beberapa orang lebih suka menggunakan kebijakan penerbit untuk mengarahkan versi perakitan baru untuk setiap bangunan. Namun saya sarankan untuk non-pengiriman build: itu tidak menghindari semua masalah pemuatan. Misalnya, jika seorang mitra menyalin aplikasi Anda, mereka mungkin tidak tahu untuk memasang kebijakan penerbit. Kemudian, aplikasi Anda akan rusak untuk mereka, meskipun itu berfungsi dengan baik pada mesin Anda.

Tetapi, jika ada kasus di mana aplikasi yang berbeda pada mesin yang sama perlu mengikat ke versi yang berbeda dari perakitan Anda, saya sarankan memberikan mereka membangun versi perakitan yang berbeda sehingga yang benar untuk setiap aplikasi dapat digunakan tanpa harus menggunakan LoadFrom / etc.

Pembuatan Kapal Adapun apakah itu ide yang baik untuk mengubah versi untuk pengiriman itu, itu tergantung pada bagaimana Anda ingin pengikatan bekerja untuk pengguna akhir. Apakah Anda ingin bangunan ini berdampingan atau di tempat? Apakah ada banyak perubahan di antara keduanya? Apakah mereka akan menghancurkan beberapa pelanggan? Apakah Anda peduli hal itu merusaknya (atau Anda ingin memaksa pengguna menggunakan pembaruan penting Anda)? Jika ya, Anda harus mempertimbangkan untuk menambah versi perakitan. Tetapi, sekali lagi, pertimbangkan bahwa melakukan itu terlalu sering dapat mengotori disk pengguna dengan perangkat lama.

Ketika Anda Mengubah Versi Majelis Anda Untuk mengubah versi yang di-hardcode ke yang baru, saya sarankan mengatur variabel ke versi dalam file header dan mengganti hardcoding di sumber dengan variabel. Kemudian, jalankan pra-prosesor selama proses pembuatan untuk memasukkan versi yang benar. Saya merekomendasikan untuk mengganti versi tepat setelah pengiriman, tidak tepat sebelumnya, sehingga ada lebih banyak waktu untuk menangkap bug karena perubahan tersebut.

Atau untuk menggunakan nomor versi 'pikiran' Anda, nomor subversi koma .. zB:

1.0.101 // revisi 101, lepaskan

atau 1.0.101-090303 // dengan tanggal rilis, saya menggunakan ini