Apa cara terbaik untuk membagi pekerjaan di antara pengembang

Tim saya dan saya sedang membangun kembali situs yang kami kembangkan sekitar sepuluh tahun yang lalu, dan kami ingin melakukannya di Agile.

Jadi setelah saya menghabiskan banyak waktu membaca (mungkin tidak cukup) saya mengalami masalah dengan pertanyaan bagaimana membagi kerja antara pengembang.

Saya akan lebih spesifik dan mengatakan bahwa situs tersebut dibagi ke modul terpisah yang tidak memiliki banyak integrasi antara satu sama lain.

Apa cara terbaik / Paling diterima untuk membagi pekerjaan antara pengembang?

• Memberi setiap orang modul yang berbeda untuk dikerjakan.
• Tetapkan semua pengembang ke modul yang sama, dan pisahkan pekerjaan dengan berbagai bagian modul (UnitTesting, DAL dan Pemetaan, Logika, UI)
• Tetapkan semua pengembang ke modul yang sama, dan pisahkan pekerjaan dengan logika yang berbeda (Misalnya setiap pengembang bertanggung jawab atas logika tertentu (mungkin metode di BL) dan Ini UnitTesting, DAL dan Pemetaan dan UI ...

Atau mungkin sesuatu yang sama sekali berbeda?

Tim saya telah berusaha untuk menjadi "gesit" untuk beberapa rilis sekarang, tetapi menjadi bagian dari perusahaan besar tidak membuatnya mudah. Saya tidak akan berpura-pura memiliki jawabannya, tetapi saya bisa membagikan beberapa pengamatan saya.

• Membagi pengembang per modul:

  • Anda perlu berhati-hati karena jika orang terlalu banyak bekerja dalam isolasi, tim Anda tidak mendapat manfaat dari saling berbagi keterampilan dan pengetahuan
  • Merencanakan pertemuan dan stand up harian bisa menjadi sangat membosankan bagi semua orang jika orang terlalu fokus pada modul mereka sendiri dan tidak melihat gambaran yang lebih besar. Setelah orang bosan, mereka mulai memeriksa dan Anda kehilangan banyak manfaat tangkas dibawa ke meja
  • Anda mungkin berakhir dengan beberapa komponen yang ditulis dengan sangat baik, dan komponen lainnya, well ... tidak begitu banyak. Jika orang-orang bekerja dalam isolasi, orang-orang senior Anda tidak akan bisa melatih yang junior.

• Semua orang bekerja pada modul yang sama pada saat yang sama

  • Kami mencoba itu untuk satu rilis, ketika manajemen memutuskan mereka akan memaksakan tangkas pada seluruh tim dan itu akan menjadi cara mereka sepenuhnya. Ini sebagai kecelakaan kereta mutlak. Kami memiliki tim yang terdiri dari 9 pengembang dalam setahun apa yang biasanya dilakukan oleh 1 pengembang. (Saya mungkin melebih-lebihkan di sini tetapi tidak banyak).
  • Tidak ada yang merasa seperti ada ruang bernapas. Mereka yang tidak peduli dengan perangkat lunak, merasa betah karena menjadi bagian dari paket yang lebih besar, mereka hanya terdilusi dalam kelompok. Kita yang memiliki hasrat untuk perangkat lunak, merasa benar-benar tertahan karena tidak ada kebebasan untuk bergerak atau pergi ke luar batas yang disetujui oleh 9 orang.
  • Semua pertemuan berlangsung selamanya sampai pada titik saya ingin menembak diri sendiri. Terlalu banyak orang dengan pendapat di ruangan yang sama dipaksa untuk bekerja pada DLL freakin yang sama. Menyeramkan.
• Dalam rilis terakhir, kami telah memutuskan untuk mencoba sesuatu yang berbeda
  • Pertama dan terpenting, pecah grup pengembangan menjadi tim yang lebih kecil dengan 3-4 pengembang. Setiap tim bekerja dalam isolasi relatif satu sama lain tetapi dalam tim orang bekerja jauh lebih kompak
  • Dengan pendekatan ini, stand up cepat dan rapat perencanaan memakan waktu 1-2 jam dibandingkan dengan padat 4 jam.
  • Semua orang merasa terlibat karena masing-masing tim hanya membahas apa yang dipedulikan pengembang di tim itu.
  • Pimpinan teknologi dari masing-masing tim berbicara dengan pimpinan teknologi lainnya secara berkala untuk memastikan keseluruhan proyek berada di jalurnya.
  • Alih-alih menjadikan orang "pemilik" modul tertentu, kami menugaskan bidang keahlian kepada orang, jadi ketika kami pertama kali memulai proyek, rasanya seperti orang memiliki modul sendiri, tetapi setelah beberapa bulan, pengembang akan mulai melihat satu sama lain kode sebagai daerah mulai tumpang tindih.
  • Ulasan kode sangat penting. Ini adalah rilis kedua di mana kami memiliki kebijakan peninjauan kode yang ketat dan semua orang di tim menyukainya. Pakar bidang tertentu selalu pada ulasan kode ketika orang lain memodifikasi kode itu.
  • Dengan ulasan kode, kami memiliki banyak berbagi pengetahuan dan Anda dapat melihat peningkatan keseluruhan kualitas kode tim kami. Juga karena kode sering ditinjau, ketika orang pergi ke bidang keahlian orang lain, kemungkinan mereka telah melihat kode setidaknya beberapa kali.
  • Porsi yang lebih besar dari masing-masing tim dihisap ke dalam pertemuan tinjauan desain, jadi meskipun mereka belum pernah melihat kode, semua orang akrab dengan aliran umum semua modul yang menjadi tanggung jawab tim mereka.
  • Kami telah melakukan ini selama sekitar 10 bulan dan rasanya seperti kami mulai dengan pendekatan modul terisolasi dan berubah menjadi semua orang bekerja dalam segala hal. Tetapi pada saat yang sama, tidak ada yang merasa mereka sempit atau terbatas. Dan untuk memastikan orang-orang masih memiliki rasa otoritas, kami meninggalkan mereka sebagai ahli bidang, meskipun itu sebagian besar formalitas sekarang.

Kami telah melakukan hal terakhir itu, dan meskipun ada banyak ruang untuk perbaikan, secara keseluruhan seluruh tim kami sangat bahagia dan itu sangat berarti, ketika kami adalah bagian dari perusahaan raksasa.

Satu hal penting yang kami salah 3 kali pertama kami "gesit", adalah masing-masing kali orang-orang diberitahu bagaimana bekerja dan mereka diberitahu apa yang harus dilakukan. Itu adalah cara nomor satu untuk membuat tim Anda benar-benar kehilangan minat terhadap proyek dan kemudian Anda berada dalam masalah besar.

Sebaliknya, coba yang sebaliknya. Beri tahu tim, mereka dapat melakukan apa pun yang mereka inginkan dan sebagai manajer / pemimpin (jika Anda adalah satu, jika tidak membuat manajer Anda mengulangi kata-kata ini), tugas Anda adalah memastikan mereka produktif dan bahagia sebisa mungkin. Proses bukanlah hal yang buruk, tetapi proses harus ada di sana untuk membantu tim Anda ketika menyadari dibutuhkannya, bukan sebaliknya.

Jika beberapa anggota tim Anda lebih suka bekerja sendirian, biarkan mereka (sampai taraf tertentu). Jika mereka lebih suka bekerja berpasangan, biarkan mereka melakukannya. Pastikan untuk membiarkan orang-orang Anda memilih pekerjaan mereka sebanyak yang Anda bisa.

Terakhir, dan ini sangat penting dan selalu diabaikan. ANDA TIDAK AKAN MENDAPAT HAK INI (kecuali jika Anda superman, atau setidaknya batman) Memiliki pertemuan retrospektif secara teratur sangat penting. Ketika kami meluncurkan retrospektif, semuanya dilakukan oleh buku dan rasanya seperti proses lain yang harus Anda lalui. Bukan itu tujuan retrospektif. Ini untuk mendengarkan tim Anda, mengidentifikasi area yang paling menyakitkan dan memperbaikinya sehingga semua orang dapat melanjutkan pekerjaan mereka. Rupanya insinyur perangkat lunak pada umumnya seperti memberikan produk dan fitur dan pertemuan retrospektif pesan terpenting yang perlu dikomunikasikan, adalah semata-mata untuk keuntungan mereka. Anda ingin mengidentifikasi dan mengatasi hambatan, mulai dari yang terbesar (atau yang paling mudah, ada '

Lakukan pertemuan dengan tim, tunjukkan pada mereka daftar yang harus dilakukan, dan tanyakan siapa yang ingin melakukan apa.

Jangan berpikir dalam modul. Pikirkan dalam elemen fungsionalitas. Jelaskan elemen fungsionalitas tersebut berdasarkan kisah pengguna (atau cara lain) dan jangan lupa untuk menggambarkan kriteria penerimaan (mungkin ditentukan oleh aplikasi Anda saat ini dan mengubah harapan bisnis). Masukkan elemen fungsional Anda ke dalam jaminan simpanan. Kemudian biarkan bisnis memprioritaskan fungsionalitas mana yang harus dikirim terlebih dahulu (Anda akan bekerja secara bertahap dan berulang dan prioritas akan memberi tahu Anda apa yang harus diterapkan terlebih dahulu).

Setelah Anda memiliki ini setidaknya untuk bagian dari aplikasi asli Anda, Anda siap untuk pengembangan. Apa yang terjadi selanjutnya tergantung pada metodologi tangkas yang Anda pilih. Bagian yang penting adalah bahwa setiap fungsi biasanya dapat dibagi menjadi beberapa tugas dan anggota tim akan memilih tugas apa yang ingin mereka lakukan - yang disebut pengaturan mandiri. Ketika Anda mulai dengan gesit, pengorganisasian diri sendiri mungkin memerlukan bantuan di mana seseorang akan memastikan bahwa tugas yang tidak populer dan populer dibagi secara merata oleh tim. Setelah tim lebih matang, pengembang tidak akan ragu untuk berbicara tentang ketidaksetujuan mereka dengan organisasi mandiri saat ini dan ini akan ditangani secara otomatis di dalam tim.

Berpikir dalam modul dari awal tidak harus menjadi cara yang baik. Anda menulis ulang aplikasi untuk beberapa alasan dan mungkin arsitektur aplikasi saat ini berdasarkan pemisahan modul yang salah adalah salah satu alasan tersembunyi di balik masalah yang terlihat. Anda juga dapat menemukan bahwa beberapa fungsionalitas dari modul yang ada akan sepenuhnya didefinisikan ulang dan dipindahkan ke tempat lain.

Meskipun saya setuju dengan jawaban David, saya merasa itu bisa mendapat manfaat dari beberapa perincian:

• Agile artinya, Anda tidak membuat keputusan ini dan mendorongnya ke dalam tim. Tidak ada manajer / pemimpin proyek seperti itu. Hanya tim.
• Orang yang paling tahu, bagaimana membagi pekerjaan adalah anggota tim itu sendiri.
• Diskusikan backlog Anda, dan cari tahu apa yang ingin Anda sadari pada iterasi / sprint berikutnya.
• Gunakan poker perencanaan atau metode serupa untuk mendapatkan gambaran tentang berapa banyak pekerjaan yang akan Anda bagi, dan baru kemudian mulai membagi paket kerja yang sebenarnya menjadi satu .

Pada dasarnya, intinya adalah: Tidak ada seorang pun di sini di SE yang bisa menjawab pertanyaan itu untuk Anda, juga tidak ada gunanya, karena jauh lebih baik jika Anda datang dengan jawaban sebagai sebuah tim.

Pendekatan paling sederhana seringkali merupakan yang terbaik.

Saya akan menghindari membagi tugas menjadi kelompok-kelompok seperti pengujian / log / UI / dll kecuali Anda dapat mendefinisikan beberapa alasan yang sangat bagus dan jelas untuk melakukannya. Alasan saya adalah bahwa ketika Anda membiarkan programmer untuk bekerja di luar bidang keahlian mereka yang biasa, itu dapat membuat hal-hal lebih menarik dan menantang bagi mereka, dan memungkinkan mereka untuk berkembang dan tumbuh dalam bidang mereka. Jika Anda merasa bahwa batasan waktu mengharuskan Anda untuk membagi pekerjaan berdasarkan keahlian, paling tidak memastikan bahwa setiap pengembang masih diharuskan untuk melakukan pengujian unit mereka sendiri, dan menggunakan tinjauan kode dan pengujian penerimaan untuk mengambil masalah. Menulis tes Anda sendiri sangat gesit, dan menunggu waktu penguji untuk menjadi tersedia bisa sangat boros.

Ketika dihadapkan dengan dilema yang sama, saya telah menggunakan pendekatan berikut:

• Cakupan proyek. Beri diri Anda ide tentang apa yang Anda hadapi, dan kembangkan daftar fitur dengan memecah proyek menjadi serangkaian tugas.

• Prioritaskan Fitur. Putuskan fitur mana yang harus diselesaikan lebih awal, dan mana yang akan memberikan nilai langsung kepada pelanggan Anda. Jangan khawatir jika pengembang Anda akhirnya bekerja pada modul yang sama, tetapi pastikan Anda memiliki proses dan alat yang baik untuk mengelola penggabungan kode.

• Libatkan tim Anda, dan minta pengembang Anda untuk membantu Anda memecah fitur menjadi daftar tugas yang lebih mudah dikelola. Tinjau sebagai kelompok dan sesuaikan tugas sesuai kebutuhan sehingga dapat lebih mudah diperkirakan.

• Minta setiap pengembang untuk memilih tugas untuk diimplementasikan - atau sekelompok tugas tergantung pada bagaimana iterasi Anda akan dijalankan - dari bagian atas antrian prioritas, yang ingin dikerjakan oleh pengembang.

• Mintalah setiap pengembang mengerjakan hanya satu hal sampai selesai sebelum melanjutkan untuk memilih item berikutnya dari bagian atas antrian prioritas. Anda mungkin tergoda untuk membuat orang-orang Anda berganti tugas sesekali, namun ini akan menyebabkan pemborosan dalam hal waktu pengembang. Jika Anda menemukan diri Anda dengan hambatan kemacetan, Anda harus menyesuaikan prioritas tugas Anda dan meminimalkan pemborosan.

• Jangan takut ada pengembang yang menjalankan iterasi yang tumpang tindih, dan kelola rilis Anda sesuai dengan itu. Ini akan membantu meminimalkan waktu yang terbuang di antara rilis yang menunggu tugas diselesaikan.

Pada akhirnya, menjadi Agile adalah tentang menemukan solusi yang bekerja dengan baik untuk tim Anda, perusahaan Anda, dan pelanggan Anda. Terserah Anda untuk menyelaraskan proses Anda dengan menemukan keseimbangan praktik yang paling sesuai untuk Anda. Bagaimana membagi tugas Anda akan menjadi bagian yang sangat penting dari proses yang jauh lebih besar, tetapi harus dibuat sesederhana yang Anda bisa untuk mendorong partisipasi yang bersedia, dan untuk menghindari kesulitan untuk menyelesaikan proses terkait masalah yang berkembang di kemudian hari.

Tidak ada diskusi organisasi tim pengembang yang akan lengkap tanpa menyebut Tim Bedah Dr. Fred Brooks .

Rumus dasarnya adalah: satu Tim Bedah per Unit Kerja

Mendefinisikan Tim Bedah

Konsep tim bedah didasarkan pada dua ide mendasar:

1. Lebih sedikit pengembang yang lebih baik per unit kerja karena cross-talk membunuh produktivitas.
2. Pengembang berkinerja tinggi jauh lebih baik daripada pengembang berkinerja rendah (dan menurut Brooks, tidak ada yang disebut pengembang keluaran-menengah), jadi Anda sebaiknya memberi mereka pekerjaan yang paling penting untuk dilakukan, dan membatasi gangguan mereka.

Tim bedah terdiri dari 3-10 pengembang:

1. Seorang programmer kepala. Pengembang output tinggi, yang melakukan sebagian besar pemrograman aktual.
2. Pilot pendamping. Pengembang output tinggi lainnya, yang melakukan beberapa pemrograman, tetapi juga beberapa tugas administratif, seperti menghadiri pertemuan dan mengumpulkan persyaratan.
3. 1 - 8 asisten. Brooks menggambarkan ini sebagai pengembang yang bertanggung jawab untuk hal-hal seperti dokumentasi, pembersihan kode, penelitian, alat tulis / algoritme, pengujian, dll. Kembali ke tahun 60an, Brooks mengusulkan 8 peran dengan tepat, tetapi dengan alat modern Anda mungkin hanya membutuhkan 1 atau 2, dan mungkin harus ditugaskan berdasarkan kebutuhan proyek Anda.

Mendefinisikan Satuan Kerja

Jadi sekarang kita bisa membentuk satu tim, apa yang kita tugaskan kepada mereka?

• Jika proyeknya sangat kecil , ini mudah. Anda menugaskan satu tim bedah untuk seluruh proyek.
• Jika tidak, maka Anda harus mulai dengan orang atau tim yang bertanggung jawab atas arsitektur seluruh proyek . Merupakan tugas mereka untuk memodulasi perangkat lunak secara tepat sehingga pekerjaan dapat dibagi di antara sub-tim tambahan. Tim arsitektur juga dapat mengerjakan pekerjaan lain, agar tidak menyebarkan pengembang terlalu tipis.

Anda akan melihat tiga pola dasar yang dapat diterima muncul:

1. Tepatnya 1 sub-tim untuk setiap lapisan (UI, DAL, dll)
2. Tepat 1 sub-tim untuk setiap modul (Halaman Utama, Situs Dukungan, Toko)
3. Gabungan keduanya (tim kerangka kerja tingkat rendah, dan tim yang berfokus UI untuk setiap modul)

Bergantung pada jumlah pengembang dan modul (dan rentang waktu) saya biasanya membuat pengembang saya memilih satu modul yang menarik (untuk mereka) dan satu modul yang menantang (lebih disukai sesuatu yang belum pernah mereka lakukan) dan kemudian sisanya saya bagi berdasarkan tingkat keterampilan dan kendala waktu. Saya menemukan ini memberi pengembang saya sesuatu yang ingin mereka kerjakan dan sesuatu untuk mendorong mereka.

Tentu saja ini tidak selalu berhasil ...

Inilah yang akan saya lakukan:

Jika semua modul kecil, maka Anda dapat memberikan masing-masing modul untuk dikerjakan. Kalau tidak, lakukan ini:

1. Tentukan setiap ukuran modul, kompleksitas, keterampilan yang diperlukan untuk melakukannya.
2. Tentukan setiap keterampilan anggota tim.
3. Tentukan orang mana yang bekerja sama dengan baik dan mana yang tidak bekerja dengan orang lain dengan baik.
4. Tetapkan modul besar untuk tim orang yang bekerja bersama dengan baik berdasarkan persyaratan keterampilan modul dan keterampilan tim.
5. Tetapkan modul yang tersisa untuk orang yang tidak dapat bekerja dengan baik dengan orang lain berdasarkan persyaratan keterampilan modul dan keterampilan tim.

Hal di atas tidak akan berfungsi jika orang yang tidak suka bekerja dengan orang lain adalah yang paling mahir dan ini adalah kasus umum, jadi buat pengecualian untuk 4 dan 5 sesuai