Bagaimana cara kerja nomor versi awal untuk produk baru?

Saat ini saya sedang menulis aplikasi desktop kecil untuk seorang teman, tetapi saya melakukannya terutama sebagai pengalaman belajar untuk diri saya sendiri. Dengan semangat mendapatkan pendidikan dan melakukan hal-hal dengan Cara yang Benar, saya ingin memiliki nomor versi untuk aplikasi ini.

Penelitian saya membawa hasil terkait ini

• Apa "konvensi penamaan versi" yang Anda gunakan?
• Bagaimana Anda memberi versi file Anda (Nomor Versi)
• Menjahit proyek, di mana nomor versi saya mulai?

tetapi tidak satupun dari mereka membahas penomoran alfabet, beta, kandidat rilis, & c. Apa konvensi untuk nomor versi di bawah 1.0? Saya tahu mereka dapat berlangsung selama beberapa waktu; misalnya, Putty sudah ada selama setidaknya satu dekade dan masih hanya pada versi beta 0,60.

Itu benar-benar tergantung pada proyek; beberapa proyek bahkan tidak merilis versi 1.0.

Pengembang MAME tidak bermaksud untuk merilis versi 1.0 dari program emulator mereka. Argumennya adalah bahwa itu tidak akan pernah benar-benar "selesai" karena akan selalu ada lebih banyak game arcade. Versi 0.99 hanya diikuti oleh versi 0.100 (versi minor 100> 99). Dengan cara yang sama Xfire 1.99 diikuti oleh 1.100. Setelah 6 tahun pengembangan, eMule bahkan belum mencapai versi 0,50. ^{Versi perangkat lunak di Wikipedia}

Salah satu metode penomoran versi yang populer (yang sudah mulai saya gunakan) adalah Semantic Versioning .

Di bawah skema ini, nomor versi dan cara perubahannya menyampaikan makna tentang kode yang mendasarinya dan apa yang telah dimodifikasi dari satu versi ke versi berikutnya.

Beberapa kutipan memberi Anda lebih banyak ide tentang cara kerjanya dan / atau menjawab beberapa pertanyaan Anda:

Bagaimana saya tahu kapan harus merilis 1.0.0?

Jika perangkat lunak Anda digunakan dalam produksi, mungkin seharusnya sudah 1.0.0. Jika Anda memiliki API stabil tempat pengguna bergantung, Anda harus 1.0.0. Jika Anda sangat mengkhawatirkan kompatibilitas ke belakang, Anda seharusnya sudah mencapai 1.0.0.

Tidakkah ini menghambat pengembangan yang cepat dan iterasi yang cepat?

Versi utama nol adalah semua tentang perkembangan yang cepat. Jika Anda mengubah API setiap hari Anda harus masih dalam versi 0.xx atau pada cabang pengembangan terpisah yang bekerja pada versi utama berikutnya.

Jika bahkan perubahan terkecil yang tidak kompatibel ke API publik memerlukan versi benjolan besar, tidak akankah saya berakhir di versi 42.0.0 dengan sangat cepat?

Ini adalah pertanyaan tentang pengembangan dan tinjauan ke masa depan yang bertanggung jawab. Perubahan yang tidak kompatibel tidak boleh diperkenalkan secara ringan ke perangkat lunak yang memiliki banyak kode dependen. Biaya yang harus dikeluarkan untuk meningkatkan dapat menjadi signifikan. Harus menabrak versi utama untuk merilis perubahan yang tidak kompatibel berarti Anda akan memikirkan dampak dari perubahan Anda, dan mengevaluasi rasio biaya / manfaat yang terlibat.

Ada juga aturan tentang cara menentukan rilis "alpha," "beta," dll. Lihat detailnya di http://semver.org/ .

[Sunting] Skema penomoran versi lain yang menarik adalah yang digunakan MongoDB :

MongoDB menggunakan versi nomor ganjil untuk rilis pengembangan.

Ada 3 angka dalam versi MongoDB: ABC

• A adalah versi utama. Ini jarang akan berubah dan menandakan perubahan yang sangat besar
• B adalah nomor rilis. Ini akan mencakup banyak perubahan termasuk fitur dan hal-hal yang mungkin merusak kompatibilitas. Bahkan B akan menjadi cabang yang stabil, dan B aneh akan menjadi pengembangan.
• C adalah nomor revisi dan akan digunakan untuk masalah bug dan keamanan.

Sebagai contoh:

• 1.0.0: rilis GA pertama
• 1.0.x: perbaikan bug ke 1.0.x - sangat disarankan untuk ditingkatkan, risikonya sangat kecil
• 1.1.x: rilis pengembangan. ini akan mencakup fitur-fitur baru yang belum sepenuhnya selesai, dan sedang berjalan. Beberapa hal mungkin berbeda dari 1.0
• 1.2.x: rilis GA kedua. ini akan menjadi puncak dari rilis 1.1.x.

Saya tidak berpikir ada "standar" seperti itu.

Ada konvensi untuk Calon Pelepasliaran yang biasanya "[versi] RC 1" dll. Tergantung pada berapa banyak versi yang Anda pikir akan Anda rilis.

Jika Anda merilis versi paling awal dari produk Anda - yang bukan fitur lengkap - maka Anda mungkin ingin menggunakan versi "0". Dengan begitu Anda dapat meningkatkan versi seiring waktu saat Anda mengisi rangkaian fitur Anda.

Saya akan menggunakan "Alpha" dan "Beta" seperti Release Candidate - untuk versi waktu terbatas untuk menunjukkan bahwa Anda merasa hampir merilis versi lengkap.

Ada halaman Wikipedia tentang Versi Perangkat Lunak . Untuk berbagi versi pra-1.0, konvensi yang digunakan oleh Apple dan lainnya berfungsi dengan baik: major.minor.maintSrev di mana S adalah indikator tahapan untuk versi pra-rilis: d = pengembangan, a = alpha, b = beta, rc = kandidat rilis. Jadi versi internal pertama Anda bisa 1.0.0d1.

Untuk revisi internal sepenuhnya, cap waktu sudah cukup.

Setiap pengembang untuk sebagian besar memutuskan standar apa yang akan mereka gunakan. Secara umum angka-angka di sebelah kiri titik desimal menunjukkan revisi besar yang kemungkinan akan sangat terlihat oleh pengguna rata-rata (mis. Fungsionalitas atau perubahan antarmuka, dll). Di sisi kanan titik desimal ini akan menjadi perubahan / modifikasi / penambahan yang tidak banyak mengubah fungsionalitas dan desain keseluruhan tetapi memang mengubah sesuatu tentang program itu sendiri (yaitu membuat fungsi lebih cepat sambil tetap melakukan hal yang sama atau diperbaiki masalah keamanan). Kemudian jika Anda menambahkan titik desimal tambahan angka-angka di sebelah kanan ini akan menunjukkan perubahan yang semakin kecil dan semakin kecil (yaitu perbaikan bug kecil / masalah keamanan dan semacamnya).

Seperti yang dikatakan orang lain, sepertinya tidak ada standar yang pasti. Organisasi kami menggunakan notasi berikut:

Rilis 1.0 ---> 2.0 (Fitur baru / lebih baik ditambahkan ke produk)

Rilis 1.0 ---> 1.1 (Fitur baru / lebih baik tingkat menengah ditambahkan ke produk)

Rilis 1.0 ---> 1.001 (Perbaikan Bug)

Tonggak "versi 1.0" sangat penting bagi pengguna komputer yang berpengalaman, karena ini menyiratkan bahwa program ini dilakukan dan berfungsi seperti yang diharapkan. Apa pun dalam versi "0.something" menyiratkan bahwa programmer sendiri berpikir bahwa program tersebut belum selesai .

Anda dapat menyimpan nomor versi "0,1", "0,2" ... untuk pencapaian fungsionalitas utama dan kemudian mengelompokkannya dengan nomor pembuatan yang sering merupakan tanggal dan cap waktu yang cukup berbutir halus.