Seberapa pentingkah untuk mengurangi jumlah baris dalam kode?

Saya adalah seorang pengembang perangkat lunak yang bekerja pada J2SE (core java).
Seringkali selama ulasan kode kita, kita diminta untuk mengurangi jumlah baris dalam kode kita.

Ini bukan tentang menghapus kode yang berlebihan, ini tentang mengikuti gaya yang berfokus pada melakukan hal yang sama dengan lebih sedikit baris dalam kode, sementara saya percaya memiliki kejelasan dalam kode bahkan jika itu berarti meningkatkan jumlah baris.

Menurut Anda apa cara yang benar dalam melakukan sesuatu?
Jika LOC (baris kode) sedikit, bagaimana pengaruhnya terhadap kode? Jika LOC adalah angka yang lebih besar, bagaimana pengaruhnya terhadap kode?

contoh dari situs web: "javaranch" -

public static void happyBirthday(int age)
{  
    if ((age == 16) || (age == 21) || ((age > 21) && (((age % 10) == 0) || ((age % 25) == 0))))        
    {
        System.out.println("Super special party, this year!");
    }
    else
    {
        System.out.println("One year older. Again.");
    }
}

VS

public static void happyBirthday(int age)
{

    boolean sweet_sixteen = (age == 16);
    boolean majority = (age == 21);
    boolean adult = (age > 21);
    boolean decade = (age % 10) == 0;
    boolean quarter = (age % 25) == 0;

    if (sweet_sixteen || majority || (adult && (decade || quarter)))
    {
        System.out.println("Super special party, this year!");
    }
    else
    {
        System.out.println("One year older. Again.");
    }
}

Masalah dengan pengukuran, tidak peduli seberapa baik dimaksudkannya, adalah tindakan mengukur item membuatnya penting, dan akibat wajarnya, tindakan tidak mengukur item membuatnya menjadi tidak penting. Sangat penting untuk mengukur apa yang penting, dan tidak mengukur apa yang tidak penting.

Mengukur SLOC (Yang secara efektif adalah ulasan Anda lakukan), membuat SLOC penting .... Apakah SLOC penting? - Sama sekali tidak, tidak pernah (Diluar kontes pemrograman yang dikaburkan ), tidak akan pernah ada dalam organisasi komersial.

Tanyakan pada diri Anda satu pertanyaan sederhana - bagaimana cara "Mengurangi SLOC dari rutin ini" membuat kode anyones lebih baik. Apa yang mungkin terjadi dalam kasus ini adalah SLOC digunakan sebagai cara naif untuk mengukur kompleksitas. Apa yang harus Anda hindari dengan cara apa pun adalah menghitung biji yang mudah dihitung - ukuran obyektif seperti SLOC, alih-alih menghitung yang penting, tetapi sulit untuk menghitungnya - misalnya Keterbacaan, kompleksitas, dll.

Saya setuju dengan pengulas kode Anda, tetapi dengan tanda bintang. Setiap pernyataan yang Anda tulis dalam kode Anda adalah tanggung jawab teknis - ini merupakan titik kegagalan potensial. Jika Anda menulis sebuah metode dengan 10 pernyataan dan rekan kerja Anda menulis satu yang mencapai fungsi yang sama dengan 5 pernyataan, itu kemungkinan akan 'lebih baik' yang diukur dengan kemungkinan masalah (ada dua kali lebih banyak tempat kode Anda bisa salah, terlalu banyak kompleks, atau bermasalah).

Ini tanda bintangnya. Ini bukan tentang jumlah sebenarnya baris kode dalam ide karena Anda dapat mengurangi jumlah baris dengan sesuatu seperti:

void someMethod() {   
 someobject.doSomething(someSingleton.getInstance().with().a().lot().of().law().of().demeter().violations()).and().if().that().werent().enough().theres().more();
}

Ini adalah satu baris kode, tetapi ini adalah tempat di mana banyak hal yang salah dapat terjadi. Jadi saya akan mengatakan fokus untuk melakukan yang paling banyak dengan pernyataan paling sedikit - tulis kode sebanyak yang Anda butuhkan untuk menyelesaikan sesuatu dan tidak lebih. Paling tidak, saya pikir itulah yang mendorong para pengulas kode Anda.

Secara pribadi, saya pikir ada keseimbangan yang harus dicapai. Seperti yang saya katakan, setiap pernyataan yang Anda tulis adalah kewajiban, tetapi jika mengeluarkan variabel lokal dengan nama deskriptif membuat metode Anda jauh lebih jelas dan lebih mudah dibaca, maka ada kasus yang harus dibuat untuk itu juga. Saya pikir Anda dapat dengan mudah masuk ke situasi di mana orang berdalih tentang perbedaan estetika yang relatif kecil, tetapi secara keseluruhan, saya pikir pengulas Anda memiliki ide yang tepat - mendukung meminimalkan jumlah hal yang bisa salah.

Mengambil saran pengulas benar-benar tidak akan ada gunanya, karena hasil langsung yang jelas adalah mempromosikan satu baris (meskipun batas panjang garis). Saya percaya pelajaran yang bisa dipelajari di sini adalah membuat kode Anda melakukan lebih sedikit hal .

Dengan kata lain, ini adalah panggilan untuk kesederhanaan. Klaim yang cukup populer bahwa kode adalah liabilitas, bukan aset , jadi mengurangi jumlahnya sambil mempertahankan fungsinya adalah upaya yang mulia. Ini dapat dicapai dengan pendekatan langsung dan lebih membumi yang menangani masalah secara langsung dan lebih memilih solusi yang ringkas.

Seperti yang pernah dikatakan Ken Thompson: Salah satu hari saya yang paling produktif adalah membuang 1000 baris kode .

Saya cenderung setuju dengan posisi Anda "memiliki kejelasan kode bahkan jika itu berarti meningkatkan jumlah baris."

Saya telah melihat terlalu banyak one-liner yang cukup singkat, tetapi tidak segera jelas apa yang mereka lakukan. Keterbacaan adalah raja karena pengembang lain harus menjaga kode Anda.

Saya berpendapat bahwa tujuan yang lebih baik adalah metode pendek. Bukan pendek demi beberapa baris kode, tetapi pendek karena mereka melakukan satu hal.

Saat ini saya bekerja sebagai pengembang aplikasi senior dan analis bisnis proyek untuk perusahaan besar dan tidak pernah menghitung garis perkembangan saya sebagai pusat perhatian. Namun, saya percaya bahwa kode yang lebih kental dapat menjadi, semakin baik, TAPI tidak dengan biaya untuk dapat dengan cepat menganalisis dan memperbaiki (atau menambah) itu. Bagi saya, ketika Anda bertanggung jawab atas aplikasi penting bisnis yang HARUS memiliki skalabilitas yang luas dan mampu melakukan perubahan dengan cepat dalam lingkungan yang terus berubah, kode yang ringkas dan mudah dibaca adalah salah satu elemen terpenting dalam pengembangan . Untuk jawaban balasan Erik Dietrich , ini:

void someMethod() {   
someobject.doSomething(someSingleton.getInstance().with().a().lot().of().law().of().demeter().violations()).and().if().that().werent().enough().theres().more();
}

akan sepenuhnya tidak dapat diterima bagi saya, namun, saya menemukan mengubah semua perusahaan kode yang ada dari:

if (boolean == true){
value.prop = option1;
}
else{
value.prop = option2;
}

untuk:

value.prop =  boolean ? option1 : option2;

adalah pilihan kondensasi kode yang luar biasa yang tidak mengorbankan keterbacaan.

Sejauh bagaimana pengaruhnya terhadap kode? Saya tidak pernah melihat peningkatan atau penurunan kinerja, katakanlah, 100 baris kode. Fakta sederhananya adalah bahwa ini lebih merupakan proses yang Anda gunakan untuk sampai pada produk akhir daripada jumlah garis yang diperlukan untuk sampai di sana. Saya telah melihat beberapa proses yang ditulis sangat kental, namun tidak efisien, melakukan berbeda dari kode lagi dengan aliran kode yang lebih baik.

IMO, itu ide buruk untuk mengukur efektivitas kode dengan jumlah LOC yang sepele. Ada banyak lagi yang membuat kode direkayasa dengan benar dan efektif.

Dalam pengalaman saya, kode efektif:

• tidak melanggar salah satu prinsip SOLID
• mudah dibaca dan cukup jelas
• lulus ujian kesederhanaan Albert Einstein: "Segala sesuatu harus dibuat sesederhana mungkin, tetapi tidak sesederhana itu."

Ada banyak jawaban di sini yang membahas pro dan kontra teknis menjaga LOC turun dan apakah itu metrik perangkat lunak berkualitas yang bermakna atau tidak. Bukan itu pertanyaannya. Tentang ini adalah bagaimana menangani manajemen yang menekankan pada kepatuhan dogmatis yang naif terhadap aturan praktis tertentu.

Sayangnya, itu cukup umum bagi orang-orang untuk menempel pada hal-hal yang merupakan nasihat yang baik ketika digunakan dalam konteks yang tepat dan diterapkan secara pragmatis, membawa mereka keluar dari konteks itu dan menerapkannya secara dogmatis sementara gagal menghargai masalah-masalah yang ada pada saran yang harus dikurangi. .

Maksud dari saran tentang menjaga LOC turun adalah untuk menghindari penciptaan metode yang mencoba melakukan terlalu banyak dalam satu waktu, dan untuk mencegah penciptaan "kelas dewa", yang tahu terlalu banyak tentang aspek-aspek desain yang bukan milik mereka. tanggung jawab langsung dan yang bergantung pada semua kelas lain dalam sistem. Keuntungan lain dari kode pendek adalah lebih mudah dibaca, meskipun seperti yang telah Anda tunjukkan, Anda dapat melakukannya secara berlebihan hingga titik di mana keterbacaan benar-benar mulai berkurang.

Ada keuntungan jelas untuk jumlah LOC rendah (metode kecil masuk ke kepala Anda lebih mudah daripada yang besar, lebih sedikit hal dalam kode berarti lebih sedikit hal yang salah, dll), tetapi juga tunduk pada hukum pengembalian yang semakin menurun. Refactoring metode 150 line menjadi sejumlah metode 20 line adalah kemenangan yang jauh lebih besar daripada refactoring metode 10 line menjadi metode 7 line.

Ketika refactoring seperti itu mengorbankan beberapa aspek lain dari desain perangkat lunak yang baik (seperti keterbacaan) maka Anda telah mencapai titik di mana Anda dapat membenarkan tidak melakukannya. Menghapus variabel yang memberikan konteks pada arti kode dan menggantinya dengan literal yang bukan merupakan hal yang sangat buruk untuk dilakukan. Kode yang bagus hampir tidak memiliki literal di dalamnya. Namun, variabel-variabel ini (dan disebut konstanta) adalah baris kode yang tidak secara langsung berkontribusi pada program dan jadi jika LOC dipuja sebagai semacam dewa maka garis klarifikasi seperti itu berada dalam bahaya besar untuk dipangkas untuk kemenangan cepat dan beberapa pujian sesat dari manajemen.

Saya percaya Anda cukup pintar untuk menyadari hal ini, pada kenyataannya itu adalah dorongan dari pertanyaan awal Anda. Masalahnya bukan pemahaman Anda tentang kapan pengurangan kode baik dan ketika tidak, masalahnya adalah dogmatisme dalam menerapkan apa yang biasanya merupakan praktik yang masuk akal tanpa pandang bulu.

Saya akan merekomendasikan meluangkan waktu untuk mengobrol dengan manajemen Anda, menjelaskan posisi Anda dan mengapa Anda merasa bahwa apa yang diminta untuk dilakukan lebih merusak kode daripada membantunya. Cobalah untuk menghindari konfrontasi, tetapi cobalah untuk tetap rasional dan tenang selama diskusi semacam itu. Penting bagi manajemen Anda untuk memahami bahwa pemrograman adalah kegiatan pragmatis, dan saran praktik terbaik hanya berguna jika diterapkan dengan cara pragmatis. Praktik terbaik ditulis dalam sebuah buku, bukan diukir di atas batu, dan ketika itu bertentangan (kode pendek versus kode yang dapat dibaca) maka terserah kepada programmer untuk menerapkan penilaian mereka mengenai praktik mana yang harus diikuti. Semoga mereka adalah orang-orang yang masuk akal yang menghargai masukan seperti ini.

Anda juga harus sedikit berani, karena jika Anda ditekan untuk mengurangi LOC di mana Anda pikir itu tidak perlu atau tidak pantas maka wajar saja jika Anda akan melakukan perubahan demi kehidupan yang tenang. Anda harus menolak melakukan ini, dan Anda harus "memiliki" keputusan itu. Dalam situasi di mana manajemen masuk akal, Anda tidak harus benar-benar mematuhi pedoman mereka, tetapi Anda harus dapat membenarkan keadaan apa pun di mana Anda tidak melakukannya.

Sayangnya, orang-orang bisa menjadi tidak rasional, terutama ketika orang-orang yang lebih rendah dalam urutan kekuasaan mempertanyakan keputusan mereka dan aturan yang telah mereka tetapkan pada Anda. Mereka mungkin memilih untuk tidak masuk akal. Anda harus siap untuk itu juga. Jika Anda dapat mendemonstrasikan kasus-kasus di mana praktik terbaik LOC berselisih langsung dengan praktik terbaik lainnya dan mengapa hal itu melukai produk, dan jika Anda dapat melakukannya di bagian basis kode yang keterlibatan pribadi mereka sedikit atau tidak sama sekali (sehingga tidak kelihatannya seperti serangan pribadi pada pekerjaan mereka atau pekerjaan yang mereka awasi) maka ini dapat membantu memperkuat argumen Anda. Sekali lagi, Anda harus siap untuk membenarkan diri sendiri dengan cara yang tenang, rasional dan mampu "memiliki" argumen yang Anda buat.

Asalkan manajemen Anda adalah orang-orang yang masuk akal maka mereka harus menghargai bahwa apa yang Anda katakan pantas jika Anda dapat memberikan bukti untuk mendukung klaim Anda.

Saya pikir Anda memang harus berusaha untuk memiliki fungsi dengan sejumlah kecil SLOC.

Jika LOC (baris kode) adalah angka kecil, bagaimana pengaruhnya terhadap kode dan jika LOC adalah angka yang lebih besar, bagaimana pengaruhnya terhadap kode?

Idealnya, sekilas lebih mudah untuk memahami 8 baris kode daripada memahami 30 baris.

Itu tidak berarti bahwa 30 LOC yang dikompres dalam 8 baris akan lebih mudah dipahami.

Apa yang Anda pikirkan adalah cara yang benar dalam melakukan sesuatu.

Biasanya dalam suatu fungsi, saya mencoba mengelompokkannya berdasarkan level abstraksi ("kode IO di sini", "validasi di sini", "perhitungan di sini" dan seterusnya).

Kemudian, saya membaginya menjadi beberapa blok, dipisahkan oleh garis kosong. Jika kode lebih dari sekitar sepuluh baris, saya mengekstrak setiap blok ke fungsi yang berbeda (saya tetap melakukannya untuk kode yang muncul lebih dari satu kali). Saya pernah mendengar argumen tentang memecah kinerja dengan cara ini (panggilan fungsi yang tidak perlu) tetapi dalam praktiknya saya tidak pernah mengalami hambatan kinerja yang disebabkan oleh ini.

Yang mengatakan, saya sudah memiliki fungsi dengan ekstraksi ini dilakukan, dan setelah itu fungsinya ~ 40 baris panjang (kode C). Jika kode dikelompokkan sebanyak mungkin, saya tidak melihat masalah dengan fungsi yang lebih panjang.

Saya pikir lebih penting untuk fokus pada kode yang bersih dan didokumentasikan secara otomatis, daripada LOC. Saya tidak terlalu menyukai contoh Anda, karena ini menjelaskan apa yang dilakukan kode, tanpa mengatakan alasannya. Sebagai contoh, ini:

boolean sweet_sixteen = (umur == 16);

cukup berlebihan. Siapa pun yang membaca "age == 16" tahu itu. Saya lebih suka menulis kode seperti ini:

public static boolean companyShouldThrowABigParty(int age) {
    return (age == 16) || (age == 21) || ((age > 21) && (((age % 10) == 0) || ((age % 25) == 0))); 
}

public static void happyBirthday(int age)
{  
    System.out.println(companyShouldThrowABigParty(age) ? "Super special party, this year!" : "One year older. Again.");
}

Logika tentang memutuskan kapan akan mengadakan pesta terpisah dari System.out, dapat diuji, dan mudah dimengerti. Lebih penting lagi, seseorang yang membaca kode dapat memahami alasannya ditulis seperti itu ("perusahaan ingin mengadakan pesta besar untuk beberapa orang").

Saya pikir lebih sedikit baris kode = lebih banyak kode yang dapat dibaca

Tetapi tentu saja, ada beberapa batasan, ketika Anda mulai mengecilkan / mengaburkan kode Anda hanya untuk mendapatkan lebih sedikit baris.

/** Pad a number with 0 on the left */
function zeroPad(number, digits) {
    var num = number+"";
    while(num.length < digits){
        num='0'+num;
    }
    return num;
}

Ini adalah minifikasi logikanya tetap sama, hanya sedikit terbaca. Ini seharusnya tidak dilakukan oleh manusia, minifikasi ini dilakukan oleh mesin untuk dibaca oleh mesin.

function zP(e,t){var n=e+"";while(n.length<t){n="0"+n}return n}

Jika Anda dapat menghapus beberapa kode, dan algoritma masih melakukan apa yang seharusnya dilakukan, ok lanjutkan. Hanya saja jangan minify kode Anda, ada alat yang lebih baik untuk melakukan itu.

Saya tidak berpikir lebih sedikit baris kode == kode lebih mudah dibaca. Namun, kenyataannya, yang sangat berbeda dari teori, adalah bahwa kode dengan sejumlah besar garis sering ditulis tanpa desain yang tepat. Akibatnya, persyaratan garis yang lebih sedikit MUNGKIN memaksa beberapa programmer untuk datang dengan desain yang lebih baik jika mereka mampu. Twist adalah bahwa banyak programmer tidak, maka persyaratannya tidak banyak membantu.

Saya tidak akan melihat jumlah baris sebagai masalah dalam keadaan normal, tetapi ini bisa mengarah ke masalah. Jika seseorang menunjukkan kepada Anda sebuah kelas dengan 1000 baris kode, maka pasti ada yang salah dengan cara kelas itu dilakukan atau dirancang.

Contoh Anda memang menunjuk ke kasus di mana lebih banyak baris kode masuk akal. Tapi itu contohnya. Setiap hari saya melihat contoh di mana jumlah baris terkait dengan kurangnya perencanaan

LOC adalah metrik yang jauh lebih berguna di awal proyek daripada selama implementasi aktual, saya pikir. Mengetahui LOC per titik fungsi memungkinkan Anda untuk memperkirakan upaya proyek, dan dari itu berapa lama proyek akan memakan waktu dan jumlah pengembang yang optimal.

Hal ini juga dapat memengaruhi pilihan desain dan bahasa: mengurangi titik fungsi atau beralih ke bahasa dengan LOC / FP yang lebih rendah harus mengurangi upaya proyek, semuanya setara.

Baris-baris kode itu sendiri tidak terlalu penting. Salah satu cara untuk melihatnya adalah membandingkannya dengan prosa. Realisasi pertama adalah bahwa properti penting dari kode dan prosa (dengan asumsi kebenaran) adalah keterbacaan. Keterbacaan (dan dapat dimengerti) membantu dengan properti lain seperti rawatan dan kebenaran.

Ada keuntungan untuk dapat menyesuaikan suatu fungsi dalam sejumlah kecil garis. Tetapi memiliki teks tanpa paragraf mengurangi keterbacaannya. Menggunakan konsep-konsep yang sulit, kata-kata yang sulit (jarang) dan cara ekspresi yang kompleks umumnya mengurangi jumlah kata yang diperlukan untuk mengekspresikan suatu ide, tetapi pada saat yang sama memindahkan tingkat membaca teks dari tingkat sekolah menengah ke akademisi profesional (dalam kasus prosa).

Secara umum sangat membantu untuk menambahkan abstraksi dalam kode Anda dan menggunakan pembantu dll. Tetapi sekali lagi, abstraksi itu bisa menjadi terlalu banyak. Yang juga bisa terjadi adalah memindahkan kompleksitas ke bagian kode yang lain. Terkadang, seperti ketika Anda sebagai seorang ahli merancang kerangka / pustaka untuk digunakan oleh programmer junior (atau siswa), adalah ide yang baik untuk melakukan ini. Tetapi jangan berharap junior untuk dapat memahami bagaimana kode Anda bekerja, hanya membuatnya sangat sulit bagi mereka untuk menggunakannya secara tidak benar.

Saat menulis kode, terutama jangan menghindar untuk menambahkan baris kosong dalam kode Anda. Mereka berfungsi sebagai paragraf dan membantu Anda memisahkan bagian yang berbeda dari fungsi Anda (bahkan jika mereka belum dimasukkan ke dalam pembantu).

Masalah besar dengan setiap metode formal evaluasi kode adalah pasti akan gagal pada beberapa kode. Ini karena pemrograman adalah semacam seni dan dengan demikian, tidak ada standar yang jelas untuk evaluasi. Tentu saja ada berbagai jenis seni - produksi massal lukisan juga ada, dan mungkin dalam bisnis ini penting berapa banyak cat yang dihabiskan untuk satu lukisan. :)

Sejujurnya, saya tidak peduli tentang pengukuran LOC. Tentu, itu bagus untuk fungsi atau prosedur sesingkat mungkin, tapi saya mengambil kode yang dapat dibaca singkat setiap saat.

Saya setuju bahwa selalu membutuhkan pengurangan LOC akan menyebabkan kode sulit dibaca.

Namun, mungkin gaya pengkodean Anda terlalu bertele-tele dan pengulas Anda menganggap cara yang lebih ringkas lebih baik. Misalnya komentar yang hanya menjelaskan satu pernyataan yang cukup jelas berkat pilihan nama variabel yang jelas tidak berguna.

Hanya ada satu hal yang diukur oleh baris kode dan itu adalah jumlah baris kode yang Anda miliki. Yang lainnya adalah udara panas, spekulasi dan prasangka.

Ada banyak contoh hebat dalam jawaban lain tentang bagaimana memiliki lebih sedikit baris kode dapat membuat sesuatu lebih buruk, tidak lebih baik, tetapi satu titik inti tampaknya telah terjawab, dan itu adalah: berapa banyak baris yang sebenarnya Anda perlukan untuk melakukan pekerjaan ini ?

Jika menyelesaikan tugas Anda membutuhkan 10 baris kode, ya, Anda melakukannya dalam 10 baris. Jika mencapai itu membutuhkan 10.000 baris, maka jadilah demikian, Anda melakukannya dalam 10.000 baris. Kultus "lebih sedikit baris kode" tidak akan membuat contoh terakhir lebih baik jika Anda melakukannya dalam 1.000 atau 2.000 atau apa pun. Pekerjaan itu membutuhkan 10.000 saluran dan 10.000 saluran itu mungkin termasuk lapisan validasi, pengecekan kesalahan, keamanan, dll. Yang akan terlewatkan jika Anda melakukannya dalam lebih sedikit.

Sunting

Karena ini telah mengumpulkan beberapa downvotes saya pikir saya harus lebih spesifik tentang apa yang saya katakan di sini. Hal pertama yang harus dilakukan siapa pun adalah membaca ini - poin yang saya minta Anda ambil darinya adalah bahwa kode tingkat tinggi yang Anda tulis mungkin memiliki sedikit atau tidak ada kemiripan dengan kode mesin yang benar-benar dieksekusi. Relevansi poin ini adalah bahwa fokus pada kode tingkat tinggi tanpa pemahaman tentang apa yang sebenarnya terjadi di bawahnya adalah sesat.

Sekarang pertimbangkan hal berikut:

• Sangat mungkin untuk menulis kode yang sangat buruk dan lambat hanya dengan satu baris - perhatikan komentar pada operator ternary di akhir tautan yang saya berikan.

• Jika sebaris kode membuat panggilan API (atau panggilan lain ke perpustakaan eksternal) maka Anda memiliki sedikit definisi dalam cara mengendalikan langsung apa yang dijalankan atau seberapa efisiennya.

• Pengecekan kesalahan, pembersihan, dll semua menambahkan baris kode tambahan dan saya cukup yakin bahwa penggemar baris kode yang lebih sedikit pun tidak akan membantah hal itu .

Jadi - baris kode adalah metrik yang rusak. Lebih sedikit baris kode tidak menjamin kinerja ekstra - bahwa panggilan API atau pustaka adalah satu baris dan dapat berada di luar kendali Anda. Lebih sedikit baris kode tidak menjamin ketahanan ekstra - pengecekan dan pembersihan kesalahan akan selalu membutuhkan baris tambahan. Lebih sedikit baris kode bahkan tidak menjamin keterbacaan tambahan atau pemeliharaan - Anda hanya perlu melihat IOCCC untuk mengetahuinya.

Jadi, apa yang lebih sedikit dari jaminan kode? Lebih sedikit baris kode, itu saja.

Sangat salah untuk fokus melakukan pekerjaan yang sama dalam 2.000 baris versus 10.000. Alih-alih fokus pada kode yang berfungsi, yang tangguh, yang berkinerja dalam toleransi yang diterima, dan yang lebih mudah dibaca dan dipertahankan ke depan. Kadang - kadang itu berarti Anda dapat melakukannya dalam jumlah LoC yang rendah, kadang - kadang itu berarti Anda harus melakukannya dalam jumlah LoC yang lebih tinggi, tetapi jumlah LoC seharusnya bukan yang penting di sini.

Seberapa pentingkah untuk mengurangi jumlah baris dalam kode? Dalam kebanyakan kasus, tidak sama sekali. Bahkan, dalam banyak kasus, lebih penting untuk meningkatkan jumlah baris kode dengan memecah operasi kompleks menjadi langkah-langkah yang lebih mudah dibaca, dan mengomentari setiap langkah serta menambahkan komentar secara umum untuk membuat kode lebih mudah dibaca dan diperluas oleh yang lain pengembang yang mengejar Anda.

Pada periode sebelumnya diasumsikan bahwa jika jumlah baris kode yang loc besar maka kode efektif dan menyelesaikan semua tugas yang biasa dilakukan tetapi disadari setelah beberapa waktu bahwa kurang adalah loc lebih memiliki efisiensi karena biaya yang dikeluarkan oleh sistem dalam mengeksekusi kode sangat kurang. Oleh karena itu untuk perbaikan loc sistem harus dibuat lebih sedikit. Karena itu diasumsikan bahwa loc harus lebih sedikit. Untuk menguranginya faktor-faktor berikut harus diperhitungkan.

1. Buat diagram alur masalah Anda
2. Cobalah untuk menggunakan jumlah loop yang lebih sedikit
3. Panggilan fungsi seharusnya tidak banyak
4. Struktur data baru seperti TRIE harus digunakan dalam kasus di mana tumpukan atau antrian digunakan untuk menyimpan informasi yang relevan.
5. Dan cobalah untuk memecahkan masalah dengan pendekatan realistis daripada imajinatif di mana Anda menyimpan sejumlah besar angka dalam array yang sangat besar dan kemudian mencoba mengaksesnya melalui array.]
6. Gunakan sebanyak mungkin makro. Selanjutnya pendekatan yang digunakan juga tergantung pada masalahnya. Jika benar-benar rumit maka kadang-kadang menggunakan pendekatan sederhana juga setara dengan yang kompleks.