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

• ฉันคิดว่าแน่นอนว่าภาษาการเขียนโปรแกรมที่ใช้งานได้จะทันได้ดังนั้นภาษาของฉันจะทำงานได้ ดูเอฟเฟกต์การฝึกฝนด้วยฟังก์ชั่นการโปรแกรม

• ฉันคิดว่า CPUs เร็ว ๆ นี้จะมี hundreads ของคอร์และเธรดจะเป็นนรกในการจัดการ ดังนั้นโมเดลนักแสดงจะต้องแทนที่จะเป็นเธรด ดูErlang - ซอฟต์แวร์สำหรับโลกที่เกิดขึ้นพร้อมกัน

• ผมยังคิดว่า OOP ที่ล้มเหลวในการสื่อสารระหว่างวัตถุที่ถูกสันนิษฐานว่าจะไม่ตรงกัน ดังนั้นฉันคิดว่าเราต้องผ่านข้อความด้วยข้อความที่ไม่เปลี่ยนรูป ส่งและลืม เช่นเดียวกับในรุ่นนักแสดง ดูการเขียนโปรแกรมเชิงวัตถุ: เส้นทางผิด?

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

• ฉันจะออกแบบไลบรารี UI ที่ยอดเยี่ยมพร้อมเค้าโครงที่ประกาศได้เช่นเดียวกับ WPF และ Android แต่ผมอยากจะมีมันเป็นในการเขียนโปรแกรมปฏิกิริยาการทำงาน

ดังนั้นภาษาของฉันจะเหมือนกับการทำงานพร้อมกันใน Erlang แต่ด้วยการพิมพ์ใน Haskell และ GUI framework ใน WPF.NET

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

1. ระบบการพิมพ์

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

//variable declarations
int anInt = 42 //anInt is now irrevocably an integer and assigning another type to it is an error
vartype aVariable = 42 //aVariable is currently an integer, but any type can be assigned to it in the future

//function definitions
int countElements(Collection c)
{
  return c.count();
} 

//c HAS to be a collection, since countElements doesn't make sense otherwise

void addToCollection(Collection& c, vartype v) 
{
  c.append(v)
}

//c is passed by reference here

2. รวบรวมและตีความ

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

3. การปิด

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

4. เชิงวัตถุ

ภาษาควรอนุญาตให้คุณเขียนโค้ดเชิงวัตถุ แต่ควรอนุญาตให้ใช้โค้ดบังคับอย่างง่ายได้เช่นกัน เช่นคุณควรจะเขียนโปรแกรม Hello world เช่นนั้น:

int main(string<> args=null)
{
  printf("hello, world"); 
  return 0;
}

// this code also demonstrates two other features,
// default arguments for functions (not explained further)
// and immutable lists like string<> (see 6. Built-in datatypes)

5. เนมสเปซ

เนมสเปซเป็นสิ่งที่ดี สิ่งเล็ก ๆ น้อย ๆ ควรเข้าไปใน namespace ทั่วโลก แต่ถ้าคุณต้องใส่ข้อมูลในเนมสเปซส่วนกลางคุณสามารถ (ala C ++)

6. ประเภทข้อมูลในตัว

ภาษาจะต้องมีประเภทข้อมูลที่มีอยู่แล้วภายในโครงสร้างต่อไปนี้:

• intประเภทข้อมูลหรือชนิด หากมีเพียงintประเภทเดียวก็ควรมีช่วงไม่ จำกัด หากมีมากกว่านั้นควรมีการถ่ายทอดสัญญาณโดยนัยในรูปแบบที่เล็กที่สุดที่สามารถเก็บผลลัพธ์ของการคำนวณได้โดยไม่ จำกัด ประเภทช่วงที่ใหญ่ที่สุด
• floatชนิดไบนารีในตัวเดียวซึ่งเทียบเท่ากับ IEEE 754double
• listชนิดที่ไม่แน่นอนซึ่งถูกนำมาใช้เป็นรายการเชื่อมโยงเป็นสองเท่าหรือบล็อกของหน่วยความจำต่อเนื่องที่ถือพอยน์เตอร์สำหรับแต่ละองค์ประกอบ
• listชนิดที่ไม่เปลี่ยนรูปที่ทำหน้าที่เหมือนอาร์เรย์ แต่ขนาดไม่สามารถเปลี่ยนแปลงได้หลังจากการสร้าง
• stringประเภทที่เปลี่ยนแปลงไม่ได้และไม่เปลี่ยนรูปโดยค่าเริ่มต้นจะไม่เปลี่ยนรูป
• mapหรือdictประเภทที่มีความไม่แน่นอนและถือกุญแจไม่เปลี่ยนรูปและค่านิยมที่ไม่แน่นอนและ / หรือเปลี่ยนรูป
• ประเภทคอลเลกชันในตัวควรพิมพ์เป็นเนื้อเดียวกันโดยค่าเริ่มต้น แต่สามารถเป็นvartyped ถ้าจำเป็น
• booleanประเภท
• A nullหรือnoneชนิดที่สามารถกำหนดให้กับตัวแปรประเภทใดก็ได้
• setประเภทที่เปลี่ยนแปลงไม่ได้และไม่เปลี่ยนรูป
• decimalประเภทซึ่งดำเนินทศนิยมลอยตัวแปรจุด
• fixedชนิดการดำเนินการว่าจำนวนจุดคงที่

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

7. โทรตามมูลค่าและอ้างอิง

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

8. พอยน์เตอร์

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

9. การประกอบแบบอินไลน์

ในการเชื่อมต่อกับ8ภาษาควรอนุญาตให้ใช้รหัสภาษาแอสเซมบลีไลน์สำหรับสถานการณ์เหล่านั้นในกรณีที่จำเป็น

10. ความปลอดภัย

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

11. พฤติกรรมที่ไม่ได้กำหนด

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

นั่นคือทั้งหมดที่ฉันสามารถคิดได้ในขณะนี้ แต่ฉันจะแก้ไข / อัปเดตโพสต์ตามที่ฉันคิดในอีกหลายสิ่ง

นี่คือลักษณะของภาษาการเขียนโปรแกรมในฝันของฉัน:

• ระบบชนิดสแตติกที่ทรงพลังพร้อมรองรับการพิมพ์บางส่วน
• การพิมพ์แบบไดนามิกที่เป็นตัวเลือก
• ทาวเวอร์ตัวเลข a la Lisp แต่พิมพ์แบบคงที่
• แมโคร a la Lisp
• หลักภาษาหน้าที่การเขียนโปรแกรมพร้อมการสนับสนุนขั้นพื้นฐานสำหรับการเขียนโปรแกรมที่จำเป็น (เช่นตระกูล ML)
• เก็บขยะ
• การอนุมานประเภท
• ต
• ซีแมนทิกส์ขี้เกียจเสริม
• โครงสร้างการควบคุมทั้งหมดจะมีให้ในรูปแบบของฟังก์ชั่นห้องสมุด (สามารถทำได้โดยใช้คุณสมบัติสองอย่างสุดท้าย)
• ไวยากรณ์ขั้นต่ำสุด (ไม่น้อยไปเท่า Lisps แต่เป็นประเภทของ Ioke / Seph)

ฉันจะออกแบบมันให้เหมือนกับ C # แต่ Microsoft ก็เอาชนะฉันได้ :)

^{_{(ยกเว้นหลักสูตรที่เหมืองจะได้รับการพิจารณาน้อยลงและสมัครเล่นมากขึ้น)}}

ฉันไม่คิดมากว่ามันจะถูกรวบรวมหรือตีความดังนั้นฉันไม่จำเป็นต้องพิสูจน์ความถูกต้อง

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

อย่างไรก็ตามฉันอาจจะได้สร้างรูปแบบใหม่แทนการเกาะติดกับไวยากรณ์ C เก่าอย่างที่เป็น C # คำสั่ง switch นั้นน่ากลัวเป็นพิเศษและฉันก็ไม่ชอบ syntax ของนักแสดงด้วย (เป็นวิธีที่ผิด ๆ ) ฉันไม่ได้ทำให้ยุ่งยากมากเกี่ยวกับรายละเอียดของไวยากรณ์แม้ว่าดังนั้นฉันไม่จำเป็นต้องพิสูจน์ในรายละเอียดยกเว้นว่าฉันไม่ต้องการมันเป็น verbose เป็น Visual Basic

คุณต้องการให้ฉันพิสูจน์อะไรอีก

นี่คือรายการคุณสมบัติที่ฉันต้องการ:

เสียงกระเพื่อมเหมือนไวยากรณ์

สไตล์เสียงกระเพื่อม

ข้อดี :

• ไวยากรณ์ที่ขยายได้อย่างง่ายดาย เคยลองใช้วง foreach ใน C หรือไม่? มันไม่ง่ายอย่างแน่นอน (ใจคุณฉันทำไปแล้ว )
• Homoiconicity คุณทำได้ง่ายๆ(eval "your data files")

ข้อเสีย :

• สัญกรณ์ที่ซ้อนกันมักอ่านยาก

ฟังก์ชั่นการเขียนโปรแกรม

สไตล์ Haskell

ข้อดี :

• การทำงานพร้อมกันง่าย ๆ รหัสทั้งหมดเป็นเธรดที่ปลอดภัย

ข้อเสีย :

• ยากที่จะใช้ผลข้างเคียงในโค้ดการทำงานที่บริสุทธิ์แม้ว่า monads จะทำงานได้ดี

การพิมพ์แบบไดนามิกที่แข็งแกร่ง

สไตล์หลาม

ข้อดี :

• การพิมพ์แบบไดนามิกทำให้โค้ดที่อ่านได้สะอาดการพิมพ์ที่แข็งแกร่งสามารถกำจัดข้อผิดพลาดประเภทได้

การใช้งาน :

อนุญาตให้ฟังก์ชั่นโอเวอร์โหลดตามประเภทที่คล้ายกับ CL ของdefgeneric:

(define (+ (a <int>) (b <int>))
  (ints-add a b))

(define (+ (a <string>) (b <string>))
  (string-concat a b))

(define (+ a b)
  (add-generic a b))

รวบรวมและตีความได้

ข้อดี :

• เพิ่มประสิทธิภาพหากคอมไพล์แล้ว (มักเป็นจริงไม่เสมอไป)

ข้อเสีย :

• สามารถ จำกัด คุณสมบัติในภาษาได้ llvm น่าจะได้รับการสนับสนุนที่ดี

การเขียนโปรแกรมระบบ

สไตล์ C

ข้อดี :

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

ข้อเสีย :

• การ จำกัด บทคัดย่อในภาษาการพิมพ์แบบไดนามิกมักไม่เหมาะสม

มาโครที่ถูกสุขลักษณะ (สไตล์ CL และสไตล์ Scheme)

ข้อดี :

• ง่ายต่อการขยายภาษาโดยเฉพาะอย่างยิ่งด้วยไวยากรณ์ Lispy ™
• ฉันเคยพูดแบบนี้มาก่อนใช่มั้ย

ข้อเสีย :

• ไม่มากนักถ้าทำด้วยไวยากรณ์ Lispy ™

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

มีหลายภาษาออกมีที่ฉันคิดว่าสวยดีไอ้ (C # เป็นที่ชื่นชอบปัจจุบันของฉัน) เนื่องจากนี่คือภาษาแฟนตาซีของฉันนี่คือสิ่งที่ฉันต้องการให้มี:

• เอกสาร API อย่างเป็นทางการของ Kick-ass Java API นั้นดีเช่นนี้และ C # /. NET ค่อนข้างดี Ruby / Rails แย่มากที่นี่
• เอกสารทั่วไปอย่างเป็นทางการของ Kick-ass (วิธีใช้, การใช้งานทั่วไป, โค้ดตัวอย่างจำนวนมาก) C # /. Net ดีสำหรับสิ่งนี้
• ชุมชนขนาดใหญ่ของผู้ทำเอกสารบล็อกและแก้ปัญหา StackOverflow เพื่อช่วยฉันให้พ้นจากสถานการณ์ที่ยากลำบาก
• ปลั๊กอิน / ไลบรารี / ส่วนขยายที่ได้รับการสนับสนุนเป็นอย่างดีมีเอกสารที่ดีและมีประสิทธิภาพ (Ruby / Rails มี 'ประสิทธิภาพ' แต่ไม่มีอีกสองอัน)
• มีความเสถียรพอสมควร - ไม่มีการเปลี่ยนแปลงทุกอย่างเพื่อทำลายรหัสที่มีอยู่เป็นประจำทุกปี (ดูที่คุณ Ruby / Rails)
• ไม่เสถียรเกินไป - สามารถปรับให้เข้ากับความก้าวหน้าในการออกแบบภาษา (ดูที่คุณ, c ++)

คำแนะนำของคอมไพเลอร์

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

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

E: ฉันขอขอบคุณความคิดเห็นที่ชี้แจงสิ่งที่ฉันขอหรืออ้างอิงตัวอย่างที่มีอยู่แล้ว

หากต้องการลองแนวคิดใหม่:

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

// a view pattern (or Active Pattern in F#)
default = \def val: !!val.Type val def

// usage of the pattern
greet = \name<(default "world") `and` hasType Str>:
  p "Hello, \{name}!"

(p "Enter your name", .input).greet // (, ) is a sequence expression, returning the last value

นี่คือคำอธิบาย:

default =ชุดจัดเก็บ\def valเริ่มมีฟังก์ชั่นแกงกะหรี่ที่มีสองข้อโต้แย้งval.Typeเป็นเช่นเดียวกับType[val], !!แปรรูปบูลีนและบูลสามารถนำมาใช้เพื่อให้valและdef are after it.

f x= f[x]= x.f .f=f[]

และgreetก็นำมาใช้name<(default "world")และhasType Str>ก็หมายความว่ารูปแบบจะถูกใช้และผูกไว้กับdefault "world" nameรูปแบบเริ่มต้นระบุค่าเริ่มต้น andเป็นอีกรูปแบบหนึ่งที่เชื่อมโยงสองรูปแบบเข้าด้วยกัน defaultรูปแบบที่ไม่สามารถล้มเหลวในขณะที่hasTypeสามารถล้มเหลว ในกรณีนั้นมันจะส่งข้อยกเว้น

ตัวแปรเป็นที่เก็บข้อมูลจริงซึ่งสามารถส่งผ่านตามหน้าที่และตารางจัดเก็บข้อมูลสามารถอ้างอิงสร้างและทำลายเมื่อขอบเขตเปลี่ยนแปลง

แฮชและสิ่งนั้นจะเหมือนใน Lua และ JavaScript

ถ้าฉันจะทำภาษาที่คอมไพล์ฉันจะสร้าง F # สำหรับ Java ด้วยคุณลักษณะที่คล้ายกับ Haskell มันเป็นภาษาที่ใช้งานได้จริงยกเว้นมีคุณสมบัติที่ผสม Quotations และ Comp Exprs เข้าด้วยกันเพื่อให้ได้การเขียนโปรแกรมที่จำเป็นโดยการเขียนบล็อกเหมือน pseudocode

โปรดจำไว้ว่าเฉพาะภาษาที่ฉันรู้จักคือ PHP และจาวาสคริปต์และฉันควรเรียนรู้เพิ่มเติมก่อนการออกแบบภาษา:

ไวยากรณ์: คิดอย่างรอบคอบเกี่ยวกับชื่อฟังก์ชันและลำดับอาร์กิวเมนต์ (เช่นยุ่งน้อยกว่า PHP)

คุณสมบัติ: มีชุดของstringฟังก์ชั่นที่ทำงานกับตัวแปรเป็นชุดของไบต์ แต่ไม่เข้าใจข้อความและชุดของtextฟังก์ชั่นที่เข้าใจการเข้ารหัสจำนวนมากและสามารถทำงานกับ UTF-8 และสตริงมัลติไบต์อื่น ๆ (และมีการเข้ารหัสสติตรวจสอบที่สร้างขึ้นในภาษาด้วยฟังก์ชั่นเช่นtext.isValidEncoding(text, encoding)ที่จะบอกคุณว่าลำดับไบต์มีรูปแบบไม่ถูกต้องและไม่ปลอดภัยที่จะถือว่าเป็นข้อความ

ฉันคิดว่าฉันชอบความคิดของการพิมพ์แบบสแตติกที่แข็งแกร่ง แต่ฉันไม่เคยใช้เลยดังนั้นฉันจึงไม่สามารถพูดได้

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

ถ้าฉันชนะลอตเตอรีและด้วยเหตุผลบางอย่างไม่มีอะไรดีไปกว่านี้ฉันจะเริ่มต้นด้วย Liskell และทำให้มันเป็นภาษาที่เต็มเปี่ยมเมื่อเทียบกับส่วนหน้าของ GHC จากนั้นทำให้ FFI ง่ายขึ้น (และอัตโนมัติ) ดังนั้นฉันจึงสามารถใช้ ไลบรารี C / C ++

ภาษาที่ดีคือภาษาที่:

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

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

• การเชื่อมต่อ C: C เป็นภาษากลางของภาษาโปรแกรมและจำนวนไลบรารีที่พัฒนาใน C นั้นน่าทึ่ง ด้วยการมีส่วนต่อประสานที่ง่าย (เช่น Python) ถึง C ภาษาจะได้รับประโยชน์โดยอัตโนมัติจากไลบรารีทั้งหมดเหล่านั้นและยังช่วยให้สามารถส่งงานหนักที่ไม่สามารถปรับให้เหมาะสมกับภาษาโลหะได้
• กระจาย : ฉันชอบใช้เวลาในการทำเธรดหลายเธรดด้วยรูทีนแบบเบาที่รันไทม์กระจายอยู่บนเธรดขึ้นอยู่กับกิจกรรมของพวกเขา ภาษาดังกล่าวสนับสนุนให้โปรแกรมเมอร์ให้เหตุผลเกี่ยวกับงานและแยกพวกเขาออกจากกัน
• การรวบรวมขยะ : ไม่ต้องพูดอะไรในทุกวันนี้;)
• ไม่เปลี่ยนรูป : ง่ายกว่ามากที่จะให้เหตุผลเกี่ยวกับสิ่งที่ไม่สามารถทำให้กลายพันธุ์ได้ง่ายขึ้นมากที่จะใช้การคำนวณแบบมัลติเธรด / กระจายเช่นกัน (คุณเพียงต้องการซิงโครไนซ์เพื่อจัดการกับอายุการใช้งาน
• Lambdas : ไปกับฟังก์ชั่นชั้นหนึ่งฉันเดา
• การส่งผ่านข้อความ : การเปลี่ยนรูปไม่ได้หมายถึงไม่มี mutex ดังนั้นเราจึงทำตามคำแนะนำของ Tony Hoares
• โมดูล : ค่อนข้างคล้ายกับเนมสเปซ แต่มีการห่อหุ้มที่ดีขึ้น
• Reflexion : การคำนวณแบบกระจายต้องใช้การทำให้เป็นอนุกรมซึ่งควรปล่อยให้คอมไพเลอร์และดีซีเรียลไลเซชันสามารถทำได้ง่ายขึ้นด้วยการสะท้อนกลับบางรูปแบบ
• การพิมพ์ที่แข็งแกร่งคงที่ : ตรวจพบข้อผิดพลาดก่อนหน้านี้อย่างน้อยก็ค่าใช้จ่าย

ในขณะนี้ภาษาที่อยู่ใกล้กับรายการนี้น่าจะเป็น Haskell แต่:

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

สำหรับคำถามแรกของคุณ "คุณจะทำอย่างไร" - คำตอบสั้น ๆ ฉันจะไม่ทำ ฉันมีทฤษฎี parser / compiler ไม่เพียงพอที่จะดึงสิ่งนั้นออก แต่ฉันได้เขียนโปรแกรมมา 25 ปีแล้วฉันจึงมีความคิดและความคิดเห็นที่จะแบ่งปัน

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

อนุญาตให้ฉันสาธิต สมมุติว่าบ้านคลาสมีคุณสมบัติเป็นประตู

var door = house.Door;

ตอนนี้คุณมีตัวแปรโลคัลที่อ้างอิงถึงอินสแตนซ์ประตู

แต่ลองคิดดูสิว่าเกิดอะไรขึ้น: คุณแค่ดึงประตูออกจากบ้านและตอนนี้คุณมีความสุขมากที่ได้ผ่านประตูไปและรหัสที่เหลือของคุณก็ไม่รู้ความจริงที่ว่าประตูนี้ติดอยู่กับบ้าน

สำหรับฉันนี่เป็นความผิดขั้นพื้นฐาน

และใช่ฉันรู้ว่านี่คือ "ง่าย" แก้ไขในแต่ละกรณี - ในกรณีนี้โดยการรักษากลับอ้างอิงจากทุกประตูไปที่บ้านมันติดอยู่ในปัจจุบัน หลักสูตรนี้เปิดแบบจำลองของคุณไปสู่ข้อผิดพลาดเนื่องจากตอนนี้เป็นหน้าที่ของคุณในการดูแลการอ้างอิงย้อนกลับสองรายการอย่างถูกต้องดังนั้นคุณจึงสร้างคุณสมบัติ House.Doors และ Door.House เป็นส่วนตัวและคุณเพิ่มวิธีการเช่น House.AddDoor (), House.RemoveDoor ( ), Door.SetHouse () ฯลฯ และวางสายทั้งหมดแล้วทดสอบหน่วยเพื่อให้แน่ใจว่าใช้งานได้จริง

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

ปัญหาคือตัวชี้ ภาษา OO ทุกภาษาที่ฉันเห็นมีอยู่จริงจากการที่การอ้างอิงวัตถุเป็นตัวชี้จริง ๆ เพราะนั่นคือสิ่งที่คอมพิวเตอร์ใช้

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

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

ฉันไม่ทราบว่าไวยากรณ์สำหรับภาษานั้นจะมีลักษณะเป็นอย่างไรหรือว่าจะสามารถแสดงข้อความได้หรือไม่ (ฉันสงสัยว่าภาษาดังกล่าวจะต้องเป็นกราฟิกอย่างไร ... )

ฉันอยากจะเห็นรัฐอุบัติเหตุทุกรูปแบบถูกกำจัดไป

ตัวอย่างเช่นในการพัฒนาเว็บเราใช้เวลาในการจัดทำข้อมูลจากฐานข้อมูลเป็นโมเดลธุรกิจเป็นมุมมองสำหรับงานนำเสนอ ... จากนั้นข้อมูลบางส่วนจะถูกนำเสนอในรูปแบบซึ่งเป็นการเปลี่ยนแปลงอีกครั้งหนึ่งจริงๆ .. และสถานะกลับมาจากแบบฟอร์มโพสต์จากนั้นเราปรับรูปร่างข้อมูลและฉายกลับไปยังมุมมองแบบจำลองเช่นตัวประสานแบบดูและแบบอื่น ๆ ... จากนั้นเราจะฉายจากมุมมองแบบจำลองกลับสู่ธุรกิจ - model ... จากนั้นเราจะใช้ mappers เชิงวัตถุ (หรืองาน grunt) เพื่อแปลงข้อมูลจาก view-model และฉายมันไปยังฐานข้อมูลเชิงสัมพันธ์ ...

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

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

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

อีกครั้งฉันไม่รู้ด้วยซ้ำว่าสิ่งนี้สามารถทำได้ด้วย IDE ดั้งเดิมหรือถ้าต้องการอินเทอร์เฟซชนิดใหม่ทั้งหมด

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

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

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

ขอให้โชคดีกับสิ่งนั้น

มันอาจจะเป็นภาษากระบวนทัศน์ที่หลากหลายสนับสนุนดังต่อไปนี้:

• การโปรแกรมเชิงโครงสร้าง / ขั้นตอน
• การเขียนโปรแกรมเชิงวัตถุ
• ฟังก์ชั่นการเขียนโปรแกรม

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

ฉันจะใช้โมเดล Python กับบล็อกที่เยื้องเพื่อทำเครื่องหมายบล็อกรหัส มันเป็น clen และอ่านดีมาก

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

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

ลองกลับไปคัดลอกจาก Python ;-) ฉันชอบที่จะมีวิธีการโต้แย้งที่เป็นทางเลือกดังนั้นฉันอาจจะมีมัน Python ไม่สนับสนุนโพรซีเดอร์ในการโอเวอร์โหลดฉันต้องการมัน

ลองดูที่คลาสฉันจะแบ่งมรดกหลาย ๆ เพื่อง่ายต่อการละเมิด ฉันจะใช้ขอบเขตส่วนตัวและคล้ายกันและฉันอาจจะใช้วิธีการที่จะทำใน C ++ ฉันจะมีคลาสนามธรรมและอินเทอร์เฟซ ฉันไม่เชื่อว่า Python มีสิ่งนั้น

มันจะสนับสนุนคลาสในความเป็นจริงฉันต้องการภาษาเชิงวัตถุที่ทรงพลังมาก

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

มันจะมีการสนับสนุน Unicode ในตัว วันนี้ความเป็นสากลมีความสำคัญมาก

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

ในที่สุดมันจะมีห้องสมุดมาตรฐานที่ดี

ว้าวเพิ่งรู้ว่าฉันรักหลามมากแค่ไหน

ก่อนอื่นฉันจะซื้อหนังสือสองสามเล่มเกี่ยวกับคอมไพเลอร์มาตรฐานสองสามเล่มและเรียนเป็นสองภาษาและคอมไพเลอร์ ฉันมีส่วนร่วมPEPและเยี่ยมชมการประชุมคณะกรรมการมาตรฐาน C ++ ฉันมีส่วนร่วมในการรวบรวมคอมไพเลอร์ที่ฉันใช้หวังว่าทั้งคุณสมบัติและข้อบกพร่อง

จากนั้นฉันจะกลับไปดูรายการสยองขวัญที่ฉันคิดขึ้นตอนนี้ซึ่งเป็นทิศทางที่ฉันจะใช้ภาษาถ้าฉันเริ่มตอนนี้:

• ฟังก์ชั่นเพราะตอนนี้ฉันยังไม่มีความเชี่ยวชาญในภาษาที่ใช้งานได้และทำให้เป็นวิธีที่ดีในการเรียนรู้ ในกรณีที่ไม่ปฏิบัติตามโดยตรง: ทุกอย่างที่เป็นค่าคงที่
• ฉันจะเติมด้วยการอนุมาน Type ให้มากที่สุดเท่าที่จะทำได้ แต่มีตัวเลือกให้ระบุอินเทอร์เฟซอย่างชัดเจน ไม่แน่ใจเกี่ยวกับประเภทอื่น สิ่งนี้จะเพิ่มขึ้นเป็นสองเท่าเมื่อฟังก์ชันทั้งหมดเป็นค่าทั่วไป
• ขณะที่คุณอาจจะเดาได้ด้วยการเชื่อมต่อ ; นั่นคือด้วยประเภทที่ให้สัญญาในการดำเนินการที่มีอยู่เท่านั้น
• การพูดว่าภาษานั้นถูกพิมพ์ออกมาอย่างรุนแรงหรืออ่อนแออย่างมากนั้นก็ไม่มีความหมายในกรณีนี้เท่าที่ฉันจะบอกได้ ฉันจะเรียกว่าพิมพ์มั่นเป็นสิ่งที่ไม่เคยเปลี่ยนสิ่งที่พวกเขาใช้อินเตอร์เฟซ
• มันจะมีการออกแบบจำนวนมากโดยการสนับสนุนสัญญา อีกครั้งเท่าที่ฉันสามารถทำได้: เงื่อนไขและ postconditions เป็นสิ่งที่จำเป็น ฉันไม่รู้ว่าค่าคงที่สำคัญสำหรับการเขียนโปรแกรมการทำงาน
• ในขณะที่ฉันอยู่ที่นี่ฉันจะดูภาษาที่คุณสามารถพิสูจน์ความถูกต้องอย่างเป็นทางการและดูว่าฉันสามารถรับอะไรจากที่นั่น
• ฉันจะออกไปและเขียนห้องสมุดทดสอบที่ยอดเยี่ยม แม้ในกรณีที่ฉันไม่ได้ทำให้มันยอดเยี่ยมอย่างน้อยฉันก็จะใช้เวลากับมันอย่างมากเพราะฉันคิดว่ามันเป็นสิ่งที่ทุกภาษาควรมี
• สำหรับไวยากรณ์ภาษานั้นอาจมีช่องว่างที่สำคัญและดูเหมือน Pythonมากหรือจะเป็นพื้นฐานของ Lojbanและแบ่งปันไวยากรณ์และคำศัพท์จำนวนมาก ในกรณีแรกฉันจะทำให้ดีที่สุดเพื่อให้ไวยากรณ์ใกล้เคียงกับ CFG มากที่สุด
• ฉันจะไม่สนใจว่าคนที่ใช้ภาษานี้จะรวบรวมมันไว้ล่วงหน้า JIT มันแปลมันสวดมนต์ที่ค่ายหรือจ่ายให้เด็ก ๆ วิทยาลัยเพื่อดำเนินการให้พวกเขา การใช้งานของฉันเองอาจเริ่มจากการเป็นล่ามหรือคอมไพเลอร์ C และในที่สุดก็ย้ายไปที่ JITter

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

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

• #langคำสั่งpre-processor ใช้เพื่อแจ้ง pre-processor ของภาษามนุษย์ที่ใช้สำหรับการเขียนโปรแกรม ตัวอย่างเช่น#lang arจะอนุญาตให้ใช้คำว่าفئةแทนclass, عرفแทนdef, และอื่น ๆ คำหลักเฉพาะภาษาที่มนุษย์จะกำหนดไว้ในไฟล์พรีโปรเซสเซอร์
• ตัวประมวลผลล่วงหน้าจะลบคำหลักที่เป็นตัวเลือกซึ่งมีวัตถุประสงค์เพื่อเพิ่มความชัดเจนให้กับโค้ด ยกตัวอย่างเช่นมันจะเอา "ประกอบด้วย" ในการclass MyClass is composed of {ที่จะเป็นclass MyClass {และลบ "เป็น" ในการที่จะกลายเป็นdef MyMethod(x: Int) as { def MyMethod(x: Int) {ในภาษา (คน) บางภาษาสิ่งนี้จะทำให้เข้าใจง่ายขึ้นโดยเฉพาะอย่างยิ่งสำหรับนักเรียน
• คอมไพเลอร์จะอนุญาตให้ใช้สัญกรณ์คำนำหน้าสำหรับการเข้าถึงคุณสมบัติ สิ่งนี้อาจไม่สมเหตุสมผลสำหรับผู้พูดภาษาละตินส่วนใหญ่ แต่สำหรับภาษาอื่นบางภาษามันสมเหตุสมผลดี ตัวอย่างเช่นการเข้าถึงคุณสมบัติในภาษาอาหรับโดยปกติจะเป็นคำนำหน้าเช่นเดียวกับในاعرض طول اسم محمدซึ่งเทียบเท่ากับprint(length(name(Mohammad)))ในการเขียนโปรแกรมภาษาอังกฤษ (วงเล็บคือเพื่อความชัดเจน)

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