Kapan ketergantungan harus diperbarui?

Kami memiliki dua krisis terkait ketergantungan utama dengan dua basis kode yang berbeda (Android, dan aplikasi web Node.js). Repo Android perlu dimigrasi dari Flurry ke Firebase, yang mengharuskan memperbarui perpustakaan Google Play Services empat versi utama. Hal serupa terjadi dengan aplikasi Node kami yang dihosting Heroku di mana tumpukan produksi kami (cedar) sudah tidak digunakan lagi dan perlu ditingkatkan ke cedar-14. Basis data PostgreSQL kami juga perlu memperbarui dari 9,2 ke 9,6.

Masing-masing dari aplikasi ini dependensi duduk basi selama hampir dua tahun, dan ketika ada yang usang dan kami mencapai 'periode sunset', itu telah menjadi utama sakit kepala untuk memperbarui mereka, atau mengganti mereka. Saya telah menghabiskan lebih dari 30 jam selama satu atau dua bulan terakhir secara perlahan menyelesaikan semua konflik dan kode rusak.

Jelas membiarkan hal-hal selama dua tahun terlalu lama. Teknologi bergerak dengan cepat, terutama ketika Anda menggunakan penyedia platform seperti Heroku. Mari kita asumsikan bahwa kita memiliki rangkaian uji lengkap, dan proses CI seperti Travis CI, yang mengeluarkan banyak dugaan dari pembaruan. Misalnya jika suatu fungsi dihapus setelah peningkatan, dan Anda menggunakannya, pengujian Anda akan gagal.

Seberapa sering dependensi diperbarui, atau kapan dependensi diperbarui? Kami memperbarui karena kami terpaksa, tetapi tampaknya semacam pendekatan pre-emptive akan lebih baik. Haruskah kita memperbarui ketika versi minor dirilis? Versi utama? Setiap bulan jika pembaruan tersedia? Saya ingin menghindari situasi seperti apa yang baru saja saya alami dengan cara apa pun.

PS - untuk salah satu proyek Rails pribadi saya, saya menggunakan layanan yang disebut Gemnasium yang melacak dependensi Anda sehingga Anda dapat diberi tahu tentang misalnya kerentanan keamanan. Ini layanan hebat, tapi kami harus memeriksa dependensi untuk proyek yang saya sebutkan secara manual.

Anda biasanya harus meningkatkan dependensi ketika:

1. Itu wajib
2. Ada keuntungan untuk melakukannya
3. Tidak melakukan itu tidak menguntungkan

(Ini tidak saling eksklusif.)

Motivasi 1 ("ketika Anda harus") adalah pengemudi yang paling mendesak. Beberapa komponen atau platform tempat Anda bergantung (mis. Heroku) menuntutnya, dan Anda harus sejalan. Peningkatan yang diperlukan sering kali disebabkan oleh pilihan lain; Anda memutuskan untuk memutakhirkan ke versi PostgreSQL begitu-dan-begitu. Sekarang Anda harus memperbarui driver Anda, versi ORM Anda, dll.

Meng-upgrade karena Anda atau tim Anda merasakan keuntungan melakukan hal itu lebih lunak dan lebih opsional. Lebih dari penilaian panggilan: "Apakah fitur baru, kemampuan, kinerja, ... sepadan dengan usaha dan dislokasi membawanya akan menyebabkan?" Di Olden Times, ada bias kuat terhadap peningkatan opsional. Itu manual dan sulit, tidak ada cara yang baik untuk mencobanya di kotak pasiratau lingkungan virtual, atau untuk mengembalikan pembaruan jika itu tidak berhasil, dan tidak ada tes otomatis yang cepat untuk mengonfirmasi bahwa pembaruan tidak "mengecewakan keranjang apel." Saat ini biasnya menuju siklus pembaruan yang jauh lebih cepat dan lebih agresif. Metode lincah suka mencoba berbagai hal; Pemasang otomatis, manajer dependensi, dan repo membuat proses pemasangan cepat dan seringkali hampir tidak terlihat; lingkungan virtual dan kontrol versi di mana-mana membuat cabang, garpu, dan rollback mudah; dan pengujian otomatis mari kita coba pembaruan kemudian dengan mudah dan evaluasi substansial "Apakah itu berhasil? Apakah itu mengacaukan sesuatu?" Bias telah berubah secara grosir, dari "jika tidak rusak, jangan perbaiki" ke "pembaruan awal, sering perbarui"

Motivasi 3 adalah yang paling lembut. Cerita pengguna tidak mementingkan diri mereka sendiri dengan "pipa ledeng" dan tidak pernah menyebutkan "dan menjaga infrastruktur tidak lebih dari rilis N di belakang yang sekarang." Kerugian versi drift (kira-kira, hutang teknis yang terkait dengan jatuh di belakang kurva) merambah diam-diam, kemudian sering mengumumkan diri mereka sendiri melalui kerusakan. "Maaf, API itu tidak lagi didukung!" Bahkan dalam tim Agile mungkin sulit untuk memotivasi inkrementalisme dan "tetap di atas" kesegaran komponen ketika itu tidak dianggap penting untuk menyelesaikan sprint atau rilis yang diberikan. Jika tidak ada yang mengadvokasi pembaruan, mereka tidak dapat dikunjungi. Roda itu mungkin tidak mencicit sampai siap untuk patah, atau bahkan sampai patah.

Dari perspektif praktis, tim Anda perlu lebih memperhatikan masalah drift versi. 2 tahun terlalu lama. Tidak ada sihir. Ini hanya masalah "bayar saya sekarang atau bayar saya nanti." Baik mengatasi masalah drift versi secara bertahap, atau menderita dan kemudian mengatasi goncangan yang lebih besar setiap beberapa tahun. Saya lebih suka incrementalism, karena beberapa platform sangat besar. API atau platform utama yang Anda andalkan tidak lagi berfungsi dapat benar-benar merusak hari, minggu, atau bulan Anda. Saya suka mengevaluasi kesegaran komponen setidaknya 1-2 kali per tahun. Anda dapat menjadwalkan ulasan secara eksplisit, atau membiarkannya dipicu secara organik oleh siklus pembaruan tahunan komponen-komponen utama yang relatif metronomik, biasanya seperti Python, PostgreSQL, dan node.js. Jika pembaruan komponen tidak memicu tim Anda dengan sangat kuat, kesegaran memeriksa rilis utama, di dataran tinggi proyek alam, atau setiap rilis k juga dapat bekerja. Apa pun yang menaruh perhatian pada mengoreksi versi melayang pada irama yang lebih teratur.

Dalam kasus khusus Anda, Anda bermigrasi dari tumpukan teknologi lama ke yang baru, dan untuk melakukan itu Anda terpaksa memperbarui dependensi Anda. Saat itu adalah waktu yang tepat untuk memperbarui dependensi.

Seandainya Anda memperbarui dependensi Anda sepanjang waktu, untuk "tidak memiliki sakit kepala sekarang", Anda harus menginvestasikan banyak waktu kerja (coding) tanpa nilai pengembalian. Dan ketika Anda melakukan pembaruan terakhir (yang sedang Anda lakukan sekarang, tetapi memperbarui 1 versi utama alih-alih 4), Anda mungkin masih mengalami sakit kepala di suatu tempat (setelah semua, versi utama berarti melanggar perubahan). Jadi saya pikir Anda berada di jalan yang benar.

Namun, jika Anda merasa terlalu sulit untuk bermigrasi, dan harus melakukan banyak refactor, kemungkinan masalahnya terletak pada basis kode Anda. Ini cukup umum untuk proyek Android untuk tidak memiliki arsitektur keseluruhan dalam hal struktur kode. Kerangka kerja injeksi ketergantungan yang baik seperti Dagger 2 , dan beberapa prinsip rekayasa perangkat lunak seperti SOLID akan membuatnya lebih mudah untuk mengubah implementasi kode sambil menjaga perilaku / persyaratan yang sama.

Juga, karena kita sedang melakukan refactoring, baca sedikit tentang Unit Testing, karena itu akan banyak membantu ketika melakukan pekerjaan semacam ini.

Jika Anda menggunakan alat manajemen paket (mis. Npm, NuGet) dan memiliki rangkaian uji otomatis yang komprehensif, maka peningkatan dependensi harus menjadi kegiatan yang mudah dilakukan, cukup perbarui paket, jalankan rangkaian uji, dan lihat apakah ada masalah. Jika ada maka kembalikan dan angkat item kerja untuk menyelidiki dan memperbaiki masalah tersebut.

Selama biaya peningkatan dependensi rendah nilainya tetap diperbarui:

• Jika ada masalah dengan peningkatan yang ingin Anda ketahui lebih cepat daripada nanti jika diperlukan perubahan ke atas.
• Meninggalkan peningkatan ketergantungan ke menit terakhir sering kali berarti Anda melakukan peningkatan tersebut pada saat krisis (misalnya sebagai tanggapan terhadap bug penting keamanan). Tetap berada di atas dependensi Anda berarti Anda mengendalikan kapan Anda menghabiskan upaya itu dan dapat melakukan peningkatan tersebut pada saat Anda tidak sibuk.
• Versi yang lebih baru mungkin memiliki peningkatan produktivitas, misalnya dokumentasi yang lebih baik, API yang lebih mudah digunakan, perbaikan bug (walaupun sebaliknya juga dimungkinkan).

Jika memutakhirkan dependensi bukanlah upaya yang rendah (mis. Karena Anda perlu menguji pembaruan secara manual atau karena ada masalah / perubahan yang diketahui) maka Anda harus mempertimbangkan pro dan kontra terhadap tugas-tugas Anda yang lain. Ketergantungan lama adalah sejenis utang teknis berbunga rendah, dan karenanya harus diperlakukan sesuai.

Anda seharusnya tidak melakukan rilis di mana Anda secara sadar menggunakan versi lama dari dependensi Anda, kecuali jika versi tersebut adalah alternatif yang didukung.

yaitu Jika Anda menggunakan V1 dan masih didukung, Anda masih dapat menggunakan versi terbaru dari v1.

Satu-satunya waktu Anda harus kedaluwarsa adalah jika:

A: Anda belum melakukan rilis dalam beberapa waktu.

B: Anda telah menggunakan v1 begitu lama sehingga tidak lagi didukung

Pembaruan dirilis karena suatu alasan, pembaruan itu berisi perbaikan keamanan yang harus Anda ikuti.

Jika versi baru ketergantungan Anda keluar, Anda juga harus melakukan rilis

Saya pikir itu harus tergantung pada perpustakaan yang bersangkutan sampai batas tertentu, tetapi saya memiliki sakit kepala ketergantungan yang sama.

Akal sehat mengatakan kepada saya bahwa versi utama mungkin adalah waktu yang tepat untuk memutakhirkan, dan versi kecil yang mengatasi kesalahan serius, atau menyertakan manfaat yang signifikan akan menggantikan itu.

Kadang-kadang kami tidak memiliki kemewahan untuk mengerjakan setiap aplikasi yang membutuhkan pemeliharaan, atau bahkan tidak mempekerjakan misi yang kritis, tetapi mereka akan menggigit Anda pada akhirnya dan satu ons pencegahan sering kali mengalahkan satu pon penyembuhan!

Perpustakaan harus diperbarui ketika menawarkan keuntungan yang akan digunakan oleh perangkat lunak Anda yang mengkompensasi pekerjaan yang dihabiskan dalam perubahan.

Bahkan pemutakhiran versi pustaka kecil dapat memecah atau menyisipkan inkonsistensi dalam aplikasi. Dari perspektif itu tidak ada perubahan kecil.

Tidak ada rasa malu dalam menggunakan lib lama. Ketika perubahan diperlukan mungkin menyakitkan tetapi itu adalah bagian dari pekerjaan.