Mengapa verbositas buruk untuk bahasa pemrograman? [Tutup]

Saya telah melihat banyak orang mengeluhkan verbositas dalam bahasa pemrograman. Saya menemukan bahwa, dalam beberapa batasan, semakin banyak bahasa pemrograman, semakin baik untuk dipahami. Saya pikir verbositas itu juga memperkuat penulisan yang lebih jelas APIuntuk bahasa itu.

Satu-satunya kelemahan yang dapat saya pikirkan adalah itu membuat Anda mengetik lebih banyak, tapi maksud saya, kebanyakan orang menggunakan IDE yang melakukan semua pekerjaan untuk Anda.

Jadi, Apa kemungkinan kerugian dari bahasa pemrograman verbose?

Tujuannya adalah pemahaman cepat

"Verbose" berarti "menggunakan terlalu banyak kata". Pertanyaannya adalah apakah "terlalu banyak" itu.

Sekilas kode yang baik harus mudah dipahami. Ini lebih mudah jika sebagian besar karakter langsung melayani tujuan kode .

Sinyal vs Kebisingan

Jika suatu bahasa bertele-tele, lebih banyak kode Anda yang berisik. Bandingkan Java "Hello World" :

class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

... dengan Ruby:

print "Hello World!"

Kebisingan menghabiskan energi mental.

Cryptic vs Clear

Di sisi lain, kepatutan berlebihan dalam bahasa juga menghabiskan energi mental. Bandingkan dua contoh ini dari Common Lisp :

(car '(1 2 3))   # 3 characters whose meaning must be memorized
# vs
(first '(1 2 3)) # 5 characters whose meaning is obvious

Ini memengaruhi seberapa banyak kode yang dapat Anda lihat dan parsing dalam sekali pandang

x++ daripada set(x,Integeradd(get(x),1))

ps. Ini bukan hanya masalah membaca kode. Pada hari-hari layar 40x25 maka bahasa jenis APL, atau Perl, lebih berguna daripada Cobol atau Fortran untuk jumlah kode yang bisa Anda baca / halaman. Tapi sekarang ini lebih tentang cache internal Anda sendiri - jika sebuah pernyataan memiliki satu operator, otak saya yang sudah tua akan lebih mudah diuraikan daripada satu dengan 3 simbol dan 4 panggilan fungsi.

Jika verbositas bahasa mengurangi keterbacaan kode, maka itu buruk.

Beberapa bahasa memiliki sintaksis verbose sedemikian rupa sehingga memahami makna kode membutuhkan waktu lebih lama (saya berpikir tentang VB.NET versus C #):

If something Then
End If

if(something)
{}

Itu benar-benar bermuara pada apa yang akrab dan nyaman dengan coder.

Lihatlah AppleScript , salah satu bahasa yang paling bisa saya pikirkan yang dapat dianggap mutakhir , cobalah untuk menulis sesuatu yang trival di dalamnya dan kembali dan coba dan bantah bahwa verbositas adalah sifat yang baik dalam suatu bahasa.

Mencoba mengingat semua semantik di mana kata kunci pergi dan apa kata kunci itu non-sepele jika Anda tidak melakukannya setiap hari.

Lihat saja semua kebisingan kata kunci dalam contoh sepele ini:

tell application "Finder"
    if folder "Applications" of startup disk exists then
        return count files in folder "Applications" of startup disk
    else
        return 0
    end if
end tell

hal yang sama diberikan bashdengan alat Unix tradisional akan singkat tetapi samar untuk sebagian besar pengguna OSX, sehingga ada keseimbangan yang harus dipukul.

Saya pikir Anda perlu mengubah pertanyaan di kepala itu dan bertanya: Mengapa beberapa orang berpikir kode singkat itu baik?

Jawaban saya adalah ada dua alasan dasar:

Alasan Mengapa Terse Bisa Menjadi Lebih Baik

Ini termasuk menjadi lebih mudah dibaca, dengan cara yang sama bahwa kalimat pendek bisa lebih dimengerti daripada kalimat berbunga-bunga dan bertele-tele. Seringkali bahasa pemrograman yang mencoba dan meniru tata bahasa bahasa Inggris akhirnya menjadi sangat bertele-tele, membutuhkan perluasan besar kode untuk melakukan tindakan paling sederhana. Seringkali Anda akan menemukan bahwa semakin banyak suatu bahasa mengemulasi bahasa tertulis maka semakin sulit untuk membujuknya melakukan operasi yang kompleks secara logis.

Alasan Mengapa Terse Bisa Lebih Buruk

Beberapa bahasa (dan saya sedang berpikir tentang Perl) menggunakan array simbol-simbol aneh, yang tampaknya hampir dipilih secara sewenang-wenang, sebagai bagian dari sintaksis mereka. Bagi siapa pun yang tidak terbiasa dengan hieroglif ini maka bahasa menjadi tidak bisa ditembus. Ini juga menjadi mudah untuk membuat kesalahan ketik yang tidak mudah dilihat. Ekspresi reguler barangkali melambangkan keanehan semacam ini.

Juga, beberapa orang suka pamer dengan menulis kode singkat karena, terus terang, mereka pikir itu membuat mereka terlihat pintar. Anda melihat ini kadang-kadang di StackOverflow, di mana orang sering akan mengirimkan jawaban yang sangat kompak dengan mengorbankan keterbacaan. Ini adalah semacam "mengesankan teman-teman Anda" dengan seberapa banyak Anda tahu filosofi, tetapi programmer yang baik menyadari bahwa " golf kode " bukan cara untuk membuat perangkat lunak yang dapat dirawat.

@ Terus terang, saya akan menyarankan bahwa salah satu cara untuk melihat masalah verbositas adalah dengan menyadari bahwa pemrograman selalu merupakan campuran dari dua gaya yang agak berbeda dalam menemukan dan mengekspresikan solusi.

Gaya pertama dan lebih verbose adalah pemrograman berorientasi bahasa (linguistik). Gaya ini menggabungkan kata-kata seperti-kata benda dan kata-kata seperti-kata dalam struktur seperti kalimat, dan dimaksudkan untuk dibaca dan dipahami dengan cara yang sama seperti paragraf yang ditulis dengan baik. Pemrograman linguistik adalah gaya pemrograman yang paling universal karena bahasa itu sendiri bersifat universal. Untuk alasan yang sama, dukungan program jangka panjang selalu membutuhkan komponen linguistik yang kuat, karena hal pertama yang akan dicari oleh programmer baru adalah sebagai pemahaman konseptual tentang apa yang sedang dilakukan. Sebagai aturan umum, semakin jauh Anda menjauh dari konteks di mana Anda membuat sebuah program, semakin penting gaya bahasa pemrograman untuk memastikan bahwa asumsi dan konsep Anda tidak akan disalahpahami oleh orang berikutnya yang mencoba memahami kode Anda. .

Gaya kedua dan lebih ringkas adalah pemrograman berorientasi matematika (matematika). Gaya penalaran ini juga bergantung pada bahasa, karena misalnya variabel analog dengan kata benda dan operator dengan kata kerja. Namun, penalaran matematis memanfaatkan kemampuan otak kita yang luar biasa dan sangat paralel untuk melakukan transformasi spasial yang kompleks pada objek yang berada dalam garis pandang kita. Dengan merepresentasikan kata benda dan kata kerja sebagai simbol yang ringkas dan khas yang dapat diatur menjadi objek imajiner yang terstruktur dengan baik - persamaan - kita kemudian dapat menggunakan kemampuan visual yang sangat paralel untuk melakukan rotasi, penggantian, gerakan, inversi, dan transformasi lain pada imajiner ini benda. Hasilnya adalah amplifikasi yang sangat besar dari jumlah kasus yang dapat kita tangani sekaligus, karena setiap simbol dapat mewakili seluruh kelas objek yang terkait erat.

Perhatikan bahwa untuk menerapkan pemrosesan visual secara efektif, Anda perlu menjaga objek imajiner Anda dalam ukuran dan fitur yang sama dengan objek nyata. Jika bidang visi yang dibutuhkan menjadi terlalu luas, atau simbol tidak dapat digunakan seperti tanda bergerak pada objek, atau jika Anda harus "membaca huruf" dan mengubahnya menjadi kata-kata, kemampuan untuk melakukan transformasi kompleks andal akan jatuh cepat bahkan untuk ahli matematika yang sangat baik.

Itulah sebabnya orang-orang yang tenggelam dalam gaya pemrograman matematika dapat benar-benar tidak bahagia jika sebuah persamaan tersebar dan diekspresikan dalam apa yang mereka sebut gaya linguistik “verbose”. Itu bukan karena persamaannya telah berubah secara signifikan, itu karena menyebarkannya seperti itu dapat membuatnya hampir mustahil untuk menerapkan gaya visual pemahaman padanya. Namun pada saat yang sama, seorang programmer baru yang sama sekali tidak akrab dengan simbol-simbol pendek cenderung lebih suka versi yang lebih verbal yang memberikan informasi lebih banyak bahasa untuk awalnya memahami apa yang dilakukan kode.

Jadi apa yang akan saya rekomendasikan?

Gunakan kedua gaya, tetapi perhatikan mengapa Anda menggunakan masing-masing gaya.

Misalnya, segala sesuatu yang memiliki peluang untuk berinteraksi dengan dunia luar harus secara intensif bertele-tele pada tingkat tertentu, bahkan jika hanya dalam bentuk komentar sebaris yang dicampur dengan kode, dan juga harus mencakup pemeriksaan otomatis untuk penggunaan yang benar. Notasi cryptic dan terutama yang tidak lengkap tidak memiliki bisnis dalam antarmuka seperti itu, karena mereka hampir dijamin akan disalahpahami pada beberapa titik. The 1999 hilangnya Mars Climate obiter karena kegagalan untuk mengenali apakah unit perangkat lunak antarmuka yang dinyatakan dalam pound atau Newton adalah contoh yang runcing bahaya mengandalkan terlalu santai di nomor mentah di software atau hardware interface.

Sebaliknya, segala bentuk pemrograman yang sangat algoritmik dan matematis adalah kandidat pemrograman ringkas yang baik yang mendukung gaya penalaran matematis. Jika seseorang yang baru harus mempertahankan kode seperti itu, biasanya akan lebih baik bagi mereka untuk mempelajari notasi matematika daripada mencoba mengubah kode menjadi bentuk yang lebih verbose. Tentu saja harus selalu ada dokumentasi yang mudah tersedia untuk menjelaskan bagian matematika kode yang tersedia untuk pengembang tersebut, tetapi itu adalah masalah terpisah.

Di antara kedua ekstrem ini ada banyak kasus di mana programmer memiliki keleluasaan besar. Saya akan menyarankan melihat bagaimana kode akan dipertahankan dalam jangka panjang, dan mencoba mengakomodasi kebutuhan orang-orang yang paling mungkin mempertahankan kode dalam jangka panjang.

Sejumlah orang telah mengisyaratkan sesuatu yang saya pikir mungkin harus dinyatakan secara eksplisit.

Verbositas cenderung mendukung pemahaman pada tingkat mikroskopis - umumnya mengarah pada pernyataan individu yang mudah dibaca dan dipahami. Verbositas juga cenderung mengurangi tingkat keakraban dengan bahasa yang diperlukan untuk memahaminya (setidaknya sampai tingkat tertentu). Bahasa yang paling bertele-tele (misalnya, COBOL) dapat setidaknya terbaca bahkan oleh non-programmer lengkap.

Kecenderungan cenderung ke arah yang berlawanan: itu membantu pemahaman pada tingkat makroskopik, terutama oleh programmer dengan keakraban paling akrab dengan bahasa tertentu. Pada saat yang sama, kurangnya keakraban dengan bahasa tertentu dapat mencegah bahkan pemahaman yang belum sempurna, bahkan dari programmer yang sebaliknya cukup berpengalaman.

Dengan demikian, keterbacaan sangat bervariasi tergantung pada audiens target. Di satu sisi, pertimbangkan proyek besar dan kompleks yang ditulis dan dikelola oleh orang-orang yang bekerja hampir secara eksklusif pada proyek itu, yang sebagian besar memiliki latar belakang pemrograman dan pendidikan yang substansial (misalnya, banyak PhD). Ini akan cenderung mendukung bahasa yang lebih ringkas.

Pada titik yang berlawanan, pertimbangkan sebuah proyek yang jauh lebih sederhana (walaupun mungkin masih cukup besar) yang dikelola terutama oleh orang-orang yang benar-benar mengkhususkan diri dalam bisnis yang terkait dengan perangkat lunak, daripada dalam perangkat lunak itu sendiri. Ini hampir pasti akan mendukung bahasa yang jauh lebih verbal.

Daripada pergi ke buku teknis, saya kembali ke Elements of Style * oleh Strunk and White. Konsep yang mendasarinya adalah "Tepat" dan "Jangan katakan lebih dari yang dibutuhkan." Yang lainnya adalah komentar.

Diterapkan untuk pemrograman, ini tentang menjadi sangat tepat, tetapi tidak memiliki bulu yang tidak dibutuhkan. Fluff ekstra bisa berupa sintaks, tetapi bisa juga lebih banyak kata daripada yang dibutuhkan untuk menyampaikan makna. (Tentu saja tidak terlalu sedikit untuk memungkinkan ambiguitas)

• Saya mengutip versi aslinya karena ini adalah versi yang paling ringkas. :-)

Pada akhirnya, apa pun yang 'berbeda' akan menyebabkan orang melolong. Saya nyaman dengan sintaks gaya C dan karenanya ok dengan bahasa lain yang memiliki sintaksis yang sama (C ++, Java, C #). Jadi saya cenderung menyukai gaya khusus ini.

Bahasa cenderung menemukan keseimbangan antara cukup deskriptif, dan tidak bertele-tele.

Perl adalah contoh di mana Anda dapat menulis kode yang sangat ringkas. Bagi yang belum tahu, kode yang ditulis oleh Ninja Perl bukanlah keajaiban.

COBOL adalah contoh dari terlalu bertele-tele.

Saya pernah membaca di suatu tempat bahwa banyak debat verbal datang dari programmer baru vs tangan lama. Analogi yang digunakan adalah ketika kita mempelajari sesuatu yang baru, kita memberi tahu diri kita sendiri sebuah "cerita" untuk melewatinya (pikirkan ketika Anda belajar aljabar di HS). Ketika kami memperoleh pengalaman, kami bergerak melampaui kebutuhan akan cerita yang menjelaskan komponen-komponen individual dan kami memahami jumlah yang lebih besar. Kode kami menjadi lebih padat dan lebih singkat, dengan komentar hanya menjelaskan item yang diperlukan, alih-alih mengulangi apa yang dikatakan kode.

Saya menemukan ini benar antara saya dan seorang rekan kerja. Dia menulis kode dengan banyak komentar yang menjelaskan apa baris kode itu, dan banyak ruang putih. Jika saya membacanya, saya menemukan bahwa saya hanya dapat memasukkan beberapa baris kode pada satu layar karena ini. Itu membuat memahami setiap baris individu jauh lebih mudah, tetapi menggosok seluruh fungsi menjadi jauh lebih sulit.

Saya cenderung menulis kode tanpa spasi atau komentar ekstra. Ini membuat melihat keseluruhan jauh lebih mudah, tetapi Anda harus bisa "mendapatkan" kode "kata-kata" masing-masing. Jika Anda mencoba membaca jawaban ini dengan setiap kata berada di barisnya sendiri, dengan banyak spasi putih / komentar / kata-kata ekstra maka akan jauh lebih mudah untuk memahami setiap kata, tetapi jauh lebih sulit untuk memahami keseluruhan.

Einstein benar: "Jadikan sesederhana mungkin, tetapi tidak sederhana."

Ini juga berlaku untuk kode. Jika Anda dapat menyederhanakan kode dengan menghapus elemen berulang dan tidak perlu, itu adalah hal yang baik.

Juga, beberapa studi kasus menunjukkan bahwa produktivitas pemrogram diukur dalam garis kode lebih atau kurang konstan. Begitu juga jumlah bug per LOC. Jadi beralih ke bahasa yang memungkinkan Anda melakukan lebih banyak per baris kode dapat dianggap sebagai peningkatan produktivitas, jika semua hal lainnya tetap sama.

Yang sedang berkata, ada kecenderungan dalam industri ini untuk lebih dari insinyur dan memperumit apa yang seharusnya menjadi hal-hal sederhana. Hal-hal sederhana seperti memasukkan rincian kontak dalam basis data relasional. Saya telah melihat beberapa solusi yang sangat rumit dan salah arah ( batuk MDA) untuk masalah khusus itu. Bahasa seperti Scala dan Ruby adalah contoh yang baik dari alat yang kuat yang di tangan orang-orang tertentu menghasilkan kode yang tidak dapat dipahami, terlalu rumit, dan tidak bisa dirawat dengan baik. Hanya karena Anda dapat menggunakan beberapa tingkat tipuan dengan beberapa goresan kunci tidak berarti Anda harus mengacaukan setiap kuku yang terlihat dengan palu tertentu.

Ketika digunakan dengan benar, Anda mendapatkan kode bersih yang bagus yang pendek dan mudah dimengerti. Bila digunakan dengan buruk, Anda lebih baik membatasi individu yang bersangkutan untuk menggunakan visual basic atau bahasa yang serupa untuk mencegah kerusakan lebih lanjut.

Keahlian sejati terletak pada membuat hal-hal rumit dengan cara yang sederhana, bukan dalam membuat hal-hal sederhana dengan cara yang rumit.

Sesuatu yang tidak dipukul orang lain adalah jumlah kode yang dapat Anda muat dalam satu layar. Ini membantu karena beberapa alasan:

• Lebih sedikit menggulir bolak-balik saat Anda mengerjakan (atau membaca) beberapa fungsi dalam satu file.
• Pengguliran horizontal kurang (berhenti membaca, klik dan seret bilah gulir, berhenti membaca, klik dan seret bilah gulir ...).
• Pemindaian lebih cepat, karena ada sintaks yang kurang berguna menghalangi cara menemukan apa yang Anda inginkan.

Karena lebih banyak kode berarti lebih banyak waktu pengembangan dan lebih banyak bug.

Jika Anda menulis 100 baris kode, bukan 300 baris kode. Itu berarti hampir 1/3 waktu pengembangan yang Anda butuhkan dan 1/3 potensi bug yang mungkin Anda temui.

Dalam sebagian besar keadaan Anda perlu menyeimbangkan efisiensi dan keringkasan, karena menulis lebih sedikit kode berarti mesin perlu melakukan lebih banyak hal dan itu akan mengurangi efisiensi.

Biasanya, orang menyukai bahasa yang mudah dibaca / verbose daripada yang samar / singkat. Namun, saya pikir sebagian besar orang berasimilasi "verbositas" dengan "kekacauan", yang bukan hal yang sama.

Misalnya: while(<>){print if($.==2 || $& && !$x++); $.=0 if (/^--+$/)}

adalah pernyataan yang sangat singkat. Ini berisi semua yang ingin Anda ketahui. Namun, karena kesempitan itu, sulit dimengerti. Di sisi lain, versi yang sedikit lebih verbose dari program yang sama akan cukup mudah dipahami karena lebih mudah dibaca. Ini tentu saja bukan properti dari bahasa itu sendiri, tetapi beberapa bahasa cenderung lebih verbositas sementara yang lain cenderung lebih ringkas dalam cara pemrograman mereka.

Yang paling ekstrem, adalah http://en.wikipedia.org/wiki/Literate_programming , yang saya anggap sebagai konsep yang cukup menarik.

Satu aspek lain adalah "verbosity yang tidak diinginkan", juga disebut "clutter". Hal-hal yang harus Anda tambahkan karena alasan teknis, kurang gula sintaksis, API kembung, dan sebagainya.

Saya pikir sintaks yang jelas dan intuitif sangat penting. Itu juga harus cukup verbal untuk memudahkan pembacaan yang mudah. Pernyataan yang terlalu pendek yang dikemas dengan terlalu banyak logika seringkali dapat menyebabkan lebih banyak waktu untuk mendekripsi daripada rekan-rekan mereka yang sedikit lebih panjang. Di sisi lain, kode kembung yang tidak berguna yang penuh dengan garis boilerplate untuk melakukan sesuatu yang benar-benar sederhana juga merupakan gangguan.

Verbosity menjadi kecenderungan untuk menggunakan teks dalam jumlah yang luas, dan Terseness menggunakan teks yang sangat sedikit ...

Verbositas buruk karena:

1. itu memperkenalkan lebih banyak peluang untuk kesalahan ketik
2. itu membuatnya lebih sulit untuk membaca kode di layar atau kertas, dan / atau memasukkan pada kartu punch
   1. ini meningkatkan waktu debug
   2. ini membuat pemahaman kode untuk peningkatan / pemeliharaan lebih sulit
   3. ini dapat menyebabkan duplikasi kode yang tidak diinginkan
3. itu agak meningkatkan kemungkinan kesalahan sintaksis
4. itu mengurangi fleksibilitas pengkodean, dalam hal itu, sebagian besar bahasa verbose sangat terstruktur dan tidak memiliki banyak cara untuk mengatakan hal yang sama.
5. ini meningkatkan waktu pengkodean dan kompilasi
6. dapat mengambil lebih banyak ruang penyimpanan.

Tingkat verbositas tertentu sangat penting untuk kejelasan, namun ...

tingkat Verbositas minimal baik karena:

1. lebih mudah bagi manusia untuk membaca dan melampirkan nilai semantik daripada kode simbolik murni
2. Dalam penamaan variabel dan fungsi, membuatnya lebih mudah untuk debug, port, dan memelihara kode
3. dalam operasi bahasa tingkat dasar dan kata kunci dari bahasa yang kompleks, itu mengarah ke lebih sedikit penugasan operasi / kata kunci yang salah.

Beberapa contoh yang indah dari perintah terlalu singkat bagi banyak orang termasuk standbys BASIC lama val(x$), str$(x)dan chr$(x)... kembali nomor dari representasi string nya, kembali string untuk nomor, dan kembali satu karakter yang memiliki nilai ascii x sebagai string.

Atau pointer C / C ++ dan oleh operator referensi &dan *versus byrefkata kunci BASIC . Dalam C / C ++, saya dapat memiliki variabel X, dan melewatkan pointer ke variabel itu, tetapi saya harus mengingat yang mana adalah pointer dan yang merupakan "gunakan pointer sebagai variabel yang ditunjuknya"; pada dasarnya, saya cukup meneruskan referensi dengan kata kunci byref di panggilan fungsi, yang lebih jelas, tetapi kurang fleksibel:

def fn Foo(x byref as float) foo= (x += x+1)
...
Foo(x)

Dalam kode ini, konten x bisa dimodifikasi karena bendera byref. Beberapa rasa memungkinkan byref di panggilan, yang lain dalam definisi, beberapa di keduanya.

Verbositas penting bagi programmer kasual untuk dapat menggunakan simbolisme dengan lebih mudah; BASIC atau python lebih mudah dibaca manusia dan lebih bertele-tele daripada C / C ++, dan karenanya jauh lebih berguna untuk programmer biasa; kesederhanaan C / C ++ membuatnya jauh lebih baik untuk programmer yang lebih berpengalaman, yang perlu melihat lebih banyak kode dan kode yang lebih kompleks pada satu layar penuh, tetapi harus mempelajari berbagai konvensi struktur simbolik. Pada akhirnya adalah APL, yang hampir sepenuhnya tidak dapat dibaca manusia.

Masalah yang terkait erat adalah kode kejelasan yang sering tidak jelas, dan kode yang terlalu bertele-tele (seperti dalam AppleScript) bisa sama tidak jelasnya. Keakraban dengan bahasa yang diberikan meningkatkan kejelasan kode singkat dalam bahasa tersebut - pemula yang mentah, menghadapi kode C ++ cenderung hanya dapat menguraikan rumus, dan bahkan banyak BASIC atau kode Python yang fungsional terlalu singkat untuk dipahami, tetapi applescript dapat menjadi bingung, umumnya, tanpa bantuan kamus bahasa. Yang paling jelas saya temui tanpa kebingungan yang disengaja adalah Inform 7 ...

Di masa lalu

Pertimbangan penting lainnya di masa lalu, tetapi yang tidak lagi penting bagi pembuat kode hobi, adalah ruang operasi dan penyimpanan. (Ini masih penting di kelas atas.) Ingatlah bahwa banyak bahasa diinterpretasikan, terutama rasa BASIC, dan banyak lagi yang dikompilasi run-time, ruang kode penting, terutama ketika disk hanya menampung 128KiB, dan kartu punch individu hanya 80B.

Ada beberapa solusi - tokenisasi sangat umum di BASIC; kata kunci bahasa individu dikurangi menjadi 1 atau 2 kata byte baik di atas 128 atau ruang karakter kontrol. Tokenisasi juga mengarah ke kompilasi bytecode (seperti pada Inform and the Z-Machine).

Kompilasi dan menghubungkan banyak file objek juga digunakan untuk mengatasi keterbatasan ruang. Bagian kode Pascal 100KiB hanya dapat dikompilasi menjadi 5KiB; dengan menautkan banyak file yang dikompilasi, seseorang dapat membangun aplikasi besar tanpa memiliki akses ke drive format besar (mengingat bahwa 10MiB luar biasa besar, dan membeli mobil baru yang mahal).

Namun, semakin banyak bahasa, semakin banyak kode yang dimasukkan ke dalam potongan disk dan ram, dan dengan demikian mengkompilasi potongan yang lebih besar sekaligus. Perlu diingat: "minicomputer" pada awal 1970-an mungkin hanya memiliki 64KiB ram (Honeywell 800 memiliki instalasi dasar 4 bank masing-masing 2048 kata masing-masing 8B). APL dan bahasa simbolik serupa mendekati 1B per instruksi ditambah operandnya, dibandingkan 3B-10B jauh lebih besar per instruksi plus operan. (Itu adalah mimpi buruk untuk mengetikkan kartu punch, terutama karena simbol pada dasarnya adalah font pada tipe-bola, dan banyak cardpunches tidak memiliki simbol pada tombol ...)

Juga, perlu diingat bahwa kartu tidak dapat dihapus ... dan banyak program dimasukkan pada kartu. Meskipun tidak mahal secara individual, kode Anda yang lebih terkompresi dapat berada di kartu, semakin sedikit yang Anda butuhkan, dan semakin besar programnya, atau semakin murah. Ini adalah bagian dari alasan BASIC memiliki rangkaian beberapa instruksi per baris dalam berbagai rasa - ini diperkenalkan untuk menghemat kartu punch. (Atau begitulah kata teks pemrograman Vax Basic saya.) Walaupun saya belum memprogram untuk pembaca kartu, saya sudah melakukan kartu meninju untuk Honeywell 800 dalam FORTRAN, BASIC, APL, dan beberapa bahasa simbolis lainnya.

Seperti halnya banyak hal, jawabannya tergantung pada definisi konkret dari "verbosity". Jika definisinya sedemikian rupa sehingga verbositas menyiratkan redundansi maka saya berpendapat itu selalu buruk. Perhatikan bahwa dengan definisi seperti itu, program Java hello world yang sering dikutip tidak akan memenuhi syarat sebagai "verbose", karena tidak ada di dalamnya yang berlebihan.

Programmer cenderung menyukai bahasa dengan kekuatan ekspresif karena memungkinkan mereka untuk membuat kode hal-hal sederhana, yang sering harus sering dilakukan, dalam potongan kode kecil. Bahasa lisan cenderung berarti bahwa banyak, banyak baris kode harus digunakan untuk melakukan hal yang sama berulang kali. Namun, mungkin ada sesuatu yang harus dibayar dengan bahasa ekspresif karena mereka mungkin tidak secepat mengeksekusi sebagai bahasa tingkat tinggi yang lebih sederhana. Jika saya bisa memberikan contoh dalam kontras antara C dan C ++. C ++ memberikan kekuatan yang lebih ekspresif kepada penulis kode - mereka dapat merangkum gagasan objek dunia nyata di kelas. Pemrogram C dapat mencapai hal yang sama tetapi mereka memang memiliki kekuatan ekspresif dari konstruk kelas untuk membantu mereka - sehingga seringkali mereka harus menulis kode yang lebih panjang, lebih rumit (untuk memahami). Tetapi kode itu mungkin berjalan lebih cepat (meskipun ini sangat tergantung pada kualitas kompiler dan sebagainya) karena tidak menggunakan "keterlambatan mengikat" C ++ (yaitu run time refactoring) untuk mengeksekusi kode. C hanya mengeksekusi kode yang dikompilasi dan ditautkan, C ++ harus membuat keputusan (dalam keadaan tertentu) pada saat run time tentang potongan kode mana yang akan dieksekusi.

Saya percaya bahwa ada jawaban untuk pertanyaan yang berakar pada masalah yang lebih mendasar dan teoritis daripada readibility dan jawaban ini terkait dengan teori informasi algoritmik yang didirikan oleh Gregory Chaitin: http://en.wikipedia.org/wiki/Algorithmic_information_theory . Dinyatakan dalam beberapa kata, "isi informasi dari suatu string setara dengan panjang dari representasi string itu sendiri yang terpendek dan terpendek", Ini menyiratkan bahwa program terpendek (yaitu dalam hal panjang leksikografinya) menyelesaikan masalah yang diberikan dengan cermat cocok dengan kompleksitas intrinsik dari masalah yang memberikan solusi dan, oleh karena itu, lebih tergantung pada sifat masalah dan lebih sedikit pada representasi masalah.