เหตุใดการใช้คำฟุ่มเฟือยจึงไม่ดีสำหรับภาษาการเขียนโปรแกรม [ปิด]

ฉันเคยเห็นคนจำนวนมากบ่นเกี่ยวกับการใช้คำฟุ่มเฟื่อยในภาษาโปรแกรม ฉันพบว่าภายในขอบเขตบางอย่างยิ่งภาษาการเขียนโปรแกรม verbose ยิ่งดีกว่าก็คือการเข้าใจ ฉันคิดว่าการใช้คำฟุ่มเฟื่อยยังตอกย้ำการเขียนที่ชัดเจนAPIสำหรับภาษานั้น

ข้อเสียเดียวที่ฉันคิดได้ก็คือมันทำให้คุณพิมพ์ได้มากขึ้น แต่ฉันหมายความว่าคนส่วนใหญ่ใช้ IDE ที่ทำงานทุกอย่างให้คุณ

ดังนั้นข้อเสียที่เป็นไปได้ของภาษาการเขียนโปรแกรม verbose คืออะไร?

เป้าหมายคือความเข้าใจที่รวดเร็ว

"Verbose" หมายถึง "ใช้คำมากเกินไป" คำถามคือ "มากเกินไป" คืออะไร

รหัสที่ดีควรเข้าใจได้ง่าย วิธีนี้จะง่ายกว่าหากตัวละครส่วนใหญ่ให้บริการตามวัตถุประสงค์ของรหัสโดยตรง

สัญญาณเสียงรบกวน

หากภาษานั้นละเอียดยิ่งรหัสของคุณก็จะดังขึ้น เปรียบเทียบ"Hello World" ของ Java :

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

... กับทับทิม:

print "Hello World!"

เสียงดังทำให้เปลืองพลังงานจิต

Cryptic vs Clear

ในทางตรงกันข้ามภาษาที่ใช้พลังงานมากเกินไปก็จะมีความตึงเครียดที่รุนแรงเช่นกัน เปรียบเทียบสองตัวอย่างนี้จากCommon LISP :

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

มันมีผลต่อจำนวนโค้ดที่คุณสามารถดูและวิเคราะห์ได้ในพริบตาเพียงครั้งเดียว

x++ ค่อนข้างมากกว่า set(x,Integeradd(get(x),1))

PS มันไม่ใช่แค่เรื่องของการอ่านโค้ด ในวันที่มีหน้าจอขนาด 40x25 หน้าจอจากนั้นภาษาประเภท APL หรือ Perl มีประโยชน์มากกว่า Cobol หรือ Fortran สำหรับจำนวนรหัสที่คุณสามารถอ่าน / หน้าได้ แต่ตอนนี้มันเป็นเรื่องเกี่ยวกับแคชภายในของคุณเอง - ถ้าคำสั่งมีโอเปอเรเตอร์เดียวมันง่ายกว่าสำหรับสมองผู้สูงอายุของฉันที่จะแยกวิเคราะห์มากกว่าหนึ่งด้วยสัญลักษณ์ 3 ตัวและการเรียกใช้ฟังก์ชัน 4 อย่าง

หากการใช้คำฟุ่มเฟื่อยภาษาเบี่ยงเบนจากความสามารถในการอ่านรหัสแสดงว่ามันไม่ดี

บางภาษามีไวยากรณ์ verbose ที่เข้าใจความหมายของรหัสใช้เวลานานขึ้น (ฉันกำลังคิดเกี่ยวกับ VB.NET กับ C #):

If something Then
End If

if(something)
{}

จริง ๆ แล้วมันลงไปถึงสิ่งที่ coder คุ้นเคยและคุ้นเคย

ลองดูที่AppleScriptหนึ่งในภาษา verbose ที่สุดที่ฉันสามารถนึกได้ว่าอาจถือได้ว่าเป็นปัจจุบันลองเขียนสิ่งที่เป็นไตรลักษณ์กลับมาแล้วลองกลับมาลองเถียงว่าการใช้คำฟุ่มเฟือยนั้นเป็นภาษาที่ดี

พยายามจำความหมายทั้งหมดของคำหลักที่ไปและสิ่งที่พวกเขาจะไม่สำคัญถ้าคุณไม่ทำมันทุกวัน

เพียงดูเสียงคำหลักทั้งหมดในตัวอย่างที่ไม่สำคัญนี้:

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

การได้รับสิ่งเดียวกันbashกับเครื่องมือ Unix แบบดั้งเดิมจะทำให้ผู้ใช้ OSX ส่วนใหญ่สับสน แต่ไม่มีความลับดังนั้นจึงมีความสมดุลที่ต้องเกิดขึ้น

ฉันคิดว่าคุณต้องหันคำถามไปที่หัวแล้วถามว่า: ทำไมบางคนถึงคิดว่ารหัสสั้น ๆ นั้นดี?

คำตอบของฉันคือเหตุผลพื้นฐานสองประการ:

เหตุผลที่ Terse นั้นดีกว่า

สิ่งเหล่านี้รวมถึงการอ่านได้ง่ายขึ้นในลักษณะเดียวกับที่ประโยคสั้น ๆ สามารถเข้าใจได้ง่ายกว่าประโยคที่มีลักษณะเป็นดอกไม้ บ่อยครั้งที่ภาษาการเขียนโปรแกรมที่พยายามเลียนแบบไวยากรณ์ของภาษาอังกฤษจบลงด้วยการยืดยาวอย่างน่ากลัวทำให้ต้องใช้รหัสขนาดใหญ่เพื่อทำการกระทำที่ง่ายที่สุด บ่อยครั้งที่คุณจะพบว่ายิ่งภาษามีการเลียนแบบภาษาเขียนมากเท่าไหร่ก็ยิ่งยากที่จะเกลี้ยกล่อมให้เข้าสู่การทำงานที่ซับซ้อนทางตรรกะ

เหตุผลที่ Terse สามารถแย่ได้

บางภาษา (และฉันคิดว่า Perl) ใช้สัญลักษณ์แปลก ๆ หลายอย่างซึ่งดูเหมือนว่าจะถูกเลือกโดยพลการเกือบเป็นส่วนหนึ่งของไวยากรณ์ สำหรับทุกคนที่ไม่คุ้นเคยกับอักษรอียิปต์โบราณเหล่านี้จากนั้นภาษาจะกลายเป็นไม่ยอมรับ นอกจากนี้ยังกลายเป็นเรื่องง่ายที่จะทำผิดพลาดที่พิมพ์ผิดที่ไม่สามารถมองเห็นได้ง่าย การแสดงออกปกติอาจเป็นตัวอย่างที่ชัดเจนของความอดทนนี้

นอกจากนี้บางคนชอบที่จะแสดงออกโดยการเขียนรหัสสั้น ๆ เพราะพวกเขาคิดว่ามันดูฉลาด คุณเห็นสิ่งนี้เป็นครั้งคราวใน StackOverflow ซึ่งผู้คนมักจะส่งคำตอบที่มีขนาดกะทัดรัดเป็นพิเศษ นี่คือ "สร้างความประทับใจให้กับเพื่อนร่วมงาน" ของคุณด้วยปรัชญาที่คุณรู้ แต่นักเขียนโปรแกรมที่ดีรู้ว่า " code golf " ไม่ใช่วิธีสร้างซอฟต์แวร์ที่สามารถบำรุงรักษาได้

@ การค้นพบฉันขอแนะนำว่าวิธีหนึ่งในการดูปัญหาการใช้คำฟุ่มเฟือยคือการตระหนักว่าการเขียนโปรแกรมนั้นเป็นการผสมผสานระหว่างสองลักษณะที่แตกต่างกันของการค้นหาและการแสดงวิธีแก้ปัญหาเสมอ

รูปแบบ verbose แรกและอื่น ๆ คือการเขียนโปรแกรมเชิงภาษา (ภาษาศาสตร์) สไตล์นี้รวมคำที่เป็นคำนามและคำกริยาเหมือนในโครงสร้างที่คล้ายประโยคและมีวัตถุประสงค์เพื่อให้สามารถอ่านและเข้าใจในแบบเดียวกับย่อหน้าที่เขียนได้ดี การเขียนโปรแกรมทางภาษาเป็นรูปแบบที่เป็นสากลที่สุดของการเขียนโปรแกรมเนื่องจากภาษานั้นเป็นสากล ด้วยเหตุผลเดียวกันนั้นการสนับสนุนโปรแกรมระยะยาวมักต้องการส่วนประกอบทางภาษาที่ทรงพลังเสมอเนื่องจากสิ่งแรกที่โปรแกรมเมอร์ใหม่จะมองหาคือความเข้าใจในแนวคิดของสิ่งที่กำลังทำอยู่ โดยทั่วไปแล้วยิ่งคุณย้ายออกจากบริบทที่คุณสร้างโปรแกรมมากเท่าไหร่ยิ่งรูปแบบการเขียนโปรแกรมทางภาษาที่สำคัญยิ่งขึ้นจะช่วยให้มั่นใจว่าสมมติฐานและแนวคิดของคุณจะไม่ถูกเข้าใจผิดโดยบุคคลถัดไปที่พยายามเข้าใจโค้ดของคุณ .

รูปแบบที่สองและสั้นกว่านั้นคือการเขียนโปรแกรมเชิงคณิตศาสตร์ รูปแบบของการใช้เหตุผลนี้ยังขึ้นอยู่กับภาษาเนื่องจากตัวแปรตัวอย่างมีความคล้ายคลึงกับคำนามและตัวดำเนินการกับคำกริยา อย่างไรก็ตามการใช้เหตุผลทางคณิตศาสตร์ยกระดับความสามารถที่น่าทึ่งและขนานอย่างมากของสมองของเราในการทำการเปลี่ยนแปลงเชิงพื้นที่ที่ซับซ้อนบนวัตถุที่อยู่ในวิสัยทัศน์ของเรา โดยการแสดงคำนามและคำกริยาเป็นสัญลักษณ์ที่กะทัดรัดและโดดเด่นซึ่งสามารถจัดเรียงไว้ในวัตถุจินตภาพที่มีโครงสร้าง - สมการ - จากนั้นเราสามารถใช้ความสามารถในการมองเห็นที่ขนานกันอย่างสูงของเราในการหมุนการเปลี่ยนการเคลื่อนไหว วัตถุ ผลที่ได้คือการขยายจำนวนมหาศาลของจำนวนกรณีที่เราสามารถจัดการได้ในครั้งเดียวเนื่องจากแต่ละสัญลักษณ์สามารถเป็นตัวแทนของชั้นเรียนทั้งหมดของวัตถุที่เกี่ยวข้องอย่างใกล้ชิด

โปรดสังเกตว่าในการใช้การประมวลผลภาพอย่างมีประสิทธิภาพคุณต้องทำให้วัตถุจินตนาการของคุณใกล้เคียงกับขนาดและฟีเจอร์ของวัตถุจริง หากสาขาที่ต้องการการมองเห็นกว้างเกินไปหรือไม่สามารถใช้สัญลักษณ์เช่นเครื่องหมายที่เคลื่อนย้ายได้บนวัตถุหรือหากคุณต้อง "อ่านตัวอักษร" และแปลงเป็นคำความสามารถในการทำการแปลงที่ซับซ้อนจะลดลงอย่างน่าเชื่อถือ อย่างรวดเร็วแม้สำหรับนักคณิตศาสตร์ที่ดีมาก

นั่นคือเหตุผลที่ผู้คนที่หมกมุ่นอยู่กับรูปแบบทางคณิตศาสตร์ของการเขียนโปรแกรมสามารถรู้สึกไม่สบายใจอย่างจริงจังหากสมการกระจายออกไปและแสดงออกในสิ่งที่พวกเขาเรียกว่ารูปแบบทางภาษา ไม่ใช่เพราะสมการมีการเปลี่ยนแปลงอย่างมีนัยสำคัญเพราะการแพร่กระจายออกไปเช่นนั้นทำให้แทบจะเป็นไปไม่ได้ที่จะใช้สไตล์การมองเห็นที่เข้าใจได้ ในขณะเดียวกันโปรแกรมเมอร์ใหม่ที่ไม่คุ้นเคยกับสัญลักษณ์สั้น ๆ น่าจะชอบเวอร์ชั่น verbose มากกว่าที่ให้ข้อมูลทางภาษามากขึ้นเพื่อทำความเข้าใจกับโค้ดในตอนแรก

ดังนั้นฉันจะแนะนำอะไร

ใช้ทั้งสองสไตล์ แต่ให้ความสนใจอย่างรอบคอบว่าทำไมคุณถึงใช้สไตล์แต่ละแบบ

ตัวอย่างเช่นสิ่งใดก็ตามที่มีโอกาสในการเชื่อมต่อกับโลกภายนอกควรได้รับการกล่าวอย่างละเอียดในบางระดับแม้ว่าจะอยู่ในรูปแบบของความคิดเห็นแบบอินไลน์ผสมกับรหัสและควรรวมการตรวจสอบอัตโนมัติเพื่อการใช้งานที่ถูกต้อง สัญลักษณ์ที่เป็นความลับและที่กำหนดอย่างไม่สมบูรณ์นั้นไม่มีธุรกิจใดในอินเตอร์เฟสดังกล่าวเนื่องจากเกือบจะรับประกันว่าจะเข้าใจผิดในบางจุด การสูญเสียปี 1999 ดาวอังคารสภาพภูมิอากาศ Obiterเนื่องจากความล้มเหลวในการรับรู้ไม่ว่าจะเป็นหน่วยซอฟต์แวร์อินเตอร์เฟซได้รับการแสดงในปอนด์หรือนิวตันเป็นตัวอย่างที่ชี้เฉพาะอย่างยิ่งจากอันตรายของการอาศัยลวกเกินไปในตัวเลขดิบที่อินเตอร์เฟซซอฟต์แวร์หรือฮาร์ดแวร์

ในทางกลับกันรูปแบบการเขียนโปรแกรมใด ๆ ที่เป็นอัลกอริธึมเชิงลึกและเชิงคณิตศาสตร์ในธรรมชาติคือการเขียนโปรแกรมรวบรัดที่ดีที่สนับสนุนรูปแบบการคิดเชิงคณิตศาสตร์ หากมีคนใหม่ต้องรักษารหัสดังกล่าวโดยปกติแล้วจะเป็นการดีกว่าสำหรับพวกเขาที่จะเรียนรู้สัญลักษณ์ทางคณิตศาสตร์แทนที่จะพยายามแปลงรหัสให้เป็นรูปแบบ verbose มากขึ้น แน่นอนควรมีเอกสารตลอดเวลาเพื่ออธิบายส่วนทางคณิตศาสตร์ของรหัสที่นักพัฒนาเช่นนั้นสามารถใช้ได้ แต่เป็นปัญหาแยกต่างหาก

ในระหว่างสุดขั้วเหล่านี้มีหลายกรณีที่โปรแกรมเมอร์มีดุลยพินิจอย่างมาก ฉันขอแนะนำให้ดูว่ารหัสจะถูกเก็บรักษาไว้ในระยะยาวอย่างไรและพยายามตอบสนองความต้องการของผู้คนที่มีแนวโน้มมากที่สุดที่จะรักษารหัสไว้ในระยะยาว

ผู้คนจำนวนมากได้บอกใบ้ถึงสิ่งที่ฉันคิดว่าน่าจะมีการระบุไว้อย่างชัดเจน

การใช้คำฟุ่มเฟื่อยมีแนวโน้มที่จะสนับสนุนความเข้าใจในระดับจุลภาค - โดยทั่วไปจะนำไปสู่คำสั่งของแต่ละบุคคลเป็นเรื่องง่ายที่จะอ่านและเข้าใจ การใช้คำฟุ่มเฟื่อยมีแนวโน้มที่จะลดระดับของความคุ้นเคยกับภาษาที่จำเป็นในการเข้าใจมัน (อย่างน้อยบางระดับ) ภาษา verbose มากที่สุด (เช่น COBOL) สามารถอ่านได้อย่างน้อยแม้โดยผู้ที่ไม่ได้เป็นโปรแกรมเมอร์ที่สมบูรณ์ก็ตาม

ความเข้าใจมักจะตรงข้าม: ช่วยให้เข้าใจในระดับมหภาคโดยเฉพาะอย่างยิ่งโดยโปรแกรมเมอร์ที่มีความคุ้นเคยมากที่สุดกับภาษานั้น ๆ ในเวลาเดียวกันการขาดความคุ้นเคยกับภาษานั้นสามารถป้องกันความเข้าใจพื้นฐานแม้กระทั่งจากโปรแกรมเมอร์ที่มีประสบการณ์ค่อนข้างมาก

ดังนั้นความสามารถในการอ่านจึงแตกต่างกันอย่างมากขึ้นอยู่กับกลุ่มเป้าหมาย ในอีกด้านหนึ่งให้พิจารณาโครงการขนาดใหญ่ที่ซับซ้อนซึ่งถูกเขียนและดูแลโดยผู้ที่ทำงานในโครงการนั้นเกือบทั้งหมดโดยส่วนใหญ่มีพื้นหลังการเขียนโปรแกรมและการศึกษามากมาย (เช่นปริญญาเอกจำนวนมาก) สิ่งนี้มีแนวโน้มที่จะสนับสนุนภาษาที่กระชับยิ่งขึ้น

ในกรณีตรงกันข้ามมากหรือน้อยพิจารณาโครงการที่ง่ายกว่ามาก (แม้ว่าอาจจะค่อนข้างใหญ่) ซึ่งดูแลโดยผู้ที่เชี่ยวชาญในธุรกิจที่เกี่ยวข้องกับซอฟต์แวร์เป็นหลักมากกว่าในซอฟต์แวร์เอง นี่จะช่วยให้ภาษา verbose มีความชัดเจนยิ่งขึ้น

แทนที่จะไปที่หนังสือทางเทคนิคฉันกลับไปใช้Elements of Style * โดย Strunk and White แนวคิดพื้นฐานคือ "แม่นยำ" และ "อย่าพูดเกินความจำเป็น" ทุกอย่างอื่นเป็นความเห็น

นำไปใช้กับการเขียนโปรแกรมมันเกี่ยวกับความแม่นยำมาก แต่ไม่มีความผิดปกติที่ไม่จำเป็น ปุยเสริมสามารถเป็นไวยากรณ์ แต่มันอาจเป็นคำมากกว่าที่จำเป็นในการถ่ายทอดความหมาย (แน่นอนไม่น้อยเกินไปที่จะให้ความกำกวมเช่นกัน)

• ฉันอ้างถึงฉบับดั้งเดิมเพราะมันกระชับที่สุด :-)

ในตอนท้ายของวันอะไรก็ตามที่ 'แตกต่าง' จะทำให้ผู้คนโหยหวน ฉันพอใจกับไวยากรณ์ของสไตล์ C และตกลงกับภาษาอื่นซึ่งใช้ไวยากรณ์ร่วมกัน (C ++, Java, C #) ดังนั้นฉันมักจะชอบสไตล์นี้โดยเฉพาะ

ภาษามีแนวโน้มที่จะพบความสมดุลระหว่างคำอธิบายที่เพียงพอและไม่ได้พูดอย่างละเอียด

Perl เป็นตัวอย่างของการที่คุณสามารถเขียนรหัสที่รัดกุมมาก สำหรับมือใหม่โค้ดที่เขียนโดย Perl นินจานั้นไม่มีอะไรจะขาดเวทมนต์

COBOL เป็นตัวอย่างของ verbose มากเกินไป

ฉันได้อ่านที่ไหนสักแห่งสักครั้งหนึ่งว่าการถกเถียงอย่างละเอียดนั้นมาจากโปรแกรมเมอร์คนใหม่และมือเก่า การเปรียบเทียบที่ใช้คือเมื่อเราเรียนรู้สิ่งใหม่เราบอกตัวเองว่า "เรื่องราว" ที่จะผ่านมันไป (คิดว่าเมื่อคุณเรียนรู้พีชคณิตใน HS) เมื่อเราได้รับประสบการณ์เราจะก้าวข้ามความต้องการเรื่องราวที่อธิบายถึงองค์ประกอบแต่ละอย่างและเราเข้าใจจำนวนที่มากขึ้น รหัสของเรามีความหนาแน่นและกระชับมากขึ้นพร้อมกับความคิดเห็นอธิบายเฉพาะรายการที่จำเป็นแทนการทบทวนสิ่งที่รหัสพูด

ฉันพบสิ่งนี้เป็นจริงระหว่างฉันและเพื่อนร่วมงาน เธอเขียนโค้ดที่มีความคิดเห็นจำนวนมากอธิบายว่าบรรทัดของโค้ดคืออะไรและมีพื้นที่ว่างจำนวนมาก ถ้าฉันอ่านมันฉันพบว่าฉันสามารถใส่โค้ดสองสามบรรทัดบนหน้าจอเดียวได้ด้วยเหตุนี้ นั่นทำให้การทำความเข้าใจแต่ละบรรทัดง่ายกว่ามาก แต่การทำหน้าที่ทั้งหมดให้ยากขึ้น

ฉันมักจะเขียนโค้ดโดยไม่มีช่องว่างหรือความคิดเห็นเพิ่มเติม สิ่งนี้ทำให้การมองเห็นง่ายขึ้นทั้งหมด แต่คุณต้องสามารถ "รับ" รหัสแต่ละคำ " หากคุณพยายามอ่านคำตอบนี้ด้วยคำแต่ละคำที่อยู่ในบรรทัดของตัวเองด้วยช่องว่าง / ความคิดเห็น / คำฟุ่มเฟือยมากมายมันจะง่ายกว่าที่จะเข้าใจคำศัพท์แต่ละคำ แต่ยากที่จะเข้าใจทั้งหมด

ไอน์สไตน์พูดถูก: "ทำสิ่งที่ง่ายที่สุด แต่ไม่ง่ายกว่านี้"

ใช้กับรหัสเช่นกัน หากคุณสามารถทำให้โค้ดง่ายขึ้นโดยการลบองค์ประกอบที่ซ้ำซ้อนและไม่ต้องใช้ความละเอียดนั่นเป็นสิ่งที่ดี

นอกจากนี้กรณีศึกษาบางกรณีชี้ให้เห็นว่าผลผลิตของโปรแกรมเมอร์ที่วัดในบรรทัดของโค้ดมีค่าคงที่มากหรือน้อย ดังนั้นจำนวนข้อผิดพลาดต่อ LOC ดังนั้นการเปลี่ยนไปใช้ภาษาที่ช่วยให้คุณทำมากขึ้นต่อบรรทัดของรหัสสามารถพิจารณาการปรับปรุงประสิทธิภาพการทำงานหากสิ่งอื่น ๆ อยู่เสมอ

ที่กล่าวว่ามีแนวโน้มในอุตสาหกรรมนี้มากกว่าวิศวกรและซับซ้อนสิ่งที่ควรเป็นสิ่งที่ง่าย สิ่งง่าย ๆ เช่นการบรรจุรายละเอียดการติดต่อในฐานข้อมูลเชิงสัมพันธ์ ฉันได้เห็นวิธีแก้ปัญหาที่ซับซ้อนและเข้าใจผิดบางอย่าง ( ไอ MDA) สำหรับปัญหานั้น ภาษาอย่าง Scala และ Ruby เป็นตัวอย่างที่ดีของเครื่องมืออันทรงพลังซึ่งอยู่ในมือของบุคคลบางคนส่งผลให้โค้ดที่ไม่สามารถเข้าใจได้ซับซ้อนเกินไปและไม่สามารถบำรุงรักษาได้ เพียงเพราะคุณสามารถใช้การเล็งได้หลายระดับด้วยการกดปุ่มเพียงไม่กี่ครั้งก็ไม่ได้หมายความว่าคุณจะต้องตอกตะปูทุกครั้งที่เห็นด้วยค้อนอันนั้น

เมื่อใช้อย่างถูกต้องคุณจะได้โค้ดที่ชัดเจนซึ่งทั้งสั้นและเข้าใจง่าย เมื่อใช้ไม่ดีคุณควร จำกัด บุคคลที่มีปัญหาในการใช้ Visual Basic หรือภาษาที่ จำกัด ในทำนองเดียวกันเพื่อป้องกันความเสียหายเพิ่มเติม

ทักษะที่แท้จริงอยู่ที่การสร้างสิ่งที่ซับซ้อนในวิธีที่ง่ายไม่ใช่การทำสิ่งที่ง่ายในวิธีที่ซับซ้อน

สิ่งที่ไม่มีใครตีได้คือจำนวนโค้ดที่คุณสามารถใส่ได้ในหน้าจอเดียว ช่วยด้วยเหตุผลหลายประการ:

• เลื่อนไปมาน้อยลงเมื่อคุณทำงาน (หรืออ่าน) ฟังก์ชั่นหลาย ๆ ไฟล์ในหนึ่งไฟล์
• การเลื่อนในแนวนอนน้อยลง (หยุดอ่านคลิกและลากแถบเลื่อนหยุดอ่านคลิกและลากแถบเลื่อน ... )
• การสแกนเร็วขึ้นเนื่องจากมีไวยากรณ์ที่ไร้ประโยชน์น้อยกว่าในการค้นหาสิ่งที่คุณต้องการ

เพราะรหัสเพิ่มเติมหมายถึงเวลาในการพัฒนามากขึ้นและข้อบกพร่องมาก

หากคุณเขียนรหัส 100 บรรทัดแทนที่จะเป็น 300 บรรทัด นั่นหมายถึงเวลาในการพัฒนาเกือบ 1/3 เท่าที่คุณต้องการและข้อบกพร่องที่อาจเกิดขึ้น 1/3

ในสถานการณ์ส่วนใหญ่คุณจำเป็นต้องรักษาความสมดุลของประสิทธิภาพและความรัดกุมเนื่องจากการเขียนโค้ดน้อยลงหมายถึงเครื่องจำเป็นต้องทำสิ่งต่าง ๆ มากขึ้นและจะลดประสิทธิภาพลง

โดยทั่วไปแล้วคนนิยมอ่านภาษา / verbose มากกว่าคนที่มีความลับ / สั้น อย่างไรก็ตามฉันคิดว่าคนส่วนใหญ่หลอมรวม "คำฟุ่มเฟื่อย" กับ "ความยุ่งเหยิง" ซึ่งไม่เหมือนกัน

ตัวอย่างเช่น while(<>){print if($.==2 || $& && !$x++); $.=0 if (/^--+$/)}

เป็นคำย่อที่สั้นมาก มันมีทุกสิ่งที่คุณอยากรู้ อย่างไรก็ตามเนื่องจากมันมีความกระชับจึงยากที่จะเข้าใจ ในทางตรงข้ามเวอร์ชันเดียวกันของ verbose มากกว่าของโปรแกรมเดียวกันจะค่อนข้างตรงไปตรงมาเพื่อทำความเข้าใจเพราะมันอ่านได้มากกว่า แน่นอนว่านี่ไม่ใช่คุณสมบัติของภาษาต่อ se แต่บางภาษามีแนวโน้มที่จะใช้คำฟุ่มเฟื่อยมากขึ้นในขณะที่คนอื่นมีแนวโน้มที่จะกระชับในการเขียนโปรแกรม

สำหรับสุดโต่งอื่น ๆ ของการใช้คำฟุ่มเฟือยคือhttp://en.wikipedia.org/wiki/Literate_programming ซึ่งฉันคิดว่าเป็นแนวคิดที่น่าสนใจ

อีกแง่มุมหนึ่งคือ "ความฟุ่มเฟื่อยที่ไม่พึงประสงค์" หรือที่เรียกว่า "ความยุ่งเหยิง" สิ่งที่คุณต้องเพิ่มด้วยเหตุผลทางเทคนิคการขาดน้ำตาล syntactic API bloated และอื่น ๆ

ฉันคิดว่าไวยากรณ์ที่ชัดเจนและใช้งานง่ายมีความสำคัญมาก นอกจากนี้ยังต้องละเอียดเพียงพอที่จะช่วยให้การอ่านง่ายขึ้น ข้อความสั้นเกินไปที่เต็มไปด้วยลอจิกมากเกินไปมักทำให้เวลาในการตัดสินใจมากกว่าคำสั่งที่ยาวกว่าเล็กน้อย ในทางกลับกันโค้ดป่องไร้ประโยชน์ที่เต็มไปด้วยเส้นสำเร็จรูปเพื่อทำบางสิ่งที่ง่ายที่สุดคือความรำคาญ

การใช้คำฟุ่มเฟื่อยเป็นแนวโน้มที่จะใช้ข้อความจำนวนมากและ Terseness การใช้ข้อความน้อยมาก ...

การใช้คำฟุ่มเฟื่อยไม่ดีเพราะ:

1. มันแนะนำโอกาสเพิ่มเติมสำหรับข้อผิดพลาดในการพิมพ์
2. มันทำให้การอ่านโค้ดบนหน้าจอหรือกระดาษทำได้ยากขึ้นและ / หรือป้อนบน punchcard
   1. นี่จะเป็นการเพิ่มเวลาดีบัก
   2. ทำให้เข้าใจโค้ดสำหรับการอัพเกรด / บำรุงรักษาได้ยากขึ้น
   3. ซึ่งอาจนำไปสู่การทำสำเนารหัสโดยไม่ตั้งใจ
3. มันเพิ่มโอกาสของข้อผิดพลาดทางไวยากรณ์บ้าง
4. มันลดความยืดหยุ่นในการเขียนโค้ดซึ่งในภาษา verbose ส่วนใหญ่มีโครงสร้างสูงและไม่มีวิธีการพูดที่เหมือนกันหลายวิธี
5. มันเพิ่มการเข้ารหัสและเวลาการรวบรวม
6. มันสามารถใช้พื้นที่เก็บข้อมูลเพิ่มเติม

การใช้คำฟุ่มเฟื่อยในระดับหนึ่งเป็นสิ่งจำเป็นสำหรับความชัดเจน ...

ระดับของ Verbosity ที่น้อยที่สุดนั้นดีเพราะ:

1. มันง่ายสำหรับมนุษย์ที่จะอ่านและแนบค่าความหมายกับรหัสสัญลักษณ์ล้วนๆ
2. ในการตั้งชื่อตัวแปรและฟังก์ชั่นทำให้ง่ายต่อการดีบักพอร์ตและบำรุงรักษาโค้ด
3. ในการดำเนินงานภาษาระดับพื้นฐานและคำหลักของภาษาที่ซับซ้อนจะนำไปสู่การมอบหมายการทำงาน / คำหลักที่ไม่ถูกต้องน้อยลง

ตัวอย่างที่ยอดเยี่ยมบางคำสั่งที่สั้นเกินไปสำหรับคนจำนวนมากรวมถึง standbys พื้นฐานของval(x$), str$(x)และchr$(x)... คืนค่าจำนวนจากการแทนค่าสตริง, ส่งคืนสตริงสำหรับตัวเลขและส่งคืนอักขระเดี่ยวที่มีค่า ascii x เป็นสตริง

หรือตัวชี้ C / C ++ และโดยผู้อ้างอิง&และ*เปรียบเทียบกับbyrefคำหลักพื้นฐาน ใน C / C ++ ฉันสามารถมีตัวแปร X และส่งต่อตัวชี้ไปยังตัวแปรนั้น แต่ฉันต้องจำว่าตัวชี้คืออะไรและตัวไหนคือ "ใช้ตัวชี้เป็นตัวแปรที่ชี้ไปที่"; โดยพื้นฐานแล้วฉันแค่ส่งการอ้างอิงด้วยคำสำคัญ byref ในการเรียกใช้ฟังก์ชันซึ่งชัดเจนมากขึ้น แต่ยืดหยุ่นน้อยกว่า:

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

ในรหัสนี้เนื้อหาของ x จะถูกปรับเปลี่ยนเนื่องจากแฟล็ก byref รสชาติบางอย่างอนุญาตให้มีการพูดคุยแบบไม่ผ่านสายขณะที่บางคนอาจให้คำจำกัดความ

คำฟุ่มเฟื่อยเป็นสิ่งสำคัญสำหรับโปรแกรมเมอร์ชั่วคราวเพื่อให้สามารถใช้สัญลักษณ์ได้ง่ายขึ้น; พื้นฐานหรือหลามเป็นมนุษย์อ่านได้มากขึ้นและ verbose มากกว่า C / C ++ และมีประโยชน์มากขึ้นสำหรับโปรแกรมเมอร์ทั่วไป; terseness ของ C / C ++ ทำให้ดีขึ้นมากสำหรับโปรแกรมเมอร์ที่มีประสบการณ์มากขึ้นซึ่งต้องการเห็นโค้ดเพิ่มเติมและโค้ดที่ซับซ้อนมากขึ้นในหน้าจอเดียว แต่ต้องเรียนรู้หลักการโครงสร้างสัญลักษณ์ต่างๆ ณ สิ้นสุดคือ APL ซึ่งเกือบจะเป็นมนุษย์ที่อ่านไม่ได้อย่างสมบูรณ์

ปัญหาที่เกี่ยวข้องอย่างใกล้ชิดคือความชัดเจน - รหัสสั้นมักจะไม่ชัดเจนและรหัส verbose มากเกินไป (เช่นใน AppleScript) อาจไม่ชัดเจนเท่ากัน ความคุ้นเคยกับภาษาที่กำหนดจะเพิ่มความชัดเจนของ terse code ในภาษานั้น - ผู้เริ่มต้นแบบดิบการเผชิญหน้ากับรหัส C ++ นั้นมีแนวโน้มที่จะสามารถแยกวิเคราะห์เฉพาะสูตรและแม้แต่รหัส BASIC หรือ Python ที่ใช้งานได้มากเกินไป งงงวยโดยทั่วไปโดยไม่ต้องขอความช่วยเหลือจากพจนานุกรมภาษา สิ่งที่ฉันพบน้อยที่สุดโดยไม่ทำให้งงโดยเจตนาคือแจ้ง 7 ...

ในสมัยก่อน

การพิจารณาที่สำคัญอีกอย่างหนึ่งในอดีต แต่สิ่งที่ไม่สำคัญสำหรับ coder งานอดิเรกอีกต่อไปคือการใช้งานและพื้นที่เก็บข้อมูล (มันยังคงมีความสำคัญในระดับสูง) โปรดทราบว่าหลาย ๆ ภาษาถูกตีความโดยเฉพาะอย่างยิ่งรสชาติพื้นฐานและอีกหลายภาษาได้รวบรวมเวลาใช้งานรหัสพื้นที่มีความสำคัญโดยเฉพาะอย่างยิ่งเมื่อดิสก์มีขนาด 128KiB เท่านั้น

มีหลายวิธีแก้ปัญหา - โทเค็นไลเซชันเป็นเรื่องธรรมดามากในเบสิก คำหลักแต่ละภาษาถูกลดขนาดเป็น 1 หรือ 2 ไบต์ใน 128 ตัวบนหรือพื้นที่อักขระควบคุม โทเค็นไลเซชั่นนำไปสู่การรวบรวม bytecode (ตามที่แจ้งและ Z-Machine)

การรวบรวมและการลิงก์ไฟล์อ็อบเจ็กต์หลายรายการยังใช้เพื่อ จำกัด พื้นที่ ส่วนรหัสปาสคาล 100KiB อาจรวบรวมเพียง 5KiB; ด้วยการเชื่อมโยงไฟล์ที่คอมไพล์หลายไฟล์เราสามารถสร้างแอปพลิเคชั่นขนาดใหญ่ได้โดยไม่ต้องเข้าถึงไดรฟ์รูปแบบขนาดใหญ่ (จำได้ว่า 10MiB มีขนาดใหญ่อย่างน่าประหลาดใจ

ภาษาที่สั้นกว่านี้มีโค้ดมากกว่าหนึ่งอันในทั้งดิสก์และหน่วยความจำและทำให้คอมไพล์ชิ้นใหญ่ขึ้นในแต่ละครั้ง โปรดทราบ: "minicomputers" ของต้นปี 1970 อาจมี ram 64KiB เท่านั้น (Honeywell 800 มีการติดตั้งพื้นฐานของธนาคาร 4 แห่งแต่ละแห่งมี 208 คำจาก 8B แต่ละแห่ง) APL และภาษาสัญลักษณ์ที่คล้ายคลึงกันเข้าหา 1B ต่อการเรียนการสอนบวกตัวถูกดำเนินการเมื่อเทียบกับ 3B-10B ที่มีขนาดใหญ่กว่าต่อคำสั่งรวมทั้งตัวถูกดำเนินการ (มันเป็นฝันร้ายที่ต้องพิมพ์ลงบน punchcards โดยเฉพาะอย่างยิ่งเมื่อสัญลักษณ์เป็นตัวอักษรบนตัวพิมพ์บอลและ cardpunch จำนวนมากไม่มีสัญลักษณ์บนแป้น ... )

นอกจากนี้โปรดทราบว่าการ์ดไม่สามารถลบได้ ... และมีการป้อนโปรแกรมจำนวนมากบนการ์ด ในขณะที่ไม่ได้มีราคาแพงทีละตัว แต่ยิ่งรหัสของคุณบีบอัดอยู่บนการ์ดมากเท่าไหร่คุณก็ยิ่งต้องการน้อยลงเท่านั้นและยิ่งโปรแกรมมีขนาดใหญ่ขึ้น นี่เป็นส่วนหนึ่งของเหตุผลที่ BASIC มีการเชื่อมคำสั่งหลายคำสั่งต่อบรรทัดในรสชาติส่วนใหญ่ - ได้รับการแนะนำให้รู้จักกับการบันทึกบนการ์ดเจาะ (หรือว่าข้อความการเขียนโปรแกรม Vax Basic ของฉัน) ในขณะที่ฉันไม่ได้ตั้งโปรแกรมสำหรับเครื่องอ่านบัตรฉันได้ทำการเจาะการ์ดสำหรับ Honeywell 800 ในภาษา FORTRAN, BASIC, APL และภาษาสัญลักษณ์อื่น ๆ อีกสองสามภาษา

เช่นเดียวกับหลายสิ่งหลายอย่างคำตอบขึ้นอยู่กับคำจำกัดความที่เป็นรูปธรรมของ "การใช้คำฟุ่มเฟื่อย" หากคำจำกัดความดังกล่าวว่าการใช้คำฟุ่มเฟือยหมายถึงความซ้ำซ้อนแล้วฉันจะเถียงว่ามันไม่ดีเสมอ โปรดทราบว่าด้วยคำจำกัดความดังกล่าวโปรแกรม Java hello world ที่อ้างถึงบ่อยครั้งจะไม่ถือว่าเป็น "verbose" เนื่องจากไม่มีสิ่งใดในนั้นที่ซ้ำซ้อน

โปรแกรมเมอร์มีแนวโน้มที่จะชอบภาษาที่มีพลังในการแสดงออกเพราะมันช่วยให้พวกเขาเขียนโค้ดสิ่งต่าง ๆ ที่เรียบง่ายซึ่งมักจะต้องทำบ่อย ๆ ในโค้ดขนาดเล็ก ภาษา verbose มักจะหมายถึงว่าต้องใช้รหัสจำนวนมากในการทำสิ่งเดียวกันซ้ำแล้วซ้ำอีก อย่างไรก็ตามอาจมีบางสิ่งในราคาที่ต้องจ่ายด้วยภาษาที่แสดงออกเนื่องจากพวกเขาอาจไม่รวดเร็วในการดำเนินการเหมือนภาษาระดับสูงที่ง่ายกว่า ถ้าฉันสามารถยกตัวอย่างในทางตรงกันข้ามระหว่าง C และ C ++ C ++ ให้พลังในการเขียนที่ชัดเจนยิ่งขึ้น - พวกเขาสามารถสรุปแนวคิดของวัตถุในโลกแห่งความเป็นจริงได้ โปรแกรมเมอร์ C สามารถทำสิ่งเดียวกันได้ แต่มีพลังในการสร้างคลาสเพื่อช่วยพวกเขา - บ่อยครั้งที่พวกเขาต้องเขียนโค้ดที่ยาวและซับซ้อนมากขึ้น (เพื่อให้เข้าใจ) แต่รหัสนั้นอาจทำงานได้เร็วขึ้น (แม้ว่าจะขึ้นอยู่กับคุณภาพของคอมไพเลอร์และอื่น ๆ ) เพราะมันไม่ได้ใช้ "การผูกปลาย" ของ C ++ (เช่นการปรับเวลารันไทม์) เพื่อรันโค้ด C เพียงแค่เรียกใช้โค้ดที่คอมไพล์และเชื่อมโยง C ++ จะต้องทำการตัดสินใจ (ในบางสถานการณ์) ณ เวลารันไทม์เกี่ยวกับโค้ดส่วนใดที่จะเรียกใช้งาน

ผมเชื่อว่ามีคำตอบสำหรับคำถามที่หยั่งรากลึกในปัญหาพื้นฐานและทฤษฎีกว่า readibility และคำตอบนี้จะเกี่ยวข้องกับทฤษฎีข้อมูลอัลกอริทึมที่ก่อตั้งโดยเกรกอรี่ Chaitin: http://en.wikipedia.org/wiki/Algorithmic_information_theory ระบุไว้ในคำไม่กี่คำ "เนื้อหาข้อมูลของสตริงเทียบเท่ากับความยาวของการเป็นตัวแทนที่สั้นที่สุดที่เป็นไปได้ของสตริงนั้น", ซึ่งหมายความว่าโปรแกรมที่สั้นที่สุด (กล่าวคือในแง่ของความยาวพจนานุกรม) แก้ปัญหาอย่างใกล้ชิด จับคู่ความซับซ้อนที่แท้จริงของปัญหาที่จะให้วิธีการแก้ปัญหาและดังนั้นจึงขึ้นอยู่กับลักษณะของปัญหาและน้อยกว่าในการเป็นตัวแทนของปัญหา