Bagaimana menentukan prioritas dan tingkat keparahan “peningkatan kode”?

15

Kami memiliki bidang "prioritas" dan "keparahan" di sistem pelacakan bug kami. Kami mendefinisikan tingkat keparahan sebagai "bagaimana hal itu berdampak pada pengguna" dan prioritas sebagai "bagaimana hal itu berdampak pada produk".

Pertanyaan saya adalah tentang bagaimana mengkategorikan tugas "perbaikan kode" dalam tingkat keparahan dan prioritas. Misalkan peningkatan tidak mengubah perilaku apa pun tetapi menjadikannya "kode yang lebih baik". Kami mengantisipasi peningkatan pemeliharaan jangka panjang secara keseluruhan tetapi sulit untuk diukur.

Ketika kami menggunakan definisi kami untuk prioritas dan tingkat keparahan, peningkatan kode mendapatkan nilai terendah untuk keduanya kecuali Anda memperkenalkan beberapa sulit untuk memprediksi manfaat jangka panjang ke dalam gambar. Oleh karena itu itu menyiratkan bahwa perbaikan kode adalah tugas sembrono dan tidak boleh dicoba.

Namun saya percaya sangat jahat untuk terus memperbaiki dan memperbaiki kode, karena:

  • Pengembangan perangkat lunak itu sendiri merupakan proses pembelajaran yang berkelanjutan dan tanpa meningkatkan kode Anda tidak bisa menjadi lebih baik.
  • Sebuah tim harus bangga dengan kode mereka.
  • Pemeliharaan di masa depan akan memakan waktu lebih sedikit dan penghematan jangka panjang akan signifikan.

Atau apakah menurut Anda tugas seperti itu seharusnya tidak pernah dibuat dan perbaikan seperti itu hanya dilakukan "sesuai permintaan", "ketika dikaitkan dengan bug"? Bahkan jika itu terkait dengan bug, bukankah itu akan menjadi titik diskusi pada tinjauan kode, misalnya "mengapa Anda melakukan perubahan struktur yang drastis ini?".

Sedat Kapanoglu
sumber

Jawaban:

16

Biasanya saya tidak suka melihat kegiatan "peningkatan kode" sebagai tugas yang dapat ditugaskan terpisah karena peningkatan kode itu sendiri tidak pernah secara langsung membawa Anda lebih dekat untuk menyelesaikan cerita atau persyaratan pengguna. Inilah sebabnya mengapa tugas peningkatan kode akan selalu menjadi prioritas rendah sehingga mereka tidak pernah ditugaskan.

Saya melihat peningkatan kode sebagai konstanta, sesuatu yang harus dilakukan setiap pengembang secara alami seperti mengetik pada keyboard. Saya memasukkannya ke dalam perkiraan saya untuk tugas apa pun. Jika tugas saya melibatkan saya menyentuh kelas atau beberapa kode sumber yang belum lama dilihat, maka saya akan berasumsi bahwa beberapa pekerjaan kebersihan mungkin dilakukan dan menambah perkiraan saya.

Skenario kasus terbaik Saya menyelesaikan tugas lebih awal dan dapat menggunakan waktu yang tersisa untuk memperbaiki kode atau bahkan mendesain. Skenario kasus terburuk, tugas ini membutuhkan waktu lebih lama dari yang diharapkan, tetapi saya memiliki waktu ekstra sebagai penyangga.

maple_shaft
sumber
4
+1, segera setelah Anda melihat peningkatan kode sebagai tugas dengan sendirinya, Anda berakhir dengan kode jelek, karena itu selalu prioritas rendah. Hanya saja, jangan menganggap tugas lain selesai selama kualitas kode tidak cukup baik menurut standar perusahaan. Melakukan tinjauan kode adalah wajib di sini.
deadalnix
1
@deadalnix Poin luar biasa tentang ulasan kode. Jika dilakukan sejak awal maka kualitas kode secara teoritis dipertahankan secara default. Dengan memelihara aplikasi lawas meskipun hal ini tidak selalu terjadi dan perbaikan kode harus diatasi saat Anda pergi.
maple_shaft
2
Dengan kode lawas, cara terbaik adalah membungkusnya dalam antarmuka yang bersih untuk tidak menyebarkan omong kosong ke seluruh basis kode. Lalu, unittesting masif pembungkusnya, jadi kami yakin kami bisa mengandalkannya, dan akhirnya menyentuh kode lawas jika diperlukan tanpa menutup seluruh proyek.
deadalnix
1
+1 Khusus untuk "Jika tugas saya melibatkan saya menyentuh kelas atau beberapa kode sumber yang belum lama dilihat". Anda hanya perlu meningkatkan kode yang perlu diubah. Jika tidak perlu segera diubah, biarkan saja.
MarkJ
1
Untuk proyek dan tim besar terutama, masih masuk akal untuk menjaga perbaikan kode sebagai tugas yang terpisah - hanya sejauh ini satu pengembang dapat pergi sambil bekerja pada fitur baru. Biasanya saya akan memesan 2-3 minggu setahun bagi tim saya untuk menerapkan peningkatan dan refactoring (dalam praktiknya, ternyata lebih lama, karena, biasanya, hanya sebagian dari tim yang dapat offline kapan saja)
blueberryfields
2

Jika Anda ingin memperbaiki kode Anda, tetapkan prioritas tugas sesuai dengan definisi Anda (yaitu "bagaimana hal itu berdampak pada produk"). Beberapa refactoring tidak akan banyak mempengaruhi produk dan beberapa akan, tergantung pada ruang lingkup pekerjaan yang diperlukan. Menetapkan prioritas yang lebih tinggi akan menunjukkan bahwa lebih banyak pengujian perlu dilakukan setelah refactoring selesai untuk memastikan tidak ada yang tak terduga terjadi.

Anda mungkin juga ingin memperkenalkan kategori baru dalam sistem pelacakan bug Anda untuk mengkategorikan jenis tugas ini sebagai tugas "Refactoring". Dengan cara ini Anda akan tahu bagaimana menafsirkan nilai prioritas; yaitu, prioritas yang lebih tinggi berarti dampak yang lebih besar dan oleh karena itu diperlukan lebih banyak pengujian.

Bernard
sumber
2
Untuk menambah itu, hutang teknis (karena kurangnya refactoring) memang berdampak pada produk, karena menjadi lebih sulit untuk mempertahankan dan memperkenalkan lebih banyak kemungkinan bug. Setelah produk terpengaruh, pengguna terkena dampak ... Di tim kami, kami memiliki tugas "Peningkatan" yang kami gunakan untuk refactoring, dan perbaikan proses / alat
Atif
2

Yang hilang adalah memverifikasi asumsi Anda tentang kode yang ada: lebih sedikit waktu dan penghematan yang signifikan dapat dicapai jika kami memperbaiki kode. Apakah ini kosmetik atau ada masalah serius?

Periksa perkiraan debugging dan peningkatan Anda. Jika mereka membutuhkan waktu lebih lama dan ada komentar terus menerus tentang harus memperbaiki kode terlebih dahulu atau membersihkannya, itu mungkin merupakan pengukuran terbaik Anda. Kemudian Anda dapat mengidentifikasi basis kode Anda sebagai: Baik, perlu pengerjaan ulang kecil atau refactoring serius diperlukan.

Semua ini bersifat relatif. Sulit untuk memberikan prioritas tinggi ini ketika ada pelanggan yang menginginkan lebih banyak fitur dan bersedia membayar segera untuk jam yang dapat ditagih.

JeffO
sumber
1

Pertanyaan menarik.

Saya pikir Anda harus memperkirakan berapa baris kode dan berapa banyak modul yang mungkin mempengaruhi perubahan.

Mungkin Anda bisa melihat berapa banyak unit test, jika Anda memilikinya, akan rusak dengan melakukan perubahan. Ini mungkin berarti mencoba mengubah cabang terlebih dahulu untuk mendapatkan ide.

Kemudian miliki ambang batas untuk tingkat dan keparahan tingkat pencocokan ini.

Anda juga harus mempertimbangkan memiliki banyak pengujian tester yang perlu dilibatkan. Jika perubahan menyentuh area permukaan aplikasi yang luas, maka banyak pengujian sistem mungkin perlu ditinjau kembali.

ozz
sumber
1

Mari kita mulai dengan dua asumsi di sini.

  1. Untuk setiap cerita baru, Anda menulis kode sesuai kemampuan Anda, mungkin ditopang dengan pengetahuan ambient dari tim Anda.
  2. Setiap kali Anda memiliki cerita yang mengubah fungsionalitas kode yang ada, Anda menggunakan pengetahuan baru Anda tentang sistem dan keterampilan yang lebih baik untuk meningkatkan kode dalam proses penerapan cerita baru.

Mengingat kedua asumsi itu, tidak pernah ada kebutuhan untuk upaya "peningkatan kode" yang eksplisit. Kode Anda meningkat saat Anda menulis sistem. Ini berarti bahwa tidak semua kode memenuhi standar terbaru dan terhebat untuk pemeliharaan, tetapi "Jika tidak rusak jangan diperbaiki." Saya menganggap kode refactoring yang tidak perlu diubah menjadi "pelapisan emas" sebanyak menambahkan fungsi yang tidak dibutuhkan terlihat. Jika kode rusak dalam beberapa cara, tulis tes valid yang gagal; mencatat bug; dan kemudian refactor untuk mengatasi bug itu.

Michael Brown
sumber
1

Saya akan mencuri suara dari gerakan Agile:

Masukkan bug, buat tebakan kasar untuk tingkat keparahan dan prioritas,

Kemudian, setiap hari, tinjau mingguan atau bulanan semua bug baru, dan berikan suara pada peringkat mereka. Idealnya Anda melakukan ini selama pertemuan perencanaan sprint dengan pengguna akhir. Kemudian Anda dapat berbicara tentang fitur-fitur selanjutnya pada saat itu juga dan menjadi positif,

Michael Durrant
sumber