Haruskah pengembang memasukkan bug ke dalam sistem pelacakan bug?

Saat mengembangkan (baik fitur atau perbaikan bug) saya kadang-kadang menemukan bug yang tidak terkait langsung dengan apa yang saya kerjakan. Apa yang harus saya lakukan dalam situasi itu. Perbaiki saja? Coba ingat untuk memperbaikinya nanti? Tuliskan di suatu tempat? Atau memasukkannya ke dalam sistem pelacakan bug?

Saya biasanya memasukkannya ke dalam sistem pelacakan bug dan membiarkan proses itu berjalan sendiri (yaitu triaging, assigning, dll.). Namun saya belum pernah melihat pengembang lain memasukkan bug. (Mengapa demikian?)

Jika Anda menemukan bug, saya tidak bisa memikirkan alasan bagus untuk tidak memasukkannya ke dalam sistem pelacakan bug, apakah Anda memperbaikinya atau tidak. Bagaimanapun, itulah gunanya sistem pelacakan bug.

Dalam beberapa kasus mungkin lebih masuk akal untuk melaporkannya kepada orang yang QA memiliki lebih banyak pengalaman berurusan dengan sistem, tetapi dalam kasus apa pun bug tersebut harus dilacak.

Mungkin saja ada beberapa alasan, valid atau tidak, bahwa pengembang tidak boleh memasukkan bug. Salah satu alasan yang mungkin adalah sistem pelacakan bug dapat dilihat oleh orang luar, dan memiliki terlalu banyak bug yang dilaporkan terlihat buruk. Itu alasan yang sangat buruk, yang harus diatasi dengan cara lain yang masih memungkinkan bug dilacak. Tanya atasan Anda.

(Tentu saja jika ada bug dalam kode yang sedang Anda kerjakan, dan itu tidak muncul dalam apa pun yang telah dirilis, tidak perlu untuk melacaknya di sistem, meskipun komentar TODO dalam kode sumber mungkin ide yang bagus. Untuk mengambil kasus ekstrem, "Kode ini tidak dapat dikompilasi karena saya belum mengetikkan titik koma di akhir baris ini" bukan bug yang dapat dilaporkan.)

Mengenai mengapa pengembang lain tidak memasukkan bug, Anda harus menanyakannya. Mungkin seharusnya begitu.

Anda harus memasukkan bug dalam sistem pelacakan bug dalam kedua kasus:

• ketika bug terkait langsung dengan kode yang sedang Anda kerjakan,

• ketika bug menyangkut kode yang sedang tidak Anda kerjakan sekarang atau bagian tempat pengembang lain bekerja.

Ini penting, karena sistem pelacakan kutu dibuat untuk ... melacak kutu. Setiap bug. Jika Anda menemukan sesuatu yang salah, jangan hanya memperbaikinya. Dokumentasikan melalui sistem pelacakan bug. Ketika nanti, seorang pelanggan yang menjalankan versi perangkat lunak sebelumnya akan melaporkan bug yang merupakan duplikat yang tepat, Anda akan dapat menautkannya ke laporan Anda. Jika Anda tidak memiliki apa pun untuk ditautkan, Anda akan membuang waktu Anda (atau kolega Anda) mencari bug di revisi sebelumnya, kemudian mencoba menyelesaikannya, dan akhirnya menemukan bahwa bug itu sudah dipecahkan secara ajaib.

Ini juga menjelaskan mengapa para freelancer harus menggunakan kontrol versi dan sistem pelacakan bug: kedua alat tersebut tidak hanya untuk tim.

Tidak ada alasan yang sah untuk tidak memasukkan cacat ke dalam sistem pelacakan cacat. Satu-satunya tempat di mana saya melihat perbaikan bug diterapkan tanpa pelacakan adalah karena prosesnya rusak secara mendasar. Jika demikian, perbaiki prosesnya.

alasan untuk tidak masuk adalah:

• Proses ini mengukur dan menghukum berdasarkan laporan cacat - jangan laporkan, jangan dihukum. Dalam hal ini, tinggalkan organisasi
• Prosesnya adalah beban - butuh banyak usaha dan waktu untuk memasukkan cacat dan sampai pada titik untuk memperbaikinya. Proses tersebut harus diubah untuk memungkinkan pengembang melacak bug ringan dengan cepat melalui proses triage / accept / fix.
• Beberapa dev adalah pemalas / ceroboh / peretas yang tidak peduli apa dampak dari hal-hal yang mereka lakukan pada orang lain. Rekrut pengembang profesional.
• Saya band satu orang, jangan melihat intinya. Pergi bekerja untuk band 2 orang dan Anda akan ....

Memperbaiki bug segera mungkin ide yang buruk. Pertama, orang lain mungkin sedang mengerjakan perbaikan yang sama, menghasilkan upaya yang digandakan, dan juga, tergantung pada metodologi pengembangan yang Anda ikuti, memprioritaskan apa yang harus dikerjakan selanjutnya (memperbaiki bug atau mengimplementasikan fitur baru) lebih dari sekadar keputusan manajemen kemudian keputusan pengembangan.

Keputusan tidak jelas dipotong, dan melibatkan pengorbanan.

(beberapa) PROS

Pelacakan bug sangat penting untuk komunikasi, terutama pada tim besar. Salah satu manfaat terbaik dari memiliki beberapa mata pada kode adalah kemampuan untuk mendeteksi masalah sebelumnya, dan manfaat itu hilang jika bug tidak dicatat atau dilacak saat Anda sedang mengembangkan.

• Seringkali, bug paling mudah diperbaiki ketika Anda sudah berada di bagian kode, berusaha memahaminya.
• Bahkan di tim yang lebih kecil, ada banyak manfaat yang didapat dari semangat juang dengan mampu membuat daftar bug, dan kemajuan dalam memperbaikinya - kadang-kadang manfaat moral itu penting bahkan pada proyek satu orang.
• Deteksi bug yang akurat bisa sangat sulit setelah fakta - melihat bug dalam kode dapat menyimpan banyak pekerjaan kemudian bermain detektif, mencoba untuk mencari tahu di mana masalah itu awalnya terjadi.
• Baik untuk pengembangan umum Anda sebagai pengembang untuk memperhatikan bug seperti yang Anda lihat, dan biasakan memperbaiki / membersihkan / membaca kode secara kritis

Bug yang ditemukan saat Anda menemukannya, secara umum, merupakan kebiasaan yang baik untuk dimiliki.

(beberapa) KONTRA

Memasukkan bug ke dalam sistem pelacakan bug dapat menyulitkan dan menghabiskan waktu, dan dapat benar-benar mengganggu pekerjaan pengembangan - lebih sering terjadi ketika bekerja dalam tim besar. Anda mungkin diharapkan untuk:

• periksa apakah entri Anda adalah duplikat sebelum masuk (ini bahkan bisa jadi implisit, Anda tidak disarankan memasukkan bug ke antrian hanya untuk menutupnya)
• berikan kasus uji berulang untuk laporan Anda
• terima interupsi nanti dengan pertanyaan tentang detail bug, untuk menerima / memverifikasi perbaikan saat ditulis
• pikirkan informasi yang tidak terkait yang sering dikumpulkan dalam sistem pelacakan kutu, seperti produk mana yang paling terpengaruh, prioritas kutu, dll ...

Terkadang pelacakan bug bukanlah penggunaan waktu Anda yang paling efisien.

Ini adalah dua prinsip umum yang bisa sulit diseimbangkan - menemukan strategi yang baik adalah sedikit seni. Dalam situasi seperti ini, saya pikir yang terbaik adalah mengadopsi heuristik yang fleksibel, yang saya ubah sesuai kebutuhan untuk proyek, tim, lingkungan kerja, dan keterampilan umum Anda. Strategi saya biasanya mengikuti pola seperti kira-kira sebagai berikut:

• Selalu mencatat masalah seperti yang Anda lihat sepanjang hari, di suatu tempat. Mungkin pada lengket, mungkin dalam file ke samping. Mungkin yang Anda login hanyalah nama file dan nomor baris, mungkin lebih. Jangan biarkan masalah mengganggu jalur pemikiran Anda saat ini terlalu banyak.

• Luangkan waktu di awal setiap hari kerja baru, sebagai bagian dari pemanasan Anda untuk bekerja, untuk berurusan dengan perekat. Saya membutuhkan 10-15 menit untuk menelusuri daftar masalah yang terdeteksi dari hari sebelumnya dan melakukan yang mana dari yang paling cepat:

  • Perbaiki masalah dan komit (mungkin untuk satu perbaikan liner atau kesalahan ketik). Jika Anda tidak diizinkan untuk melakukan tanpa laporan bug, buat proyek sampingan untuk komitmen kecil. Ketika perbaikan yang cukup menumpuk di proyek sampingan, luangkan beberapa jam untuk mendokumentasikan dan berkomitmen.
  • Catat masalah ini dalam sistem pelacakan bug (untuk masalah yang jelas membutuhkan waktu lebih lama untuk diperbaiki, tetapi tanpa overhead yang berat)
  • Catat masalah ini dalam dokumen "untuk melihat saat tidak sibuk" (Saya biasanya menambahkan "// TODO - ini terlihat rusak, perbaiki" ketik komentar ke sumber). Secara teratur ambil satu hari (saya coba sebulan sekali) untuk memeriksa daftar dan mencatatnya - permintaan fitur, laporan bug, diskusikan dengan manajer, dll ...

Seiring waktu, saya menemukan semua jenis tweak berguna. Sebagai contoh:

• Di lingkungan yang lebih kaku, saya mungkin hanya membongkar pekerjaan pelaporan bug ke tim pengujian - dapatkan tester untuk bertemu dengan saya selama satu jam setiap sesekali, serahkan daftar masalah, dan minta mereka untuk melakukan logging. Di lingkungan di mana tes logging adalah masalah besar, biasanya tester akan senang untuk meningkatkan produktivitas mereka.
• Beberapa tim menolak untuk mengizinkan perbaikan apa pun yang tidak memiliki laporan bug pelanggan di belakangnya. Saya akan menjaga proyek penuh perbaikan di samping, dan langsung melakukannya ketika masalah yang relevan dilaporkan oleh klien, untuk poin brownies gratis.
• Beberapa tim mengharuskan orang yang "memiliki" sepotong kode menjadi orang yang melakukan perbaikan. Saya akan memperlakukan kode "pemilik" seperti pemimpin pengujian dan bertemu secara informal untuk menyerahkan masalah sesekali

Saya menemukan bahwa, secara umum, ketika Anda mengikuti jenis strategi ini, semakin banyak rekan kerja Anda dan anggota perusahaan lainnya akan mulai menghargai pekerjaan Anda, dan komitmen terhadap kualitas. Setelah cukup waktu, Anda akan memiliki rasa hormat dan otoritas yang diperlukan untuk mengoptimalkan seluruh proses sesuai keinginan Anda. Mengawasi peluang tersebut, dan mengambilnya sesuai kebutuhan.

Saya percaya bahwa jika pengembang menemukan bug yang tidak terkait dengan apa yang mereka kerjakan dan bahwa mereka tidak akan memperbaikinya, mereka harus memasukkannya ke dalam sistem hanya untuk memiliki beberapa catatan tentang itu. Dengan begitu, ketika QA mulai menguji (dan masih belum diperbaiki) Anda bisa memberi mereka bug daftar ini sebagai "cacat yang diketahui" sehingga mereka tidak mulai melaporkan bug yang sama.

Mungkin pengembang lain yang menemukan bug melacaknya sendiri jika mereka berencana untuk memperbaikinya, tetapi dalam kasus itu mereka berisiko 2 pengembang menemukan dan memperbaiki bug yang sama secara independen.

Saya akan menambahkan bahwa bahkan jika bug sudah diperbaiki (yang seharusnya tidak terjadi sebelum merekamnya di pelacak masalah) itu adalah ide yang baik untuk melacaknya.

Dengan cara ini, jika masalah tersebut muncul lagi di masa mendatang (regresi terjadi!) Relatif mudah untuk mengenali masalah tersebut sebagai "sudah ditangani" dan membaca bagaimana itu diperbaiki pertama kali.

Mengapa demikian? Karena sebagian besar pengembang melihat masalah yang harus mereka angkat dan kode yang harus mereka tulis dan bayangkan lebih mudah untuk tidak repot.

Tapi, apakah itu hal yang benar untuk dilakukan tergantung pada proses Anda. Apakah Anda memiliki tim QA? Apakah Anda pikir mereka keberatan jika Anda hanya mengubah kode yang tidak akan dilacak? Bagaimana dengan ulasan kode? Apakah akan melewati celah itu? Bagaimana dengan bisnisnya? Apakah mereka perlu tahu Anda telah memperbaiki bug sehingga mereka tidak meningkatkan bug yang sama nanti?

Bagaimana dengan pengembang lain? Bagaimana jika mereka memperbaikinya dengan cara yang berbeda secara bersamaan? Bagaimana jika mereka menemukan bug yang sama kemudian dan yang dapat Anda lakukan hanyalah berkata "oh, sial, saya tahu kami pernah mengalami hal seperti ini sebelumnya - sekarang apa itu?"

Ada sekitar sejuta alasan untuk merekam bug dalam sistem pelacakan bug. Jika Anda PASTI Anda tidak menemukan salah satu dari masalah itu maka tentu saja, jangan repot-repot. Tetapi jika Anda sama sekali tidak yakin maka Anda harus merekamnya, bahkan jika kebanyakan orang tidak.

Pemrograman adalah pekerjaan kompleks secara fundamental. Bugnya kompleks. jadi saya biasa menilai bug dengan dua faktor:

1. Seberapa sering bug semacam itu muncul lagi di masa depan? Apakah perkiraan ini akurat atau tidak, teruslah memperkirakan.
2. Ketika bug semacam itu muncul lagi, apakah itu mudah dimengerti? Ini akurat ketika Anda menganalisis bug ini dan memperbaikinya.

Saya akan mengklasifikasikan bug ke dalam salah satu dari jenis berikut:

1. Kemungkinan muncul kembali di masa depan, dan mudah dimengerti
2. Kemungkinan muncul lagi di masa depan, tetapi sulit dimengerti
3. Jarang muncul lagi di masa depan, dan mudah dimengerti
4. Jarang muncul lagi di masa depan, tetapi sulit dimengerti

Dalam kasus 1, buku masak atau FAQ adalah perangkat yang baik bagi tim untuk memperbaiki bug tersebut di masa mendatang.

Dalam kasus 2, catatan yang rumit dan komprehensif adalah penting bagi tim karena merupakan usaha yang sia-sia jika programmer lain menanggung bug seperti itu lagi. Misalnya: kebocoran memori.

Dalam kasus 3, saya pikir ini bukan masalah besar bahwa tidak ada yang tersisa untuk dicatat karena Anda tidak akan menghabiskan terlalu banyak waktu untuk memperbaiki bug yang mudah. Misalnya, salah ketik untuk id elemen dalam HTML.

Dalam kasus 4, bug semacam itu menciptakan dilema. Perlu beberapa waktu untuk menulis catatan yang rumit dan komprehensif untuk menggambarkan bug semacam itu. Namun catatan ini jarang digunakan di masa depan. Namun, tanpa catatan, kemunculan bug semacam itu akan menjadi perjuangan lagi. Misalnya, bug seperti itu muncul karena virus komputer di komputer seseorang.

Tentu saja Anda harus memasukinya. Atau setidaknya laporkan ke orang-orang QA Anda jika itu proses normal Anda.

Bahkan jika Anda hanya memperbaiki bug sendiri, Anda akan menginginkan catatan perubahan sehingga kemudian dapat diuji untuk memastikan bahwa perbaikannya benar-benar berfungsi dan belum ada regresi. Mungkin juga pengguna mungkin melaporkan bug di beberapa titik, dan jika ada di sistem dan ditandai sebagai diperbaiki, orang-orang dukungan Anda dapat memberi tahu mereka bahwa itu sudah diatasi.

Memang Anda harus merekamnya dalam sistem, dan jika itu tidak dipraktikkan maka ada baiknya untuk memulai.

Di masa lalu saya, saya adalah bagian dari tim produk, dan kami berada pada rilis beta dari produk baru dan kadang-kadang kami menemukan bug yang pada saat itu kami gunakan untuk mencatat dan mengirimkan ke masing-masing orang yang menangani modul (kami memiliki sistem pelacakan bug, tetapi kami tidak berpikir untuk mendorongnya ke sana). Kemudian ketika hari berlalu barang-barang dalam surat mulai diabaikan karena prioritas lain dan yang akhirnya menyebabkan beberapa malam tanpa tidur.

Lalu, bang suatu hari, Nirvana! Mengapa kita tidak menggunakan pelacak bug, bahkan jika Anda menemukan sesuatu yang tampak seperti bug dan bisa jadi itu bukan bug (pemikiran Anda tentang prosesnya salah / cacat). Paling tidak itu masuk dalam daftar yang kemudian dapat diuji dan yang paling penting dari semua umpan balik tentang mengapa itu penting atau di sisi lain itu sempurna dan begitulah seharusnya bekerja karena alasan 1 ... 2 ... .

Sekarang Anda memiliki daftar dan juga bagi mereka yang telah salah paham beberapa bagian dari aplikasi mereka memiliki umpan balik berdasarkan yang mereka dapat mengklarifikasi pikiran mereka. Situasi menang-menang.

Dengan asumsi kode yang sudah diuji (dan terutama jika dirilis) benar-benar.

Ada sejumlah alasan untuk ini:

Memori - Sistem ini benar-benar tidak mungkin melupakan bug, pengembang apa pun mungkin.

Metrik - Jumlah bug yang ditemukan, ditutup, dan waktu yang dibutuhkan bisa menjadi metrik yang mudah ditangkap untuk memberi tahu Anda bagaimana kualitas kode Anda mengalami kemajuan

Urgensi - Ini mungkin tampak sebagai hal yang paling penting di dunia bagi pengembang, namun waktu yang dihabiskan untuk memperbaiki masalah ini mungkin lebih baik dihabiskan untuk sesuatu yang diinginkan pengguna akhir terlebih dahulu (lihat juga memori).

Duplikasi - Mungkin sudah terlihat dan sedang diperiksa / diperbaiki oleh orang lain. Atau mungkin itu telah melanggar aturan urgensi dan ditunda. Tentu saja fakta bahwa Anda telah menemukannya lagi tidak hanya berarti bahwa itu tidak boleh dilakukan, itu mungkin berarti bahwa (karena terus muncul) yang sekarang lebih mendesak untuk diperbaiki.

Root root analysis - Bug termudah untuk diperbaiki adalah bug yang tidak pernah ada. Mungkin saja tim harus melihat bug ini untuk mencari tahu bagaimana hal itu terjadi. Ini jelas bukan untuk menghukum orang yang bertanggung jawab (yang tidak pernah membantu) tetapi untuk mencari tahu bagaimana situasi dapat dihindari di masa depan.

Analisis dampak lebih luas - Bug termurah untuk ditemukan adalah yang Anda ketahui sebelum Anda menemukannya. Dengan melihat bug ini (terutama setelah melakukan analisis akar penyebab) mungkin dengan cepat menjadi jelas bahwa masalah ini bisa ada di tempat lain dalam kode. Sebagai hasilnya, tim dapat memilih untuk menemukannya sebelum mengangkat kepalanya yang jelek di saat yang lebih memalukan.

Jumlah waktu yang dihabiskan untuk ini (jika ada) sangat tergantung pada tingkat kematangan dan kualitas kode. Analisis akar penyebab kemungkinan akan berlebihan bagi tim kecil yang mengerjakan kode demonstrasi, tetapi tim besar tentang pengembangan bisnis kritis mungkin perlu mempelajari pelajaran secara efektif dan efisien.

Dari pengalaman ada dua alasan luas yang membuat pengembang menghindari menggunakan alat:

1. Alat penanganan bug dan / atau proses dianggap terlalu berat untuk pengembangan
2. Pengembang menemukan tantangan mental untuk memperbaiki bug lebih menarik daripada hal-hal yang sedang mereka kerjakan.

Butir 1 menyiratkan bahwa sistem yang lebih baik / sederhana mungkin diperlukan; atau sebagai alternatif, pembenaran yang lebih meyakinkan dari sistem yang ada mungkin dilakukan.

Butir 2 harus menjadi tanda peringatan yang bermanfaat bagi pemimpin pengembangan tentang alokasi tugas saat ini.

Saya sebagian besar setuju dengan FrustratedWithFormsDesign tapi saya pikir itu lebih jelas jika seluruh masalah dipecah menjadi dua bidang:

• Pelaporan Bug.
• Memperbaiki Bug.

Ini sering diperlakukan sebagai sama dan memisahkan mereka hampir pasti akan banyak membantu.

Ini dapat ditangani dengan: Pelaporan Bug: - masukkan ke dalam sistem, seperti yang dikatakan semua orang.

Memperbaiki bug: - Setiap minggu atau dua (sesuaikan dengan jadwal pengembangan Anda, dll.) Semua orang berkumpul di proyek dan memutuskan apa yang harus diperbaiki, oleh siapa, dll. Ini adalah semua orang berada di halaman yang sama dan dapat melihat apa yang perlu dilakukan. Dalam Pengembangan Agile ini adalah pertemuan Perencanaan Sprint.

Alat bagus yang ingin digunakan orang juga membuat perbedaan besar. Saya suka Pivotal Tracker dan lulus tes 'alat yang sangat berguna' ketika saya mulai menggunakannya hanya untuk melacak hal-hal yang ingin saya lakukan atau perbaiki dalam proyek pribadi saya sendiri!

Jika Anda melihat sesuatu maka katakan sesuatu!

Saya bahkan memasukkan laporan bug tentang modul saya sendiri karena saya tidak ingin mengganggu tugas saya saat ini. Dan saya bisa memastikan semua langkah untuk mereproduksi sudah termasuk :-)

Dan bahkan lebih baik ketika orang lain melihat bahwa Anda telah mendaftarkan sesuatu sebagai bug yang dikenal. Mereka suka tahu orang lain juga menemukannya.

Saya pikir ini lebih merupakan pertanyaan politis daripada pertanyaan tentang praktik terbaik.

• apakah entri bug menyalahkan sombody?
• dapat pelanggan membaca entri bug dan melihat bahwa ada kesalahan tambahan. Apakah ini masalah reputasi untuk perusahaan Anda?
• Apakah ini benar-benar bug atau fitur yang tidak Anda sadari?
• siapa yang akan membayar perbaikan bug?

Menurut pendapat saya itu adalah praktik yang baik untuk menambahkan bug yang tidak sepele ke dalam sistem pelacak tetapi manajemen harus memutuskan bagaimana cara mengatasinya.

Untuk kasus yang tidak sepele, Anda tidak boleh memperbaiki masalah tanpa berkonsultasi dengan orang lain untuk memastikannya

• ini benar-benar bug dan bukan fitur
• sombody lain dapat menguji perbaikan dan memastikan bahwa perbaikan tidak memperkenalkan bug baru (regresi)