Intinya, tidak, tetapi Anda harus tetap melakukan yang terbaik. Saya akan menjelaskan alasannya (atau langsung saja ke kesimpulan jika Anda tidak memiliki cukup kesabaran)
Pertimbangkan masalah sepele seperti implementasi pencarian biner. Satu implementasi yang sangat populer memiliki bug yang tidak terdeteksi selama sekitar dua dekade. Jika dua puluh baris membutuhkan waktu dua puluh tahun untuk membuat bebas bug digunakan secara luas dan bahkan terbukti benar, dapatkah kita benar-benar mengharapkan program besar bebas bug?
Berapa banyak bug yang bisa kita harapkan dari sebuah program besar? Satu angka yang saya temukan adalah "10 cacat per 1000 baris" (Code Complete 2nd edition, halaman 517 - hanya menggunakan contoh, tidak mengutip data apa pun) Itu memberi kami sekitar 200.000 hingga 300.000 bug dalam perangkat lunak Anda. Untungnya, kami memiliki cara untuk meningkatkan kualitas program. Pengujian unit, ulasan kode, dan pengujian manual biasa diketahui mengurangi jumlah bug. Meski begitu, jumlahnya masih akan tinggi.
Jika kita bisa menyelesaikan 95% dari semua bug itu akan luar biasa. Namun kami masih memiliki 10.000 hingga 15.000 bug dalam perangkat lunak.
Untungnya, karena perangkat lunak ini banyak digunakan (dan, karenanya, diuji secara luas) bug akan ditemukan. Jadi secara bertahap kami akan mendapatkan lebih sedikit bug. Namun, lebih sedikit bug juga berarti bahwa bug yang tersisa lebih sulit ditemukan - jadi jangan berharap kurva linear dalam memperbaiki bug. Beberapa bug terakhir akan sangat sulit ditemukan dan dapat lolos dari deteksi selama beberapa tahun (dengan asumsi mereka pernah ditemukan).
Anda juga keliru berasumsi bahwa jika perangkat lunak tidak berubah, tidak ada bug baru yang akan muncul. Jika perangkat lunak tergantung pada pustaka pihak ketiga, versi baru dapat merusak beberapa fitur - memperkenalkan bug baru meskipun kode aplikasi masih sama. Sistem operasi baru juga dapat merusak aplikasi yang sebelumnya berfungsi sempurna (lihat Windows Vista untuk contoh populer). Pertimbangkan juga bug penyusun, dll.
Tidak jelas apakah alat pembuktian kode benar-benar dapat memecahkan masalah perangkat lunak kereta. Tentu saja tidak mungkin menyelesaikan masalah penghentian untuk program apa pun, tetapi mungkin saja membuktikan bahwa suatu program berperilaku seperti yang ditentukan ... Tetapi kemudian apa? Mungkin program buktinya memiliki bug. Mungkin spesifikasinya sendiri memiliki bug.
Jadi jelas, kita dapat sangat mengurangi jumlah bug, tetapi sangat tidak mungkin kita akan mencapai nol.
Karena ada beberapa anggapan bahwa setiap perbaikan yang Anda buat menghasilkan lebih banyak bug, tapi saya rasa itu tidak benar.
(penekanan ditambahkan)
Anda benar. Pernyataan ini salah. Ini sebuah contoh:
int main() {
int x[10];
x[10] = 8; //Buffer overflow here
return 0;
}
Sekarang, mari kita perbaiki bug ini:
int main() {
int x[11];
x[10] = 8; //No buffer overflow here
return 0;
}
Lihat? Kami memperbaiki bug dan tidak memperkenalkan yang baru.
Namun, sudah pasti benar bahwa setiap kali Anda memperbaiki bug Anda berisiko membuat bug baru, meskipun risiko ini dapat dikurangi (misalnya dengan pengujian unit).
Katakanlah untuk setiap 100 bug yang saya perbaiki, saya tidak sengaja memperkenalkan yang baru. Jadi jika saya memperbaiki 10 000 bug, saya memperkenalkan 100 bug baru. Dan jika saya memperbaiki bug baru itu, saya memperkenalkan satu bug. Tapi lalu bagaimana? Program ini sekarang memiliki 9.999 bug lebih sedikit, jadi mungkin lebih baik daripada sebelumnya (dengan asumsi bug baru tidak 10.000 kali lebih buruk daripada yang sebelumnya).
Selain itu, memperbaiki bug dapat mengekspos bug baru. Tetapi bug-bug itu dapat diperbaiki juga. Jika Anda melakukan hal yang benar, pada akhirnya perangkat lunak akan berada dalam kondisi yang lebih baik daripada yang dimulai.
Saya sudah tua oleh beberapa programmer top bahwa lebih baik tidak memperbaiki banyak bug karena gagasan yang saya sebutkan di OP.
Perilaku ini lalai. Jika ada bug dan Anda bisa memperbaikinya. Lakukan. Tentu saja Anda harus melakukan yang terbaik untuk mencegah penambahan yang baru tetapi jika saya memperkenalkan satu bug kecil untuk setiap 10 bug serius yang saya perbaiki, itu bukan alasan yang sah untuk berhenti memperbaiki bug. Bahkan, itu adalah alasan bagus untuk terus memperbaiki bug .
Jadi semakin sedikit bug yang Anda perbaiki, semakin sedikit bug yang akan kembali kepada Anda di masa mendatang
Semakin sedikit bug yang Anda perbaiki, semakin banyak bug yang tersisa di perangkat lunak Anda, yang mengganggu pengguna Anda. Memang, mereka tidak akan "kembali kepada Anda di masa depan". Mereka tidak akan kembali karena mereka tidak pernah pergi. Gagasan "kembali" terkait dengan regresi. Sekali lagi, adalah mungkin untuk mengurangi risiko regresi.
Beberapa bug tidak dapat diperbaiki karena mereka menjadi sangat banyak digunakan sehingga orang-orang mulai bergantung pada mereka dan memperbaiki bug akan merusak program untuk para pengguna tersebut. Itu terjadi. Namun, dapatkah mereka dianggap bug dalam kasus itu?
Mentalitas "perbaiki bug, buat bug" mungkin terkait dengan Monster yang Mengerikan itu - kode yang sangat tidak dapat dibaca dan tidak dapat dipelihara sehingga hanya dengan menyentuhnya akan menciptakan bug. Jika Anda memiliki monster di basis kode Anda, Anda mungkin perlu membatalkan un-monsterify sebelum menyelesaikan sesuatu.
Akhirnya, jika Anda seorang programmer yang mengerikan, ada risiko apa pun yang Anda sentuh menciptakan bug baru. Ini jelas akan membuat programmer senior gugup. Namun, mengatakan "Jangan lakukan apa-apa. Jangan menyentuh apa pun. Jangan bernafas." mungkin bukan cara yang tepat untuk menciptakan lingkungan kerja yang sehat. Pendidikan lebih baik.
Kesimpulan:
- Perangkat lunak yang terus mendapatkan banyak fitur baru tetapi tidak ada perbaikan bug pasti akan menyedot.
- Perangkat lunak yang mendapatkan cukup banyak fitur baru tetapi memperbaiki bugnya memiliki peluang lebih besar untuk dapat digunakan.
- Mereka yang mencoba memiliki beberapa bug memiliki (rata-rata) lebih sedikit bug daripada mereka yang tidak peduli.
- Tidak masuk akal untuk mengharapkan suatu program pada akhirnya menjadi bebas bug.
- Pemrogram senior belum tentu kompeten.
- Perbaiki bug Anda.
- Adopsi metodologi yang meningkatkan kualitas perangkat lunak Anda.