Apa manfaat dari menghindari penggunaan debugger?

Sepanjang karier saya, saya perhatikan bahwa beberapa pengembang tidak menggunakan alat debugging, tetapi lakukan pemeriksaan langsung pada kode yang salah untuk mencari tahu apa masalahnya.

Walaupun berkali-kali dapat dengan cepat menemukan kesalahan dalam kode tanpa debugger adalah keterampilan yang baik untuk dimiliki, tampaknya kurang produktif untuk menghabiskan banyak waktu mencari masalah ketika debugger akan dengan mudah menemukan kesalahan kecil seperti kesalahan ketik.

Apakah mungkin mengelola kompleks tanpa debugger? Apakah itu disarankan? Apa manfaat yang bisa didapat dengan menggunakan " debugging psikis ?"

Apa yang tampak seperti menebak dari luar sering kali menjadi apa yang saya sebut "debugging in your mind". Di satu sisi, ini mirip dengan kemampuan grandmaster untuk bermain catur tanpa melihat papan catur.

Ini adalah jauh teknik debugging yang paling efisien yang saya tahu, karena tidak memerlukan debugger sama sekali. Otak Anda menjelajahi banyak jalur kode pada saat yang sama, menghasilkan perubahan haluan yang lebih baik daripada yang bisa Anda dapatkan dengan debugger.

Saya tidak sadar tentang teknik ini sebelum secara singkat memasuki dunia pemrograman kompetitif , di mana menggunakan debugger berarti kehilangan detik berharga. Setelah sekitar satu tahun berkompetisi, saya mulai menggunakan teknik ini hampir secara eksklusif sebagai garis pertahanan awal saya, diikuti oleh debug logging, dengan menggunakan debugger yang sebenarnya berada di tempat ketiga yang jauh. Salah satu efek samping yang bermanfaat dari praktik ini adalah saya mulai menambahkan bug baru dengan lebih lambat, karena "men-debug dalam pikiran saya" tidak berhenti ketika saya menulis kode baru.

Tentu saja metode ini memiliki keterbatasan, sebagian besar karena keterbatasan pikiran seseorang dalam memvisualisasikan beberapa jalur melalui kode. Saya belajar untuk menghormati keterbatasan pikiran saya ini, beralih ke debugger untuk memperbaiki bug dalam algoritma yang lebih maju.

Semakin saya tahu basis kode, semakin sedikit saya membutuhkan debugger (tapi saya masih akan memeriksa kesalahan yang dilaporkan, ini adalah petunjuk penting dalam alasan apa pun).

Ini adalah alat yang bagus untuk memahami perilaku dinamis dari kompleksitas kecil hingga menengah, tetapi saya sering menemukan bahwa itu memfokuskan saya pada detail alih-alih gambaran yang lebih besar. Dan setelah beberapa saat, di situlah masalahnya: dalam interaksi lingkup yang lebih luas yang perilaku dinamisnya cenderung lebih mudah dimengerti dengan alat lain (pencatatan input dan output pada batas-batas modul misalnya).

Mereka mungkin bukan programmer yang buruk, tetapi mereka mungkin adalah pemecah masalah yang sangat tidak efisien.

Saya cenderung mengikuti saran dari Debugging: 9 Aturan yang Tidak Terpisahkan untuk Menemukan Bahkan Masalah Perangkat Lunak dan Perangkat Keras yang Paling Sulit Dihadapi (David Agans), dan yang ini jatuh tepat di bawah panduan "Berhenti berpikir dan melihat"

Pekerjaan apa pun membutuhkan penggunaan alat yang tepat dengan cara yang benar. Jika Anda memiliki debugger maka gunakan untuk melihat apa yang sebenarnya terjadi. Sebagian besar bug disebabkan oleh asumsi.

Saya telah bekerja dengan pengembang yang menolak menggunakan debugger karena mereka lebih tahu. Tanggapan klasik yang pernah saya dapatkan adalah 'kecelakaan itu bukan disebabkan oleh saya, saya menghabiskan sepanjang hari memeriksa kode [di mana kode mogok] dan tidak ada yang salah'. (Bagaimana dengan nilai nol yang dibaca dari db?) Bos sepertinya berpikir itu adalah jawaban yang bagus tetapi pelanggan tidak.

Saya turun dari tim secepat mungkin. Tujuan mereka adalah menyibukkan pekerjaan dan membuat masalah sederhana 10 menit menjadi masalah yang tampak sibuk sepanjang hari.

Panduan terbaik Anda untuk praktik debugging adalah buku Lengkap Steve McConnel . Bab 23 mencakup debugging secara rinci, dan saya akan menyaring beberapa poin dari itu.

1. Memahami masalah itu penting, dan penggunaan debugger bukan pengganti untuk itu.
2. Menebak adalah pendekatan yang buruk untuk debugging. Jika kolega Anda benar-benar menggunakan dugaan, alih-alih memikirkan masalahnya, maka mereka melakukan pekerjaan yang buruk. Tebak berarti menempel pernyataan cetak acak dalam kode dan berharap menemukan sesuatu yang bermanfaat.
3. Jika kolega Anda benar-benar tidak tahu cara menggunakan debugger (daripada memilih untuk tidak menggunakan debugger) maka ya, mereka tidak kompeten, seperti halnya seseorang yang tidak tahu sintaks bahasa yang seharusnya mereka gunakan.

Sulit dikatakan. Debugging dengan menebak mungkin berfungsi jika Anda sudah memiliki ide tentang bug itu (nilai yang salah diteruskan ke fungsi pustaka, kemungkinan SQL tidak valid, dll). Saya akui saya terkadang melakukannya ketika kesalahan itu sendiri tampak kecil atau jelas, seperti "buffer karakter terlalu kecil" - jejak stack menunjukkan kepada saya baris yang gagal dan saya tidak perlu debugger untuk menyelesaikannya.

Melakukan ini sepanjang waktu bisa kontraproduktif dan jika beberapa "tebakan" pertama gagal, menebak mungkin adalah strategi pemecahan masalah yang salah dan seorang debugger yang sebenarnya harus dipanggil. Biasanya, saya akan mengatakan tidak ada yang salah dengan menggunakan debugger .

Yang sedang berkata, saya telah bekerja dengan alat dan lingkungan di mana debugger sangat sulit untuk bekerja dengan benar, atau sangat minim dan tidak berguna sehingga menebak itu sayangnya sering merupakan pendekatan yang lebih baik. Saya telah bekerja dengan beberapa alat eksklusif yang bahkan tidak memiliki debugger yang tepat. Saya kira itu mungkin bahwa jika seseorang bekerja di lingkungan seperti itu terlalu lama mereka pada akhirnya akan kehilangan kepercayaan mereka pada para penentang dan hanya mengandalkan pendekatan menebak.

Saya terkejut bahwa diskusi tentang topik ini belum menyebutkan "unit testing".

Karena saya melakukan pengembangan berbasis tes, saya tidak menghabiskan banyak waktu di debugger. 10 tahun yang lalu, saya biasanya dengan patuh melangkah melalui debugger:

1. Setelah menulis sepotong kode untuk memastikan itu berhasil dan
2. Ketika saya menerima laporan bug untuk mencoba mendiagnosis masalah

Apa yang saya temukan setelah 10 tahun pengembangan berbasis tes adalah bahwa saya jauh lebih produktif sebagai programmer jika:

1. Saya menulis unit test sebelum saya menulis kode untuk memastikan bahwa saya menulisnya dengan benar
2. Saya menulis unit test segera setelah menerima laporan bug untuk mencoba menduplikasi dan menelusuri masalah.

Mengizinkan komputer menjalankan kode dan memvalidasi hasilnya ribuan kali lebih cepat daripada yang dapat saya pikirkan atau melangkahi kode untuk memvalidasi hasil secara mental, dan tidak membuat kesalahan.

Saya masih harus melangkah melalui debugger sesekali, dan saya masih terlibat dalam menganalisis kode secara mental ... tetapi jarang, dan sebagian besar untuk kode yang sangat rumit.

Secara pribadi, saya mencoba meminimalkan penggunaan debugger dengan:

• menggunakan checker statis dan opsi kompiler serupa yang mengisyaratkan kemungkinan sumber bug hanya dengan menganalisis kode
• menulis kode dengan sesedikit mungkin efek samping , dengan gaya paling fungsional, menghilangkan keadaan yang bisa berubah jika memungkinkan
• unit menulis tes dengan rincian minimum yang masuk akal
• tidak menelan pengecualian

Tentu saja, semua orang membuat kesalahan, jadi bahkan ketika membuat program dengan cara ini, jika sebuah tes gagal, saya menggunakan debugger untuk memeriksa nilai ekspresi menengah. Tetapi dengan berpegang pada prinsip-prinsip di atas, cacat lebih mudah ditemukan, dan debugging tidak berarti proses yang menyakitkan dan tidak pasti.

Gunakan debugger jika memungkinkan. Debugger hanya akan mengatasi masalah (oh, lihat, kami tidak memeriksa nilai ini), atau memberikan banyak konteks yang berguna saat menganalisis kode yang relevan (wow, tumpukan benar-benar kacau, saya akan baik itu masalah buffer overflow).

Debugging adalah alat yang sangat berguna untuk memeriksa keadaan objek dan variabel dalam kode Anda saat run time.

Seperti yang disebutkan sebelumnya dalam jawaban di atas, debugging sangat membantu, tetapi ada beberapa kasus di mana itu terbatas.

Dalam pengalaman saya, saya menemukan menggunakan debugger sangat berguna karena membantu mengungkapkan asumsi palsu yang saya buat tentang keadaan kode saya. Beberapa orang tidak begitu pandai membaca kode untuk menemukan bug, sehingga debugging dapat membantu mengungkapkan asumsi palsu yang Anda atau pengembang lain buat tentang keadaan kode.

Mungkin Anda berharap bahwa suatu parameter tidak akan menjadi nol ketika diteruskan ke suatu metode, jadi Anda tidak pernah memeriksa kasus itu dan melanjutkan dalam metode seolah-olah parameter itu tidak akan pernah menjadi nol. Kenyataannya adalah bahwa parameter pada akhirnya akan menjadi nol di beberapa titik bahkan jika Anda menetapkan sebagai pra-kondisi untuk metode yang parameternya tidak boleh nol. Itu akan selalu terjadi.

Berbeda dengan kegunaan debuggers dalam contoh-contoh di atas, saya merasa sulit dan agak tidak berguna untuk digunakan ketika multi-threading (yaitu, concurrency, pemrosesan asinkron) terlibat. Ini bisa membantu, tetapi mudah untuk kehilangan orientasi Anda dalam kabut multi-ulir ketika breakpoint debugger dipukul di satu utas di titik A dan utas yang sepenuhnya terpisah di titik B. Pengembang dipaksa untuk mendorong breakpoint baru " proses berpikir "di atas" tumpukan "otaknya dan mengarahkan dirinya ke kode pada titik breakpoint baru. Setelah relevansi breakpoint B menurun, pengembang kemudian beralih kembali ke breakpoint pertama, dan harus mengingat apa yang dia cari sebelum pemicu breakpoint B. Saya tahu ini mungkin penjelasan yang membingungkan,

Selain itu, ketidakpastian kode konkurensi dapat mengalihkan perhatian pengembang dalam debugging kode konkurensi.

Kesimpulannya, menurut pendapat jujur ​​saya:

• Debugging saat konkurensi digunakan = peningkatan kecenderungan kehilangan fokus "pola pikir debugging"

dan

• kapan saja = peningkatan produktivitas debugging b / c perhatian Anda tidak terganggu oleh breakpoint yang tidak terduga (tidak terduga karena kondisi balapan).

Kurasa mereka agak terlalu hardcore. Secara pribadi ketika saya menemukan bug, saya memeriksa kembali kode, mencoba untuk melacaknya dalam pikiran saya dari logika program, karena kadang-kadang membantu saya mengungkap masalah lain atau efek samping lebih mudah daripada hanya menggunakan debbuger dan memperbaiki bug di mana ia memanifestasikan dirinya .

Bahkan ketika saya pikir saya sudah memahaminya, saya biasanya men-debug itu untuk memastikan saya benar. Ketika masalahnya sedikit lebih kompleks, saya percaya debugging sangat penting.

Juga ... hanya pendapat saya tetapi, tidak ada alasan untuk tidak mengambil keuntungan yang layak dari alat yang dapat dibawa oleh IDE modern ke meja. Jika itu membantu Anda menyelesaikan pekerjaan Anda lebih cepat dan dengan cara yang lebih dapat diandalkan, Anda harus menggunakannya.

Benci untuk menggeneralisasi, tetapi banyak programmer yang saya temui berpikir hanya ada satu cara untuk menyelesaikan masalah (cara mereka). Mudah untuk mengasumsikan bahwa setiap tes yang mungkin telah dipikirkan. Perspektif yang berbeda bisa sangat berharga.

Pemrograman dengan coba-coba dapat muncul dengan beberapa pendekatan baru yang hebat, dan menangkap hal-hal yang orang lain lewatkan.

Kelemahannya, biasanya butuh waktu lebih lama.

Eh, itu tergantung orangnya. Secara pribadi, saya tidak terlalu sering menggunakan debugger. Ketika saya memprogram pengendali mikro, saya pada dasarnya menggunakan LED atau menulis data ke EEPROMs untuk "men-debug" kode di atasnya. Saya tidak menggunakan JTAG.

Ketika saya memprogram perangkat lunak untuk PC atau server, saya cenderung menggunakan pencatatan dan banyak keluaran konsol. Untuk bahasa C-style, saya menggunakan arahan preprocessor, dan di Jawa saya menggunakan level log.

Karena saya tidak menggunakan debugger, apakah Anda akan mengatakan saya melakukan sesuatu yang salah? Pekerjaan editor, untuk menunjukkan di mana saya memiliki kesalahan sintaksis, dan ketika ada kesalahan logis, saya hanya perlu menjalankan tes.

Ada perbedaan antara tidak perlu menggunakan debugger dan tidak tahu cara (atau menolak) menggunakan debugger. Debugger hanyalah salah satu dari banyak alat untuk digunakan dalam melacak dan memperbaiki bug. Saya telah bekerja dengan pengembang yang dapat memecahkannya di kepala mereka dan orang lain yang berpikir mereka bisa.

Campuran terbaik adalah menulis kode Anda sehingga mudah untuk menguji melalui unit test, dan mencatat kesalahan. Maka Anda harap Anda tidak perlu melihat log atau menggunakan debugger. Ini seperti membeli asuransi. Mudah-mudahan Anda tidak perlu menggunakannya, tetapi begitu Anda menemukan bug yang tidak dapat diselesaikan dengan memeriksa ulang kode, maka sudah terlambat untuk menambahkan penanganan / pencatatan kesalahan yang tepat, tes unit, atau belajar menggunakan debugger.

Alat / platform yang berbeda mendukung teknik debugging yang berbeda (debugger, logging, unit test, dll.) Selama seorang pengembang terbiasa dengan beberapa teknik untuk platform / alat mereka, selain hanya antara memeriksa ulang kode, maka mereka mungkin pengembang yang terampil, tetapi jika mereka hanya memiliki satu trik ketika harus melakukan debug maka mereka pada akhirnya akan mengalami bug yang tidak dapat mereka temukan atau perbaiki.

Banyak jawaban, tetapi tidak menyebutkan tentang Heisenbug ?!?!

Heisenbugs terjadi karena upaya umum untuk men-debug suatu program, seperti memasukkan pernyataan keluaran atau menjalankannya dalam debugger, biasanya memodifikasi kode, mengubah alamat memori variabel dan waktu pelaksanaannya.

Saya menggunakan debugger, hanya dalam kasus terburuk (untuk bug yang sulit ditemukan). Juga, sesuai praktik terbaik yang dibicarakan oleh banyak pengembang / penguji terkenal, ada baiknya untuk menguji unit ini secara menyeluruh. Dengan begitu, Anda dapat mengatasi sebagian besar masalah dan karenanya tidak perlu menggunakan debugger.

Saya membaca argumen menentang debugger debugging di sini baru-baru ini (atau apakah itu StackOverflow?). Anda harus memiliki kasus uji terhadap kode Anda. Jika tes Anda lulus, debugging Anda mungkin tidak akan menjalankan bug (asumsi: Anda akan men-debug dengan data yang mirip dengan data pengujian Anda).

Di sisi lain, penebangan adalah wajib. Jika Anda lulus tes dan menggunakan untuk produksi, Anda mungkin menemukan bahwa Anda memiliki bug. Bukti bug berasal dari sesuatu yang terjadi di masa lalu. yaitu seseorang berkata, "Bagaimana itu bisa masuk ke sana?" Jika Anda tidak memiliki log yang baik, Anda tidak akan pernah menemukan penyebabnya. Bahkan debugger mungkin tidak berguna pada saat itu karena Anda tidak tahu seperti apa data yang sebenarnya menjalankan bug. Anda harus dapat men-debug aplikasi dari log.

Sayangnya, saya sedikit memparafrasekan, dan mungkin melakukan argumen asli yang merugikan. Secara khusus, posisi "Ada pembantu debugging penting untuk menghabiskan waktu pengembangan mendukung" mungkin ortogonal dengan pentingnya debugger. Tetapi bagian tentang kesulitan dalam pengaturan kondisi sistem dalam konfigurasi yang membuat debugging berguna untuk menemukan bug menurut saya sebagai sesuatu untuk dipikirkan.

Dengan tes unit yang bagus, dan pengecualian yang memberi Anda backtrace, Anda jarang harus menggunakan debugger.

Terakhir kali saya menggunakan debugged adalah ketika saya mendapatkan file inti di beberapa aplikasi lawas.

Apakah saya menjadi "antek debbuger" atau apakah orang-orang ini "terlalu keras"?

Tidak juga. Mereka hanya jenis orang yang suka membuat hidup mereka lebih sulit dari yang seharusnya.

Debugging hanyalah alat yang harus digunakan oleh pengembang yang baik.

Tentu saja kadang-kadang Anda dapat mengingat di mana bug itu berada jika Anda tahu basis kode. Tetapi Anda juga bisa kehilangan satu hari atau seminggu untuk menemukan bug sial hanya dengan melihat kode.

Dalam bahasa yang diketik secara dinamis tanpa semacam debugging (bahkan jika itu hanya membuang nilai ke konsol) menebak terkadang menjadi tidak mungkin.

Jadi untuk menjawab pertanyaan Anda - mungkin mereka adalah programmer yang brilian, tetapi kemampuan pemecahan masalah dan kemahiran mereka saat berburu bug buruk.

Tergantung pada ruang lingkup masalah. Jika programnya kecil dan segala sesuatunya terpecah, Anda mungkin dapat mengetahuinya dengan melihat. Jika program ini 4,5 juta baris kode yang dikembangkan oleh tim yang terdiri dari 100+ orang selama beberapa tahun maka bug tertentu tidak mungkin dikenali.

Yang dimaksud dalam program tersebut (dalam C) adalah memori yang ditimpa. Debugger dengan memory breakpoint mengidentifikasi baris kode yang menyinggung begitu bug muncul. Tetapi dalam kasus ini tidak ada cara seseorang bisa membaca dan mempertahankan semua 4,5 juta baris kode untuk mengidentifikasi satu tempat seseorang menulis melewati array mereka (ditambah mereka harus tahu tata letak runtime dari memori untuk keadaan program gargantuan sekitar 10 menit dalam jangka panjang input untuk sampai ke titik itu).

Poinnya adalah: Dalam program kecil atau hal-hal yang sangat termodulasi Anda bisa lolos tanpa debugger. Jika program ini benar-benar besar dan kompleks, maka debugger dapat menghemat banyak waktu. Seperti yang dikatakan orang lain, ini adalah alat, dan memiliki situasi di mana ia unggul di atas metode lain, dan yang lain di mana itu bukan pilihan terbaik.

Jika bug terjadi di komputer klien, atau di komputer yang lingkungannya jauh berbeda dengan Anda, maka menyiapkan debugger / debugger jarak jauh adalah rumit. Jadi, untuk hari yang dingin di mana Anda mendapatkan bug dari lapangan, respons 'tapi ... saya tidak punya debugger' tidak membantu. Oleh karena itu, Anda perlu mengembangkan serangkaian keterampilan pemecahan masalah dan menemukan bug hanya melalui pemahaman kode dan file log.

Benar-benar omong kosong: "Pemrogram sungguhan tidak membutuhkan Debuggers." Mungkin juga mengatakan bahwa seorang programmer sejati tidak memerlukan IDE, cukup beri saya buku catatan dan pensil kusam. Debugger adalah alat seperti yang lain yang membantu produktivitas.

Juga, pertimbangkan bahwa tidak semua orang yang ditugasi kode debug mengetahui kode itu. Banyak kontraktor waktu datang ke lingkungan di mana mereka hanya memiliki cita-cita umum tentang apa yang terjadi. Mereka bahkan dapat diberikan deskripsi terperinci tentang suatu lingkungan - atau peta skema berusia 20 tahun dan panduan untuk konvensi penamaan misterius (coba pahami perbedaan antara tabel X1234 dan tabel X4312 dengan bidang F1, F2, dan F3 [ya, sampah seperti ini ada] ketika Anda baru), tetapi berkali-kali deskripsi itu salah; jika tidak, mengapa ada kesalahan "misteri".

Sebagai seseorang yang baru mengenal suatu lingkungan, Anda dapat menghabiskan waktu berjam-jam untuk memetakan dan mengenal "basis data" besar untuk area masalah yang mungkin Anda perbaiki dan tidak perlu melihatnya lagi. Ini sangat membuang waktu dan uang. Jika Anda memiliki akses ke debugger, Anda melihat apa yang terjadi, memperbaikinya, dan hilang dalam hitungan menit. Semua ini "Anda tidak perlu debuggers" hooey hanya puffery elitis.