Menghabiskan terlalu banyak waktu untuk debugging

Kemarin, saya meluncurkan rilis v1.0 dari proyek Web yang saya habiskan sekitar 6 minggu bekerja (on dan off, itu). Saya belum membuat catatan yang pasti tentang waktu saya, tetapi menurut pengalaman saya, saya akan memperkirakan bahwa dari semua waktu yang saya habiskan untuk pemrograman, setengahnya dihabiskan untuk debugging. Saya memperkirakan bahwa sekitar 15-20 jam yang baik menghabiskan debugging, yang bagi saya adalah waktu berharga yang bisa lebih baik dihabiskan menulis kode baru atau menyelesaikan proyek sebelumnya. Ini juga terutama tidak membantu bahwa saya akan menjadi mahasiswa baru di perguruan tinggi dalam 5 minggu.

Masalahnya, saya merasa tidak enak karena menghabiskan semua waktu debugging. Semua waktu yang dihabiskan untuk debugging membuat saya menyadari bahwa saya membuat beberapa kesalahan yang cukup bodoh ketika saya sedang mengembangkan proyek saya, kesalahan yang menghabiskan banyak waktu untuk diperbaiki.

Bagaimana saya bisa mencegah hal ini terjadi di masa depan? Saya tidak ingin menghabiskan 50% dari waktu debugging saya, saya lebih suka menghabiskan 10% debugging dan sisanya menulis kode baru. Apa sajakah teknik yang dapat saya coba untuk membantu saya mencapai tujuan ini?

Anda sedang meminta Holy Grail dari rekayasa perangkat lunak, dan belum ada jawaban "" untuk pertanyaan ini.

Yang penting adalah Anda melacak jenis kesalahan yang Anda buat dan kemudian melakukan analisis kesalahan tersebut untuk menentukan apakah ada kecenderungan umum. Analisis akar penyebab adalah nama formal untuk jenis introspeksi ini, dan ada banyak materi di web mengenai hal itu.

Profesional menggunakan sistem pelacakan bug sehingga mereka dapat (1) tahu apa yang perlu diperbaiki, tetapi juga (2) menganalisis apa yang harus diperbaiki setelah fakta. Anda tidak perlu bersikap formal - menyimpan catatan di notebook mungkin baik untuk Anda.

Cacat Tahap Desain

Jika Anda menemukan bahwa sebagian besar kesalahan Anda berasal dari kesalahpahaman tentang pernyataan masalah, atau jika Anda terus menemukan Anda memilih algoritma atau jalur yang salah untuk diikuti dalam menyelesaikan masalah Anda, Anda memiliki masalah dalam tahap desain.

Penting bagi Anda untuk meluangkan lebih banyak waktu di awal proyek dan menulis dengan tepat apa yang perlu dilakukan dan bagaimana seharusnya melakukannya. Tinjau pekerjaan ini dengan hati-hati dan tinjau kembali masalah aslinya dan tentukan apakah Anda benar-benar menanganinya dengan cara yang benar. Satu atau tiga jam ekstra di awal dapat menghemat banyak waktu.

Kesalahan Pengkodean

Jika desain Anda solid, tetapi Anda terus-menerus memperjuangkan bahasa yang Anda kodekan, dapatkan sendiri beberapa alat yang akan menganalisis kode Anda dan memperingatkan Anda sejak dini dan sering kali Anda membuat kesalahan.

Jika Anda memprogram dalam C, aktifkan semua peringatan kompiler, gunakan pemeriksa semantik lint, dan gunakan alat seperti valgrinduntuk menangkap masalah umum terkait memori dinamis.

Jika Anda pemrograman Perl, menghidupkan strictdan warningsdan mengindahkan apa yang dikatakan.

Tidak peduli bahasa apa yang Anda gunakan, mungkin ada banyak alat di luar sana untuk membantu menangkap kesalahan umum jauh sebelum Anda mencapai tahap debugging.

Cacat Tahap Integrasi

Ketika Anda mengembangkan kode Anda mengikuti praktik modularitas yang baik, Anda harus mulai menempelkan bagian-bagian yang terpisah bersama-sama. Misalnya, bagian berbeda dari kode Anda mungkin berkaitan dengan input pengguna, interaksi basis data, tampilan data, algoritme / logika, dan masing-masing dibangun relatif independen satu sama lain (yaitu, Anda cenderung berkonsentrasi pada bagian yang ada di tangan daripada khawatir tentang integrasi dengan yang lainnya).

Di sinilah pengembangan tes driven (TDD) sangat berguna. Setiap modul kode Anda dapat memiliki tes yang memverifikasi bahwa mereka bekerja sesuai dengan bagaimana mereka dirancang. Tes-tes ini harus ditulis terlebih dahulu atau sangat awal dalam proses sehingga Anda dapat memiliki satu set "pembantu" untuk membuat Anda jujur. Ketika Anda mulai membuat semuanya bekerja bersama, dan Anda menemukan bahwa Anda harus mengubah cara ini atau itu diterapkan atau berinteraksi dengan sub-sistem lain, Anda dapat kembali ke tes Anda untuk memastikan bahwa apa yang telah Anda lakukan untuk membuat semuanya bekerja bersama tidak merusak kebenaran kode.

Dan seterusnya...

Ambil beberapa buku tentang rekayasa perangkat lunak dan teknik pengkodean praktis, dan Anda akan belajar banyak cara untuk membuat pengembangan tidak semrawut dan lebih dapat diandalkan. Anda juga akan menemukan bahwa pengalaman lama yang biasa - dapatkan gelar dari sekolah yang keras - akan membuat Anda menjadi bugar juga.

Apa yang hampir semuanya bermuara adalah bahwa sedikit waktu dan pekerjaan di muka terbayar dalam dividen besar kemudian dalam proses pengembangan / rilis.

Fakta bahwa Anda telah memperhatikan masalah ini begitu awal dalam karir Anda berbicara baik untuk masa depan Anda, dan saya berharap yang terbaik untuk Anda.

Tulis Tes Unit

Tes unit menulis untuk kode Anda akan memaksa Anda untuk berpikir tentang arsitektur Anda dan mendorong Anda untuk menulis kode Anda dalam potongan-potongan kecil, dikendalikan dengan hati-hati, dapat diuji. Ini akan sangat mengurangi upaya debugging Anda, dan sejumlah kecil debugging yang Anda lakukan akan terbatas pada bagian kode yang kecil dan terfokus dengan ketat.

Selain itu, tes yang Anda tulis akan "mencakup" kode Anda; Anda dapat mengetahui kapan perubahan yang Anda lakukan pada kode memecah sesuatu, karena satu atau lebih dari tes yang ada akan gagal. Ini mengurangi keseluruhan kerumitan upaya debugging Anda dan meningkatkan kepercayaan diri Anda bahwa kode itu berfungsi.

Yang menarik, tentu saja, adalah bahwa waktu yang dihabiskan untuk debugging sekarang dihabiskan untuk menulis tes. Tetapi Anda hanya perlu menulisnya sekali, dan mereka dapat dieksekusi sebanyak yang diperlukan setelah menulisnya.

50% untuk debugging (dalam arti luas) tidak terlalu buruk. Orang-orang biasanya menghabiskan lebih banyak waktu merancang, menguji, memperbaiki bug, refactoring, dan menulis unit test daripada Anda menulis kode yang sebenarnya. Itu bagian dari pekerjaan.

Dan sejujurnya, ini jauh lebih buruk dalam pemrograman pemeliharaan - cukup sering, saya menghabiskan waktu satu jam untuk mencari tahu apa yang salah, lalu lima menit menulis kode untuk memperbaikinya, dan kemudian setengah jam menguji semuanya. Itu lebih dari 5% coding vs hampir 95% non-coding.

Ada beberapa hal yang dapat Anda lakukan untuk mengurangi waktu debugging:

• Tulis kode debuggable . Ini berarti: penanganan kesalahan yang tepat (dengan beberapa pemikiran dimasukkan ke dalamnya), penataan kode Anda untuk membuatnya mudah diikuti, menggunakan menegaskan, melacak, dan apa pun yang dapat membuat hidup debugger lebih mudah. Hindari garis yang rumit; garis yang melakukan lebih dari satu hal harus dipisah sehingga Anda melangkah secara individual.
• Tulis kode yang dapat diuji . Pisahkan kode Anda menjadi fungsi-fungsi sederhana (atau apa pun yang didukung oleh bahasa pilihan Anda); hindari efek samping, karena ini sulit ditangkap dalam tes unit. Rancang fungsi Anda sehingga dapat dijalankan secara terpisah. Hindari fungsi multiguna. Hindari kasing tepi. Dokumentasikan apa yang seharusnya dilakukan fungsi Anda.
• Tulis tes . Memiliki unit test berarti Anda tahu bahwa fungsi Anda berfungsi setidaknya untuk sebagian dari inputnya; itu juga berarti Anda memiliki pemeriksaan kewarasan untuk mengonfirmasi bahwa perubahan Anda tidak merusak apa pun. Pastikan Anda memahami konsep cakupan kode dan cakupan input, serta keterbatasan pengujian unit.
• Atur 'meja kerja' . Bagaimana tepatnya Anda melakukan ini tergantung pada bahasa yang dimaksud. Beberapa bahasa, seperti Python atau Haskell, datang dengan interpreter interaktif, dan Anda dapat memuat kode yang ada ke dalamnya untuk bermain dengannya. Ini sempurna, karena Anda dapat memanggil fungsi Anda dalam konteks apa pun yang Anda suka, dengan upaya minimal - alat yang sangat berharga untuk menemukan dan mengisolasi bug. Bahasa lain tidak memiliki kemewahan ini, dan Anda harus menggunakan sedikit program tes interaktif.
• Tulis kode yang dapat dibaca . Biasakan untuk menulis kode Anda untuk mengekspresikan niat Anda sejelas mungkin. Dokumentasikan semua yang tidak terlalu jelas.
• Tulis kode sederhana . Jika otak Anda sendiri kesulitan memahami seluruh basis kode, maka itu tidak sederhana, dan sangat tidak mungkin orang lain akan dapat sepenuhnya memahaminya. Anda tidak dapat men-debug kode secara efektif kecuali Anda memahami apa yang seharusnya dilakukan.
• Mudah di tombol 'Hapus' . Kode apa pun yang tidak Anda butuhkan saat ini berada di tempat sampah. Jika Anda membutuhkannya nanti, hidupkan kembali dari kontrol sumber (pengalaman menunjukkan bahwa ini sangat langka). Semakin banyak kode yang Anda buang, semakin kecil permukaan debug Anda.
• Reaktor lebih awal dan sering. Tanpa refactoring, Anda tidak dapat menjaga kode Anda dalam status debuggable sambil menambahkan fitur baru.

Perencanaan Lebih Lanjut

Tidak dapat dihindari bahwa Anda akan menghabiskan banyak waktu untuk debugging, 10% adalah tujuan yang cukup ambisius. Meskipun salah satu cara terbaik untuk mengurangi waktu yang dihabiskan untuk debugging dan pengembangan adalah menghabiskan lebih banyak waktu dalam fase perencanaan.

Ini dapat berkisar dari diagram, hingga kode pseudo pada pad perencanaan. Either way, Anda akan memiliki lebih banyak waktu untuk mengunyah apa yang perencanaan Anda lakukan daripada membuat kesalahan selama pengembangan.

Bekerja lebih hati-hati

Ini adalah perangkat lunak yang setara dengan "ukur dua kali potong sekali":

• Jangan kode jika Anda merasa terganggu atau lelah.
• Luangkan cukup waktu untuk memikirkan masalah sehingga Anda memiliki solusi yang bersih dan elegan. Solusi sederhana cenderung memiliki masalah.
• Berikan semua perhatian Anda pada tugas tersebut. Fokus.
• Baca kode Anda dengan cepat setelah pengkodean untuk mencoba dan mencari kesalahan. Ulasan kode sendiri.
• Jangan menunggu terlalu lama antara pengkodean dan pengujian. Umpan balik segera penting untuk ditingkatkan.
• Hindari melakukan hal-hal yang umumnya mengarah pada kesalahan. Baca pada kode bau .
• Pilih alat yang tepat untuk pekerjaan itu.

Semua yang dikatakan, tidak ada yang akan sepenuhnya menghilangkan cacat. Anda harus menerima ini sebagai fakta kehidupan. Dengan adanya rencana fakta untuk cacat ini, mis. Unit test. Juga jangan menganggap ini berarti "mengambil selamanya" (alias analisis-kelumpuhan). Ini tentang menemukan keseimbangan.

Jawaban lain sudah mencakup sebagian besar dari apa yang ingin saya katakan, tetapi saya tetap ingin memberikan pendapat saya (sangat jujur):

Pada dasarnya, untuk pekerjaan perangkat lunak non-sepele, berharap untuk menghabiskan sebagian besar waktu Anda untuk pemeliharaan dan debugging. Jika Anda bekerja pada sistem perangkat lunak produksi yang matang, dan Anda menghabiskan kurang dari 80-90% waktu Anda untuk pemeliharaan dan debugging, Anda melakukannya dengan baik!

Sekarang jelas, perbedaan antara "pemeliharaan" dan "debugging" agak subyektif. Apakah Anda hanya menganggap "bug" sebagai masalah dengan kode yang ditemukan setelah dirilis dan pengguna mengeluhkannya? Atau apakah itu setiap hal kecil yang salah dengan kode Anda setelah Anda menambahkan sesuatu (ditemukan dalam fase pengujian pra-rilis Anda sendiri)? Dalam sistem perangkat lunak non-sepele (tergantung pada pola penggunaan) yang satu bisa jauh lebih besar dari yang lain. Tetapi bagaimanapun juga, ini adalah pemrograman yang membutuhkan sesuatu yang lebih besar dari program mainan "Hello world" - banyak dan banyak perawatan dan debugging. Beberapa orang bahkan mengatakan sesuatu seperti " semuanya setelah baris kode pertama harus diharapkan menjadi 'mode pemeliharaan',

TL; DR: Bagi saya sepertinya Anda mungkin memiliki gambaran yang sedikit tidak realistis tentang pemrograman sistem perangkat lunak non-sepele. Sebagian besar upaya adalah dalam finetuning, pemeliharaan, refactoring, memperbaiki bug, dan secara umum melakukan hal-hal yang akan datang di bawah "debugging" (pemeliharaan) - setidaknya dalam arti yang sangat umum - sebagai lawan dari melakukan pekerjaan baru yang benar-benar baru, menulis kode baru yang segar.

Sulit untuk memberikan teknik khusus tanpa detail spesifik tentang apa yang Anda lakukan dan teknologi apa yang Anda gunakan. Tetapi bahkan coders yang sangat bagus menghabiskan banyak waktu pengujian dan debugging.

Banyak yang menulis kode bagus tanpa banyak bug adalah pengalaman. Anda membuat kesalahan, lalu memperbaikinya, lalu Anda mengingat kesalahan apa dan apa yang harus Anda lakukan untuk melakukannya dengan benar, dan Anda tidak membuat kesalahan yang sama di lain waktu. Dan jika Anda bahkan belum kuliah dan Anda sudah mulai berpikir serius tentang cara-cara untuk membuat lebih sedikit kesalahan, saya akan mengatakan Anda pasti di depan permainan.

INTEGRASI TERUS MENERUS (CI) adalah jawabannya.

Integrasi Berkelanjutan = Sistem Manajemen Konfigurasi (yaitu, Git, Mercurial, SVN, dll.) + Alat CI + Tes Unit + Tes Asap

Rumus itu seharusnya mendorong Anda untuk membaca lebih lanjut tentang Integrasi Berkelanjutan (CI). Berikut adalah beberapa sumber di area ini:

• Aturan XP tentang Mengintegrasikan Sering
• Martin Fowler's Bliki di CI
• Integrasi Berkelanjutan: Meningkatkan Kualitas Perangkat Lunak dan Mengurangi Risiko Buku ini adalah buku yang luar biasa!

Sungguh, untuk mengurangi debugging Anda bisa memuatnya dengan perencanaan lebih mendalam. Belum kuliah? Saya pikir Anda akan melihat di kelas menengah hingga akhir kuliah, Anda akan membahas perincian siklus hidup pengembangan perangkat lunak yang mungkin bisa menyinari kebodohan Anda.

Ketika saya mencoba menjelaskan kepada atasan saya, cara terbaik untuk mengurangi pemeliharaan kode dan dukungan teknis adalah menghabiskan waktu untuk merencanakan kode Anda secara komprehensif terlebih dahulu.

Pengembangan yang digerakkan oleh pengujian dapat membantu mengurangi waktu debug dengan:

• memiliki banyak tes yang kecil dan terfokus berarti jika seseorang gagal hanya ada sedikit kode yang dapat menyebabkan masalah.
• bekerja dalam langkah-langkah kecil (dengan menulis tes yang gagal dan kemudian lulus) berarti Anda dapat fokus pada satu tugas pada satu waktu. Yaitu, membuat masa lalu tes saat ini.
• refactoring setelah Anda membuat tes lulus mendorong Anda untuk menjaga kode Anda jelas dan mudah dipahami - membuatnya lebih mudah untuk diikuti jika terjadi masalah.

Bahkan jika Anda menggunakan TDD, Anda masih akan memiliki waktu ketika Anda perlu menggunakan debugger. Ketika ini terjadi, Anda harus mencoba menulis unit test untuk mereproduksi skenario yang menyebabkan sesi debugging. Ini akan memastikan bahwa jika masalah itu terjadi lagi, masalah tersebut akan segera ditangkap ketika pengujian gagal, dan pengujian akan bertindak sebagai penanda untuk area kode yang menyebabkan masalah - mengurangi kebutuhan untuk debugging.

Debug tidak bisa dihindari dalam pemrograman, tetapi kuncinya di sini adalah, apakah kode Anda mudah di-debug atau tidak? Jika Anda perlu menghabiskan berjam-jam hanya untuk men-debug sesuatu yang sederhana, maka pasti ada sesuatu yang salah dengan arsitektur kode Anda.

Anda harus terbiasa menulis kode bersih, dan menghilangkan kebiasaan buruk seperti menyalin kode tempel dan menulis metode panjang, dll.

Selain itu, Anda harus memperbaiki kode Anda dari waktu ke waktu. Saya sarankan Anda membaca buku Martin Fowler: Refactoring: Meningkatkan Desain Kode yang Ada

Yang lain telah menyebutkan pengujian dan tinjauan kode. Keduanya sangat berguna tetapi memiliki perbedaan utama - kapan terbaik untuk melakukannya. Pengujian paling baik dilakukan sangat dekat dengan awalnya menulis kode, sehingga Anda dapat lebih mudah mengingat mengapa Anda melakukan hal-hal dengan cara tertentu dan dapat lebih cepat menemukan masalah ketika gagal dalam pengujian. Tinjauan kode, di sisi lain, lebih baik dilakukan sedikit di kemudian hari. Anda ingin melihat kode tanpa ingatan yang sempurna sehingga Anda tidak mengabaikan detail yang Anda ingat tetapi tidak dimasukkan. Anda ingin menyadari tempat-tempat di mana kode Anda tidak jelas. Anda ingin sedikit usaha ekstra untuk mengetahui apa yang dilakukan kode. Anda ingin dapat menerapkan pengetahuan baru yang Anda peroleh tentang masalah atau interaksi dengan kode lain atau teknik baru. Pada dasarnya,

Semua ini masih bersinggungan dengan pertanyaan Anda. Untuk mengurangi waktu debugging, Anda harus memahami mengapa Anda harus debug pada awalnya. Kesalahpahaman tentang masalah, pengetahuan yang tidak sempurna tentang alat dan teknologi Anda, dan hanya dengan berjalan ke dalam "data nyata tidak cocok dengan data sampel" semua jenis masalah akan terwujud dalam cara yang berbeda dan membutuhkan teknik dan jenis praktik yang berbeda untuk menghindari di masa depan.

Poin terakhir yang akan saya buat adalah pengalaman. Tidak ada cara mudah untuk mendapatkan ini, Anda hanya perlu meluangkan waktu. Ketika Anda mendapatkan pengalaman, Anda akan menghabiskan lebih sedikit waktu debugging karena Anda akan menulis kode yang lebih baik untuk memulai, perhatikan masalah sebelumnya, dan mengembangkan intuisi yang lebih baik untuk apa sumber masalah mungkin. Terus lakukan itu dan Anda akan terus berkembang selama karier Anda.

Jawaban bagus di atas tetapi tidak ada yang disebutkan secara langsung (meskipun sebagian besar mengisyaratkan hal ini):

BACA BACA BACA BACA dan pada mual ...

Semakin banyak Anda tahu, semakin sedikit Anda tidak tahu. Agak klise, tapi tetap dasar kebenarannya.

Setelah Anda mengikuti tips di atas dan secara analitis mendokumentasikan bug, cobalah untuk mengklasifikasikannya, dan kemudian membaca literatur yang bersangkutan.

Apakah ini masalah keputusan desain? Baca tentang Pola Desain.

Apakah itu kurangnya pengetahuan tentang kerangka kerja atau bahasa? Mengejutkan itu!

dll

Ada dua hal yang pengembang tidak pernah dapat hindari: perubahan (satu-satunya yang konstan dalam TI) dan RTFMing ...

Tes dan konfirmasi unit

Jika memungkinkan, faktor kode Anda menjadi potongan-potongan kecil yang dapat diuji secara terpisah. Ini tidak selalu praktis. Beberapa fungsi tergantung pada input yang sangat rumit. Beberapa melakukan sesuatu yang tidak dapat dengan mudah diverifikasi dengan cara otomatis, seperti menarik barang ke layar. Terkadang non-determinisme terlibat, dll.

Ketika Anda tidak dapat menulis unit test yang baik, hal terbaik berikutnya adalah menegaskan. Sementara unit test memeriksa untuk melihat apakah Anda mendapatkan jawaban yang benar pada beberapa input yang telah ditentukan, menegaskan periksa kewarasan langkah perantara pada input dunia nyata. Jika kode Anda memiliki bug, itu akan gagal dengan cepat, dekat dengan akar masalah dan dengan pesan kesalahan yang jelas, daripada jauh dari masalah dengan pesan kesalahan yang ambigu. Lebih jauh, tegaskan asumsi dokumen dan buat kode Anda lebih mudah dibaca.

Ketika Anda memulai sebuah proyek, berapa banyak pendekatan alternatif yang Anda identifikasi?

Apakah Anda memiliki dua hingga empat pendekatan yang berbeda, dengan pro dan kontra untuk masing-masing? Apakah Anda kemudian membuat pilihan yang masuk akal dari antara mereka?

Lalu, yang paling penting, apakah Anda menganggap kesederhanaan itu sangat penting?

Alasan saya bertanya adalah, dalam pengalaman saya, volume kode, dan dengan demikian jumlah bug (belum lagi kinerja), dapat bervariasi lebih dari satu urutan besarnya antara satu pendekatan desain dan lainnya. Apa yang saya lihat dilakukan oleh orang yang sangat berpengalaman adalah menyelesaikan pekerjaan tanpa kode lebih dari yang diperlukan.

Mereka sepenuhnya kompeten dan menyadari semua algoritma struktur data, fitur bahasa berorientasi objek, dan sebagainya, tetapi kode mereka tampak seolah-olah tidak , karena mereka menggunakan hal-hal itu dengan hemat , atau tidak sama sekali, jika masalahnya tidak tidak membutuhkannya.

Setiap kali Anda memperbaiki bug, Anda ingin menghindari membuat kesalahan yang sama lagi. Untuk melakukannya, Anda dapat melakukan hal berikut:

• Tuliskan dalam log rekaman cacat , yang meliputi:

  • jenis cacat
  • fase di mana cacat disuntikkan
  • fase di mana ia dihapus
  • perbaiki waktu
  • deskripsi masalah dan perbaiki

• Gunakan panduan gaya untuk menormalkan gaya kode yang Anda tulis

• Integrasikan aturan pengkodean aman ke dalam proses peninjauan kode Anda

• Visualisasikan aliran kontrol dan data

Referensi

• Studi Empiris tentang Dampak PSP terhadap Insinyur Individual (pdf)

• Panduan Gaya Google CPP

• Mengakui Kekalahan Pada K&R di LCTHW - Zed A. Shaw

• Plug-in IDE - Cara Pengujian Keamanan untuk Mengotomatiskan Tinjauan Kode | Komunitas Keamanan Cyber ​​TCS

• Aturan Aturan Keamanan ditetapkan untuk kode yang dikelola

• Secure Coding di C ++ 11 dan C ++ 14

• Visualisasikan eksekusi kode Java

• Visualisasi SPARQL

• Tutorial WWW2012 Memvisualisasikan Kueri SPARQL