Saya memimpin tim pengembangan dan saya ingin merilis produk kami sesering mungkin (Pengiriman Berkelanjutan).
Dalam banyak kasus, kami harus mengimplementasikan fitur yang membutuhkan waktu lebih lama untuk diterapkan daripada waktu antara rilis. Saya masih ingin orang-orang melakukan kode mereka setiap hari (Integrasi Berkelanjutan).
Berkali-kali menerapkan fitur baru mengharuskan fitur yang ada diubah dan fitur yang ada, tentu saja, masih perlu bekerja, bahkan jika fitur baru belum selesai.
Jika pengembang menggunakan pendekatan yang tepat , mereka dapat menyesuaikan fitur yang ada dengan hati-hati dan semua hal di atas tidak menjadi masalah.
Namun, sebenarnya apa pendekatan yang benar? Pemikiran pemrograman saya yang selaras memberi tahu saya apa yang harus dilakukan untuk setiap kasus individu, tetapi saya perlu belajar lebih banyak dan saya memerlukan beberapa bahan bacaan yang dapat saya baca dan rujuk anggota tim untuk membaca. Atau metode lain untuk belajar cara yang benar untuk mempelajari pendekatan ini akan dilakukan.
Jadi itu pertanyaannya. Bagaimana cara memastikan anggota tim mempelajari pendekatan yang tepat untuk menerapkan setengah fitur?
Saya telah mencari orang yang mengklaim memiliki strategi mengenai hal ini, tetapi belum menemukannya, kecuali orang yang menulis beberapa pemikiran acak tentang topik ini. Mungkin saya tidak menggunakan kata-kata pencarian yang tepat atau mungkin tidak ada yang membuat panduan resmi tentang ini.
Jawaban:
Saya mengambil pandangan yang berbeda dari jawaban lain di sini sudah. Saya setuju dengan Anda bahwa Anda ingin mengintegrasikan perubahan dari pengembang sesegera mungkin, dan untuk terus menguji gabungan kode.
Namun, saya tidak setuju bahwa haknya untuk mengirim kode dikembangkan pagi ini, hanya karena kami merilis sore ini. Itu adalah resep untuk pelanggan yang kecewa.
Solusinya adalah memiliki cabang di pohon kontrol versi Anda, dan bahwa Anda memiliki proses terpisah untuk mempromosikan delta yang diverifikasi dari cabang pengembangan ke cabang rilis.
Dengan begitu Anda mendapatkan yang terbaik dari kedua dunia. Anda memiliki pengembang yang melakukan integrasi terus-menerus, dan keuntungan yang didapat, Anda memiliki pengiriman kode yang stabil secara teratur ke pelanggan, dan Anda memiliki proses baru yang menguji fitur yang telah selesai di cabang pengembang, dan jika mereka lulus pengujian menjadikannya bagian dari produk yang dirilis. .
Ada dua alat yang saya kenal yang mendukung proses semacam ini dengan baik. Jika struktur pengembangan Anda sederhana, maka git, dengan git-flow mengimplementasikan struktur percabangan yang baik yang bekerja dengan baik dalam tim kecil hingga menengah (mungkin 20 pengembang).
Untuk tim pengembangan yang lebih besar, atau di mana strategi percabangan yang lebih kompleks diperlukan untuk mendukung banyak 'putaran' produk Anda, akurasi adalah yang terbaik yang ada. Pengembang yang tidak terlibat dalam mengelola perubahan akan mengeluh bahwa ini lebih sulit daripada sub-versi dll ... tetapi hal itu mendukung lingkungan pengembangan yang kompleks.
sumber
Ada dua masalah di sini: satu menerapkan setengah fitur; yang lain adalah menjaga produk pengiriman bekerja selama pengembangan berkelanjutan.
Menerapkan setengah fitur
Desain menyeluruh yang kuat akan membantu dalam hal ini. Ini memungkinkan Anda menerapkan fitur dengan batasannya yang ditentukan dengan jelas - misalnya, API ke bit kode yang berdekatan, harapan tentang struktur data, dan pemahaman tentang bagaimana dan kapan kode yang diimplementasikan akan dipanggil.
Pengujian dapat mencakup versi kode yang dibuat-buat untuk bagian fitur lainnya; ini membantu kelancaran transisi ketika Anda menerapkan setengahnya.
Menjaga agar produk pengiriman tetap berfungsi
Ada beberapa opsi di sini:
Terakhir, jika Anda mengalami masalah dengan salah satu solusi ini, pertimbangkan apakah Anda telah membagi fitur di sepanjang batas yang benar. Jika Anda mengiris berbagai cara dengan cara yang berbeda, apakah akan lebih mudah untuk dipisahkan?
sumber
Dengan mengajar mereka. (duh)
Belajar akan melibatkan iterasi: mencoba sesuatu, melihat cara kerjanya, dan kemudian memodifikasi pendekatan mereka untuk mencapai hasil yang lebih baik. Untuk hal semacam ini, saya akan menganjurkan tinjauan desain / kode. Anda bisa melihat bagaimana fitur setengah dirancang / diimplementasikan dan memiliki kesempatan untuk memberikan umpan balik. "Ini dan itu tidak akan berhasil karena mereka akan merusak CI kita; bagaimana dengan XYZ?", "Kerja bagus di sini, itu benar-benar bersih."
Melakukan ulasan sebagai sebuah tim akan membantu semua orang mempelajari apa yang sudah Anda ketahui secara intuitif.
sumber
Hal terbesar yang akan membantu Anda di sini adalah memiliki pemisahan kekhawatiran yang baik sehingga sejauh mungkin satu area kode tidak mengganggu yang lain.
Ini adalah tempat di mana menggunakan Ketergantungan Injeksi dan pemrograman ke antarmuka sangat membantu, sehingga Anda dapat memiliki implementasi ISupportingFeature saat ini di situs dan kemudian ketika Anda perlu membuat INewFeature yang tergantung pada implementasi yang berbeda, Anda bisa mengembangkannya dengan implementasi baru dan mempertahankan yang sudah ada dalam produksi sampai diuji dengan baik dan siap untuk ditayangkan. Dengan asumsi Anda memiliki DI Anda bekerja dari sistem konfigurasi semacam ini ini akan memungkinkan Anda untuk memiliki kode yang sama secara paralel di sistem Anda dan menggunakan kode stabil setiap saat.
Sebenarnya pendekatan konfigurasi ini dijelaskan oleh Martin Fowler sebagai Feature Toggle.
Tentu saja, masalahnya hanya muncul jika Anda menggunakan semua kode sepanjang waktu. Ini persis jenis skenario yang dirancang untuk fitur cabang dan meskipun saya mengakui bahwa Pak Fowler mengerutkan dahi mereka, saya tidak tahu bahwa mereka semua seburuk itu, terutama jika mereka dibuat dan digunakan dalam rencana dan pemikiran- melalui jalan.
sumber