Kategorikan tugas / bug menurut risiko perubahan

Proyek yang sedang saya kerjakan memiliki masalah: bug dan tugas sering diberikan kepada orang-orang yang terlalu baru atau terlalu berpengalaman dan pekerjaan mereka akhirnya menghasilkan lebih banyak bug di ujung jalan. Masalahnya adalah bagian dari perangkat lunak kami jauh lebih "berbahaya" untuk bekerja daripada yang lain karena masalah kualitas kode. Saya telah mencoba untuk mengatasi masalah ini dengan memperkirakan risiko yang terkait dengan tugas dan memperhatikan dengan cermat pengembang mana yang ditugaskan tugas mana.

Kami menggunakan JIRA jadi saya mulai memberi label masalah untuk melacak estimasi ini. Saya perhatikan bahwa saya akhirnya menggunakan beberapa metrik untuk mengkategorikan bug / tugas:

• Seberapa jelas / lugas itu. Misalnya apakah itu sesuatu yang akan membutuhkan banyak pekerjaan desain atau hanya perbaikan bug UI sederhana.
• Seberapa terpelihara area kode yang terpengaruh. Apakah itu area yang dirancang dengan baik atau bola lumpur yang besar.
• Seberapa banyak program yang saya pikir akan dipengaruhi oleh perubahan yang diperlukan.

Label saya agak berantakan karena saya tidak memiliki ide yang jelas ketika saya mulai apa kategori yang mungkin dan saya masih tidak. Saya sedang berpikir tentang meminta bidang baru ditambahkan (sesuatu seperti "Risiko") sehingga kami dapat memerlukan perkiraan sebelum menugaskan pekerjaan kepada seseorang.

Adakah yang pernah menangani hal semacam ini sebelumnya?

Salah satu kegagalan dari sebagian besar pendekatan pelacakan bug adalah mereka hanya berurusan dengan satu sisi persamaan - pandangan pengguna akhir dari sistem. Ini adalah bug penting untuk diperbaiki agar bisa menunggu seminggu (prioritas), bug ini menyakitkan untuk ini adalah skesalahan pluralisasi (keparahan).

Sebuah posting blog yang menggambarkan pelacakan bug multidimensi membahas cara mengatasi ini termasuk tampilan pengembang: PEF dan REV.

Nilai PEF adalah pandangan pengguna:

• P ‍ain - seberapa menyakitkan bug ketika ditemui?
• E FFort - berapa banyak usaha yang dibutuhkan untuk bekerja di sekitar?
• F requency - seberapa sering bug terjadi?

Sisi REV dari pandangan pengembang:

• R ‍isk - seberapa berisiko perbaikannya?
• E ‍ffort - berapa banyak upaya yang diperlukan untuk memperbaikinya?
• V ‍dapat diverifikasi - seberapa mudahnya memverifikasi bahwa bug telah diperbaiki?

Masing-masing diukur pada skala 1..9 dengan 1 rendah / mudah dan 9 tinggi / keras. Angka-angka ditambahkan bersama untuk memberikan skor untuk PEF dan REV.

Bagian yang membahas bit yang dijelaskan:

• Seberapa jelas / lugas itu. Misalnya apakah itu sesuatu yang akan membutuhkan banyak pekerjaan desain atau hanya perbaikan bug UI sederhana.
• Seberapa terpelihara area kode yang terpengaruh. Apakah itu area yang dirancang dengan baik atau bola lumpur yang besar.
• Seberapa banyak program yang saya pikir akan dipengaruhi oleh perubahan yang diperlukan.

Faktor-faktor ini menjadi upaya dan risiko yang dijelaskan dalam REV.

Ya, itu adalah sesuatu yang telah diperjuangkan sebelumnya. Saya telah (dulu) menggunakan model ini untuk bidang khusus di Redmine dan itu cukup berhasil.

Keuntungan besar ini muncul ketika Anda membandingkan skor PEF dan REV. Jika Anda memiliki PEF 21 dan REV 7, itu adalah sesuatu yang bisa menjadi kemenangan besar. Sementara PEF 7 dan REV 21 adalah sesuatu yang harus dihindari untuk sementara waktu karena risiko dan upaya cenderung lebih besar daripada manfaat memperbaikinya.

Satu kemudian dapat melihat skor REV dan menetapkan hal-hal dengan Risiko rendah untuk pengembang yang kurang berpengalaman (risiko rendah, usaha tinggi sering ideal untuk situasi ini).

Saya akan mengatakan bahwa apa yang Anda maksudkan di sini bisa lebih baik disebut 'kompleksitas'. Tentu saja, perubahan yang lebih kompleks adalah semakin tinggi 'risikonya' adalah bahwa beberapa bug baru dapat diperkenalkan oleh programmer yang tidak berpengalaman. Bukan ide yang buruk untuk memperkenalkan bidang seperti itu jika itu adalah masalah nyata.

Namun, menilai dari apa yang Anda tulis, Anda tampaknya memiliki dua masalah:

1. Anda berhadapan dengan programmer baru atau tidak berpengalaman.
2. Kualitas (banyak / beberapa) kode Anda tampaknya dipertanyakan.

Selain memperkenalkan sesuatu seperti bidang 'kompleksitas' (yang akan membantu mengelola dan memprioritaskan pekerjaan Anda), saya sarankan Anda fokus mengurangi risiko dua masalah di atas.

Untuk mengatasi masalah pertama, saya akan membuat proses di mana programmer baru terlebih dahulu mendiskusikan semua bug baru dengan programmer yang lebih berpengalaman sebelum mengerjakan bug. Juga, saya pasti akan memperkenalkan ulasan kode untuk menurunkan risiko bug baru yang diperkenalkan dan digunakan sebagai kesempatan pelatihan bagi programmer baru untuk mempercepat lebih cepat.

Sehubungan dengan kualitas kode, saya akan melakukan dua hal. Pertama, hentikan proses pembusukan: sepakati standar pengkodean dan praktik yang akan mencegah kode inferior baru diperkenalkan. Ulasan kode yang disarankan akan membantu di sini juga. Kedua, saya akan mengidentifikasi bagian terburuk dari kode Anda dan mulai refactoring dan membersihkannya.

Ya, itu ide yang baik untuk tidak memberikan masalah pengembang yang terlalu kompleks. Tetapi flipside adalah bahwa jika Anda hanya membiarkan mereka melakukan hal-hal mudah maka mereka tidak akan belajar.

Saya menyarankan strategi alternatif adalah melembagakan rezim tinjauan kode. Biarkan para pemula bekerja mengerjakan hal-hal rumit (sesuai alasan), tetapi tinjau pekerjaan mereka secara menyeluruh.

Dalam jangka pendek, ini lebih banyak pekerjaan untuk semua orang. Dalam jangka panjang, Anda akan berakhir dengan seluruh tim pengembang yang dapat menangani hal-hal rumit, DAN "berada di halaman yang sama" sejauh menyangkut kualitas kode.