Bagaimana Anda mengatasi perubahan dalam kerangka sumber terbuka yang Anda gunakan untuk proyek Anda?

Ini mungkin merupakan kekhasan pribadi saya, tetapi saya suka menjaga kode dalam proyek-proyek yang hidup mutakhir - termasuk perpustakaan / kerangka kerja yang mereka gunakan. Sebagian darinya adalah saya percaya aplikasi web lebih aman jika sepenuhnya ditambal dan mutakhir. Sebagian darinya hanyalah sentuhan keterpaksaan obsesif di pihak saya.

Selama tujuh bulan terakhir, kami telah melakukan penulisan ulang utama perangkat lunak kami. Kami menjatuhkan kerangka kerja Xaraya, yang lambat dan pada dasarnya mati sebagai produk, dan dikonversi ke Cake PHP. (Kami memilih Cake karena memberi kami peluang untuk melakukan penulisan ulang perangkat lunak kami dengan sangat cepat, dan cukup banyak peningkatan kinerja atas Xaraya untuk menjadikannya layak untuk sementara kami.)

Kami menerapkan pengujian unit dengan SimpleTest, dan mengikuti semua konvensi penamaan file dan database, dll.

Kue sekarang sedang diperbarui ke 2.0. Dan, sepertinya tidak ada jalur migrasi yang layak untuk peningkatan. Konvensi penamaan untuk file telah berubah secara radikal, dan mereka menjatuhkan SimpleTest untuk PHPUnit.

Ini cukup banyak akan memaksa kita untuk tetap di cabang 1,3 karena, kecuali ada semacam alat konversi, itu tidak akan mungkin untuk memperbarui Kue dan kemudian secara bertahap meningkatkan kode warisan kami untuk menuai manfaat dari kerangka kerja Kue baru . Jadi, seperti biasa, kita akan berakhir dengan kerangka kerja lama di repositori Subversion kami dan hanya menambalnya sendiri sesuai kebutuhan.

Dan inilah yang membuat saya setiap saat. Begitu banyak produk open source tidak membuatnya cukup mudah untuk menjaga proyek berdasarkan mereka up to date. Ketika para pengembang mulai bermain dengan mainan mengkilap baru, beberapa tambalan penting akan dilakukan untuk cabang yang lebih tua, tetapi sebagian besar fokus mereka akan berada di basis kode baru.

Bagaimana Anda menghadapi perubahan radikal dalam proyek sumber terbuka yang Anda gunakan? Dan, jika Anda mengembangkan produk sumber terbuka, apakah Anda tetap mengingat jalur peningkatan ketika Anda mengembangkan versi baru?

Masalahnya bukan unik untuk open source. Masalah yang sama terjadi pada proyek komersial. Mungkin lebih dari itu karena Anda tidak memiliki sumber, Anda dapat mempertahankan diri jika perusahaan kehilangan dukungan.

Proyek open source tipe pengguna akhir memiliki siklus peningkatan yang cepat dan versi lama kehilangan dukungan dengan sangat cepat. Di sisi lain, proyek-proyek yang dirancang untuk pengguna untuk menempatkan upaya pengkodean yang signifikan di atas cenderung memiliki siklus dukungan lama dari cabang lama setelah peningkatan besar. Cukup lama bagi Anda untuk mengambil waktu pertama Anda menunggu untuk stabil dan matang, kemudian bermigrasi dan secara menyeluruh menguji kode Anda sendiri.

Mungkin sulit menahan godaan untuk memiliki yang terbaru dan terhebat, tetapi sadari ada tradeoff mendasar dalam perangkat lunak antara stabilitas dan fitur baru. Anda tidak dapat memiliki satu tanpa mengorbankan yang lain. Karena itulah ada cabang perbaikan bug, sehingga Anda dapat memilih sisi spektrum mana yang paling sesuai dengan kebutuhan Anda.

Kami telah mengatasi masalah ini dengan memodulasi kode kami.

Situs web utama kami dibangun sekitar delapan tahun yang lalu, dan kami cukup beruntung untuk dibangun oleh salah satu kontributor awal untuk Kerangka Kerja Spring sehingga merupakan fondasi yang cukup bagus. Tapi sayangnya kami juga kurang beruntung sehingga pengembang ini memutuskan untuk membayar Spring setelah ada argumen tentang arah yang dituju, jadi basis kode ini sekarang terjebak pada garpu yang tidak terawat pada Spring 1.1.4 (atau sesuatu yang vintage).

Kami mencoba menulis ulang kode untuk pindah ke versi baru Spring, tetapi itu terbukti sangat sulit. Jadi solusi kami adalah mulai membangun fitur baru dari situs sebagai modul dalam aplikasi yang sepenuhnya terpisah, menggunakan kerangka kerja terbaru seperti Spring 3.x, Hibernate 3.6, dll.

Sekarang kami memiliki dua aplikasi web yang berjalan di URL dasar yang sama, dan kami menggunakan modul mod_proxy Apache untuk mengalokasikan setiap jalur ke aplikasi yang sesuai. Misalnya, "/ anggota" pergi ke aplikasi lama dan "/ direktori" pergi ke aplikasi baru. Namun pengunjung ke situs tidak akan tahu bahwa mereka menggunakan aplikasi yang berbeda; mereka terlihat persis sama dengan pengguna.

Dua aplikasi perlu berkomunikasi, misalnya ketika seorang anggota login ke situs (menggunakan aplikasi baru kami), kami perlu memberi tahu aplikasi lama yang sedang mereka masuki. Kami melakukan ini menggunakan layanan web sederhana, hanya terpapar pada localhost. Jumlah integrasi yang dibutuhkan antara kedua aplikasi ternyata minimal.

Bagian penting dari membuat pekerjaan ini adalah untuk mengidentifikasi dan mengemas bersama aset bersama. Jadi semua teks statis, grafik, stylesheet, Javascript, dan templat dipindahkan dari aplikasi asli ke proyek ketiga - terpisah yang digunakan aplikasi baru dan lama. Ini memastikan bahwa kedua aplikasi web terlihat dan bertindak dengan cara yang sama meskipun keduanya terpisah.

Saya membayangkan bahwa seiring waktu kita akan mengganti lebih banyak dan lebih banyak dari aplikasi asli sampai akhirnya benar-benar tidak diperlukan. Hal yang menyenangkan tentang teknik ini adalah kita dapat melakukannya secara perlahan melalui serangkaian perubahan kecil yang berisiko rendah - tidak perlu untuk pergantian mendadak besar-besaran dan berisiko ke sistem baru.

Saya tidak selalu melakukannya. Banyak proyek sumber terbuka memiliki cabang pemeliharaan aktif dipelihara untuk rilis utama sebelumnya. Terkadang itu dikelola oleh orang-orang yang membutuhkan versi itu untuk dipertahankan. Banyak proyek tetap pada rilis besar sampai mereka sendiri siap untuk rilis besar.

Dan inilah yang membuat saya setiap saat.

Setiap saat? Anda harus membuat pilihan yang sangat buruk. Pasti ada satu contoh di mana itu tidak terjadi.

Ketika para devs mulai bermain dengan mainan mengkilap baru

Itu sebuah petunjuk. Hindari mainan baru yang mengilap saat menggunakan proyek sumber terbuka. Hindari rilis 1.0.

Bagaimana Anda menghadapi perubahan radikal dalam proyek sumber terbuka yang Anda gunakan?

Langkah 1. Pilih proyek open source dengan sangat, sangat hati-hati. Selalu bandingkan dua atau lebih proyek yang bersaing.

Langkah 2. Ketika membandingkan dua proyek yang bersaing, cobalah untuk memahami fitur "esensial" yang ditawarkan dan bagaimana mereka berdua mendekatinya. Hindari "mengawini" satu API tertentu terlalu dini.

Langkah 3. Rangkullah prinsip-prinsip desain "Late Binding" dan "Loose Coupling". Cobalah untuk melindungi dari perubahan proyek sumber terbuka.

Langkah 4. Buat perbandingan biaya / manfaat secara eksplisit antara proyek sumber terbuka dan "gulirkan proyek Anda sendiri". Sekali-sekali, menciptakan solusi Anda sendiri mungkin lebih baik daripada mengatasi dengan solusi open source.

Mengubah nama file seharusnya tidak terlalu sulit. Ya, itu skrip besar dan jelek. Ya, itu harus dijalankan selama beberapa minggu saat melakukan konversi. Tapi itu biaya yang terbatas.

Jika jika terjadi setiap waktu, maka kembangkan strategi koping yang lebih baik. Karena pengamatan Anda tentang dunia nyata adalah bahwa hal itu akan selalu terjadi, maka berharap dunia nyata untuk berubah tidak akan banyak membantu. Anda memiliki pengalaman yang sulit dimenangkan dalam perubahan. Manfaatkan itu. Anggap itu seperti infeksi dan kembangkan respons imun Anda sendiri.