Praktik Terbaik: Versi Perangkat Lunak [ditutup]

Apakah ada pedoman atau praktik terbaik standar tentang bagaimana membuat versi perangkat lunak yang Anda kembangkan di waktu luang Anda untuk bersenang-senang, tetapi tetap akan digunakan oleh beberapa orang? Saya pikir itu perlu untuk versi perangkat lunak tersebut sehingga Anda tahu tentang versi yang dibicarakan (misalnya untuk memperbaiki bug, dukungan, dan sebagainya).

Tapi di mana saya memulai versi? 0,0.0? atau 0,0? Lalu bagaimana cara saya menambah angka? rilis besar. perubahan kecil? dan bukankah komitmen terhadap sistem kontrol versi adalah versi lain? atau ini hanya untuk versi yang digunakan secara produktif?

Anda harus mulai dengan versi 1, kecuali Anda tahu bahwa versi pertama yang Anda "rilis" tidak lengkap.

Mengenai bagaimana Anda menambah versi, terserah Anda, tetapi gunakan penomoran mayor, minor, build sebagai panduan.

Tidak perlu memiliki setiap versi yang Anda komit ke kontrol sumber sebagai versi lain - Anda akan segera memiliki jumlah versi yang sangat besar. Anda hanya perlu menambah nomor versi (dalam beberapa cara) ketika Anda merilis versi baru ke dunia luar.

Jadi, jika Anda membuat perubahan besar, pindah dari versi 1.0.0.0 ke versi 2.0.0.0 (Anda berubah dari WinForms ke WPF misalnya). Jika Anda membuat perubahan yang lebih kecil, pindah dari 1.0.0.0 ke 1.1.0.0 (Anda menambahkan dukungan untuk file png). Jika Anda membuat perubahan kecil, maka mulai dari 1.0.0.0 ke 1.0.1.0 (Anda memperbaiki beberapa bug).

Jika Anda benar-benar ingin mendapatkan detail, gunakan angka terakhir sebagai nomor build yang akan bertambah untuk setiap checkin / commit (tapi saya pikir itu terlalu jauh).

Saya akan menggunakan x.y.zsemacam versi

x- rilis utama - rilis
ykecil
z- nomor build

Saya pada dasarnya mengikuti pola ini:

• mulai dari 0.1.0

• ketika sudah siap saya bercabang kode dalam repo sumber, tag 0.1.0 dan buat cabang 0.1.0, kepala / trunk menjadi 0.2.0-snapshot atau yang serupa

• Saya menambahkan fitur baru hanya ke bagasi, tetapi perbaikan backport ke cabang dan pada waktunya saya melepaskannya dari 0.1.1, 0.1.2, ...

• Saya menyatakan versi 1.0.0 ketika produk dianggap fitur lengkap dan tidak memiliki kekurangan utama

• sejak saat itu - semua orang dapat memutuskan kapan akan menambah versi utama ...

Saya menggunakan aturan ini untuk aplikasi saya:

xyz

Dimana:

• x = nomor versi utama, 1- ~.
• y = nomor fitur, 0-9. Tambah nomor ini jika perubahan berisi fitur baru dengan atau tanpa perbaikan bug.
• z = nomor perbaikan terbaru, 0- ~. Tambah nomor ini jika perubahan hanya berisi perbaikan bug.

Contoh:

• Untuk aplikasi baru, nomor versi dimulai dengan 1.0.0.
• Jika versi baru hanya berisi perbaikan bug, tambah nomor perbaikan terbaru sehingga nomor versi menjadi 1.0.1.
• Jika versi baru berisi fitur-fitur baru dengan atau tanpa perbaikan bug, tambah nomor fitur dan setel ulang nomor hotfix ke nol sehingga nomor versi menjadi 1.1.0. Jika nomor fitur mencapai 9, tambah nomor versi utama dan setel ulang fitur dan nomor perbaikan terbaru ke nol (2.0.0 dll)

Kami menggunakan abcd mana

• a - mayor (bertambah pada pengiriman ke klien)
• b - minor (bertambah pada pengiriman ke klien)
• c - revisi (bertambah pada rilis internal)
• d - build (ditambah oleh cruise control)

Contoh lain dari A.B.Cpendekatan ini adalah Eclipse Bundle Versioning . Bundel Eclipse memiliki segmen keempat:

Dalam Eclipse, nomor versi terdiri dari empat (4) segmen: masing-masing 3 bilangan bulat dan sebuah string major.minor.service.qualifier. Setiap segmen menangkap maksud berbeda:

• segmen utama mengindikasikan kerusakan pada API
• segmen minor menunjukkan perubahan "terlihat secara eksternal"
• segmen layanan menunjukkan perbaikan bug dan perubahan aliran pengembangan
• segmen kualifikasi menunjukkan bangunan tertentu

Ada juga tanggal versioning skema , misalnya: YYYY.MM, YY.MM,YYYYMMDD

Ini cukup informatif karena tampilan pertama memberi kesan tentang tanggal rilis. Tetapi saya lebih suka skema xyz, karena saya selalu ingin tahu titik pasti suatu produk dalam siklus hidupnya (Major.minor.release)

Jawaban dasarnya adalah "Itu tergantung".

Apa tujuan Anda dalam membuat versi? Banyak orang menggunakan version.revision.build dan hanya mengiklankan version.revision kepada dunia karena itu adalah versi rilis dan bukan versi dev. Jika Anda menggunakan 'versi' check-in maka Anda akan dengan cepat menemukan bahwa nomor versi Anda menjadi besar.

Jika Anda merencanakan proyek Anda maka saya akan menambah revisi untuk rilis dengan perubahan kecil dan versi kenaikan untuk rilis dengan perubahan besar, perbaikan bug atau fungsi / fitur. Jika Anda menawarkan rilis tipe beta atau nightly build, maka perluas versi dengan menyertakan build dan increment pada setiap rilis.

Namun, pada akhirnya, itu terserah Anda dan itu harus masuk akal bagi Anda.

Seperti yang dikatakan Mahesh: Saya akan menggunakan versi xyz

x - rilis mayor y - rilis minor z - build number

Anda mungkin ingin menambahkan datetime, mungkin sebagai ganti z.

Anda menambah rilis minor saat Anda memiliki rilis lain. Rilis utama mungkin akan tetap 0 atau 1, Anda mengubahnya ketika Anda benar-benar membuat perubahan besar (seringkali ketika perangkat lunak Anda berada pada titik di mana itu tidak kompatibel dengan rilis sebelumnya, atau Anda mengubah seluruh kerangka kerja Anda)

Anda tahu Anda selalu dapat memeriksa untuk melihat apa yang dilakukan orang lain. Perangkat lunak open source cenderung memungkinkan akses ke repositori mereka. Misalnya Anda bisa mengarahkan browser SVN Anda ke http://svn.doctrine-project.org dan lihat sistem versi yang digunakan oleh proyek nyata.

Nomor versi, tag, semuanya ada di sana.

Kami mengikuti pendekatan abc seperti:

Menambah 'a' jika ada beberapa perubahan besar yang terjadi dalam aplikasi. Seperti kita memutakhirkan aplikasi .NET 1.1 ke .NET 3.5

meningkat 'b' jika ada beberapa perubahan kecil seperti CR atau Peningkatan baru diimplementasikan.

meningkat 'c' jika ada beberapa perbaikan cacat dalam kode.

Saya mulai versi pada segmen terendah (non hotfix). Saya tidak membatasi segmen ini hingga 10. Kecuali jika Anda melacak build maka Anda hanya perlu memutuskan kapan Anda ingin menerapkan kenaikan. Jika Anda memiliki fase QA maka itu mungkin di mana Anda menerapkan kenaikan ke segmen terendah dan kemudian segmen berikutnya ketika melewati QA dan dilepaskan. Tinggalkan segmen paling atas untuk perubahan Perilaku / UI utama.

Jika Anda seperti saya, Anda akan membuatnya menjadi hibrid dari metode ini agar sesuai dengan laju perkembangan perangkat lunak Anda.

Saya pikir abc atau abcd pola yang paling diterima terutama jika Anda memiliki QA / Compliance dalam campuran. Saya memiliki begitu banyak kelemahan sekitar tanggal menjadi bagian reguler dari versi yang saya berikan untuk arus utama.

Saya tidak melacak build jadi saya suka menggunakan pola abc kecuali ada perbaikan terbaru yang terlibat. Ketika saya harus menerapkan perbaikan terbaru maka saya menerapkan parameter d sebagai tanggal dengan waktu. Saya mengadopsi parameter waktu sebagai d karena selalu ada potensi beberapa dalam sehari ketika hal-hal benar-benar meledak dalam produksi. Saya hanya menerapkan segmen d (YYYYMMDDHHNN) ketika saya sedang mencari perbaikan produksi.

Saya pribadi tidak akan menentang skema perangkat lunak va.b revc di mana c adalah YYYYMMDDHHMM atau YYYYMMDD.

Semua itu dikatakan. Jika Anda bisa mengambil alat untuk mengkonfigurasi dan menjalankannya, itu akan membuat Anda tidak perlu pusing karena harus menyusun segi pendapat dari versi dan Anda bisa mengatakan "gunakan alat" ... karena semua orang dalam proses pengembangan biasanya sangat patuh .