Apakah kode yang baik tidak mungkin dalam pengembangan perangkat lunak modern? [Tutup]

Tampaknya bahkan alat pengembang menjadi lebih solid dan kuat, menulis kode yang baik telah menjadi tantangan. Meskipun alat-alat itu lebih kuat, kualitas kode tidak menjadi lebih baik. Saya datang dengan dua faktor penting, ada sedikit waktu dan proyek lebih kompleks. Karena alat yang kita gunakan saat ini lebih kuat, lebih mudah untuk menulis kode yang lebih kompleks, tetapi tidak punya waktu untuk merencanakan dan tanpa melihat ke belakang menurunkan kualitas kode dan meningkatkan bug dan pemeliharaan. Bukannya kami tidak menulis kode kompleks sebelumnya. Kita menulis kode yang lebih rumit.

Pertanyaan saya adalah sebagai berikut: Mengingat kita memiliki bahasa dan alat yang lebih kuat.

• Mengapa menulis kode yang baik lebih sulit?
• Apakah faktor, waktu, dan kerumitan berkontribusi terhadap hal ini?
• Apakah metodologi tidak dipraktikkan dengan benar?

Jenis proyek yang saya pertimbangkan adalah aplikasi perusahaan dengan kompleksitas besar dan logika bisnis. Definisi "kode yang baik" adalah perorangan, jangan terjebak dalam interpretasi "kode yang baik".

Seperti yang dinyatakan oleh DeMarco dan Lister di Peopleware sekitar 20 tahun yang lalu, sebagian besar proyek perangkat lunak yang gagal gagal bukan karena tantangan teknis, tetapi masalah sosiologis . Ini tidak berubah dalam dekade terakhir, tidak peduli seberapa banyak alat kami telah membaik.

Manajemen yang salah, harapan yang tidak realistis, gagal mendapatkan orang yang tepat untuk pekerjaan itu, dan / atau tidak membiarkan mereka melakukan pekerjaan mereka, akibatnya gagal mempertahankannya; tempat kerja dan alat yang tidak cocok untuk pekerjaan pengembangan SW; konflik pribadi yang tidak tertangani; politik ; ini hanya beberapa dari masalah-masalah khas yang mungkin membuat proyek hancur sejak awal.

Mengapa menulis kode yang baik lebih sulit?

Saya tidak begitu yakin benar-benar sulit untuk menulis kode yang baik sekarang daripada beberapa dekade yang lalu. Bahkan, dibandingkan dengan kode mesin atau perakitan, semua yang kita miliki sekarang di arus utama lebih mudah untuk ditangani. Hanya kita mungkin perlu menghasilkan lebih banyak.

Apakah hanya karena faktor-faktor yang disebutkan, waktu dan kompleksitas?

Ya, kompleksitas yang dapat dicapai tentu saja meningkat (dan terus meningkat) karena kekuatan alat kami meningkat. Dengan kata lain, kami terus mendorong batas. Yang saya terjemahkan sehingga sama sulitnya untuk memecahkan tantangan terbesar hari ini seperti 30 tahun yang lalu untuk menyelesaikan tantangan terbesar hari itu.

OTOH karena bidang ini telah berkembang sangat pesat, sekarang ada lebih banyak masalah "kecil" atau "diketahui" daripada 30 tahun yang lalu. Masalah-masalah ini secara teknis (seharusnya) tidak menjadi tantangan lagi, tapi ... di sini memasuki pepatah di atas :-(

Juga jumlah programmer sejak itu tumbuh sangat pesat. Dan setidaknya persepsi pribadi saya adalah bahwa tingkat rata-rata pengalaman dan pengetahuan telah menurun, hanya karena ada jauh lebih banyak yunior tiba terus ke lapangan daripada ada senior yang bisa mendidik mereka.

Apakah metodologi tidak dipraktikkan dengan benar?

IMHO tentu tidak. DeMarco dan Lister memiliki kata-kata kasar tentang Metodologi M besar. Mereka mengatakan bahwa tidak ada metodologi yang bisa membuat proyek berhasil - hanya orang-orang dalam tim yang bisa. OTOH metodologi kecil-m yang mereka puji cukup dekat dengan apa yang sekarang kita kenal sebagai "gesit", yang menyebar luas (IMHO karena alasan yang baik). Belum lagi praktik yang baik seperti pengujian dan refactoring unit, yang hanya 10 tahun yang lalu tidak dikenal secara luas, dan saat ini bahkan banyak lulusan tahu ini.

Masalah yang terkait dengan pengkodean di bawah tenggat waktu yang tidak realistis dan berurusan dengan utang teknis telah diketahui sejak Weinberg '71 dan juga Brooks '72. Literatur menjadi sulit untuk digali secara online sebelum itu, tetapi saya cukup yakin ada laporan CDC, IBM, dan NASA yang mengatakan hal yang sama.

Saya pikir kita semua memiliki ide dan ambang batas sendiri untuk "Kode yang Baik". Namun, ada sejumlah masalah yang semuanya berkontribusi:

• Aplikasi yang salah dari "get it berfungsi kemudian memperbaikinya" berarti kita meninggalkan kode mati dan 10 varian berbeda dari metode yang sama di mana masing-masing digunakan hanya sekali dalam basis kode. Barang-barang ini sepertinya tidak pernah dibersihkan.
• Kurang waktu dan anggaran. Klien menginginkan 100 fitur baru dalam 3 bulan, beberapa di antaranya non-sepele, dan mereka tidak ingin menghabiskan uang untuk hal-hal yang tidak dapat mereka lihat secara langsung.
• Kurang peduli. Mari kita hadapi itu, beberapa pengembang peduli tentang cara kode terlihat dan berperilaku lebih dari yang lain. Lihat poin-poin pertama sebagai contoh.
• Kami benar-benar tidak tahu cara membuat "kode yang baik". Konsep kode saya yang baik terus berkembang. Apa yang saya pikir baik satu dekade lalu tidak lagi baik.
• "Kode yang baik" adalah penilaian nilai. Selain "berfungsi", dan tidak ada bug yang dikenal, kriteria lain untuk kode yang baik pada dasarnya adalah masalah pendapat.

Pada akhirnya, saya pikir yang terbaik adalah mengejar lebih baik daripada mengejar "baik" atau "terbaik". Jika kita melihat kode terbaik di luar sana, akankah kita mengenalinya?

Mengapa menulis kode yang baik lebih sulit?

Karena perangkat lunak semakin dibangun di atas lapisan abstraksi. Setiap teknologi baru yang mengklaim membuat pengembangan lebih mudah dan lebih cepat hanya menambah satu tingkat kompleksitas yang perlu dipahami pengembang. Sekarang, abstraksi ini dapat memiliki manfaat besar bagi produktivitas, tetapi jika Anda tidak memahami apa yang mereka coba sembunyikan maka itu membuat perangkat lunak lebih rentan terhadap bug dan kualitas buruk.

Apakah kode yang baik tidak mungkin dalam pengembangan perangkat lunak modern?

Memang itu tidak mungkin. Tetapi tidak untuk alasan apa pun yang sudah Anda dengar.

Ruang lingkup sebagian besar proyek jauh melampaui kapasitas otak manusia. Itulah sebabnya orang datang dengan ide abstraksi , yaitu menyembunyikan detail dan memanjat pohon abstraksi lebih tinggi sampai kepadatan cabang (jumlah informasi yang harus ditangani) berkurang hingga tingkat yang dapat diterima.

Kami telah melakukan itu, kami memecahkan masalah kompleksitas, tetapi itu belum menghilangkan masalah yang lebih besar yang kami miliki sebelumnya.

Masih terlalu rumit untuk kita tangani.

Untuk menciptakan solusi berkualitas tinggi kita harus dapat melihat dan memahami semuanya secara bersamaan pada saat yang bersamaan, yaitu semua modul pada detail implementasi yang besar dan kecil. Sekaligus untuk melihat perbedaan, lihat setiap bagian kode dalam konteks semua skenario yang mungkin dan optimalkan seluruh basis kode pada saat yang sama.

Kami tidak akan pernah bisa melakukan itu.

Dan jika kita tidak bisa, kita tidak akan pernah menghasilkan kode kualitas.

Manajer akan melihat segelintir modul tetapi tidak akan tahu masalah internal dan batasan per modul.

Pemrogram modul akan mengetahui keterbatasan lokal tetapi tidak akan dapat mengoptimalkannya dalam konteks gambar yang lebih besar.

Tidak ada cara untuk mengkomunikasikan pemahaman antara manajer dan programmer (dan bahkan antara programmer). Dan kalaupun ada, kapasitas otak manusia tidak bisa mengatasinya.

Ada sedikit yang bisa kita lakukan kecuali terus berusaha (latihan yang sia-sia). Mari kita terus kode operasional kurang lebih dan menikmati hidup.

Saya menyangkal premis dari pertanyaan Anda. Lebih mudah dari sebelumnya untuk menulis kode yang baik, dan karena itu kami menangani masalah jauh lebih sulit yang telah kami tangani sebelumnya.

Saya tidak ingin memilih vendor tertentu, tetapi membandingkan Windows 1.0 dengan Windows 7. Yang terakhir berisi ribuan kali lebih banyak kode, tetapi waktu rata-rata antara crash telah meningkat seratus kali lipat. Kami seharusnya dapat menanamkan lembar bentang Excel dalam dokumen Word sejak Windows 3.1, tetapi hari ini sebenarnya lebih atau kurang berfungsi.

Tanpa ingin jatuh ke sentimentalitas "Anda anak-anak sekarang ini dengan mengetik bebek dan VM", saya sarankan Anda tidak tahu betapa sulitnya untuk menulis kode yang baik di tahun 80-an: model memori TINY, SMALL, dan HUGE, overlay , panggilan OS yang tidak disewakan (ngeri). Bagus untuk semua itu.

Aplikasi modern yang lebih kompleks daripada mereka 20-30 tahun yang lalu, karena lingkungan mereka lebih kaya dan lebih fleksibel.

Itu adalah khas untuk program-DOS untuk duduk dalam lingkaran ketat menunggu penekanan tombol berikutnya dari pengguna, dan kemudian memanggil kode yang sesuai, dan kembali untuk menunggu penekanan tombol berikutnya.

Aplikasi modern mana pun di mana Anda tidak dapat menggunakan mouse di ALL untuk apa pun, memiliki masalah penjelasan yang serius. Dan hal-hal dapat terjadi dalam urutan apa pun, karena sangat mungkin bagi pengguna untuk mengetik, klik dengan mouse dan terus mengetik sementara RSS-feed sedang diperbarui dalam aplikasi yang menampilkan entri terbaru kepada pengguna saat ia mengetik.

Semua hal yang multi-tugas ini pada hakekatnya jauh lebih kompleks daripada ketika semua yang harus Anda pikirkan adalah kunci dari pengguna. Itu membuatnya lebih sulit untuk menulis kode yang benar-benar bagus.

Mudah-mudahan ketika para peneliti telah menemukan bagaimana kita dapat membuat program multi-tasking lebih bermanfaat dilihat dari sudut pandang pengembang, ini mungkin mudah tetapi untuk sekarang kita terjebak dengan semua orang yang mencoba untuk melakukannya dengan baik, tetapi tidak cukup tahu bagaimana melakukannya. Itu.

Sepertinya saya bahwa perangkat lunak telah berkembang untuk mengisi kecepatan prosesor, memori, disk, dan waktu programmer yang tersedia. Orang bisa menyatakan bahwa itu karena perangkat lunak mencapai lebih banyak. Yah, saya yakin itu menghasilkan lebih banyak, tetapi tidak cukup untuk membenarkan mengasapi.

Saya pikir ada hukum kuno sains yang perlu diingat:

Alam membenci kekosongan.

Francois Rabelas (Biksu dan satiris Prancis 1494-1553)

Bahkan, saya pikir sudah menjadi lebih mudah untuk menulis kode yang baik, yaitu program yang berfungsi seperti yang diharapkan dan dipelihara, selama dekade terakhir. Alat yang tersedia sekarang lebih baik, libs lebih matang dan komprehensif, perangkat keras menjadi lebih cepat sehingga kita tidak harus menggunakan trik pengoptimalan.

Jadi mengapa kita tidak melakukannya?

IMO alasan utamanya adalah kita terus mencari cara dan alasan untuk melakukan penyalahgunaan. Alih-alih menggunakan cara lama, mudah, mungkin membosankan, seperti membuat Windows yang dapat dieksekusi, kami mendorong batas-batas yang mungkin dan mencari cara untuk misalnya menciptakan kembali sesuatu seperti PhotoShop sebagai aplikasi web. Mengapa? Karena kita bisa. Atau setidaknya kami pikir begitu.

Kapan terakhir kali SIAPA SAJA tidak menulis eksploit atau belajar untuk melakukan hal tersebut di sekitar dengan perakitan (tidak termasuk peretas kernel dan orang-orang ASIC)? Berapa banyak bug yang telah ditemukan di perpustakaan inti C? Hampir tidak ada dan sedikit. Yang saya katakan adalah bahwa orang mampu kode yang sangat baik. Alat dan bahasa yang lebih baik membuatnya kurang 'wajib' dan lebih 'opsional'. Bukannya saya pikir kita semua harus menulis kode yang benar-benar mengerikan, tetapi ketika saya memikirkan konstruksi logis yang rumit ... tidak ada yang akan bermimpi menulis sesuatu dengan array hash dalam perakitan. Harus ada cara yang 'lebih baik' untuk menangani logika daripada menggunakan konstruk yang rumit. Sekalipun kodenya indah, terkadang pendekatannya tidak elegan. Saya pikir itu semacam mengatasi masalah yang Anda sebutkan. Kode yang baik tidak selalu hanya terorganisir,

Saya pikir itu karena alat yang lebih baik, dan komputer yang lebih cepat lebih responsif berarti kita berharap untuk mendapatkan lebih banyak kompleksitas produk akhir perunit waktu daripada yang kita lakukan beberapa tahun (atau beberapa dekade) kembali. Jadi kompleksitas aplikasi terus meningkat, dan asumsi kami tentang tingkat produktivitas yang wajar terus bertambah.

Di tempat saya bekerja, pengembang selalu terburu-buru (karena selalu ada lebih banyak hal yang pelanggan inginkan maka mereka punya waktu untuk). Jadi banyak blok kode disalin dengan pengeditan minimal, dan tanpa upaya dibuat untuk benar-benar memahaminya. Dan tentu saja kesalahan bisa terjadi. Saya baru saja melihat bug diperbaiki, di mana pengembang telah menyalin beberapa kode yang telah saya optimalkan, tanpa menyadari bahwa asumsi yang membuat optimasi itu valid tidak benar di mana ia meletakkannya.

Ini semua bermuara pada harapan, baik internal (harapan kita sendiri), dan dari organisasi kita. Kami berusaha melakukan sebanyak mungkin dalam waktu sesingkat mungkin. Dan kesalahan pasti terjadi.

Juga respon komputer mendorong pengeditan cepat cepat, kemudian kompilasi dan uji coba. Di masa lalu (seperti 35 tahun yang lalu), perputaran sangat lambat, sehingga saya akan mencetak kode (sumber adalah kartu punch kemudian), dan melakukan langkah-langkah manual kode sebelum mengirimkan dek saya. Sekarang, kita cukup mengedit kompilasi dan menjalankan. Jadi banyak bug yang akan kita temui, melalui penelusuran kode metodis, sekarang kita mengandalkan kompiler dan / atau suite unit test untuk ditangkap.

Bagaimana orang menjadi lebih buruk dalam menghasilkan kode yang baik?

Jika Anda menggunakan .NET dan bahasa seperti C #, misalnya (dan saya sadar itu bukan satu-satunya platform / bahasa), saya berpendapat bahwa pengkodean dengan baik telah menjadi jauh, jauh lebih mudah karena otomatisasi banyak hal dalam Visual Studio lingkungan Hidup.

Jika ada, fakta sederhana bahwa kita sekarang memiliki IDE yang sangat canggih yang mampu membimbing kita melalui proses pengkodean dan pengembangan membuat "kode yang baik" lebih mudah untuk dicapai.

Programmer sekarang dapat fokus pada benar-benar menghasilkan struktur yang baik daripada menghabiskan begitu banyak waktu hanya mengetik kurung dan kurung dan baris baru dan mengingat panggilan metode dan nama kelas.

Dua sen saya.

Ya, kita sebagai industri tidak mempraktikkan apa yang dikenal sebagai metodologi yang baik. Referensi: Construx Software Development Software milik Steve McConnell 's Low Hanging Fruit .

kualitas kode belum membaik

tolong jangan terjebak dalam interpretasi "kode yang baik"

Tautologi logis yang bagus.

Kode tidak menjadi lebih baik karena orang terus memindahkan definisi "baik".

Jika Anda dapat 'membahas "kode yang baik", maka Anda tidak dapat membandingkan dan Anda benar-benar tidak dapat memutuskan apakah itu "tantangan" atau tidak.