Apa yang biasanya diwakili oleh angka-angka dalam versi (yaitu v1.9.0.1)?

Mungkin ini pertanyaan yang konyol, tapi saya selalu berasumsi setiap angka yang digambarkan oleh titik mewakili satu komponen perangkat lunak. Jika itu benar, apakah mereka pernah mewakili sesuatu yang berbeda? Saya ingin mulai menetapkan versi ke berbagai build perangkat lunak saya, tetapi saya tidak begitu yakin bagaimana seharusnya strukturnya. Perangkat lunak saya memiliki lima komponen berbeda.

Dalam versi 1.9.0.1 :

• 1 : Revisi besar (UI baru, banyak fitur baru, perubahan konseptual, dll.)

• 9 : Revisi kecil (mungkin perubahan pada kotak pencarian, 1 fitur ditambahkan, kumpulan perbaikan bug)

• 0 : Rilis perbaikan bug

• 1 : Nomor build (jika digunakan) —itulah alasan Anda melihat framework .NET menggunakan sesuatu seperti 2.0.4.2709

Anda tidak akan menemukan banyak aplikasi turun ke empat level, 3 biasanya sudah cukup.

Ada spesifikasi Semantic Versioning

Ini adalah ringkasan dari versi 2.0.0:

Diberikan nomor versi MAJOR.MINOR.PATCH, tambahkan:

1. Versi MAYOR ketika Anda membuat perubahan API yang tidak kompatibel,
2. Versi MINOR ketika Anda menambahkan fungsionalitas dengan cara yang kompatibel dengan versi sebelumnya, dan
3. Versi PATCH saat Anda melakukan perbaikan bug yang kompatibel dengan versi sebelumnya.

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

Ini bisa sangat sewenang-wenang, dan berbeda dari produk ke produk. Misalnya, dengan distribusi Ubuntu, 8.04 mengacu pada 2008.April

Biasanya angka paling kiri (utama) menunjukkan rilis utama, dan semakin jauh Anda pergi ke kanan, semakin kecil perubahan yang terlibat.

major.minor [.maintenance [.build]]

http://en.wikipedia.org/wiki/Software_versioning#Numeric

Semakin banyak poin, semakin kecil rilisnya. Tidak ada standar solid nyata di luar itu - dapat berarti hal yang berbeda berdasarkan apa yang diputuskan oleh pengelola proyek.

WordPress, misalnya, mengikuti baris berikut:

1.6 -> 2.0 -> 2.0.1 -> 2.0.2 -> 2.1 -> 2.1.1 -> 2.2 ...

1.6 hingga 2.0 akan menjadi rilis besar - fitur, perubahan antarmuka, perubahan besar pada API, kerusakan 1.6 template dan plugin, dll. 2.0 hingga 2.0.1 akan menjadi rilis minor - mungkin memperbaiki bug keamanan. 2.0.2 hingga 2.1 akan menjadi rilis yang signifikan - fitur baru, umumnya.

Angka dapat berguna seperti yang dijelaskan oleh jawaban lain, tetapi pertimbangkan bagaimana mereka juga bisa agak tidak berarti ... Sun, Anda tahu SUN, java: 1.2, 1.3, 1.4 1.5 atau 5 lalu 6. Dalam nomor versi Apple II yang baik. Sesuatu. Saat ini, orang menyerah pada nomor versi dan menggunakan nama konyol seperti "Feisty fig" (atau sesuatu seperti itu) dan "hardy heron" dan "europa" dan "ganymede". Tentu saja ini jauh kurang berguna karena, Anda akan kehabisan bulan jupiter sebelum Anda berhenti mengubah program, dan karena tidak ada urutan yang jelas Anda tidak dapat membedakan mana yang lebih baru.

Dalam versi v1.9.0.1: Ini adalah skema pembuatan versi eksplisit yang digunakan saat Anda tidak ingin menggunakan nama untuk pra-rilis atau membangun seperti -alpha, -beta.

1: Versi utama yang mungkin merusak kompatibilitas ke belakang

9: Menambahkan fitur baru untuk mendukung aplikasi Anda bersama dengan kompatibilitas mundur dengan versi sebelumnya.

0: Beberapa perbaikan bug minor

1: Nomor build (Nomor pra-rilis)

tetapi saat ini, Anda tidak akan menemukan skema pembuatan versi seperti itu. Lihat Versi Semantik [semver2.0] https://semver.org/

Nomor versi biasanya tidak mewakili komponen terpisah. Bagi sebagian orang / software jumlahnya cukup sewenang-wenang. Bagi orang lain, bagian berbeda dari string nomor versi memang mewakili hal yang berbeda. Misalnya, beberapa sistem menambah bagian dari nomor versi ketika format file berubah. Jadi V 1.2.1 adalah format file yang kompatibel dengan semua versi V 1.2 lainnya (1.2.2, 1.2.3, dll.) Tetapi tidak dengan V 1.3. Pada akhirnya, terserah Anda skema apa yang ingin Anda gunakan.

Biasanya:

MajorVersion.MinorVersion.Revision.Build

Itu tergantung, tetapi representasi tipikal adalah mayor.minor.release.build .

Dimana:

• mayor adalah versi rilis utama perangkat lunak Anda, pikirkan .NET 3.x
• minor adalah versi rilis minor dari perangkat lunak Anda, pikirkan .NET x.5
• rilis adalah rilis versi itu, biasanya perbaikan bug akan meningkatkannya
• build adalah angka yang menunjukkan jumlah build yang telah Anda lakukan.

Jadi misalnya, 1.9.0.1, berarti itu adalah versi 1.9 dari perangkat lunak Anda, mengikuti 1.8 dan 1.7, dsb. Di mana 1.7, 1.8 dan 1.9 dalam beberapa hal biasanya menambahkan sejumlah kecil fitur baru bersamaan dengan perbaikan bug. Karena xx0.x, ini adalah rilis awal 1.9, dan ini adalah build pertama dari versi itu.

Anda juga dapat menemukan informasi bagus di artikel Wikipedia tentang subjek tersebut .

Mayor Minor Bugs

(Atau beberapa variasi itu)

Bug biasanya merupakan perbaikan bug tanpa fungsionalitas baru.

Minor adalah beberapa perubahan yang menambahkan fungsionalitas baru tetapi tidak mengubah program secara besar-besaran.

Mayor adalah perubahan dalam program yang merusak fungsionalitas lama atau terlalu besar sehingga mengubah cara pengguna menggunakan program.

Setiap orang memilih apa yang ingin mereka lakukan dengan angka-angka ini. Saya tergoda untuk memanggil rilis abc karena itu agak konyol. Meskipun demikian, apa yang saya lihat selama 25+ tahun terakhir perkembangannya cenderung berjalan seperti ini. Katakanlah nomor versi Anda adalah 1.2.3.

Angka "1" menunjukkan revisi "utama". Biasanya ini adalah rilis awal, perubahan kumpulan fitur yang besar atau penulisan ulang bagian-bagian kode yang signifikan. Setelah set fitur ditentukan dan setidaknya diterapkan sebagian, Anda pergi ke nomor berikutnya.

"2" menunjukkan rilis dalam rangkaian. Seringkali kami menggunakan posisi ini untuk mengejar fitur yang tidak berhasil dalam rilis utama terakhir. Posisi ini (2) hampir selalu menunjukkan penambahan fitur, biasanya dengan perbaikan bug.

"3" di sebagian besar toko menunjukkan rilis patch / perbaikan bug. Hampir tidak pernah, setidaknya di sisi komersial, apakah ini menunjukkan penambahan fitur yang signifikan. Jika fitur muncul di posisi 3 maka itu mungkin karena seseorang memeriksa sesuatu sebelum kami tahu kami harus melakukan rilis perbaikan bug.

Di luar posisi "3"? Saya tidak tahu mengapa orang melakukan hal semacam itu, itu hanya menjadi lebih membingungkan.

Terutama beberapa OSS di luar sana membuang semua ini keluar dari kesalahan. Misalnya, Trac versi 10 sebenarnya 0.10.XX Saya rasa banyak orang di dunia OSS yang kurang percaya diri atau hanya tidak ingin mengumumkan bahwa mereka telah menyelesaikan rilis besar.

Dari file C # AssemblyInfo.cs Anda dapat melihat berikut ini:

// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
/ You can specify all the values or you can default the Build and Revision Numbers 
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]

release.major.minor.revision akan menjadi tebakan saya.
Tapi itu bisa sangat bervariasi antar produk.

Major.minor.point.build biasanya. Mayor dan minor sudah cukup jelas, point adalah rilis untuk beberapa perbaikan bug minor, dan build hanyalah pengenal build.

Ya. Rilis mayor menambahkan fitur baru yang besar, dapat merusak kompatibilitas atau memiliki dependensi yang sangat berbeda, dll.

Rilis minor juga menambahkan fitur, tetapi lebih kecil, terkadang versi porting yang dilucuti dari rilis mayor beta.

Jika ada komponen nomor versi ketiga, biasanya untuk perbaikan bug penting, dan perbaikan keamanan. Jika ada lebih banyak, itu sangat tergantung pada produk sehingga sulit untuk memberikan jawaban umum.

Paradigma rilis utama.pelepasan kecil. Perbaikan rilis.bug cukup umum, saya kira.

Dalam beberapa kontrak dukungan perusahaan, ada $$$ (atau pelanggaran kewajiban kontrak) terkait dengan bagaimana rilis tertentu ditetapkan. Sebuah kontrak, misalnya, mungkin memberikan hak kepada pelanggan untuk beberapa rilis utama dalam periode waktu tertentu, atau berjanji bahwa akan ada kurang dari x jumlah rilis minor dalam satu periode, atau bahwa dukungan akan terus tersedia untuk begitu banyak rilis. Tentu saja tidak peduli berapa banyak kata yang dimasukkan ke dalam kontrak untuk menjelaskan apa itu rilis utama versus rilis kecil, itu selalu subjektif dan akan selalu ada area abu-abu - yang mengarah pada kemungkinan bahwa vendor perangkat lunak dapat mempermainkan sistem untuk mengalahkan ketentuan kontrak tersebut.

Orang tidak selalu mengenali perbedaan halus antara nomor versi seperti 2.1, 2.0.1, atau 2.10 - tanyakan kepada staf dukungan teknis berapa kali mereka mengalami masalah dengan ini. Pengembang berorientasi pada detail dan akrab dengan struktur hierarki, jadi ini adalah titik buta bagi kami.

Jika memungkinkan, tunjukkan nomor versi yang lebih sederhana kepada pelanggan Anda.

Dalam kasus pustaka, nomor versi memberi tahu Anda tentang tingkat kompatibilitas antara dua rilis, dan dengan demikian seberapa sulit upgrade akan.

Rilis perbaikan bug perlu menjaga kompatibilitas biner, sumber, dan serialisasi.

Rilis minor memiliki arti yang berbeda untuk proyek yang berbeda, tetapi biasanya mereka tidak perlu menjaga kompatibilitas sumber.

Nomor versi utama dapat mematahkan ketiga bentuk tersebut.

Saya menulis lebih banyak tentang alasannya di sini .

Kombinasi mayor, minor, patch, build, security patch, dll.

Dua yang pertama besar & kecil-- sisanya akan bergantung pada proyek, perusahaan, dan terkadang komunitas. Di OS seperti FreeBSD, Anda akan memiliki 1.9.0.1_number untuk mewakili patch keamanan.

Sedikit bergantung pada bahasanya, Delphi dan C # misalnya memiliki arti yang berbeda.

Biasanya, dua angka pertama mewakili versi mayor dan minor, yaitu 1.0 untuk rilis nyata pertama, 1.1 untuk beberapa perbaikan bug penting dan fitur baru minor, 2.0 untuk rilis fitur baru yang besar.

Angka ketiga bisa merujuk ke versi "sangat kecil", atau revisi. 1.0.1 hanyalah perbaikan bug yang sangat kecil untuk 1.0.0 misalnya. Tetapi itu juga dapat membawa nomor Revisi dari Sistem Kontrol Sumber Anda, atau nomor yang terus bertambah yang bertambah dengan setiap build. Atau stempel tanggal.

Sedikit lebih detail di sini . "secara resmi", di .net, 4 angka tersebut adalah "Major.Minor.Build.Revision", sedangkan di Delphi ada "Major.Minor.Release.Build". Saya menggunakan "Major.Minor.ReallyMinor.SubversionRev" untuk pembuatan versi saya.

Umumnya, nomor dalam format version.major.minor.hotfix, bukan komponen internal individu. Jadi v1.9.0.1 akan menjadi versi 1, rilis mayor 9 (dari v1), rilis minor (dari v1.9) 0, hot fix 1 dari (v1.9.0).

Nomor pertama biasanya disebut sebagai nomor versi utama. Ini pada dasarnya digunakan untuk menunjukkan perubahan signifikan antara build (yaitu saat Anda menambahkan banyak fitur baru, Anda menaikkan versi mayor). Komponen dengan versi utama yang berbeda dari produk yang sama mungkin tidak kompatibel.

Nomor berikutnya adalah nomor versi minor. Ini dapat mewakili beberapa fitur baru, atau sejumlah perbaikan bug atau perubahan arsitektur kecil. Komponen dari produk yang sama yang berbeda dengan nomor versi minor mungkin atau mungkin tidak bekerja bersama dan mungkin tidak boleh.

Berikutnya biasanya disebut nomor build. Ini dapat bertambah setiap hari, atau dengan setiap build yang "dirilis", atau dengan setiap build sama sekali. Mungkin hanya ada perbedaan kecil antara dua komponen yang berbeda hanya berdasarkan nomor pembuatan dan biasanya dapat bekerja sama dengan baik.

Angka terakhir biasanya merupakan angka revisi. Sering kali ini digunakan oleh proses build otomatis, atau saat Anda membuat build sekali pakai "sekali pakai" untuk pengujian.

Saat Anda menaikkan nomor versi, itu terserah Anda, tetapi angka tersebut harus selalu bertambah atau tetap sama . Anda dapat meminta semua komponen berbagi nomor versi yang sama, atau hanya menaikkan nomor versi pada komponen yang diubah.

Nomor versi perangkat lunak yang kompleks mewakili seluruh paket dan tidak tergantung pada nomor versi bagian-bagian tersebut. Gizmo versi 3.2.5 mungkin berisi Foo versi 1.2.0 dan Bar versi 9.5.4.

Saat membuat nomor versi, gunakan sebagai berikut:

1. Nomor pertama adalah rilis utama. Jika Anda membuat perubahan signifikan pada antarmuka pengguna atau perlu merusak antarmuka yang ada (sehingga pengguna Anda harus mengubah kode antarmuka mereka), Anda harus pergi ke versi utama yang baru.

2. Angka kedua harus menunjukkan bahwa fitur baru telah ditambahkan atau sesuatu bekerja secara berbeda secara internal. (Misalnya database Oracle mungkin memutuskan untuk menggunakan strategi yang berbeda untuk mengambil data, membuat sebagian besar lebih cepat dan beberapa hal lebih lambat.) Antarmuka yang ada harus terus berfungsi dan antarmuka pengguna harus dikenali.

3. Penomoran versi selanjutnya tergantung pada orang yang menulis perangkat lunak - Oracle menggunakan lima grup (!), Yaitu. versi Oracle adalah seperti 10.1.3.0.5. Dari grup ketiga ke bawah, Anda hanya boleh memperkenalkan perbaikan bug atau perubahan kecil dalam fungsionalitas.

yang kurang bervariasi akan menjadi dua yang pertama, untuk mayor.minor, setelah itu bisa apa saja mulai dari build, revisi, rilis, hingga algoritme khusus apa pun (seperti di beberapa produk MS)

Setiap organisasi / kelompok memiliki standarnya masing-masing. Yang penting adalah Anda tetap berpegang pada notasi apa pun yang Anda pilih jika tidak, pelanggan Anda akan bingung. Karena itu saya biasanya menggunakan 3 angka:

x.yz.bbbbb. Di mana: x: adalah versi utama (fitur baru utama) y: adalah nomor versi minor (fitur baru kecil, peningkatan kecil tanpa perubahan UI) z: adalah paket layanan (pada dasarnya sama dengan xy tetapi dengan beberapa perbaikan bug bbbb: adalah nomor pembuatan dan hanya benar-benar terlihat dari "kotak tentang" dengan detail lain untuk dukungan pelanggan. bbbb adalah format gratis dan setiap produk dapat menggunakannya sendiri.

Inilah yang kami gunakan:

1. Angka pertama = Era sistem keseluruhan. Perubahan setiap beberapa tahun dan biasanya mewakili perubahan mendasar dalam teknologi, atau fitur klien, atau keduanya.
2. Nomor kedua = revisi skema database. Kenaikan jumlah ini membutuhkan migrasi database dan begitu juga dengan perubahan yang signifikan (atau sistem mereplikasi dan mengubah struktur database membutuhkan proses peningkatan yang hati-hati). Disetel ulang ke 0 jika angka pertama berubah.
3. Angka ketiga = software hanya berubah. Ini biasanya dapat diimplementasikan pada klien demi klien karena skema database tidak berubah. Disetel ulang ke nol jika angka kedua berubah.
4. Nomor versi subversi. Kami mengisi ini secara otomatis pada pembangunan menggunakan alat TortoiseSVN. Jumlah ini tidak pernah me-reset tetapi terus bertambah. Dengan menggunakan ini, kami selalu dapat membuat ulang versi apa pun.

Sistem ini sangat membantu kami karena setiap angka memiliki fungsi yang jelas dan penting. Saya telah melihat tim lain bergulat dengan pertanyaan nomor mayor / minor (seberapa besar perubahan itu besar) dan saya tidak melihat manfaatnya. Jika Anda tidak perlu melacak revisi database, cukup gunakan nomor versi 3 atau 2 digit, dan buat hidup lebih mudah!

versi: v1.9.0.1

dimana-

. v adalah singkatan dari versi. Ini bervariasi dengan perusahaan ke perusahaan tergantung pada nomenklatur yang diadopsi dalam organisasinya. Ini mungkin diam di beberapa organisasi seperti 1.9.0.1

. 1 menunjukkan versi utama, akan diperbarui pada modifikasi Arsitektur di tumpukan aplikasi, infrastruktur (platform) atau antarmuka jaringan yang terbuka

. 9 incates minor, akan diupdate pada aktivitas seperti menambahkan komponen baru seperti ui, api, database dll; di bawah arsitektur tertentu

. 0 menunjukkan fitur, akan diperbarui pada setiap peningkatan pada komponen yang ada (ui, api, database dll)

. 1 menunjukkan penghitung build di semua fase mayor, minor, dan fitur. Ini juga termasuk perbaikan terbaru pasca rilis produksi.