Kepemilikan kode dengan beberapa tim Scrum

Jika dua tim Scrum menggunakan komponen perangkat lunak yang sama, siapa yang bertanggung jawab untuk menyediakan visi arsitektur yang jelas dari komponen itu dan mempertahankan / mengembangkan visi ini ketika basis kode berkembang? Di Scrum Anda seharusnya memiliki kepemilikan kode kolektif, jadi bagaimana memastikan pengembangan yang dilakukan oleh Tim A tidak mengganggu pengembangan yang dilakukan oleh Tim B?

Saya bukan ahli Scrum, tetapi AFAIK "kepemilikan kode kolektif" dimaksudkan untuk menjadi per tim dan per produk (dan saya pikir pertanyaan Anda tidak spesifik untuk Scrum, itu dapat diterapkan pada proses pengembangan "kode bersama" apa pun).

Jika Anda memiliki dua tim A, B, dua produk A, B dan komponen C bersama, ada beberapa skenario yang memungkinkan. Mungkin komponen bersama terutama dimiliki oleh produk A (dan hanya digunakan kembali, tetapi tidak dikembangkan, oleh tim untuk produk B). Dalam situasi ini tim A jelas bertanggung jawab atas visi arsitektur. Atau sebaliknya: itu jelas milik produk B - jadi tanggung jawab ada di sana. Jika tim A bertanggung jawab, tim B mungkin menggunakan garpu komponen untuk memungkinkan perbaikan bug yang mendesak (harus juga ada cara untuk mengintegrasikannya ke dalam jalur utama C), tetapi B harus menghindari melakukan pengembangan komponen yang lebih besar.

Namun, jika kedua produk A dan B memiliki banyak "persyaratan mengemudi" untuk C, Anda harus mengelola C sebagai produk yang sepenuhnya terpisah, dengan versi sendiri, manajemen rilis, manajemen perubahan, tes unit dll, dan tim terpisah yang memiliki tanggung jawab untuk komponen itu. Tim itu bisa jadi hanya "tim virtual", yang terdiri dari pengembang terpisah dari tim A, B, atau keduanya. Tim ini memiliki "kepemilikan kode bersama" untuk C, dan tanggung jawab untuk "visi arsitektur". Bayangkan C beeing komponen yang dikirimkan oleh vendor pihak ketiga.

Tidak ada konsep "visi arsitektur yang jelas" di Scrum atau gesit!

Saya telah lama menjadi arsitek, dan jelas bagi saya bahwa untuk memiliki visi arsitektur, seseorang harus memiliki pandangan yang jelas tentang persyaratan di masa depan. Karena dalam kebanyakan kasus persyaratannya tidak jelas sama sekali, tidak masuk akal untuk memiliki visi yang tetap.

Yang diperlukan adalah memiliki arsitektur yang cukup mudah beradaptasi dengan persyaratan yang berubah. Dengan kata lain, banyak hal berubah, dan arsitektur berubah - saya tidak menganjurkan arsitektur "lunak" yang dapat dikonfigurasi ulang. Saya berbicara tentang menerima bahwa arsitektur yang dimiliki saat ini akan segera usang dan perlu diubah, jadi tidak ada yang harus "menikah" dengannya.

Kepemilikan kode kolektif berarti bahwa setiap orang harus - secara teori - dapat mengubah apa pun. Ini harus dipahami sebagai "kebalikan dari silo". Dengan kata lain, mungkin ada penghalang keterampilan di tempat, yang normal dan diharapkan - tidak semua orang adalah DBA berpengalaman yang dapat menyempurnakan pertanyaan SQL, untuk memberikan contoh - tetapi dari sini tidak mengikuti bahwa hanya DBA yang dapat tangan mengoptimalkan permintaan. Akan ada "pakar domain fitur" yang dapat membantu orang lain menjadi mahir, tetapi tugasnya tetap harus ditanggung semua orang.

Sebagai contoh: jika saya adalah pakar domain pada fitur "A", maka saya masih mengharapkan orang lain melakukan pekerjaan pada fitur "A", tetapi saya kemungkinan akan dikonsultasikan ketika perubahan besar perlu terjadi atau orang membutuhkan bantuan. Fitur "A" tentu bukan fitur saya . Ini akan menjadi fitur yang saya ketahui dengan baik. Adalah minat saya untuk mengetahui lebih banyak fitur, dan minat orang lain untuk mengetahui fitur ini.

Dalam sintesis: arsitektur dirancang dan dirancang ulang beberapa kali oleh pengembang saat persyaratan muncul dan berubah. Setiap orang diharapkan untuk membuat perubahan yang diperlukan sesuai dengan keahlian mereka, dan tahu kapan harus meminta bantuan. Tidak ada visi jangka panjang pada arsitektur karena kami mempercayai orang-orang dan kami tidak mempercayai persyaratan .

Misalnya, spotify menggunakan peran bernama "Pemilik Sistem" untuk menyelesaikan masalah, langsung dari dokumen:

Secara teknis, siapa pun diperbolehkan mengedit sistem apa pun. Karena regu adalah tim fitur yang efektif, mereka biasanya perlu memperbarui beberapa sistem untuk mendapatkan fitur baru ke dalam produksi. Risiko dengan model ini adalah bahwa arsitektur suatu sistem akan kacau jika tidak ada yang berfokus pada integritas sistem secara keseluruhan.

Untuk mengurangi risiko ini, kami memiliki peran yang disebut "Pemilik Sistem". Semua sistem memiliki pemilik sistem, atau sepasang pemilik sistem (kami menganjurkan pemasangan). Untuk sistem kritis operasional, Pemilik Sistem adalah pasangan Dev-Ops - yaitu, satu orang dengan perspektif pengembang dan satu orang dengan perspektif operasi.

Pemilik sistem adalah orang “pergi” ke (s) untuk setiap masalah teknis atau arsitektur yang terkait dengan sistem itu. Dia adalah koordinator dan membimbing orang yang membuat kode dalam sistem itu untuk memastikan bahwa mereka tidak tersandung satu sama lain. Ia berfokus pada hal-hal seperti kualitas, dokumentasi, utang teknis, stabilitas, skalabilitas, dan proses pelepasan.

Pemilik Sistem bukanlah arsitek bottleneck atau menara gading. Dia tidak secara pribadi harus membuat semua keputusan, atau menulis semua kode, atau melakukan semua rilis. Dia biasanya anggota regu atau pemimpin bab yang memiliki tanggung jawab sehari-hari selain kepemilikan sistem. Namun, dari waktu ke waktu ia akan mengambil "hari sistem pemilik" dan melakukan pekerjaan rumah tangga pada sistem itu. Biasanya kami mencoba untuk menjaga kepemilikan sistem ini kurang dari sepersepuluh dari waktu seseorang, tetapi tentu saja ini sangat bervariasi antar sistem.

Saya sangat menyukai ide ini, memiliki manfaat atau kepemilikan kode kolektif di tingkat perusahaan (tidak hanya di tingkat tim) tetapi dengan pemilik sistem ini berusaha untuk memastikan integritas arsitektur.

Tautan ke dokumen lengkap: https://dl.dropboxusercontent.com/u/1018963/Articles/SpotifyScaling.pdf , dokumen pendek namun sangat, sangat menarik berdasarkan pengalaman nyata tentang penskalaan tangkas.

Ini masalah yang sulit dipecahkan, dan tentu saja tidak diselesaikan oleh Scrum, yang merupakan metodologi manajemen proyek, bukan metodologi pengembangan.

Solusi paling efektif yang saya temukan adalah manajemen paket yang baik (nuget / gem / etc) dan versi. Jangan pernah memaksakan perubahan pada tim lain sampai mereka siap untuk mengkonsumsinya. Biarkan mereka tetap menggunakan build lama, sementara Anda pindah ke yang baru.

Pastikan Anda memiliki strategi pembuatan versi yang menjelaskan perubahan mana yang dipecah dan ekstensi mana.

Juga, saat Anda melakukan perubahan, dorong ulasan kode ke seseorang DI SETIAP TIM. Biarkan mereka melihat bagaimana hal itu mempengaruhi mereka, jauh sebelum mereka dipaksa untuk mengkonsumsinya sehingga mereka dapat menerapkan perubahan mereka sendiri di atas.

Dan, ketika segalanya menjadi sangat berantakan; ketika satu tim perlu membuat perubahan dan tidak dapat menggunakan perubahan lain dengan mudah (ini HARUS kasus yang sangat langka), cabang kode, buat paket yang sama sekali berbeda, tetapi menjadikannya prioritas untuk kembali ke kode umum segera setelah waktu memungkinkan.

Jawaban yang tidak selalu sejelas mungkin adalah membiarkan tim memutuskan bagaimana mereka akan membagikan komponen yang diberikan.

Misalnya, tim saya baru-baru ini mulai mengembangkan lini produk baru yang memiliki banyak kesamaan kode dengan dua tim lain yang telah mengembangkan produk serupa sejak lama. Produk kami berbeda dalam beberapa hal, jadi kami kadang-kadang harus mencari cara untuk menambahkan poin penyesuaian ke kode umum.

Kami memiliki beberapa bentrokan tentang kode itu, dan mencoba beberapa cara ad hoc berbeda untuk berurusan dengan kepemilikan bersama. Kemudian dengan fitur baru yang besar muncul, kami memutuskan bahwa kami perlu mengumpulkan semua tim untuk mendapatkan halaman yang sama, yang menghasilkan kelompok yang lebih kecil yang terdiri dari beberapa anggota dari setiap tim yang sedang mengerjakan perinciannya.

Solusi yang dihasilkan oleh tim kami mungkin tidak berfungsi dalam situasi lain. Anda mungkin memerlukan sesuatu yang lebih sederhana, atau sesuatu yang jauh lebih formal. Intinya adalah, Anda mengambil kepemilikan kolektif dan mencari tahu apa yang cocok untuk Anda.

Saya akan mengambil kebebasan untuk berasumsi:

• tes penerimaan otomatis
• komponen menggunakan prinsip-prinsip OOP yang baik: Kopling Rendah dan Kohesi Tinggi.

Jika asumsi di atas benar maka seharusnya hanya ada saat-saat ketika dua tim akan saling mengganggu. Mereka dapat menyelesaikannya menggunakan cara berikut:

• Segera setelah tes penerimaan dari tim lain gagal, bicarakan dengan mereka untuk memahami apakah penggunaan mereka atas komponen bersama itu benar atau milik Anda. Jika kedua penggunaan baik-baik saja maka lihat apakah bagian umum dari penggunaan itu didorong ke atas (dire-reforasi) ke komponen dasar umum dan varians dalam penggunaan dikelola menggunakan kelas anak atau mungkin melalui komposisi.
• Buat satu orang bertanggung jawab atas komponen ketika sedang dalam pengembangan aktif. Dia harus bertindak sebagai sumber daya bersama antara tim.