Bagaimana Anda menangani versi dalam proyek multi-sisi?

Saya tahu ini adalah pertanyaan luas jadi saya akan mencoba sespesifik mungkin. Pertanyaan ini lebih merupakan pertanyaan "organisasional" daripada pertanyaan teknis.

Kami memiliki proyek multi-sisi dengan komponen utama ini:

• Server, hosting logika bisnis inti (model data)
• Kantor belakang untuk klien yang menggunakan logika bisnis inti
• API aplikasi (REST) ​​yang menggunakan logika bisnis inti juga
• Ada aplikasi smartphone (iOS dan android) menggunakan API aplikasi
• Ada aplikasi tablet lain (android) yang berbeda dari smartphone yang menggunakan API aplikasi yang sama.

Segera, saya akan di produksi dengan klien aktif. Dan seperti proyek apa pun, saya harus mempertahankan semua komponen yang berbeda dari waktu ke waktu. Itu berarti semua hal berikut dapat ditingkatkan:

• kode logika bisnis inti di server (digunakan oleh back-office, API, dan sebagai efek samping, oleh aplikasi seluler)
• API itu sendiri (digunakan oleh aplikasi smartphone dan tablet)
• semua aplikasi seluler (via appstore / googleplay)

Tentu saja, bagian sisi server (kode logika bisnis inti dan kode API) dapat segera diubah sendiri. Namun, aplikasi seluler baru harus diunduh oleh klien di appstore / googleplay, dan saya tidak bisa memastikan mereka up to date.

Bisakah Anda memberikan panduan, kiat praktik yang baik, untuk membuat pembaruan tesis ini lancar dan, tidak berisiko bagi klien?

Komponen mana yang saya perlukan untuk "versi"? Bagaimana memastikan semuanya berfungsi bahkan jika klien tidak memutakhirkan aplikasi selulernya? Haruskah saya memaksanya untuk meningkatkan agar pekerjaan saya lebih mudah?

Singkatnya, bagaimana saya harus mengatur agar proyek multi-sisi saya hidup seiring waktu?

Karena Anda tidak dapat mengontrol kapan aplikasi seluler akan diperbarui ke rilis baru, Anda perlu versi setidaknya REST API Anda. Jika tidak, tidak mungkin untuk membuat perubahan yang tidak kompatibel ke belakang untuk antarmuka itu.

Selain REST API, ada baiknya untuk versi juga antarmuka komunikasi lainnya yang pergi melalui antarmuka jaringan. Dengan begitu, Anda juga tidak dipaksa untuk memutakhirkan semua klien backoffice pada saat yang sama dengan server dan Anda dapat menerapkan migrasi bertahap ke versi baru dengan periode "uji beta".

Selain memvariasikan antarmuka komunikasi, Anda juga harus berusaha membuat perubahan mundur sebanyak mungkin. Idealnya Anda dapat meluncurkan versi antarmuka baru yang masih sepenuhnya mendukung klien lama sehingga mereka tidak melihat ada yang berubah.

Posting ini membuat poin menarik tentang pertanyaan Anda.

Dengan cara yang lebih praktis, jika Anda memiliki 3 komponen:

• 2 Konsumen: Front-End dan Aplikasi Seluler
• 1 penyedia API: Back-End

Anda dapat menggunakan skema versi khas Mmp (Major.minor.patch) untuk masing-masing tetapi, pada url Back-End Anda, Anda dapat memasukkan sesuatu sebagai http://youhost/M.m/resourceURI.

Saat Anda berevolusi dan perubahan dalam API tidak memengaruhi kontrak Anda dengan konsumen yang Anda pertahankan M.msebagaimana adanya di URL. Dari saat Anda membuat perubahan di BackEnd yang mempengaruhi konsumen Anda (baik itu perubahan perilaku atau objek yang berbeda) Anda menggunakan M.m+1, M+1.m+1atau M+1.m.

Cara agar segala sesuatu tetap berjalan adalah dengan menggunakan Back-End baru bersamaan dengan yang lama, sementara pengguna Anda menginstal konsumen baru, dan perlahan-lahan menghentikan API yang lebih lama.

Anda dapat melihat jawaban yang jauh lebih baik daripada saya, di sini: Versi REST API di Stackoverflow

Saya sarankan Anda menginstal server integrasi berkesinambungan, menghubungkannya ke repositori kode Anda dan repositori snapshot / rilis dan mengotomatiskan build Anda. Ini akan memiliki sejumlah keunggulan:

1. Setiap komponen akan diversi ketika dilepaskan. Ini termasuk perpustakaan tingkat rendah serta produk akhir Anda.
2. Setiap komit kode akan memicu pembuatan snapshot. Ini membantu menjaga kejujuran pengembang Anda, terutama jika Anda menggunakan fasilitas ini untuk mengirim email kepada pelakunya yang melanggar pembangunan.
3. Setiap build dapat menjalankan tes unit. Ini sangat meningkatkan kualitas kode.
4. Setiap rilis akan ditandai, jadi jika perbaikan produksi diperlukan, mudah untuk bercabang dari tag dan melakukan perbaikan.
5. Anda perlu mempertahankan register kompatibilitas. (mis. BackOffice 1.0.23 kompatibel dengan REST API 2.0.267 dll). Saya tidak tahu alat yang akan membantu di bidang ini.

Pengalaman saya dengan alat sumber terbuka: SVN, Maven 2, Jenkins dan Nexus, tetapi ada alternatif untuk semua ini.

Jangan meremehkan waktu belajar untuk meningkatkan kecepatan tim Anda. Tetapi begitu mereka mencapai kecepatan, mereka tidak akan pernah kembali.

Untuk tim yang relatif kecil untuk pengembangan dan penyebaran, model kompatibilitas Klien N-1 seperti yang digunakan oleh IBM Jazz dapat bekerja dengan cukup baik

Cobalah untuk menjaga klien dan server di nomor versi yang sama. [Alih-alih mengelola matriks versi independen dan kompatibilitasnya]

Buat kebijakan bahwa versi klien Xyy harus bekerja dengan semua versi server di atas Xyy tetapi lebih rendah dari X + 2.0.0

Untuk server versi 4.0, idealnya harus ada versi klien 4.0 untuk setiap jenis klien. Namun, kompatibilitas harus dijaga agar memungkinkan versi klien dan server yang sedikit berbeda.

Klien versi 4.x harus kompatibel dengan server versi 4.x dan di atas tetapi di bawah 6.0; Server 4.x harus kompatibel dengan semua klien versi 3.0 dan di atasnya tetapi kurang dari atau sama dengan 4.x

Dengan cara ini Anda dapat memperbarui versi di server tanpa khawatir tentang rilis segera dari versi baru klien, tetapi hanya akan memiliki jendela kompatibilitas yang didefinisikan dengan baik untuk dipelihara.

Ref: IBM Jazz Model [ https://www.ibm.com/support/knowledgecenter/en/SSYMRC_6.0.0/com.ibm.jazz.install.doc/topics/c_n-1.html]

Pertama, saya mulai dengan membingkai masalah sedikit berbeda. Anda telah menanyakan perangkat lunak mana yang perlu Anda "versi". Versi adalah istilah kelebihan beban dalam CS, dan dapat berarti sekitar 100 hal berbeda. Hal utama yang akan saya lihat adalah:

1. Kontrol Versi - Kontrol versi adalah alat manajemen konfigurasi yang membantu Anda melacak snapshot dan riwayat pengembangan Anda. SEMUA KODE HARUS DI BAWAH KONTROL VERSI. Saya tidak peduli apakah itu hanya skrip kenyamanan yang Anda tambahkan ke folder bin Anda, apa pun yang layak menghabiskan waktu menulis bernilai dua detik untuk ditambahkan ke perangkat lunak kontrol revisi.
2. Manajemen Konfigurasi - Bagaimana cara mengontrol apa yang ada di build. Semua perangkat lunak harus memiliki tingkat manajemen konfigurasi tertentu. Saya suka menjelaskan kepada manajer perbedaan antara kontrol versi dan manajemen konfigurasi karena kontrol versi hanyalah alat untuk melacak riwayat pengembangan, sementara manajemen konfigurasi adalah pedoman untuk bagaimana kita membuat sejarah, dan bagaimana kita melakukan hal-hal seperti memutuskan kode itu bagus.
3. Versi perangkat lunak - menugaskan nama untuk rilis kode. Ini adalah hal yang banyak orang lekat ketika mereka pertama kali melihat masalah karena mereka terbiasa melihat "MineSweeper 7.1.29290149210" atau apa pun pada barang yang mereka beli, tapi jujur ​​saya menemukan ini bagian paling kecil dari masalah yang jauh lebih besar. Sejujurnya, hanya menggunakan hash yang dihasilkan oleh 1 dan tidak terlalu peduli bahwa itu tidak dapat dibaca manusia baik untuk dilakukan.

Jadi karena itu yang paling samar dan paling menarik bagi saya, saya hanya akan fokus pada # 2. Tidak ada solusi satu-ukuran-cocok untuk semua, cookie-cutter untuk manajemen konfigurasi. Aturan yang berfungsi baik untuk tim 2 atau 3 bisa jadi terlalu longgar untuk menjaga kewarasan dalam proyek yang membutuhkan ratusan pekerja. Aturan yang berlaku bagi tim besar mungkin memerlukan terlalu banyak overhead untuk tim kecil. Kemungkinan besar Anda harus membuat sesuatu sendiri untuk mengumpulkan sesuatu, tetapi saya akan menggunakan daftar berikut sebagai cara untuk mengembangkan spesifikasi untuk sistem manajemen konfigurasi Anda:

1. Bagaimana saya bisa melacak versi (dan masalah yang terkait dengannya) yang saya dukung di pasar?
2. Bagaimana saya memutuskan jalur pengembangan mana yang siap untuk dirilis ke sistem produksi? (Bisa juga siap untuk langkah lain dalam suatu proses)
3. Siapa yang seharusnya mengendalikan / mengelola konfigurasi sistem? Apa alur kerja untuk menambahkan kode untuk didistribusikan ke pengembang lain?
4. Bagaimana saya akan mengontrol interaksi antara bagian-bagian yang berinteraksi? Bagaimana saya tahu jika mengubah bagian akan merusak sisa sistem?
5. Bagaimana kami akan meningkatkan sistem manajemen konfigurasi kami dari waktu ke waktu.

Perlu bantuan menjawab pertanyaan di atas? Anda mungkin harus menyewa konsultan atau manajer rekayasa perangkat lunak ... menjawab yang dapat mengisi buku teks dan jauh dari ruang lingkup untuk jenis forum ini.