Bagaimana cara memperbarui perpustakaan pihak ketiga Anda?

Katakanlah saya memiliki proyek yang bergantung pada 10 perpustakaan, dan di dalam bagasi proyek saya, saya bebas menggunakan versi perpustakaan mana pun. Jadi saya mulai dengan versi terbaru. Kemudian, masing-masing perpustakaan mendapat pembaruan sebulan sekali (rata-rata). Sekarang, menjaga trunk saya sepenuhnya terbarui akan membutuhkan memperbarui referensi perpustakaan setiap tiga hari.

Ini jelas terlalu banyak. Meskipun biasanya versi 1.2.3 adalah pengganti drop-in untuk versi 1.2.2, Anda tidak pernah tahu tanpa pengujian. Tes unit tidak cukup; jika itu adalah mesin DB / file, Anda harus memastikan bahwa itu berfungsi dengan baik dengan file yang dibuat dengan versi yang lebih lama, dan mungkin sebaliknya. Jika ada hubungannya dengan GUI, Anda harus memeriksa semuanya secara visual. Dan seterusnya.

bagaimana kamu menangani ini? Beberapa pendekatan yang mungkin:

• Jika tidak rusak, jangan memperbaikinya . Tetap menggunakan versi perpustakaan Anda saat ini selama Anda tidak melihat ada yang salah dengan itu ketika digunakan dalam aplikasi Anda, tidak peduli seberapa sering vendor perpustakaan menerbitkan pembaruan. Perubahan kecil tambahan hanyalah pemborosan.
• Perbarui sering untuk menjaga perubahan kecil. Karena Anda harus memperbarui suatu hari dalam keadaan apa pun, lebih baik perbarui sesering mungkin sehingga Anda melihat ada masalah sejak dini ketika masalah itu mudah diperbaiki, daripada melompati beberapa versi dan membiarkan potensi masalah menumpuk.
• Sesuatu di antaranya. Apakah ada sweet spot?

Saya terkejut - dan benar-benar terkejut - pada sejumlah jawaban di sini yang mengatakan "jangan perbarui kecuali Anda harus". Saya sudah melakukan itu, dan sementara itu lebih mudah dalam jangka pendek, dalam jangka panjang membakar seperti neraka. Lebih sering, pembaruan yang lebih kecil jauh, lebih mudah untuk dikelola daripada yang besar sesekali, dan Anda mendapatkan manfaat dari fitur-fitur baru, perbaikan bug, dan sebagainya lebih cepat.

Saya tidak membeli gagasan bahwa perubahan pustaka entah bagaimana lebih sulit untuk diuji daripada perubahan kode. Itu sama saja - Anda membuat perubahan pada basis kode, dan Anda perlu memvalidasinya sebelum Anda berkomitmen, dan lebih dalam sebelum Anda merilis. Tetapi Anda harus sudah memiliki proses untuk melakukan ini, karena Anda membuat perubahan kode!

Jika Anda bekerja dalam iterasi, dari dua hingga empat minggu lamanya, saya akan menyarankan membuat memperbarui perpustakaan sekali per iterasi tugas, yang harus dilakukan sesegera mungkin setelah awal, ketika hal-hal sedikit lebih santai daripada sebelum iterasi tenggat waktu, dan proyek memiliki lebih banyak kapasitas untuk menyerap perubahan. Dapatkan seseorang (atau pasangan jika Anda melakukan pemrograman berpasangan) untuk duduk, lihat perpustakaan mana yang telah diperbarui, dan coba bawa masing-masing dan jalankan pembangunan kembali dan uji. Anggaran setengah hari hingga sehari untuk setiap iterasi, mungkin. Jika semuanya berfungsi, periksa perubahannya (saya berasumsi Anda menyimpan pustaka di kontrol sumber, seperti yang kita lakukan; saya tidak yakin bagaimana Anda akan menyebarkan perubahan dengan cara yang terkendali jika tidak). Ini jelas akan jauh lebih mudah jika Anda memiliki tes otomatis daripada jika pengujian sepenuhnya manual.

Sekarang, pertanyaannya adalah apa yang Anda lakukan jika pembaruan merusak - apakah Anda menghabiskan waktu memperbaikinya, atau mengabaikannya? Saya sarankan condong ke arah yang terakhir; jika dapat diperbaiki dalam satu jam, lakukanlah, tetapi jika pembaruan akan mengambil pekerjaan yang signifikan untuk diintegrasikan, kemudian tingkatkan sebagai tugas pengembangannya sendiri, untuk diperkirakan, diprioritaskan, dan dijadwalkan seperti yang lainnya. Kemungkinannya adalah kecuali itu membawa perbaikan atau peningkatan yang sangat penting, prioritasnya akan rendah, dan Anda tidak akan pernah bisa melakukannya. Tapi Anda tidak pernah tahu, pada saat putaran iterasi berikutnya memperbarui putaran hari, masalahnya mungkin telah diperbaiki sendiri; bahkan jika tidak, setidaknya sekarang Anda tahu bahwa ada hambatan di jalur pembaruan, dan itu tidak akan mengejutkan Anda.

Jika Anda tidak melakukan iterasi sejauh itu, saya akan mengatur semacam jadwal mandiri untuk pembaruan - tidak lebih dari bulanan. Apakah ada ritme proyek lain yang dapat Anda ikat, seperti ulasan status bulanan, atau rapat dewan arsitektur? Hari bayaran? Pizza malam? Bulan purnama? Apa pun, Anda perlu menemukan sesuatu yang jauh lebih pendek daripada siklus rilis tradisional, karena mencoba memperbarui semuanya dalam sekali jalan setiap 6-18 bulan akan terasa menyakitkan dan melemahkan semangat.

Tidak perlu dikatakan, jika Anda melakukan cabang stabilisasi sebelum rilis, Anda tidak akan menerapkan kebijakan ini kepada mereka. Di sana, Anda hanya akan memperbarui perpustakaan untuk mendapatkan perbaikan kritis.

Saya mengevaluasi.

• Pertama-tama saya mencari bug yang kami buat terhadap perpustakaan itu dan melihat apakah mereka sudah diperbaiki.
• Kedua saya mencari perbaikan bug lain di lib yang bisa kita manfaatkan (mungkin sesuatu yang mungkin terjadi di sudut jalan).
• Ketiga saya mencari perbaikan di lib / API dan kemudian menyelidiki dampak dari mengubah kode kami untuk memanfaatkan itu dan tradeoff benfit. Saya sudah terlalu sering meng-upgrade lib sebelumnya tanpa benar-benar memanfaatkan fitur baru mereka, sungguh konyol!

Saya kemudian menimbang semua itu terhadap tetap dengan lib yang ada.

Selalu uji - semoga tes unit / integrasi Anda akan memastikan bahwa tidak ada regresi besar yang terjadi.

Masalah utama dengan perpustakaan pihak ketiga, adalah bahwa Anda perlu menguji ulang aplikasi ANDA ketika Anda memperbaruinya, sebelum dapat diproduksi. Jadi, kecuali jika Anda memiliki bug yang dilaporkan, yang mengharuskan memperbarui perpustakaan, Anda tidak menyentuh mereka sampai Anda punya waktu untuk melakukan siklus penjaminan kualitas yang lengkap.

Ini biasanya dilakukan ketika merilis versi baru.

Namun, saya menyarankan agar Anda memiliki rangkaian uji untuk membangun berkelanjutan yang memungkinkan Anda memperbarui perpustakaan di cabang pengembangan dan melakukannya secara otomatis. Ini akan memastikan bahwa Anda menemukan lebih awal ketika rusak, sehingga Anda dapat mengajukan laporan bug ke proyek.

Sebagian, seperti yang dijelaskan dalam cabang vendor svn . Prosedur yang dijelaskan di sana sangat berguna, ketika Anda terus menggunakan pustaka pihak ketiga sumber terbuka untuk waktu yang lama, dan telah membuat perubahan untuk menyesuaikannya dengan kebutuhan Anda.

Saya akan berpikir tentang memperbarui semua perpustakaan proyek tepat sebelum atau setelah rilis. Namun ini bisa keluar dari tangan jika Anda mengandalkan lebih dari 10 atau 15 perpustakaan, dalam hal ini semacam mekanisme pemeriksaan pembaruan akan sangat membantu. Keuntungan dari ini adalah bahwa Anda memiliki waktu yang didedikasikan untuk menguji perpustakaan Anda dan dapat memperbaiki masalah apa pun dalam satu pass. Anda juga tidak harus terus melacak pembaruan dari setiap perpustakaan, Anda cukup memeriksa pada hari tertentu untuk setiap pembaruan.

Saya juga akan menentang segala jenis fitur pembaruan otomatis di cabang dev. Akan membuat frustasi jika di tengah-tengah saya mengerjakan sesuatu proyek rusak karena perpustakaan otomatis memperbarui sendiri, atau saya tiba-tiba mendapat peringatan Depresiasi untuk menggunakan API yang baru saja digantikan oleh sesuatu yang lain.

Anda harus bertanya, apa yang sebenarnya Anda inginkan dari pembaruan? Kebanyakan perbaikan keamanan sebenarnya adalah tambalan sepele, dalam bentuk perbaikan:

• Dinonaktifkan oleh satu kesalahan di mana kode arbitrer dapat disalin ke ruang yang tidak digunakan dalam buffer
• Pointer yang menggantung, atau hal lain yang memicu perilaku deterministik yang tidak ditentukan tetapi (lebih tepatnya)
• Bug yang mengizinkan beberapa jenis DoS
• Bug yang secara tidak sengaja membuat pengintaian data pribadi menjadi mudah
• Kesalahan matematika
• Maintainers menyentuh hal-hal yang seharusnya tidak mereka lakukan (Bug SSL Debian, siapa pun?)

Jika Anda melihat sebagian besar CVE dalam lima tahun terakhir, tambalan yang memperbaikinya biasanya cukup sepele, jika Anda menggunakan perpustakaan terbuka, yang saya harap demikian.

Kemudian Anda memiliki perbaikan bug yang sebenarnya, yang mungkin Anda inginkan, tetapi mungkin Anda sudah memperbaikinya sendiri. Jika tidak rusak, jangan memperbaikinya.

Akhirnya, Anda memiliki fitur baru .. dan mungkin fitur yang sudah usang. Anda perlu memeriksa catatan rilis dan perbedaan dengan hati-hati. Bisakah Anda menggunakannya, bahkan jika mereka merusak API yang bergantung pada banyak hal lain? Jika ya, sekarang saatnya untuk operasi .. jika tidak, ceri pilih yang Anda inginkan dan lanjutkan.

Beberapa mungkin tidak setuju dengan saya, tetapi saya menolak untuk menggunakan perpustakaan tanpa kode sumber.

Ini bervariasi tergantung hal-hal seperti pada perpustakaan, untuk apa mereka digunakan, seberapa meresapnya mereka dalam kode Anda, biaya (dalam hal waktu dan uang) untuk melakukan upgrade, dan sebagainya.

Idealnya Anda akan selalu memiliki yang terbaru setiap saat, tetapi jika versi yang baru tidak kompatibel, lalu bagaimana? Anda mungkin harus menangguhkan pembaruan tersebut untuk rilis di masa mendatang hingga Anda dapat menangani perubahan dengan hati-hati. Mungkin ada beberapa perubahan perilaku yang halus (seperti "Anda sekarang perlu mengatur properti X sebelum memanggil metode Y, atau Anda mendapatkan kebocoran memori lambat") yang sulit untuk diverifikasi dalam pengujian.

Di sisi lain, versi baru bisa memiliki beberapa perbaikan keamanan yang serius, jadi Anda harus memperhitungkannya juga.

Versi singkat: bawa berdasarkan kasus per kasus.

Ini akan tergantung pada jadwal rilis Anda.

Tetapi saran saya adalah menginstal satu set perpustakaan di semua mesin pengembang. Anggap itu standar emas jika Anda ingin menyebutnya sesuatu, maka mulailah pengembangan Anda untuk rilis itu.

Hanya sekali rilis telah digunakan dan Anda berada dalam fase pasca rilis, menilai kembali perpustakaan Anda, versi dan fiturnya. Jika mereka menawarkan beberapa peningkatan signifikan atau fungsionalitas baru maka instal kemudian sebelum dimulainya siklus pengembangan berikutnya.

Instal hanya versi baru jika ada masalah besar atau bug yang harus diperbaiki sebelum menggunakan perangkat lunak.

Ini berarti Anda akan kehilangan beberapa versi tetapi itu akan menghemat beberapa sakit kepala dan masalah versi yang memungkinkan Anda berkonsentrasi pada pengembangan aplikasi Anda.

Eksternal Subversi

Apa yang hebat dalam fitur itu adalah Anda dapat menentukan revisi yang Anda inginkan.

Harap dicatat bahwa pembaruan akan lebih lambat jika Anda memiliki banyak eksternal.

Saat ini saya sedang menyiapkan sesuatu seperti itu:

• 1 repo lincah untuk setiap ekstensi aplikasi saya
• repo lincah yang mengumpulkan versi spesifik dari beberapa perpustakaan pihak ke-3
• repo SVN untuk sumber daya grafis / karya (tetapi mungkin berubah menjadi sesuatu yang lain)
• repo mercurial untuk aplikasi saya, yang menggunakan fitur subrepos mercurial untuk menggunakan versi spesifik dari repo pary ke-3, dan beberapa ekstensi dasar

Sekarang ketika saya perlu bekerja pada ekstensi yang tidak "dasar" (secara implisit dimasukkan sebagai subrepo dalam aplikasi repo), saya cukup mendapatkan klon repo di folder ekstensi dan membiarkan CMake menghasilkan proyek dan solusi untuk seluruh aplikasi.

Dengan begitu, saya bisa:

• ubah pihak ke-3 dalam klon, periksa apakah berfungsi dengan aplikasi, dorong di repo pary ke-3, lalu perbarui versi subrepo dari aplikasi repo ke versi repo pihak ke-3 yang baru
• bekerja pada ekstensi secara mandiri, semua berkumpul atau hanya memilih yang spesifik
• tidak perlu khawatir harus menautkan proyek bersama, ini dilakukan oleh Cmake hanya dengan meminta sub-proyek dipindai dengan seluruh aplikasi repo.

Belum memiliki banyak pengalaman dengan organisasi ini, tetapi saya pikir itu cukup berguna.

Jika perangkat lunak Anda kritis terhadap keamanan, Anda harus memperbarui sesegera mungkin, tanpa alasan. Anda tidak ingin sedikit bug di perpustakaan grafis membuat seluruh program Anda rentan.

Kalau tidak, ketika lib matang, itu "Jika tidak rusak, jangan memperbaikinya." untuk saya. Cepat atau lambat, saya mungkin memerlukan fitur versi yang lebih baru dan tidak punya pilihan selain memperbarui, tetapi sampai saat itu, upaya tersebut sulit untuk dibenarkan. Di sisi lain, ketika saya bekerja dengan lib atau kerangka kerja yang relatif baru, seperti Grails atau ExtJS, saya tetap up-to-date dengan versi terbaru karena produk-produk ini belum terasa benar-benar matang, sehingga memperbarui kemungkinan akan menyelamatkan saya dari menjalankan ke salah satu bug yang diperbaiki versi selanjutnya.

Saya menggunakan NuGet untuk memperbarui perpustakaan pihak ketiga saya.

Ketika seorang teman, rekan kerja, atau blog memberi tahu saya bahwa salah satu DLL pihak ketiga saya kedaluwarsa, NuGet membuatnya sangat mudah untuk memperbaruinya.