สิ่งใดที่คุณต้องการให้นักออกแบบภาษาให้ความสนใจ? [ปิด]


38

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

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

กรุณาอย่าโพสต์:

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

โปรดทำโพสต์:

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

ฉันหวังว่ามันจะเป็นหัวข้อที่สนุกและน่าตื่นเต้น

แก้ไข: อธิบายสิ่งที่ฉันหมายถึงโดย Syntax Flame Wars ฉันไม่ได้พยายามหลีกเลี่ยงการอภิปรายทั้งหมดของไวยากรณ์โดยเฉพาะอย่างยิ่งเพราะไวยากรณ์เป็นส่วนพื้นฐานของการออกแบบภาษาโปรแกรม


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

สิ่งที่ฉันต้องการหลีกเลี่ยงคือสงครามเปลวไฟ หากคุณสามารถพูดคุยเกี่ยวกับไวยากรณ์โดยไม่ต้องเริ่มสงครามไฟให้ไปหามัน
Berin Loritsch

คำตอบ:


49

การสนับสนุน Unicode เป็นค่าเริ่มต้น

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


2
+1 อันที่จริงภาษาควรอนุญาตให้คุณใช้อักขระใด ๆ สำหรับตัวระบุของคุณ พวกเราไม่ใช่คนอังกฤษ
Berin Loritsch

13
@Berin: จริง ๆ แล้วถึงฉันเป็นคนฝรั่งเศส แต่ฉันชอบโปรแกรมภาษาอังกฤษมากกว่ามาก ปัญหาคือการสื่อสารหากคุณเขียนโปรแกรมด้วยตัวระบุภาษาฮังการีสเปนหรือโปรตุเกสอย่าคาดหวังว่าฉันจะสามารถก้าวเข้ามา ... ในบริบทของความเป็นสากลเป็นสิ่งสำคัญอย่างยิ่งที่นักพัฒนาสามารถสื่อสารระหว่างกันได้ และนั่นหมายถึงการใช้ภาษากลางสำหรับตัวระบุความคิดเห็นและเอกสาร ภาษาอังกฤษเป็นภาษากลางของผู้พัฒนา
Matthieu M.

11
ฉันต้องการเพิ่มการสนับสนุน Unicode ควรเป็นธรรมชาติเมื่อใช้ภาษา หากเป็นไปได้ไม่ควรใช้ความพยายามเป็นพิเศษในการ "เพิ่มเข้าไปใน" ควร "แค่ทำงาน" (ในกรณีที่เหมาะสม)
RHSeeger

4
ที่เกี่ยวข้องภาษาควรสร้างความแตกต่างพื้นฐานระหว่างข้อความ (ลำดับของตัวอักษร) และข้อมูลไบนารี (ลำดับของไบต์) C # ได้รับสิทธินี้กับและstring byte[]เช่นเดียวกับงูหลาม 3.x ด้วยและstr bytesC (++) charผิดพลาดไปอย่างมาก
dan04

1
@RHSeeger - แน่นอน !!! u'My Unicode Štring'แม้จะอยู่ในหลามคุณต้องพิมพ์ ฉันหวังว่าคุณจะลืมสายอักขระที่คุณกำลังติดต่อด้วยและเขียนโค้ด friggin
orokusaki

25

ฉันมีคู่:

  • Generics / แม่แบบ ตัวอย่างเช่น Java generics นั้นทรงพลัง แต่ไม่จำเป็นต้องยืดหยุ่น นอกจากนี้เนื่องจากพวกเขาใช้การลบประเภทฉันได้เห็นปัญหาในการใช้พวกเขาอย่างเป็นนามธรรมโดยเฉพาะอย่างยิ่งในส่วนต่อประสาน และคอมไพเลอร์ไม่ควรเตือนเมื่อมีการใช้งานทั่วไปที่ไม่เฉพาะเจาะจง (เหมือนHashmapแทนHashmap<String, int>) ฉันคิดว่าพวกเขาสามารถปรับปรุงได้อย่างมีนัยสำคัญ การสร้างเทมเพลตที่ดีนั้นมีประโยชน์มาก แต่มักถูกทอดทิ้ง

  • สนับสนุน Good Date ในไลบรารีมาตรฐาน ฉันหมายถึงความสามารถในการเพิ่มและลบวันที่เวลาและนาทีและไม่ต้องจัดการกับจำนวนมิลลิวินาทีตั้งแต่วันที่ 1 มกราคม 1970


2
"การสนับสนุนที่ดี" เป็นความต้องการที่สูงชัน มันหมายความว่ายังไง? ฉันคิดว่าวันที่และเวลาเป็นหนึ่งในสิ่งที่คุณไม่สามารถทำให้ดีได้ ไม่ว่าคุณจะทำให้มันง่ายและผิดหรือคุณทำให้มันถูกและไม่ซับซ้อน มันยากจริงๆที่จะตีพื้นกลางที่ดี
ร่า

@ ไก่ประเด็นคือการสนับสนุนวันที่มักจะแย่มาก เก่าjava.util.Dateมี gotchas และปัญหาที่เป็นไปได้เกือบทั้งหมด ฉันรู้เพียงส่วนหนึ่งของjava.time.*แพ็คเกจใหม่แต่มันสะอาดใช้งานง่ายและไม่มีข้อผิดพลาด AFAICT ผู้ใช้ขั้นสูงอาจพบปัญหา แต่เป็นการปรับปรุงครั้งใหญ่ +++ ปัญหาดูเหมือนว่าจะเป็นปัญหาที่ซับซ้อนและรุ่นแรกจะรีบเร่งและแตก
maaartinus

24

กรุณาทำให้ภาษาของคุณวิเคราะห์ / ตรวจสอบได้สำหรับคนรักษาความปลอดภัยคอมพิวเตอร์

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

เมื่อเวอร์ชันภาษาใหม่หรือไลบรารี่หลักออกมาสิ่งที่ปลอดภัยก่อนหน้านี้อาจไม่:

  1. ไลบรารีอาจมีประสิทธิภาพมากขึ้น: เช่นตอนนี้ URL ของไลบรารีรองรับ javascript:
  2. อาจมีวิธีใหม่ในการแปลงสตริงหรือไบต์เป็นรหัส: เช่นevalหรือดีซีเรียลไลเซชันไลบรารี่
  3. เทคนิคการสะท้อนภาษาอาจมีประสิทธิภาพมากกว่าเช่นการเปิดเผยตัวแปรท้องถิ่น

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

ดังนั้นโปรดคิดเกี่ยวกับเราเมื่อออกแบบและกำหนดเวอร์ชันของภาษา ด้านล่างเป็นเคล็ดลับ:

กำหนดดั้งเดิมสองสามอย่างที่โปรแกรมสามารถย่อยสลายได้

HTML5 ไม่ดีเท่านี้ พวกเขาได้เห็นได้ชัดว่าใส่มากคิดว่าเป็นความปลอดภัยและมีคนที่ฉลาดมากบาง แต่แทนที่จะระบุองค์ประกอบโปรแกรมใหม่ ๆ เช่น<video>ในแง่ของคนเก่าหรือสร้างสิ่งที่เป็นนามธรรมทั่วไปที่ใหม่<video>และเก่า<img>ทั้งสามารถระบุได้ในแง่ของ<video>ยัง องค์ประกอบโปรแกรมแบบใช้ครั้งเดียวที่มีผลต่อความปลอดภัยของตัวเอง

ทำให้ภาษาของคุณคล้อยตามการวิเคราะห์แบบคงที่ (แม้ว่าจะไม่ได้พิมพ์แบบคงที่)

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

ควรชัดเจนว่าตัวระบุใดเป็นตัวแปรท้องถิ่นและไม่ใช่

เช่นอย่าทำผิดพลาดเหมือนกับ JavaScript รุ่นเก่าซึ่งทำให้ไม่สามารถบอกได้ว่าxเป็นการอ้างอิงตัวแปรท้องถิ่นในด้านล่าง (อ้างอิงจากการอ่านตัวอักษรของข้อมูลจำเพาะรุ่นเก่า):

if (Math.random() > 0.5) {
  Object.prototype.x = 0;
}

function f() {
  var x = 1;
  (function () {
    alert(x);  // Might alert 0, might alert 1.
  })();
}

อนุญาตให้มีการรักษาความปลอดภัยในการย่อยสลาย

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

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

บางภาษาเช่น Newspeak ใช้โมเดลความสามารถของวัตถุ นั่นเป็นวิธีที่ยอดเยี่ยมและเป็นวิธีที่ยอดเยี่ยมในการรักษาความปลอดภัยในการย่อยสลาย

แต่ถ้าคุณทำอย่างนั้นไม่ได้การทำให้กราฟโมดูลเป็นสิ่งประดิษฐ์ที่วิเคราะห์ได้แบบสแตติกสามารถทำให้คุณได้รับประโยชน์บ้าง หากฉันสามารถพิสูจน์ได้ว่าโมดูลไม่สามารถเข้าถึงโมดูลไฟล์ I / O (ยกเว้นโดยการเรียกรหัสในโมดูลใน TCB) จากนั้นฉันสามารถออกกฎคลาสทั้งหมดของปัญหาจากโมดูลนั้น

จำกัด อำนาจของภาษาสคริปต์ฝังตัว

ระบบที่มีประโยชน์มากมายถูกจัดระเบียบเป็นแกนหลักแบบคงที่ซึ่งจะช่วยปิดโค้ดจำนวนมากที่เขียนด้วยภาษาแบบไดนามิก (แม้ใช้งานได้)

และการฝังภาษาสคริปต์สามารถทำให้ระบบขยายได้มากขึ้น

แต่ภาษาสคริปต์ไม่ควรมีสิทธิ์เต็มที่ใน VM

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

ถือว่าevalเป็นภาษาที่ฝังตัวเป็นภาษาสคริปต์

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

ใช้โมเดลการทำงานพร้อมกันง่าย ๆ

พวกเราด้านความปลอดภัยไม่ต้องการที่จะกังวลเกี่ยวกับสภาพการแข่งขันเมื่อพยายามที่จะคิดออกว่าทรัพย์สินการรักษาความปลอดภัยจะถูกเก็บไว้

โปรดพิจารณาทางเลือกในการทำเกลียวก่อนที่จะตกลงบนเธรดเป็นตัวเลือกเริ่มต้นที่แทบจะเป็นไปไม่ได้ที่จะปลอดภัย

อย่างง่ายอย่างหนึ่งคือการทำงานพร้อมกันของเหตุการณ์ลูปเหมือนที่พบใน E, Verilog และ JavaScript

อย่ากระตุ้นให้เกิดความสับสน

บางภาษาเป็นภาษาที่ใช้กาวและพวกเขาก็จัดการกับสตริงในภาษาต่าง ๆ มากมาย

ตัวอย่างเช่น JavaScript มักจะประกอบด้วยสตริงของ HTML, CSS, XML, JSON และแม้แต่ JavaScript มันยากมากสำหรับโปรแกรมเมอร์ที่จำการเข้ารหัสสตริงข้อความธรรมดาอย่างถูกต้องเมื่อรวมมันเพื่อสร้างสตริงในภาษาอื่นดังนั้นโปรแกรม JS แปลกใจมีปัญหา quoting สับสนทุกชนิด: XSS แย่ที่สุด

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


พังทลายที่สวยงาม
Qix

23

ภาษาที่ดีที่สุดบางภาษาได้รับการออกแบบโดยคนที่ต้องการสร้างภาษาให้ตนเอง

ดังนั้นฉันคิดว่านักออกแบบภาษาควรให้ความสำคัญกับผู้ใช้น้อยลง คุณไม่สามารถทำให้ทุกคนพอใจได้คุณไม่ควรทำเช่นนั้น


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

5
@Berin: ฉันไม่คิดว่าประเด็นคือคุณไม่ควรฟังผู้ใช้ของคุณ แต่อย่าฟังผู้ใช้ที่ต้องการใช้ภาษาเพื่อสิ่งที่ไม่ได้ออกแบบมาให้ทำ หากคุณออกแบบภาษาเพื่อแก้ไขชุดหรือปัญหาที่เฉพาะเจาะจงคุณควรตอบสนองผู้ใช้ที่ต้องการแก้ไขปัญหาเหล่านั้นด้วย อย่างไรก็ตามคุณพูดถึงเรื่องสุดขีดและบางครั้งภาษาสามารถค้นหาช่องว่างในโดเมนใหม่ดังนั้น +1
Jeremy Heiler

2
@ Jeremy ใช่นั่นคือสิ่งที่ฉันพูด แต่ฉันคิดว่ามันผิดปกติสำหรับภาษาที่ทำงานได้ดีในโดเมนที่ไม่ได้ออกแบบมา
dan_waterworth

@dan_waterworth: ภาษาที่ประสบความสำเร็จมักใช้งานได้ดีในโดเมนที่ไม่ได้ออกแบบมาให้
David Thornley

8
แทนที่จะเป็น "ไม่ฟังผู้ใช้" คำแนะนำนั้นดีกว่าเพราะ "ไม่ฟังผู้ใช้ที่คุณไม่มี"
chrisaycock

16

ใช้เวลาเพียง 5-10% ในการเขียนโค้ด นักออกแบบภาษาควรใส่ใจกับความยากลำบากในการใช้งานซอฟต์แวร์ซึ่งหมายถึงการแก้ไขข้อผิดพลาดและข้อบกพร่อง

นั่นหมายความว่าควรมีการเริ่มต้นดีบั๊ก ไม่ใช่เครื่องมือบางอย่างที่มีไวยากรณ์ arcane และคำสั่งแป้นที่ดีกว่าคำสั่งการพิมพ์เพียงเล็กน้อยเท่านั้น


2
+1 การดีบักเป็นหนึ่งในสถานที่ที่บางภาษาดีกว่าคนอื่น - และ IDEs บางอย่างสร้างความแตกต่างระหว่างภาษาที่ใช้งานได้กับภาษาที่เข้าใกล้คุณ
Berin Loritsch

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

1
ไม่ใช่แค่การดีบัก แต่ทำให้ยากที่จะเขียนข้อบกพร่อง ฉันมีความสุขมากเมื่อ Java แนะนำขอบเขตการตรวจสอบอัตโนมัติในอาร์เรย์ ... แต่ที่นี่เรา 15 ปีต่อมายังคงทำผิดพลาดในภาษาอื่น
Alex Feinman

3
จะดีกว่าไหมถ้ามีภาษาที่พบว่าบั๊กในเวลารวบรวม? ตัวอย่างเช่นเมื่อฉันใช้ Ada ใช้เวลาในการดีบักเกอร์น้อยลงอย่างมากจากนั้นเมื่อฉันใช้ C หรือ C ++
มาร์ติ

12

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

สำหรับแนวคิดทางปรัชญาที่เกี่ยวข้องมีสิ่งเหล่านี้เป็นแนวคิดที่สำคัญที่สุดจาก Zen of Python:

  • ชัดเจนดีกว่าโดยปริยาย
  • จำนวนการอ่าน
  • กรณีพิเศษไม่พิเศษพอที่จะทำลายกฎ
  • แม้ว่าการปฏิบัติจริงชนะความบริสุทธิ์
  • ควรมีอย่างน้อยหนึ่งวิธีที่ชัดเจนกว่าที่จะทำ
  • หากการนำไปปฏิบัตินั้นยากที่จะอธิบายเป็นความคิดที่ไม่ดี
  • Namespaces เป็นหนึ่งในแนวคิดที่ยอดเยี่ยม - ลองทำสิ่งเหล่านี้ให้มากขึ้น!

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

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


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

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

4
@Mason Wheeler: เหตุผลเดียวที่คุณต้องประกาศตัวแปรในภาษาอื่นคือคุณต้องประกาศว่าเป็นประเภทใด Python เป็นแบบไดนามิกดังนั้นจึงไม่จำเป็นต้องประกาศประเภทจึงไม่จำเป็นต้องมีการประกาศ ฉันไม่เห็นว่าสิ่งนั้นเกี่ยวข้องกับอะไรโดยนัย / ชัดเจน ประเภทใน Python นั้นชัดเจน ตัวแปรก็เช่นกัน หลังจากสิบปีที่พิมพ์ผิดไม่เคยทำให้เกิดข้อผิดพลาดยากที่จะแก้ปัญหา ในความเป็นจริงพวกเขาจะแก้จุดบกพร่องเล็กน้อย
Lennart Regebro

8
+1 สำหรับรายการ -1 สำหรับ fanboy-ness ให้ความสนใจกับทุกภาษาที่ได้รับความสำเร็จที่สำคัญและพยายามที่จะรวมหรืออย่างน้อยวิเคราะห์การบังคับใช้ขององค์ประกอบเหล่านั้นดูเหมือนว่าวิธีการปฏิบัติมากขึ้น
Steven Evers

3
@ เลนนาร์ท: ฉันจะบอกว่าความสามารถ (แต่ไม่จำเป็นต้องดูกฎ 4) เพื่อระบุประเภทฟังก์ชั่นของรัฐเป็นสิ่งที่ดี มันคล้ายกับการออกแบบตามสัญญา นั่นคือจุดที่ฉันต้องการทำ
Theo Belaire

11

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

โดยทั่วไปแล้วนี่คือ metaprogramming ... แต่ส่วนใหญ่ฉันจะใช้เพื่อสร้างโครงสร้างการควบคุมใหม่


น่าสนใจ การสนับสนุนการเขียนโปรแกรมเมตาที่ดีอาจทำได้ยาก แต่ก็มีประสิทธิภาพมากเมื่อเป็นเช่นนั้น ฉันได้ยินจากคนที่ชอบเสียงกระเพื่อมที่การใช้เสียงกระเพื่อมเป็นสิ่งที่ดีที่สุด - แต่พวกเขาพูดแบบนั้นเกี่ยวกับทุกอย่างในเสียงกระเพื่อม ตัวอย่างใด ๆ ของสิ่งที่คุณคิดว่าการเขียนโปรแกรมเมตาถูกต้องหรือไม่
Berin Loritsch

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

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

ฉันคิดว่า Mata-Lua หรือ Template Haskell ทำงานได้ดีในการให้สิ่งนี้ (ไม่ดีเท่าที่โครงการของแมโคร แต่นั่นคือสิ่งที่คุณจ่ายสำหรับการใช้มากขึ้นแล้ว parens ในภาษา)
ธีโอ Belaire

10

สิ่งที่สำคัญที่สุดคือภาษาของคุณต้องมี "สไตล์" ตัวอย่างเช่นฉันจะเรียก C เป็นภาษาการเขียนโปรแกรมระบบที่ใช้ตัวชี้ ฉันจะเรียก Erlang ภาษาการเขียนโปรแกรมการทำงานพร้อมกันอย่างมาก บางภาษาอื่น ๆ (เช่น C ++ และ Java เนื้อหา) เป็นสิ่งที่อัลลันเคย์เรียกว่าภาษา "agglutinative": ภาษาของแฟรงเกนสไตน์ประกอบไปด้วยคุณสมบัติมากมาย

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

  1. พิสูจน์ว่ามันจำเป็นจริงๆ
  2. พิสูจน์ว่าไม่สามารถทำได้ในห้องสมุด
  3. พิสูจน์ว่าเป็นของภาษา

2
กล่าวอีกนัยหนึ่งภาษาควรมีหลักการออกแบบหนึ่งครอบคลุมและภาษาควรสอดคล้องกับหลักการนั้น ความคิดเห็นเกี่ยวกับการวิวัฒนาการของภาษานั้นได้รับการรับประกัน (ฉันเคยเห็นมาแล้วไม่กี่ครั้ง)
Berin Loritsch

1
เตือนฉันถึงคำพูด C ++ ที่ฉันโปรดปราน ... ปลาหมึกยักษ์ที่ทำโดยจับขาพิเศษไว้กับสุนัข
ocodo

4
พิสูจน์ให้เห็นว่ามันไม่สามารถทำได้ในห้องสมุด +1
Qix

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

10

ขอบคุณสำหรับคำถามที่ดีมาก คุณได้รับคำตอบที่ดีพอสมควร

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

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

ฉันวัดความจำเพาะโดเมนของภาษาตามขอบเขตที่ทำให้กราฟนั้นง่ายขึ้น นั่นเป็นคุณสมบัติที่พึงปรารถนาอย่างยิ่งและสามารถเข้าถึงได้ในหลาย ๆ วิธีไม่ว่าจะด้วยการกำหนดคลาส / รูทีนที่เหมาะสม (คำนาม / คำกริยา) ไปยังมาโครการเขียน parser และ interpreter / compiler ของคุณเอง

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

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


9

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


2
ชนิดจำนวนเต็มที่ถูก จำกัด ala C, C ++, D, Java, C #, ฯลฯ มีที่แน่นอน การเขียนโปรแกรมบางประเภทไม่สนใจและต้องการเพียงความแตกต่างของจำนวนเต็มกับจุดลอยตัว ถึงอย่างนั้นบางทีเราแค่ต้องการประเภทตัวเลขและกังวลเกี่ยวกับส่วนหนึ่งของตัวเลขในภายหลัง ในระยะสั้นการเขียนโปรแกรมทางธุรกิจมีความไวน้อยกว่าประเภทจำนวนเต็มที่เฉพาะเจาะจงกว่าความจริงที่ว่าตัวเลขเป็นจำนวนเต็ม เมื่อคุณใช้โปรโตคอลในระดับต่ำกฎจะเปลี่ยนไปอย่างมาก
Berin Loritsch

2
สิ่งที่ฉันคิดว่าประเภทใน Ada ที่คุณสามารถพูดtype Date_Of_Month is 1 .. 31;และออกจากการตัดสินใจเช่น 16 หรือ 32 บิตเพื่อเพิ่มประสิทธิภาพ แต่ที่สำคัญกว่ากำหนด 32 หรือ 0 หรือ -5 RANGE_ERRORถึงตัวแปรชนิดที่จะช่วยให้คุณ
Martin

ช่วงที่ใช้งานได้ดีกับสิ่งต่าง ๆ เช่นDate_Of_Month(หรือMonth_Of_Year) ที่มีช่วงการใช้งานที่ชัดเจน แต่มีหลายกรณีที่อาจเป็นไปได้มากที่สุดที่คลุมเครือ type Persons_Age is 0..120? เกิดอะไรขึ้นถ้ามีคนทำลายสถิติอันยืนยาว? type Year is 0..9999? ถ้าคุณเป็นนักอียิปต์
dan04

type Egyptian_Year is -9999 .. 300;หากคุณเป็นศคุณจำเป็นต้องลบเลือน จากประสบการณ์ของฉันคุณสามารถค้นหาขอบเขตที่มีประโยชน์สำหรับจำนวนเต็มเกือบตลอดเวลา ในแง่นี้คุณควรพิจารณาว่าtype Scrolls_Found is array Egyptian_Year of Natural;คุณไม่สามารถ / ไม่ควรมีประเภทที่ไม่ จำกัด เป็นดัชนีอาร์เรย์ มันเป็นเพียงเวกเตอร์โจมตีสำหรับแฮ็กเกอร์ BTW: Ada อนุญาตให้คำนวณขอบเขตในช่วงรันไทม์
Martin

1
@kai ไม่มีใครบอกว่าต้องใช้คุณสมบัติเฉพาะของระบบพิมพ์ทุกที่โดยไม่มีข้อยกเว้น ฉันแน่ใจว่า Ada อนุญาตให้ใช้ประเภทตัวเลข "ปกติ" ได้เช่นกัน และประเภทตัวเลขที่ล้อมรอบนั้นมีประโยชน์สำหรับปัญหาบางอย่าง (ค่อนข้างบ่อย)
Sarge Borsch

8

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


8

แบบแผนการตั้งชื่อ (ฉันกำลังมองหาคุณ PHP)


แม้ว่าปัญหาการออกแบบภาษาจะน้อยลง แน่นอนว่าคุณมักจะต้องจับตามองในสิ่งที่เข้ามาในห้องสมุดมาตรฐาน แต่นักออกแบบภาษาไม่สามารถบังคับใช้การตั้งชื่ออนุสัญญา;)

3
คุณสามารถสำหรับห้องสมุดมาตรฐาน
Malfist

3
อย่าพูดถึง PHP ภาษาที่ใช้กันโดยทั่วไปที่แย่ที่สุด ไม่ได้ออกแบบโดยนักวิทยาศาสตร์คอมพิวเตอร์เพียงแค่ผู้ชายที่ต้องการแม่แบบและสเตียรอยด์ก็ถูกเพิ่มเข้ามา
Keyo

@delnan: บางภาษาเช่น Mercury หรือ Eiffel กำหนดอนุสัญญาการตั้งชื่อ (ชื่อระดับทุนทั้งหมดตัวแปรที่ขึ้นต้นด้วยตัวพิมพ์ใหญ่ ฯลฯ ) และพวกมันถูกบังคับใช้โดยคอมไพเลอร์ Fortran กล่าวว่าตัวแปรที่เริ่มต้นด้วย i, j, k เป็นจำนวนเต็ม (ดังนั้นการใช้แบบดั้งเดิมเป็นตัวแปรลูปในภาษาส่วนใหญ่ ... ) และอื่น ๆ ค่อนข้างน่ารำคาญถ้าคุณไม่ชอบการประชุม แต่ดีสำหรับความสอดคล้องของรหัสที่มาอย่างน้อย
PhiLho

@PhiLho: มีข้อ จำกัด มาก มันไม่สามารถบังคับใช้ - เพียงแค่ตัวอย่างเดียว - การใช้ตัวพิมพ์ใหญ่หรือขีดล่าง (ที่มีความหมายและมีความหมาย) (สามารถลองได้ แต่จะเสี่ยงต่อการมีสติของโปรแกรมเมอร์ในกระบวนการ)

7

การบูรณาการชั้นหนึ่งกับสภาพแวดล้อมการพัฒนา

ทุกวันนี้การเขียนโค้ดทำได้ในสภาพแวดล้อมที่หลากหลาย สำหรับ HTML / CSS / JS เรามี Firebug และเครื่องมือโต้ตอบอื่น ๆ สำหรับ Java, Eclipse และ IDEA และ IDE จริงอื่น ๆ และอื่น ๆ มีระบบนิเวศน์ของเครื่องมือเริ่มต้นด้วยตัวแก้ไข แต่ไม่สิ้นสุดที่นั่น:

  • การจัดระเบียบโค้ดภายในและระหว่างไฟล์
  • การเน้นสมาร์ท
  • สมาร์ทเสร็จ / พิมพ์ทำนาย
  • การดีบักแบบคงที่ (ข้อผิดพลาดทางไวยากรณ์การกำหนดความหมายและข้อผิดพลาดของสไตลิส)
  • การสร้างและการใช้งานเทมเพลตและมาโคร
  • การควบคุมเวอร์ชัน (การกำหนดเวอร์ชันการรวมการแยกสาขา, ... )
  • การพัฒนาแบบกระจายที่มีผู้เขียนหลายคน (ความคิดเห็น, เอกสารอินไลน์, คำอธิบายประกอบ, ... )
  • การดีบักแบบรันไทม์ (การติดตามสแต็ก, การก้าว, นาฬิกา, ... )
  • การดีบักแบบโต้ตอบ "สด" (เช่น Firebug - พฤติกรรมการแก้ไขของระบบสด)
  • ... ฉันไม่รู้ด้วยซ้ำว่ามีอะไรต่อไป

ภาษาควรถูกสร้างขึ้นเพื่อให้การสนับสนุนกิจกรรมเหล่านี้ ความคืบหน้าบางอย่างเกิดขึ้นแล้ว - คำอธิบายประกอบใน Java เพื่อช่วยให้นักพัฒนาซอฟต์แวร์รายอื่นเข้าใจเจตนาของโค้ดเช่น

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


คุณหมายถึงบางอย่างเช่น ASIS (ISO / IEC 15291: 1999“ สเปคของ Ada Semantics Interface”)? ASIS ไม่ครอบคลุมทั้งหมดที่คุณต้องการ แต่ค่อนข้างมาก ฉันมักจะต้องการบางอย่างเช่น ASIS สำหรับภาษาการเขียนโปรแกรมอื่น ๆ ดูsigada.org/wg/asiswgสำหรับรายละเอียด
มาร์ติ

บางสิ่งเหล่านี้ค่อนข้างถูกในการทำหรือมาจาก IDE ของคุณฟรี: การจัดระเบียบโค้ด, การเน้นไวยากรณ์, การพับโค้ด, การควบคุมเวอร์ชัน, เทมเพลต / มาโคร คนอื่นต้องการความพยายามมากขึ้น: การดีบักแบบรันไทม์, การดีบักแบบสมาร์ท, การพิมพ์แบบสมาร์ท / การทำนายการรีแฟคเตอร์ ฯลฯ ขณะที่ละเลยการออกแบบภาษาที่สอดคล้องกันนั้นยากกว่ามากเมื่อคุณต้องกังวลเกี่ยวกับปลั๊กอิน IDE
Berin Loritsch

6

การคำนวณแบบกระจาย

อาหารกลางวันฟรีมากกว่า วันนี้เราต้องการโปรแกรมที่ทำงานบนหลายคอร์ / โปรเซสเซอร์หลายตัว (และในสถานการณ์พิเศษคอมพิวเตอร์หลายเครื่อง)

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

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

ฉันชอบวิธีการของGoในการแก้ปัญหา: มีหลายเธรดในตัวและวิธีการที่ใช้ (ช่องสัญญาณและ goroutines) ตั้งค่าความคิดได้ง่ายกว่าวิธีสัญญาณแบบดั้งเดิม / mutex / ล็อคแบบดั้งเดิม มันยังง่ายต่อการเข้าถึงโครงสร้างที่ไม่ซิงโครไนซ์พร้อมกันแม้ว่า (Go มีตัวชี้) หรือการหยุดชะงัก (วงจรของการรอช่องสัญญาณ ... )

ฉันคิดว่าภาษาที่นิยมใช้ข้อมูลที่ไม่สามารถเปลี่ยนแปลงได้เช่นภาษาที่ใช้งานได้อาจมีสิทธิ์ (ฉันชอบประสบการณ์ที่นั่น)

นอกจากนี้โมเดลนักแสดงอาจเป็นเป้าหมายต่อไปของเรา มันมีความหมายสำหรับการคำนวณแบบกระจายเช่นกัน


อีกตัวอย่างหนึ่งคือ Erlang ชุดรูปแบบทั่วไประหว่างภาษาของการจัดเรียงนี้เป็นวิธีการที่ใช้ร่วมกันไม่มีอะไรที่รัฐจะถูกส่งผ่านเป็นหลักพร้อมกับข้อความ วิธีการวัดขนาดได้ดี
Berin Loritsch

@Berin: ถูกต้องแม้ว่าฉันจะไม่ได้อ้างถึง Erlang ในข้อความเพราะฉันรู้เพียงเล็กน้อย แต่ฉันจำได้อย่างถูกต้องว่ามันใช้โมเดลนักแสดง
Matthieu M.

6

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


JavaDoc, CppDoc, RubyDoc เป็นต้นเป็นเครื่องมือที่ดีในการทำความเข้าใจกับไลบรารีมาตรฐานรวมถึงไลบรารีที่คุณสร้าง มันไม่ได้ถูกสร้างขึ้นเท่ากันทั้งหมดและบางอันก็ง่ายกว่าการนำทางอื่น ๆ
Berin Loritsch

ตกลงเว็บไซต์ Java API เป็นสินทรัพย์ที่ยอดเยี่ยม มันมีรูปแบบมาตรฐานที่ยอดเยี่ยมสำหรับการสร้างเอกสาร API ด้วย ผลผลิตที่เพิ่มขึ้นจากการใช้ IDE ที่มีอยู่แล้วภายในรองรับการวิเคราะห์ JavaDoc (netbeans) เป็นสิ่งที่น่าอัศจรรย์ แม้ว่าฉันจะมีความทรงจำที่น่ากลัวดังนั้นมันอาจเป็นประโยชน์กับฉันมากกว่าคนอื่น
toc777

6

ความสามารถในการช่วยคอมไพเลอร์ตรวจสอบรหัสของคุณมากขึ้น

ในฐานะที่เป็นโปรแกรมเมอร์ระบบฝังตัวฉันมักจะใช้ C แต่ฉันหวังเสมอว่าฉันจะมีวิธีการที่ดีกว่า / ดีกว่าในการบอกคอมไพเลอร์ว่าฉันคาดหวังอะไรจากรหัสของฉันเพื่อให้สามารถตรวจสอบได้

EG ฉันสามารถมีฟังก์ชั่น

f(int x)

แต่ฉันต้องการ

f(int range[-5..25] x)

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


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

3
คุณควรใช้ Pascal คุณสามารถกำหนดประเภทที่ครอบคลุมช่วงของจำนวนโดยพลการเช่น -5 .. 25 ซึ่งคอมไพเลอร์สามารถตรวจสอบได้ในเวลาคอมไพล์ (ตราบใดที่คุณกำหนดค่าคงที่เท่านั้น)
Mason Wheeler

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

1
ฉันจะใช้ Ada ยกเว้นว่าแพลตฟอร์มที่ฉันทำงานไม่มีคอมไพเลอร์ Ada มันมีคอมไพเลอร์ C เท่านั้นดังนั้นนี่คือวิชาการทั้งหมด
Rocketmagnet

1
ฉันใช้การยืนยันจำนวนมากอยู่แล้ว แต่มันจะดียิ่งขึ้นถ้ามีสิ่งนี้และสิ่งอื่น ๆ เป็นคุณลักษณะภาษา
Rocketmagnet

5

ไวยากรณ์ขนาดเล็กที่มีคำหลักน้อยที่สุดเนื่องจากไวยากรณ์ verbose นั้นยากที่จะเรียนรู้และไม่ช่วยให้สามารถอ่านได้

ตัวอย่างที่เลวร้ายที่สุดคือ Ada:

procedure Hello is
begin
  Put_Line("Hello World!");
end Hello;

คำที่เติมเช่นเดียวกับ .. ไม่สมเหตุสมผลสำหรับการเขียนโปรแกรมภาษา


4
public static voidผมคิดว่าตัวอย่างที่เลวร้ายที่สุดคือภาษาที่คุณพูด
Joey Adams

1
แนวคิดไม่ใช่เรื่องใหม่และนำมาใช้แล้วในรูปแบบของ SmallTalk ซึ่งไม่มีคำหลักเลย ดังนั้นคุณควรใช้ SmallTalk เป็นตัวอย่างที่ดีสำหรับการเรียกร้องของคุณ BTW: ถ้าคุณไม่รู้ว่าอะไรISคือสิ่งนั้นแล้วคุณยังไม่เข้าใจ Ada (คุณเคยเขียนโปรแกรม Ada หรือไม่): ISแยกการประกาศขั้นตอนออกจากการประกาศตัวแปรท้องถิ่นและแยกข้อกำหนดจากการนำไปปฏิบัติ แน่นอนว่าคุณจะสังเกตเห็นได้เมื่อเปรียบเทียบคุณสมบัติและการใช้งานฟังก์ชั่นเพื่อดูว่าISเหมาะสมแล้วและไม่ได้เป็นสารตัวเติมเลย
มาร์ติ

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

7
คำที่เติมอาจใช้เพื่อวัตถุประสงค์ถ้าพวกเขาช่วยในการแก้ปัญหาไวยากรณ์ ยกตัวอย่างเช่นผมชอบมากที่จะif x then … if (x) …เราแลกเปลี่ยนวงเล็บสองคำสำหรับคำหลักตามบริบท สิ่งนี้สมเหตุสมผลเนื่องจากเงื่อนไขxอาจเป็นนิพจน์ที่ซับซ้อนพร้อมกับวงเล็บของมันเอง การกำจัดคู่นอกสุดสามารถเพิ่มความสามารถในการอ่านได้อย่างมาก อีกทางเลือกหนึ่งคือใช้เครื่องหมายโคลอนที่นี่เช่นใน Python ในความเป็นจริงฉันเชื่อว่าฟิลเลอร์ที่น่าสงสัยส่วนใหญ่สามารถถูกแทนที่ด้วยโคลอน ไม่แน่ใจว่าวิธีใดที่ฉันชอบ
Konrad Rudolph

3
@ Konrad: ถ้ามันทำให้เข้าใจผิดไวยากรณ์มันไม่ได้เป็นสารตัวเติม is เป็นฟิลเลอร์เพราะ Ada จะได้รับอนุญาตให้procedure Hello begin ... endมีความคลุมเครือ
dan04

4

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

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

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

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


2
องค์ประกอบของฟังก์ชั่นของ Haskell เป็นไปในทิศทางใด (f ∘ g)(x) = f(g(x))มันแปลตรงของ
Jon Purdy

@ จอน Purdy: หมายความว่าคุณต้องเขียนฟังก์ชันตามลำดับย้อนหลังของแอปพลิเคชัน ทั้งในรูปแบบถูกนำไปใช้อาร์กิวเมนต์แรกตามด้วยg fหากคุณต้องการที่จะเรียงลำดับรายชื่อกลุ่มนั้นและได้รับรายการแรกของรายการเหล่านั้นคุณจะเขียน(map head . group . sort) listหรือหรือmap head $ group $ sort list map head (group (sort list))ในทุกกรณีคุณจะต้องเขียนการปฏิบัติงานย้อนหลัง โดยวิธีการนำเข้าControl.Arrowช่วยให้คุณพูด(sort >>> group >>> map head) listแต่>>>ผู้ประกอบการดูค่อนข้างอึดอัดใจและ verbose กับฉัน
Joey Adams

2
ฉันไม่คิดว่าฉันยังคิดว่าสิ่งที่ถูกต้องจากซ้ายไปขวา (map head . group . sort) listอ่านว่า "รายการแรกของแต่ละกลุ่มในเรียงลำดับlist" ซึ่งค่อนข้างเป็นธรรมชาติ - และสำหรับหูของฉันมีฟังก์ชั่นมากกว่า(sort >>> group >>> map head) listซึ่งอ่านค่อนข้างค่อนข้างย้อนหลังและเป็น "เรียงลำดับจากนั้นจึงจัดกลุ่มรายการแรกของแต่ละกลุ่ม .. list"
Jon Purdy

@JoeyAdams - ประกอบการลักษณะค่อนข้างอึดอัดและ verbose - ไม่กี่ภาษาการทำงานมากขึ้นล่าสุดได้เริ่มต้นใช้เป็นผู้ประกอบการผูกมัดซ้ายไปขวาซึ่งอาจจะเล็ก ๆ น้อย ๆ ง่ายในสายตา ...>>>|>
จูลส์

4

ตั้งแต่เราอยู่ในปี 2011

  • สเปคที่สมบูรณ์อย่างแน่นอน ไม่มีรูขึ้น - ลงตามแบบใน C
  • การสนับสนุนมัลติเธรด ไม่เพียง แต่คุณสมบัติการซิงโครไนซ์ (ล็อค) แต่คุณสมบัติภาษาที่ทำให้การมัลติเธรดเป็นเรื่องง่ายเหมือนกับการเขียนลูป:

    ทั้งหมด (o ใน myCollection) {o.someMethod ()}

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

  • ความสอดคล้อง (ฉันรู้ว่ามันขออะไรมากทั้งความสอดคล้องและกระบวนทัศน์ที่หลากหลาย ... )


ฉันอยู่กับคุณ 100% สำหรับสเปคที่สมบูรณ์ กระบวนทัศน์ที่หลากหลายและสม่ำเสมอจะเป็นการกระทำที่สมดุล คุณสามารถระบุชุดของพฤติกรรมสำหรับกระบวนทัศน์แบบไดนามิกเป็นชุดย่อยของพฤติกรรมสำหรับการตรวจสอบแบบคงที่ - แต่ฉันคิดว่าวิธีการทั้งสองนี้สามารถให้ยืมตัวเองกับรูปแบบการเขียนโปรแกรมที่แตกต่างกันมาก พวกเขาควรจะแยกภาษาในตอนนั้น บางทีคู่ภาษาที่สอดคล้องกับความเข้ากันได้ 100% อาจเป็นสิ่งที่คุณกำลังมองหา?
Berin Loritsch

ภาษาอย่างสกาล่า (และบางทีแฮสเค็ลล์ฉันไม่รู้จักเพียงพอ) มีระบบพิมพ์แบบสแตติกที่แข็งแกร่งและมีความทนทานขอบคุณการอนุมานและการอนุมาน
PhiLho

2
ฟีเจอร์ที่ขึ้นอยู่กับสถาปัตยกรรมนั้นดีเมื่อภาษาให้โปรแกรมเมอร์กำหนดว่าอะไรคือสิ่งที่สำคัญหรือไม่สำคัญ สิ่งที่ทำให้ C น่ากลัวก็คือไม่มีวิธีที่จะประกาศ "ประเภทตัวเลขซึ่งล้อมโมดูโล 65536"; แม้ว่าแพลตฟอร์มจะใช้ uint16_t แต่มาตรฐานนั้นต้องการให้การใช้งานบางอย่างคำนึงถึงความแตกต่างระหว่างสองuint16_tค่าเมื่อลงนามแล้ว มันไม่มีวิธีสำหรับโปรแกรมเมอร์ที่จะระบุพฤติกรรมที่ต้องการ
supercat

ฉันไม่เห็นด้วยกับ multiparadigm; ที่ออกจากห้องเลื้อยมากเกินไปสำหรับการต่อสู้สไตล์การเข้ารหัส Library A เขียนด้วยกระบวนทัศน์แบบไดนามิกจำนวนมาก ห้องสมุด B เป็นลายลักษณ์อักษรกับพวงของกระบวนทัศน์แบบคงที่ ตอนนี้ Library A ต้องคุยกับ Library B; พื้นกลางอยู่ที่ไหน หากคุณต้องเขียนกาวระหว่างโค้ดสองภาษาในภาษาเดียวกันภาษานั้นมีข้อบกพร่อง IMO โดยเนื้อแท้
Qix

3

กระบวนการที่มีน้ำหนักเบา

ฉันต้องการมีกระบวนการแบบ Lightweight เช่นเดียวกับใน Erlang เป็นปัญหาหลักสำหรับรันไทม์ สิ่งนี้หายไปใน JVM และ. NET CLR LWP ช่วยในการสร้างซอฟต์แวร์พร้อมกันอย่างหนาแน่น เป็นการดีที่ไม่ควรมีราคาแพงกว่าในการสร้างกระบวนการเนื่องจากเป็นการสร้างวัตถุในภาษา ฉันต้องการสร้างกระบวนการนับล้านในแอปพลิเคชันของฉัน

มันถูกใช้เป็นเธรดพูลที่มีการกำหนดเวลาล่วงหน้าดังนั้นงานเดียวไม่ได้บล็อกงานอื่นและงานสามารถกำหนดเวลาใน cpu-core ใด ๆ ที่มีอยู่

รองรับการเรียกซ้ำแบบหาง

ฉันต้องการได้รับการสนับสนุนสำหรับการเรียกซ้ำแบบหาง นี่อาจเป็นปัญหาสำหรับสภาพแวดล้อมรันไทม์ เช่น JVM ไม่รองรับการเรียกซ้ำแบบหาง

การเขียนโปรแกรมกระจายง่าย

ผมอยากที่จะมีการสนับสนุนสำหรับการส่ง ( ! ) และได้รับพื้นฐานไปยังส่วนของแอพลิเคชันที่ทำงานบนเครื่องอื่น ๆ ใน netword เช่นเดียวกับใน Erlang สิ่งนี้ทำให้ง่ายต่อการสร้างแอพพลิเคชั่นที่ปรับขนาดได้เช่นดาต้าสโตร์แบบกระจาย เพิ่มไปยังอนุกรมที่มีอยู่แล้วในภาษาก็มีประโยชน์มากเช่นเดียวกับใน erlang และไม่เหมือนใน Java อย่างมากฉันต้องทำด้วยตนเอง



Scala มีการเรียกซ้ำแบบหางและรวบรวมไปยัง JVM คอมไพเลอร์ IBM Java ก็สามารถทำการเรียกซ้ำหาง - บางครั้ง
มาร์ติ

3

อำนวยความสะดวกในการเปรียบเทียบโปรแกรม

จำกัด รูปแบบพิเศษ

ใน Python ไม่มีเหตุผลที่ดีว่าทำไมการพิมพ์ไม่ใช่ฟังก์ชั่นบิวอิน มันดูและทำหน้าที่เหมือนฟังก์ชั่นยกเว้นที่ไม่ต้องการทำอะไรกับ parens

เราต้องการforหรือforeachไม่whileและสิ่งที่พวกเขาต้องการเป็นรูปแบบพิเศษของพวกเขาเอง วิธีการเกี่ยวกับการวนลูปหนึ่งและแมโครเริ่มต้นบางอย่างเพื่อให้น้ำตาล syntactic ของรูปแบบวนรอบตัวแปร

การเขียนโปรแกรมเมตาสำหรับรูปแบบพิเศษ

form['if'](test-fn, body-fn)


การเรียงลำดับของ Ruby มี "รูปแบบพิเศษ" สำหรับการวนซ้ำอย่างน้อยในแง่ที่ว่าวัตถุที่ทำซ้ำได้มักจะมีวิธีการeachที่ใช้บล็อกของรหัสเป็นอาร์กิวเมนต์ (ทับทิมยังมีforและwhileลูป แต่ไม่เคารพตัวเองโปรแกรมเมอร์ทับทิมใช้จริงพวกเขา.)
mipadi

@mipadi: ฉันเป็นแฟนตัวยงของบล็อก Ruby และสำนวนที่เกี่ยวข้อง
dietbuddha

บางทีพวกเขาคิดว่า - คุณจะยิงตาของคุณ :) ฉันเดาว่ามันคือการรวมตัวกันของพวกเจ้าทั้งหมด "งูใหญ่" และ "ไม่มีเหตุผลที่ดี" อย่างไรก็ตาม metaprogramming เป็นปัญหาการออกแบบภาษาที่ถูกต้องซึ่งมักจะถูกละเลย ด้วยเหตุผลนี้เองที่ฉันจะลงคะแนนเสียงนี้
Berin Loritsch

@Berin: จริง ๆ แล้วฉันใช้และเป็นแฟนของ Python ซึ่งทำให้สนุกมากขึ้น
dietbuddha

ลูปประเภทหนึ่งจะทำให้โฟลว์ของโค้ดไม่ชัดเจน ตัวอย่างเช่นdo..whileลูปจะดูอย่างไรถ้ามีลูปประเภทหนึ่งที่มีการประเมินที่ด้านบน ดูเหมือนว่าจะไม่เป็น .. ในขณะที่วนรอบทั้งหมด
Qix

2

ความสามารถของเครือข่าย

ภาษาที่จัดส่งโดยไม่มีการสนับสนุนเครือข่ายบางอย่างนั้นค่อนข้างง่อยในโลกปัจจุบัน

แอปพลิเคชันในโลกแห่งความเป็นจริงส่วนใหญ่จำเป็นต้องสื่อสารผ่านเครือข่ายบางประเภท:

  • อัปเดตอัตโนมัติ
  • การเข้าถึงฐานข้อมูล
  • webservices

นอกจากนี้ยังเป็นรากฐานสำคัญของการสนับสนุนการคำนวณแบบกระจาย / คลาวด์แน่นอน


8
แต่มันอาจเป็นคุณสมบัติห้องสมุดมาตรฐานได้ดี
Donal Fellows

@ Donal: ฉันไม่เคยพูดเป็นอย่างอื่น (หรืออย่างน้อยก็ไม่ได้คิดอย่างนั้น) คำถามเปิดให้ทั้งภาษาและคุณสมบัติห้องสมุด จุดของฉันเป็นเพียงว่าถ้าคุณได้รับแพคเกจภาษาและไม่มีความสามารถของเครือข่ายในที่นั่นคุณจะเติมเต็มความเจ็บปวดเร็วแทนที่จะในภายหลัง :)
Matthieu เมตร

3
ห้องสมุดมาตรฐานเป็นส่วนหนึ่งของประสบการณ์ทางภาษาและควรได้รับการดูแลด้วยความเคารพและให้ความเคารพ ฉันเห็นด้วยกับข้อกำหนดนี้สำหรับไลบรารีมาตรฐาน
Berin Loritsch

1

ฉันชอบภาษาการเขียนโปรแกรมที่เรียนรู้ได้ง่ายและง่ายต่อการรวมเพื่อสร้างสิ่งใหม่

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

ภาษาที่แนวคิดสามารถนำไปใช้กับองค์ประกอบทั้งหมดนั้นมีประโยชน์มาก (ฉันคิดว่านี่เรียกว่า orthogonality) ดังนั้นในครั้งต่อไปที่คุณเผชิญกับคุณลักษณะภาษาใหม่คุณสามารถอนุมานวิธีใช้

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

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


มุมฉากหมายถึงคุณลักษณะแต่ละอย่างทำสิ่งที่แตกต่าง ดูเครื่องมือเช่น grep หรือ awk พวกเขาทำสิ่งหนึ่งดี จากนั้นให้คุณเรียงตามลำดับที่แตกต่างกันเพื่อทำสิ่งที่คุณต้องการ
Theo Belaire

1
  • ความสามารถในการอ่าน : ยิ่งน้อย / น้อยที่สุดสัญลักษณ์ที่ใช้ในไวยากรณ์ความสะอาดและดีกว่า
  • ประเภทของ Object Oriented : วิธีการ, ไม่ใช่ฟังก์ชั่น
  • ความสามารถในการทำความเข้าใจ : อินเทอร์เฟซที่คล่องแคล่วในตัวชื่อที่ครอบคลุมและสั้นสำหรับคลาสไลบรารี / อินเทอร์เฟซและประเภทต่างๆ

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

สำหรับฉันรหัสสะอาดเป็นรหัสที่สามารถอ่านได้ ฉันยังพูดที่เล็กที่สุด: มี ":" แทน "=>" ในอาร์เรย์ PHP หรือมี "." แทนที่จะเป็น "->" จะเป็นการปรับปรุงอย่างแน่นอน (และฉันสนุกกับ PHP อยู่แล้ว)
dukeofgaming

4
@ Mason: ฉันและนักเขียนทางเทคนิคที่ดีหลายคน (เช่น William Zinsser) ไม่เห็นด้วย การใช้คำฟุ่มเฟื่อยเป็นศัตรูของการอ่านไม่รุนแรง
Konrad Rudolph

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

1
จุดแรกของคุณขัดแย้งโดยตรงกับสองหลังของคุณ
Qix

1

การเพิ่มคุณสมบัติให้กับภาษาการเขียนโปรแกรมที่มีอยู่ ดังนั้นภาษาใหม่ B คือภาษาเก่า A บวกกับคุณสมบัติ X

ตัวอย่างที่มีอยู่:

  1. C เพิ่มคลาส => C ++
  2. Java เพิ่มบางสิ่ง => C #

2
นี่คือการขยายขนาดใหญ่มาก ตัวอย่างที่ดีกว่านี้คือความแตกต่างระหว่าง C กับ Objective-C
Jon Purdy

0

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

ฉันหวังว่าในวันนั้นเมื่อเรามีกำลังการคำนวณและภาษาที่คุณออกแบบแอพลิเคชันของคุณและคุณจะได้ไม่ต้องกังวลเกี่ยวกับรายละเอียดภาษา

อัปเดต: ฉันส่งลิงค์ไปที่LabViewภาษาดังกล่าว

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


3
คอมพิวเตอร์มีพลังมากพอที่จะทำสิ่งนี้ มันเป็นเพียงแค่ไม่ปฏิบัติตามที่คุณจะต้องมีการรับลงไปในรหัสสำหรับเหตุผลบางอย่างหรืออื่น
Jeremy Heiler

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

1
กล่าวโดยย่อในขณะที่ฉันสงสัยอย่างจริงจังถึงประโยชน์ของวิธีการนี้ในแง่ทั่วไปมีแอปพลิเคชันเฉพาะที่ใช้ในปัจจุบันและทำงานได้ดีสำหรับแอปพลิเคชันนั้น Re: คะแนนของคุณ ... 1. คอมพิวเตอร์มีพลังในการคำนวณด้านเทคนิคไม่ใช่ปัญหา 2. ปัญหาคือการให้ภาษาภาพที่แสดงออกเพียงพอที่จะทำงานในความหมายทั่วไปโดยไม่หลงทางในรายละเอียด นอกเหนือจากแอปพลิเคชันแบบเฉพาะข้อความดูเหมือนว่าจะเป็นการแสดงออกที่กะทัดรัดมากขึ้นของโปรแกรม ฉันโหวตขึ้นเพราะมันใช้ได้กับคำถามที่โพสต์
Berin Loritsch

1
@Amir: โปรดอธิบายว่าทำไมคอมพิวเตอร์ต้องมีประสิทธิภาพมากกว่าเพื่อ "การเขียนโปรแกรมกราฟิก" เพื่อผลักดันการพัฒนาซอฟต์แวร์?
Jeremy Heiler

7
@Amir: คุณกำลังสับสนกับข้อ จำกัด ทางเทคนิคกับพื้นฐานที่มากกว่า เหตุผลที่เราไม่มีภาษาคอมพิวเตอร์กราฟิกจำนวนมากคือเราไม่รู้ว่าจะทำอย่างไรให้ดี (และไม่รู้ว่าสามารถทำได้ดีหรือไม่) ฉันรับรู้เกี่ยวกับ LabView และเคยได้ยินเกี่ยวกับการทำสิ่งที่ซับซ้อนอยู่ภายในหรือเปลี่ยนแปลงสิ่งที่เรียบง่าย เราไม่ต้องการคอมพิวเตอร์ที่ทรงพลังกว่านี้ในการออกแบบภาษาดังนั้นลองทำโปรแกรมตัวอย่างในภาษาสมมุติ
David Thornley
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.