Apakah lebih mahal untuk memperbaiki bug di akhir proyek?

Dalam posting blog oleh Andrew Hay , aksioma berikut diajukan:

Biayanya lebih besar untuk memperbaiki bug pada akhir proyek yang dilakukannya untuk memperbaiki bug yang sama sebelumnya dalam proyek.

Namun, ini tampaknya tidak pasti, terutama setelah membaca posting blog tentang Less Wrong , dan data yang saya lihat mendukungnya sudah sangat tua.

Apakah ini masih aksioma yang akurat hari ini?

Satu-satunya data sulit yang pernah saya lihat adalah Boehm dan Papaccio, Memahami dan Mengontrol Biaya Perangkat Lunak .

Ini berasal dari tahun 1988 dan merupakan studi sekitar 80 proyek perangkat lunak. Mereka menyimpulkan bahwa keputusan yang dibuat lebih awal dan terlambat dikoreksi dapat menelan biaya 50-200 kali dari yang seharusnya jika dikoreksi lebih awal. Tetapi jenis keputusan awal yang mereka bicarakan adalah OS mana yang akan dijalankan dan bahasa serta basis data mana yang digunakan.

Jadi angka-angka itu mungkin terlalu banyak sehubungan dengan pengembangan perangkat lunak saat ini. Namun, sekarang kami memiliki banyak pengalaman di bidang ini dan kami tahu secara naluriah bahwa hal itu masih berlaku hingga saat ini.

Secara ekstrem, kita tahu bahwa jika kegagalan dalam persyaratan ditangkap tepat sebelum kita pergi ke produksi, ini menyebabkan banyak pengerjaan ulang dan proyek tertunda atau memang dibatalkan, di mana jika telah ditangkap sebelum pekerjaan apa pun dilakukan, kami sudah baik-baik saja.

Sunting: Doc Brown membuat poin yang baik dalam komentarnya.

Penelitian Boehm dilakukan pada proyek COBOL dan FORTRAN di saat kompilasi dan waktu berjalan sangat lambat. Saya memulai karir saya di awal 90-an di COBOL dan siklus kompilasi dan tes yang diperlukan begitu lama sehingga layak untuk mengeringkan tes sebelum melewati siklus (atau setidaknya selama fase build, untuk berjaga-jaga Anda dapat menangkap sesuatu dan membatalkannya lebih awal, menghemat satu jam atau lebih).

Pada gilirannya, bos kami biasanya menertawakan keluhan kami karena belum lama ini mereka harus membawa sekotak kartu punch yang diurutkan dengan tangan ke ruang server dan membiarkannya di sana selama sehari.

Jadi itu pasti lebih benar daripada sekarang.

Namun, baru-baru ini, saya telah melihat blog menggunakan kembali visualisasi Steve McConnell untuk masalah ini ( ref , tanggal 1996) seolah-olah grafik itu sebenarnya berdasarkan angka keras. Bukan itu. Ini visualisasi, untuk menjelaskan maksudnya secara sederhana.

Saya pikir premis Morendil, dalam artikel yang dikutip OP, bagus. Ilmu yang kita miliki tentang hal ini buruk dan ketinggalan zaman namun diperlakukan sebagai kanon. Tetapi saya juga berpikir bahwa itu bertahan dengan baik dan terdengar benar karena kita tahu dari pengalaman pahit bahwa itu masih benar, setidaknya sampai titik tertentu. Dan saya pikir ungkapan dramatis "disiplin penyakit" tidak membantunya.

Meskipun saya tidak mengetahui adanya data keras atau bukti lain untuk mendukung klaim ini, minimal , saya pikir itu masuk akal.

Pikirkan seperti ini .. Jika Anda memiliki sistem yang kompleks dengan subsistem yang saling tergantung (seperti yang dilakukan sebagian besar aplikasi non-sepele), pikirkan masalah knock-on yang mungkin merupakan hasil dari perubahan yang dilakukan pada salah satu sistem. Jika subsistem terbukti benar (melalui unit test dan sejenisnya) dan diperbaiki lebih awal, jumlah bug yang akan disebabkan oleh ketukan saja dikurangi hanya dengan memperbaiki lebih awal.

Juga, jika Anda memperbaiki bug lebih awal, implementasinya masih segar di benak pengembang. Bergantung pada lamanya proyek yang diberikan, jika Anda memperbaiki bug pada akhirnya, pengembang perlu meluangkan waktu untuk mencari tahu apa yang mereka tulis dan (mungkin) bagaimana subsistem yang bergantung pada kode mereka pada pekerjaan. Waktu yang dihabiskan untuk mempelajari kembali ini = $.

Saya ragu bahwa itu mungkin untuk menghasilkan cara yang kaku secara ilmiah untuk mengukur ini - ada terlalu banyak faktor lain yang terlibat, dan tidak ada dua proyek yang cukup sebanding untuk dijadikan lebih dari studi kasus. Pemikiran logis seharusnya membuat Anda jauh. Beberapa argumen:

• Jumlah total kode dalam suatu proyek cenderung tumbuh menjelang akhir. Semakin lama Anda menunggu memperbaiki bug, semakin besar basis kode yang harus Anda sentuh.
• Kualitas kode baru yang ditambahkan ke proyek berkurang menjelang akhir, setidaknya jika ada tekanan (yang biasanya diberikan): tenggat waktu yang menjulang membuat orang melemparkan praktik terbaik ke laut hanya untuk mengirim tepat waktu. Ini berarti bahwa semakin Anda memperbaiki bug, semakin banyak kode buruk yang harus Anda saring.
• Meskipun duplikasi kode umumnya disukai, itu terjadi setiap saat, dan karena mudah untuk menyalin-tempel, tetapi sulit untuk menggabungkan kembali bagian kode duplikat, jumlah kode yang pernah disalin-salin biasanya meningkat selama masa proyek. Semakin banyak kode yang disalin berarti semakin besar kemungkinan bug Anda akan diduplikasi dan perlu ditemukan dan diperbaiki beberapa kali (dan akibatnya, peluang lebih tinggi bahwa beberapa kemunculannya tidak diperhatikan).
• Memperbaiki bug adalah perubahan ke basis kode; Anda berharap untuk membuat segalanya lebih baik, tetapi perubahan selalu membawa risiko. Perubahan yang menyebabkan masalah serius dalam proyek dengan beberapa bulan lagi harus meninggalkan banyak ruang untuk manajemen kerusakan, tetapi dua hari sebelum pengiriman, Anda berada dalam masalah serius.
• Semakin lama bug itu sendiri ada, semakin besar kemungkinan bagian-bagian lain dari aplikasi mulai mengandalkan kesalahannya. Kemudian ketika Anda memperbaikinya, Anda tiba-tiba mengeluarkan sekelompok bug sekunder dalam kode yang tidak mengharapkan fungsi Anda untuk benar-benar memberikan hasil yang didokumentasikan dengan benar.

Ini adalah hal-hal dasar yang diterima dari rekayasa sistem - dan ini berlaku untuk segala bentuk pengembangan teknis (baik itu membangun jembatan, rudal, kapal perang atau perangkat lunak).

Pada dasarnya, biaya barang naik sekitar urutan besarnya ketika Anda bergerak melalui tahap pengembangan.

Sesuatu yang berharga $ 10 untuk diperbaiki pada saat menyusun ide ...

Harganya sekitar $ 100 jika Anda perlu memperbarui spesifikasi ....

Atau biayanya sekitar $ 1000 jika sesuatu diterapkan dan Anda perlu melakukan perubahan pada saat itu (dan memperbarui spek, dan mendapatkan persetujuan dan sebagainya) tetapi belum melalui semacam penerimaan formal / tes jual

Atau biaya sekitar $ 10.000 jika sesuatu diterapkan dan pelanggan diterima, dan Anda perlu melakukan perubahan pada saat itu (dan memperbarui spek, dan mendapatkan persetujuan, dan menguji ulang dan menjalankan kembali penerimaan dan kualifikasi pelanggan, dan sebagainya)

Dan biaya setelah penyebaran / peluncuran / pengerjaan layanan bahkan lebih lagi.

Banyak contoh dan mudah untuk memahaminya: sistem perbankan dengan perubahan ruang lingkup yang serius dibuat setelah Anda memiliki 25.000 karyawan yang menggunakannya akan dikenakan biaya paket dalam waktu pelatihan ulang ... bahkan sebelum Anda mempertimbangkan pelingkupan, pengkodean, pengujian, regresi, dll dll.

TENTANG jarak tempuh Anda akan bervariasi: biaya dan dampak perubahan situs web e-commerce penghangat kaus kaki elektronik Fred Nurke agak berbeda dengan biaya perubahan perangkat lunak pada komputer kontrol penerbangan pesawat.

Saya tidak memiliki akses ke data atau fakta, jadi saya hanya bisa menawarkan pengamatan anekdotal yang diperoleh dari 20 tahun terakhir saya di TI.

Saya percaya ada perbedaan besar antara cara sebagian besar pengembang membuat perangkat lunak saat ini dibandingkan dengan 20 tahun yang lalu. Dengan gerakan Agile yang telah mendapatkan banyak momentum, khususnya dalam 5-6 tahun terakhir, saya telah melihat perubahan sikap yang nyata di tempat kerja. Sedemikian rupa sehingga kualitas apa yang kita lakukan tampaknya tumbuh dengan pesat setiap tahun, dan dengan setiap proyek saat kita menerapkan pelajaran yang telah kita pelajari dari proyek ke proyek. Proses lean dikombinasikan dengan fokus pada pengembangan uji-pertama telah berkembang dari yang sangat kontroversial menjadi hal biasa. Sedemikian rupa sehingga berjalan ke banyak perusahaan hari ini, jika Anda tidak nyaman dengan Agile Anda akan beruntung jika mereka tidak menunjukkan pintu.

Jadi apa dampaknya ini. Pertama-tama, saya perhatikan bahwa masalah sering diidentifikasi lebih awal. Seringkali itu adalah kasus bahwa jika masalahnya tidak terlihat terlalu besar, kadang-kadang dapat ditahan tanpa batas waktu. Dalam beberapa kasus yang jarang terjadi, saya telah melihat bug yang dianggap sepele menjadi masalah serius ketika ditangani kemudian, karena beberapa masalah mendasar menjadi jelas yang tidak dipertimbangkan pada saat itu. Kadang-kadang ini dapat menyebabkan siklus perbaikan berlarut-larut, dan itu bisa mahal sampai taraf tertentu, tetapi biaya itu sering diukur lebih sedikit dalam hal sumber daya, dan lebih sering dalam hal dampak pada hubungan antara pelanggan dan pengembang. Pelanggan semakin terbiasa dengan cara berpikir Agile ini, yang mengembalikan hasilnya kepada mereka jauh lebih cepat daripada sebelumnya, dengan sprint pengembangan yang sangat iteratif dan perputaran cepat antara permintaan dan implementasi, sehingga mereka mengharapkan banyak dari kita. Dan sejauh menyangkut bug yang sebenarnya, waktu untuk memperbaiki bug lebih sering sangat berkurang sebagai akibat dari memiliki serangkaian pengujian yang solid untuk mendukung perubahan, dan kemampuan untuk membuat tes baru yang darinya memberikan wawasan dan solusi untuk masalah yang dilaporkan.

Jadi secara keseluruhan, tampak bahwa upaya keseluruhan untuk memperbaiki bug dalam banyak kasus berkurang jika ada serangkaian pengujian yang kuat di tempat, dan prosedur untuk memastikan bahwa pengujian tetap menjadi fokus dari apa yang dilakukan pengembang, tetapi biaya yang sebenarnya dalam beberapa hal sebagian telah bergeser setidaknya dari implementasi, ke area bisnis lainnya, karena dalam beberapa hal, fokusnya juga telah bergeser dari pasokan murni dan permintaan ke manajemen hubungan.

Hal lain yang menjadi jelas adalah naluri kami beberapa tahun yang lalu yang menyatakan bahwa menjadi Agile akan mengurangi siklus pemeliharaan kami telah terbukti pada tingkat yang benar dan yang salah. Tepat dalam arti bahwa pengujian solid telah membuatnya lebih mudah untuk debug dan memperbaiki kode kami ke tingkat yang besar, dan untuk mengurangi jumlah bug yang dirilis ke kode produksi secara keseluruhan, dan salah dalam arti bahwa kami sekarang bekerja lebih keras untuk menghindari keharusan untuk mempertahankan kode lama, dengan terus-menerus memperbaiki kode dan meningkatkan arsitektur sehingga semakin jarang kita perlu mengembangkan produk baru sepenuhnya dari awal.

Jadi pada akhirnya, apa artinya ini sehubungan dengan pertanyaan OP? Ya, itu artinya jawabannya benar-benar tidak seburuk yang pernah kita pikirkan. 15 tahun yang lalu, saya mungkin akan menjawab pertanyaan sebagai Ya, tapi sekarang saya merasa lebih realistis untuk mengatakan bahwa itu terlalu sulit untuk diukur secara empiris, karena sifat dari apa yang kita lakukan untuk mengembangkan perangkat lunak telah banyak berubah sejak pertama kali kita mulai bertanya pada diri sendiri pertanyaan OP saat itu. Dalam beberapa hal, semakin kita memajukan teknik dan keterampilan kita sebagai sebuah industri, semakin jauh pertanyaan itu berkembang dari ya pasti, ke titik di mana saya menduga bahwa dalam beberapa tahun singkat kita akan mengatakan bahwa itu tidak masalah ketika kami memperbaiki bug, karena pengujian dan proses kami akan jauh lebih kuat, sehingga waktu perbaikan bug akan lebih sedikit didorong oleh upaya untuk menghemat anggaran kami, dan lebih banyak lagi oleh prioritas untuk memenuhi kebutuhan pelanggan kami, dan biaya relatif akan menjadi hampir tidak ada artinya secara kontekstual.

Tapi seperti yang saya katakan, ini bukan bukti data yang didukung, hanya pengamatan saya selama beberapa tahun terakhir, dan usus saya mengatakan kepada saya bahwa akan ada lebih banyak kebijaksanaan mengejutkan yang akan datang yang akan meningkatkan cara kita melakukan sesuatu.

Bug awal akan merambat ke bagian lain dari sistem sehingga ketika Anda memperbaiki bug Anda mungkin terpaksa menulis ulang beberapa bagian sistem yang mengandalkan bug itu sendiri.

Selain dari waktu ke waktu Anda akan foget bagaimana beberapa bagian dari program ini dibangun dan Anda harus mengingatkan diri sendiri. Ini semacam hutang teknis (jika Anda terburu-buru dalam tahap awal, Anda akan mengalami kesulitan menyelesaikannya karena pintasan yang Anda ambil).

Sesederhana itu dan tidak ada yang perlu dibuktikan.

Saya pikir Anda mencoba untuk mempercepat proyek secepat mungkin untuk menghadirkan beberapa solusi kerja untuk karyawan Anda. Kabar baiknya adalah Anda akan melakukannya dengan sangat cepat, berita buruknya adalah Anda mungkin tidak akan pernah menyelesaikannya tanpa menulis ulang sepenuhnya jika Anda terus menulis omong kosong secepat mungkin dan berencana untuk memperbaiki semuanya dalam beberapa bulan. Anda mungkin bahkan tidak akan bisa memperbaiki ini.

Yah, saya mungkin tidak bisa memberi Anda bukti definitif yang Anda minta, tapi saya bisa menceritakan kejadian yang cukup baru dari pekerjaan saya.

Kami menambahkan fitur yang memberikan kemampuan manajemen alur kerja ke produk kami. Hal-hal BDUF yang khas, spesifikasi ditandatangani dan disetujui oleh klien. Diimplementasikan ke spec. Keluhan dari Hari 1 tentang penerapan.

Kami belum melakukan walkability kegunaan nyata dengan klien, hanya mengambil kata-kata mereka untuk apa yang mereka inginkan. Hasil: ratusan jam pengerjaan ulang - analisis, desain, implementasi, dan QA harus diulang. Semua karena spec melewatkan kasus penggunaan tertentu. Bug dalam spesifikasi, jika Anda mau.

Saya telah melihat hal serupa di pekerjaan sebelumnya ketika seseorang dalam rantai membuat asumsi yang berbeda dari asumsi pengguna akhir. Bug coding langsung relatif mudah untuk ditangani jika tertangkap dekat ketika mereka terjadi, tetapi bug desain dapat membunuh seluruh sistem.

Jika Anda memperbaiki bug setelah rilis, maka Anda memiliki biaya untuk menemukan dan memperbaiki bug - yang mungkin memerlukan waktu atau biaya lebih banyak untuk melakukan post release. Namun Anda memiliki putaran pengujian Integrasi, pengujian regresi, pengujian UA, kegiatan rilis, dll yang perlu dipertanggungjawabkan. Kecuali jika perbaikan bug dilakukan dengan sejumlah perbaikan lain atau pembaruan versi, Anda akan memiliki biaya tambahan untuk aktivitas pengujian dan rilis yang akan dihindari dengan menyertakan perbaikan dalam rilis awal - karena biaya ini akan dibagi lebih dari sejumlah perbaikan / pembaruan / fitur.

Juga pertimbangkan biaya yang akan menyebabkan bug digunakan, jika hanya kosmetik, maka mungkin tidak masalah, tetapi bug fungsi atau kinerja dapat membuat biaya dengan kegiatan pendukung atau mengurangi produktivitas atau perhitungan yang salah.

Tanyakan kepada Intel berapa harga Pentium Bug, Rocket Ariane 5 adalah contoh yang baik. Bug ini diperbaiki pada akhir proyeknya. Saya telah bekerja pada sistem di mana "upaya" pada rilis perangkat lunak memiliki anggaran 6 angka. Dalam kasus ekstrim ini, mudah untuk melihat biayanya. Dalam kasus lain (kebanyakan?), Biaya disembunyikan oleh kebisingan, tetapi masih ada.

Tidak ada keraguan bahwa bug membutuhkan biaya saat mereka ada. Satu item, laporan Cacat, luangkan waktu untuk mengkompilasi, triase dan tutup sebagai dup, waktu adalah uang - oleh karena itu bug terbuka menciptakan biaya berkelanjutan. Oleh karena itu, penangguhan bug harus lebih mahal daripada memperbaiki bug lebih awal.

Jika bug lolos ke alam liar, biayanya memiliki langkah bijaksana ...... Apakah "Akhir dari proyek" sebelum atau setelah rilis perangkat lunak?

Saya pernah membaca artikel yang memiliki dua poin menarik (sayangnya referensi yang saya miliki sudah lama hilang, jadi saya harus mendalilkan di sini). Poin pertama yang mereka buat adalah bahwa sekitar 50% dari semua kesalahan diperkenalkan dalam spesifikasi persyaratan dan sekitar 90% dari semua kesalahan yang ditemukan selama tes UAT atau Sistem.

Poin kedua yang mereka miliki adalah bahwa untuk setiap fase dalam model-V biayanya meningkat 10 kali lipat. Apakah faktornya benar atau tidak, saya menemukan jenis yang tidak relevan tetapi kesalahan yang paling mahal adalah ketika desain Anda didasarkan pada asumsi yang salah. Hal ini menyebabkan sejumlah besar penulisan ulang. Semua kode yang berfungsi karena asumsi itu tetapi gagal ketika asumsi yang benar diterapkan harus ditulis ulang.

Saya telah mengalami seluruh model domain yang harus ditulis ulang karena satu asumsi yang salah dalam spesifikasi persyaratan. Jika bug semacam itu diketahui lebih awal, yaitu ketika meninjau spesifikasi persyaratan biayanya sangat rendah. Dalam kasus khusus ini akan mengambil sepuluh baris teks. Dalam kasus di mana ia ditemukan selama UAT (karena ini) biayanya adalah besar (dalam contoh yang diberikan biaya proyek meningkat sebesar 50%)

Tidak ada data statistik, tetapi pengalaman pribadi:

Kode kontrol motor roket yang saya kerjakan memiliki garis seperti powerCutoff = someCondition && debugOptions.cutoffIsAllowed;. Opsi default tidak ada cutoff diizinkan. Build 'final' seharusnya menghapus semua opsi debug, jadi baris diubah ke powerCutoff = someCondition;.

Apakah Anda menangkap bug saat meninjau kode? Kami tidak melakukannya. Pertama kali kondisi pemicu terjadi dalam pengujian yang menyebabkan cutoff tak terduga hanya beberapa bulan sebelum penerbangan pertama.

Bug ini akan menelan biaya kurang dari satu jam seandainya tertangkap saat ditinjau. Mungkin dikenakan biaya satu atau dua hari jika tertangkap selama integrasi, menyebabkan pengujian berulang. Jika ketahuan saat kualifikasi formal, bisa memakan biaya satu atau dua minggu dengan menyebabkan rangkaian uji lengkap memulai kembali dengan bangunan baru.

Karena itu, biayanya membengkak. Pertama kami merancang dan menjalankan tes untuk menentukan apakah unit penerbangan bahkan dapat memicu kondisi tersebut. Setelah ditentukan menjadi kemungkinan nyata, ada biaya untuk rekayasa, manajemen, dan analisis pelanggan dari perbaikan terbaik, melepaskan bangunan baru, membuat dan melaksanakan rencana uji regresi baru, pengujian sistem di beberapa unit dan simulator. Semua itu menghabiskan biaya ribuan jika tidak puluhan ribu jam kerja. Ditambah 15 menit asli untuk benar-benar membuat perubahan kode yang tepat.

Sayangnya, seperti banyak hal, itu tergantung.

Jika pesan dialog salah eja, ini mungkin 'sepele' untuk diperbaiki (perbarui string, bangun kembali / paket, pindahkan kembali). Atau jika tata letak perlu diperbarui, modifikasi ke file .css mungkin cukup.

Jika bugnya adalah output dari metode kritis yang memiliki spesifikasi dan bukti 100+ halaman salah, maka investigasi itu sendiri bisa memakan waktu berjam-jam atau berhari-hari. Inilah yang dimaksud 'aksioma' lama, dan apa, di antara hal-hal lain, TDD dan lincah coba hindari (gagal lebih awal dan jelas, buat kemajuan bertahap yang aman, yada).

Dari pengalaman saya baru-baru ini dengan tim multi-scrum pada satu proyek, 'bug' biasanya menggabungkan / masalah integrasi yang hanya muncul pada akhir rilis sebagai cabang fitur dipromosikan ke stabil. Ini adalah yang terburuk, karena konflik sering membutuhkan dukungan tim lintas sementara tim berada dalam kesibukan untuk menyelesaikan tujuan mereka sendiri, tetapi saya tidak tahu bahwa mereka lebih mahal daripada bug lain, seperti yang terjadi ketika mereka terjadi: terlambat rilis, tetapi pada waktu paling awal mereka bisa. Itu yang membuat mereka yang terburuk.