Mengapa begitu banyak pengembang percaya bahwa kinerja, keterbacaan, dan pemeliharaan tidak bisa hidup berdampingan?

Saat menanggapi pertanyaan ini , saya mulai bertanya-tanya mengapa begitu banyak pengembang percaya bahwa desain yang baik seharusnya tidak memperhitungkan kinerja karena hal itu akan mempengaruhi keterbacaan dan / atau pemeliharaan.

Saya percaya bahwa desain yang baik juga mempertimbangkan kinerja pada saat itu ditulis, dan bahwa pengembang yang baik dengan desain yang baik dapat menulis program yang efisien tanpa mempengaruhi pembacaan atau pemeliharaan.

Meskipun saya mengakui bahwa ada kasus-kasus ekstrem, mengapa banyak pengembang bersikeras program / desain yang efisien akan menghasilkan keterbacaan yang buruk dan / atau pemeliharaan yang buruk, dan akibatnya kinerja tidak menjadi pertimbangan desain?

Saya pikir pandangan seperti itu biasanya reaksi terhadap upaya optimasi prematur (mikro) , yang masih lazim, dan biasanya jauh lebih berbahaya daripada kebaikan. Ketika seseorang mencoba untuk melawan pandangan seperti itu, mudah untuk jatuh ke - atau setidaknya terlihat seperti - yang lain ekstrim.

Namun demikian benar bahwa dengan pengembangan sumber daya perangkat keras yang sangat besar dalam beberapa dekade terakhir, untuk sebagian besar program yang ditulis hari ini, kinerja tidak lagi menjadi faktor pembatas utama. Tentu saja, seseorang harus memperhitungkan kinerja yang diharapkan dan dapat dicapai selama fase desain, untuk mengidentifikasi kasus-kasus ketika kinerja mungkin (datang) masalah utama . Dan kemudian memang penting untuk mendesain kinerja sejak awal. Namun, kesederhanaan keseluruhan, keterbacaan dan pemeliharaan masih lebih penting . Seperti yang lain dicatat, kode yang dioptimalkan kinerja lebih kompleks, lebih sulit untuk dibaca dan dipelihara, dan lebih rentan terhadap bug daripada solusi kerja yang paling sederhana. Dengan demikian segala upaya yang dihabiskan untuk optimasi harus dibuktikan - tidak hanya dipercaya- untuk membawa manfaat nyata, sambil menurunkan pemeliharaan program jangka panjang sesedikit mungkin. Jadi desain yang bagus mengisolasi bagian-bagian kompleks, kinerja intensif dari sisa kode , yang dijaga sesederhana dan sebersih mungkin.

Datang pada pertanyaan Anda dari sisi pengembang yang bekerja pada kode kinerja tinggi, ada beberapa hal yang perlu dipertimbangkan dalam desain.

• Jangan pesimis sebelum waktunya. Ketika Anda memiliki pilihan antara dua desain dengan kompleksitas yang sama, pilih salah satu yang memiliki karakteristik kinerja terbaik. Salah satu contoh C ++ yang terkenal adalah prevalensi post-increment dari penghitung (atau iterator) dalam loop. Ini adalah pesimisasi prematur yang sama sekali tidak perlu bahwa MUNGKIN tidak membebankan biaya apa pun kepada Anda, tetapi MUNGKIN, jadi jangan lakukan itu.
• Dalam banyak kasus Anda belum memiliki bisnis untuk mendekati optimasi mikro. Optimalisasi algoritmik adalah hasil yang lebih rendah dan hampir selalu lebih mudah dipahami daripada optimasi level rendah.
• Jika dan HANYA jika kinerja benar-benar kritis, Anda menjadi kotor dan kotor. Sebenarnya, Anda mengisolasi kode sebanyak yang Anda bisa terlebih dahulu, dan MAKA Anda turun dan kotor. Dan itu menjadi sangat kotor di sana, dengan skema caching, evaluasi malas, optimisasi tata letak memori untuk caching, blok intrinsik atau perakitan inline, template lapis demi lapis, dll. Anda menguji dan mendokumentasikan seperti orang gila di sini, Anda tahu itu akan terjadi salahnya jika Anda harus melakukan pemeliharaan dalam kode ini, tetapi Anda harus melakukannya karena kinerjanya sangat penting. Sunting: Ngomong-ngomong, saya tidak mengatakan kode ini tidak boleh indah, dan harus dibuat seindah mungkin, tetapi masih akan sangat kompleks dan sering berbelit-belit dibandingkan dengan kode yang kurang dioptimalkan.

Lakukan dengan benar, cantik, cepat. Dalam urutan itu.

Jika saya bisa berasumsi untuk "meminjam" @ diagram bagus greengit, dan membuat tambahan kecil:

|
P
E
R
F
O  *               X <- a program as first written
R   * 
M    *
A      *
N        *
C          *  *   *  *  *
E
|
O -- R E A D A B I L I T Y --

Kita semua telah "diajari" bahwa ada kurva tradeoff. Juga, kita semua berasumsi bahwa kita adalah pemrogram yang optimal sehingga program apa pun yang kita tulis begitu ketat hingga berada pada kurva . Jika suatu program berada pada kurva, setiap peningkatan dalam satu dimensi harus menimbulkan biaya di dimensi lain.

Dalam pengalaman saya, program hanya mendekati kurva apa pun dengan disetel, tweak, dipalu, wax, dan secara umum berubah menjadi "golf kode". Sebagian besar program memiliki banyak ruang untuk perbaikan di semua dimensi. Inilah yang saya maksud.

Justru karena komponen perangkat lunak yang berperforma tinggi, umumnya urutan besarnya lebih kompleks daripada komponen perangkat lunak lain (semua hal lain dianggap sama).

Bahkan kemudian itu tidak memotong jelas, jika metrik kinerja merupakan persyaratan yang sangat penting maka sangat penting bahwa desain memiliki kompleksitas untuk mengakomodasi persyaratan tersebut. Bahayanya adalah pengembang yang membuang sprint pada fitur yang relatif sederhana mencoba memeras beberapa milidetik tambahan dari komponennya.

Terlepas dari itu, kompleksitas desain memiliki korelasi langsung dengan kemampuan pengembang untuk dengan cepat belajar dan menjadi terbiasa dengan desain seperti itu, dan modifikasi lebih lanjut terhadap fungsionalitas dalam komponen yang kompleks dapat mengakibatkan bug yang mungkin tidak dapat ditangkap oleh unit test. Desain yang rumit memiliki lebih banyak aspek dan kemungkinan uji untuk mempertimbangkan menjadikan cakupan 100% unit test lebih dari mimpi pipa.

Dengan itu dikatakan perlu dicatat bahwa komponen perangkat lunak yang berkinerja buruk dapat berkinerja buruk hanya karena itu ditulis bodoh dan rumit yang tidak perlu berdasarkan ketidaktahuan penulis asli, (membuat 8 panggilan database untuk membangun satu entitas ketika hanya satu yang akan melakukan , kode yang sama sekali tidak perlu yang menghasilkan lintasan kode tunggal, dll.) Kasus-kasus ini lebih merupakan masalah peningkatan kualitas kode dan peningkatan kinerja yang terjadi sebagai konsekuensi dari refactor dan BUKAN konsekuensi yang dimaksudkan tentunya.

Namun, dengan asumsi komponen yang dirancang dengan baik, komponen itu akan selalu lebih kompleks daripada komponen yang dirancang dengan baik yang serupa yang disesuaikan untuk kinerja (semua hal lainnya dianggap sama).

Bukan karena hal-hal itu tidak bisa hidup berdampingan. Masalahnya adalah bahwa kode semua orang lambat, tidak dapat dibaca, dan tidak dapat dipelihara pada iterasi pertama. Sisa waktu dihabiskan untuk memperbaiki apa pun yang paling penting. Jika itu kinerja, maka lakukanlah. Jangan menulis kode yang sangat buruk, tetapi jika itu harus X cepat, maka buatlah X cepat. Saya percaya bahwa kinerja dan kebersihan pada dasarnya tidak berkorelasi. Kode performan tidak menyebabkan kode jelek. Namun, jika Anda menghabiskan waktu untuk menyetel setiap bit kode agar cepat, coba tebak apa yang tidak Anda lakukan? Menjadikan kode Anda bersih dan terawat.

    |
    P
    E
    R
    F
    O *
    R * 
    M *
    SEBUAH *
    N *
    C * * * * *
    E
    |
    O - READABILITY -

Seperti yang dapat Anda lihat...

• Keterbacaan yang mengorbankan dapat meningkatkan kinerja - tetapi hanya sangat banyak. Setelah titik tertentu, Anda harus menggunakan cara "nyata" seperti algoritma dan perangkat keras yang lebih baik.
• Juga, kehilangan kinerja dengan biaya keterbacaan dapat terjadi hanya sampai batas tertentu. Setelah itu, Anda dapat membuat program Anda sebanyak yang Anda inginkan tanpa mempengaruhi kinerja. Misalnya menambahkan lebih banyak komentar bermanfaat tidak merusak kinerja.

Jadi, kinerja dan keterbacaan terkait tetapi sedikit - dan dalam kebanyakan kasus, tidak ada insentif besar nyata lebih memilih yang pertama daripada yang terakhir. Dan saya berbicara di sini tentang bahasa tingkat tinggi.

Menurut pendapat saya kinerja harus menjadi pertimbangan ketika itu adalah masalah aktual (atau misalnya persyaratan). Tidak melakukan hal itu cenderung mengarah pada optimasi mikro, yang mungkin mengarah pada kode yang lebih membingungkan hanya untuk menyimpan beberapa mikrodetik di sana-sini, yang pada gilirannya mengarah pada kode yang kurang dapat dipertahankan dan kurang dapat dibaca. Sebaliknya seseorang harus fokus pada hambatan nyata sistem, jika perlu , dan memberi tekanan pada kinerja di sana.

Intinya bukan keterbacaan harus selalu truf efisiensi. Jika Anda tahu dari awal bahwa algoritma Anda harus sangat efisien, maka itu akan menjadi salah satu faktor yang Anda gunakan untuk mengembangkannya.

Masalahnya adalah kebanyakan kasus menggunakan tidak perlu kode cepat menyilaukan. Dalam banyak kasus IO atau interaksi pengguna menyebabkan lebih banyak keterlambatan daripada eksekusi algoritme Anda. Intinya adalah bahwa Anda tidak harus keluar dari cara Anda untuk membuat sesuatu lebih efisien jika Anda tidak tahu itu adalah leher botol.

Mengoptimalkan kode untuk kinerja seringkali membuatnya lebih rumit karena umumnya melibatkan melakukan sesuatu dengan cara yang cerdas, bukan yang paling intuitif. Kode yang lebih rumit lebih sulit untuk dipelihara dan sulit untuk diambil oleh pengembang lain (keduanya adalah biaya yang harus dipertimbangkan). Pada saat yang sama, kompiler sangat baik dalam mengoptimalkan kasus-kasus umum. Ada kemungkinan bahwa upaya Anda untuk memperbaiki kasus umum berarti bahwa kompiler tidak mengenali pola lagi dan dengan demikian tidak dapat membantu Anda membuat kode Anda dengan cepat. Perlu dicatat bahwa ini tidak berarti menulis apa pun yang Anda inginkan tanpa memperhatikan kinerja. Anda seharusnya tidak melakukan apa pun yang jelas tidak efisien.

Intinya adalah jangan khawatir tentang hal-hal kecil yang mungkin membuat segalanya lebih baik. Gunakan profiler dan lihat bahwa 1) apa yang Anda miliki sekarang adalah masalah dan 2) apa yang Anda ubah menjadi peningkatan.

Saya pikir sebagian besar programmer mendapatkan firasat hanya karena sebagian besar waktu, kode kinerja adalah kode yang didasarkan pada lebih banyak informasi (tentang konteks, pengetahuan perangkat keras, arsitektur global) daripada kode lain dalam aplikasi. Sebagian besar kode hanya akan mengungkapkan beberapa solusi untuk masalah spesifik yang dirangkum dalam beberapa abstraksi dengan cara modular (seperti fungsi) dan itu berarti membatasi pengetahuan konteks hanya pada apa yang memasukkan enkapsulasi tersebut (seperti parameter fungsi).

Ketika Anda menulis untuk kinerja tinggi, setelah Anda memperbaiki optimasi algoritmik apa pun, Anda masuk ke detail yang membutuhkan lebih banyak pengetahuan tentang konteksnya. Itu mungkin secara alami membanjiri programmer yang tidak merasa cukup fokus untuk tugas itu.

Karena biaya pemanasan global (dari siklus CPU ekstra yang diskalakan oleh ratusan juta PC ditambah fasilitas pusat data besar-besaran) dan masa pakai baterai yang biasa-biasa saja (pada perangkat seluler pengguna), seperti yang diperlukan untuk menjalankan kode yang dioptimalkan dengan buruk, jarang muncul di sebagian besar Kinerja programmer atau ulasan sejawat.

Ini adalah eksternalitas negatif ekonomi, mirip dengan bentuk polusi yang diabaikan. Jadi rasio biaya / manfaat dari berpikir tentang kinerja sama sekali condong secara mental dari kenyataan.

Desainer perangkat keras telah bekerja keras menambahkan fitur hemat daya dan penskalaan jam ke CPU terbaru. Terserah programmer untuk membiarkan perangkat keras mengambil keuntungan dari kemampuan ini lebih sering, dengan tidak mengunyah setiap siklus clock CPU yang tersedia.

TAMBAH: Dahulu kala, biaya satu komputer adalah jutaan, jadi mengoptimalkan waktu CPU sangat penting. Kemudian biaya pengembangan dan pemeliharaan kode menjadi lebih besar daripada biaya komputer, sehingga optimasi jauh lebih buruk dibandingkan dengan produktivitas programmer. Sekarang, bagaimanapun, biaya lain menjadi lebih besar daripada biaya komputer, biaya menyalakan dan mendinginkan semua pusat data sekarang menjadi lebih besar dari biaya semua prosesor di dalam.

Saya pikir sulit mencapai ketiganya. Dua menurut saya bisa layak. Sebagai contoh, saya pikir itu mungkin untuk mencapai efisiensi dan keterbacaan dalam beberapa kasus, tetapi rawatan mungkin sulit dengan kode yang disesuaikan. Kode yang paling efisien di planet ini umumnya akan kekurangan baik pemeliharaan dan mudah dibaca sebagai mungkin jelas bagi kebanyakan, kecuali Anda adalah tipe yang dapat memahami sisi Soa-Vectorized, multithreaded kode SIMD bahwa Intel menulis dengan inline perakitan, atau paling pemotongan Algoritma -edge digunakan dalam industri dengan makalah matematika 40 halaman yang diterbitkan hanya 2 bulan yang lalu dan 12 perpustakaan senilai kode untuk satu struktur data yang sangat kompleks.

Efisiensi Mikro

Satu hal yang saya sarankan yang mungkin bertentangan dengan pendapat umum adalah bahwa kode algoritme paling pintar seringkali lebih sulit untuk dipertahankan daripada algoritma langsung paling mikro-tuned. Gagasan bahwa peningkatan skalabilitas menghasilkan lebih banyak untung daripada tanggung jawab atas kode yang disetel mikro (mis: pola akses yang ramah-cache, multithreading, SIMD, dll.) Adalah sesuatu yang akan saya tantang, setidaknya pernah bekerja di industri yang dipenuhi dengan sangat kompleks struktur data dan algoritma (industri FX visual), terutama di bidang-bidang seperti pemrosesan mesh, karena bang mungkin besar tetapi uangnya sangat mahal ketika Anda memperkenalkan algoritma dan struktur data baru yang belum pernah ada yang pernah dengar sebelumnya karena mereka adalah merek baru. Selanjutnya, saya

Jadi ide ini bahwa optimasi algoritmik selalu truf, katakanlah, optimasi terkait dengan pola akses memori selalu merupakan sesuatu yang saya tidak setuju. Tentu saja jika Anda menggunakan semacam gelembung, tidak ada optimasi mikro yang dapat membantu Anda di sana ... tetapi karena alasan itu, saya tidak berpikir itu selalu sangat jelas. Dan bisa dibilang optimasi algoritmik lebih sulit dipertahankan daripada optimasi mikro. Saya akan merasa jauh lebih mudah untuk mempertahankan, katakanlah, Intel Embree yang mengambil algoritma BVH klasik dan langsung dan hanya menyetel-buangnya daripada kode OpenVDB Dreamwork untuk cara-cara mutakhir dalam mempercepat simulasi fluida secara algoritmik. Jadi dalam industri saya setidaknya, saya ingin melihat lebih banyak orang yang akrab dengan arsitektur komputer lebih mengoptimalkan mikro, seperti yang dimiliki Intel ketika mereka melangkah ke panggung, sebagai lawan datang dengan ribuan dan ribuan algoritma baru dan struktur data. Dengan optimalisasi mikro yang efektif, orang berpotensi menemukan semakin sedikit alasan untuk menemukan algoritma baru.

Saya bekerja di basis kode warisan sebelum di mana hampir setiap operasi pengguna tunggal memiliki struktur data unik dan algoritma di belakangnya (menambahkan hingga ratusan struktur data eksotis). Dan kebanyakan dari mereka memiliki karakteristik kinerja yang sangat miring, yang berlaku sangat sempit. Akan jauh lebih mudah jika sistem itu dapat berputar di sekitar beberapa lusin struktur data yang lebih luas berlaku, dan saya pikir itu bisa terjadi jika mereka dioptimalkan secara mikro jauh lebih baik. Saya menyebutkan kasus ini karena optimasi mikro berpotensi meningkatkan kemampuan pemeliharaan dalam kasus seperti itu jika itu berarti perbedaan antara ratusan struktur data yang pesimis mikro yang bahkan tidak dapat digunakan dengan aman untuk tujuan baca-saja yang ketat yang melibatkan kehilangan cache yang tersisa dan benar vs

Bahasa Fungsional

Sementara itu beberapa kode yang paling bisa dipelihara yang pernah saya temui cukup efisien tetapi sangat sulit dibaca, karena ditulis dalam bahasa fungsional. Secara umum keterbacaan dan pemeliharaan uber adalah ide-ide yang bertentangan menurut pendapat saya.

Sangat sulit untuk membuat kode dapat dibaca, dan dipelihara, dan efisien sekaligus. Biasanya Anda harus sedikit berkompromi dalam salah satu dari ketiganya, jika tidak dua, seperti kompromi keterbacaan untuk pemeliharaan, atau kompromi pemeliharaan untuk efisiensi. Biasanya rawatan yang menderita ketika Anda mencari banyak dari dua lainnya.

Keterbacaan vs Pemeliharaan

Sekarang seperti yang saya katakan, saya percaya keterbacaan dan pemeliharaan bukanlah konsep yang harmonis. Lagi pula, kode yang paling mudah dibaca bagi sebagian besar dari kita manusia memetakan dengan sangat intuitif pola-pola pemikiran manusia, dan pola-pola pikiran manusia secara inheren rawan kesalahan: " Jika ini terjadi, lakukan ini. Jika itu terjadi, lakukan itu. Jika tidak, lakukan ini. Ups , Saya lupa sesuatu! Jika sistem ini berinteraksi satu sama lain, ini harus terjadi sehingga sistem ini dapat melakukan ini ... oh tunggu, bagaimana dengan sistem itu ketika peristiwa ini dipicu?"Saya lupa kutipan persisnya, tetapi seseorang pernah mengatakan bahwa jika Roma dibangun seperti perangkat lunak, hanya akan membutuhkan pendaratan burung di dinding untuk menjatuhkannya. Begitulah halnya dengan sebagian besar perangkat lunak. Ini lebih rapuh daripada yang sering kita pikirkan. Beberapa baris kode yang tampaknya tidak berbahaya di sana-sini dapat menghentikannya hingga membuat kita mempertimbangkan kembali seluruh desain, dan bahasa tingkat tinggi yang bertujuan agar dapat dibaca sebagai mungkin, tidak ada pengecualian untuk kesalahan desain manusia semacam itu. .

Bahasa fungsional murni hampir tidak kebal terhadap hal ini seperti yang bisa dilakukan seseorang (bahkan tidak mendekati kebal, tetapi relatif lebih dekat daripada kebanyakan). Dan itu sebagian karena mereka tidak memetakan secara intuitif ke pemikiran manusia. Mereka tidak dapat dibaca. Mereka memaksakan pola berpikir pada kita yang membuat kita harus menyelesaikan masalah dengan sesedikit mungkin kasus khusus menggunakan jumlah minimum pengetahuan yang mungkin dan tanpa menimbulkan efek samping. Mereka sangat ortogonal, mereka memungkinkan kode untuk sering diubah dan diubah tanpa kejutan begitu epik sehingga kita harus memikirkan kembali desain pada papan gambar, bahkan sampai mengubah pikiran kita tentang desain keseluruhan, tanpa menulis ulang semuanya. Tampaknya tidak lebih mudah untuk mempertahankan daripada itu ... tetapi kodenya masih sangat sulit dibaca,

Satu masalah adalah waktu pengembang yang terbatas berarti bahwa apa pun yang Anda upayakan untuk dioptimalkan menghilangkan waktu yang dihabiskan untuk masalah lain.

Ada percobaan yang cukup bagus yang dilakukan pada referensi ini dalam Kode Lengkap Meyer. Kelompok pengembang yang berbeda diminta untuk mengoptimalkan kecepatan, penggunaan memori, keterbacaan, ketahanan, dan sebagainya. Ditemukan bahwa proyek mereka mendapat skor tinggi dalam apa pun yang diminta untuk dioptimalkan, tetapi lebih rendah dalam semua kualitas lainnya.

Karena programmer berpengalaman telah belajar bahwa itu benar.

Kami telah bekerja dengan kode yang ramping dan berarti dan tidak memiliki masalah kinerja.

Kami telah mengerjakan banyak kode yang, untuk mengatasi masalah kinerja SANGAT kompleks.

Salah satu contoh langsung yang muncul dalam pikiran adalah bahwa proyek terakhir saya termasuk 8.192 tabel SQL sharded secara manual. Ini diperlukan karena masalah kinerja. Pengaturan untuk memilih dari 1 tabel jauh lebih sederhana daripada memilih dari dan memelihara 8.192 pecahan.

Ada juga beberapa potongan kode terkenal yang sangat optimal yang akan membengkokkan otak kebanyakan orang yang mendukung kasus bahwa kode yang sangat optimal sulit untuk dibaca dan dipahami.

Inilah yang paling terkenal menurut saya. Diambil dari Quake III Arena dan dikaitkan dengan John Carmak, meskipun saya pikir sudah ada beberapa iterasi fungsi ini dan itu awalnya tidak dibuat olehnya ( bukankah Wikipedia hebat? ).

float Q_rsqrt( float number )
{
    long i;
    float x2, y;
    const float threehalfs = 1.5F;

    x2 = number * 0.5F;
    y  = number;
    i  = * ( long * ) &y;                       // evil floating point bit level hacking
    i  = 0x5f3759df - ( i >> 1 );               // what the fuck?
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
    //      y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

    return y;
}