ภาษาโปรแกรม Racket
(racket-lang.org)- Racket เป็นภาษาที่พัฒนาเต็มที่โดยมี การเขียนโปรแกรมเชิงภาษา เป็นแกนกลาง และจัดการทั้งการพัฒนาแอปพลิเคชันทั่วไปกับการสร้างภาษาใหม่ภายในระบบนิเวศเดียวกัน
- แกนสำคัญคือ macro และ
#langซึ่งทำให้สามารถสร้างไวยากรณ์ใหม่, ภาษาเฉพาะโดเมน, และไวยากรณ์ผิวหน้าที่มีอยู่เดิมในรูปแบบไลบรารีและใช้งานในระดับโมดูลได้ - ไลบรารีมาตรฐาน ที่ครอบคลุมตั้งแต่เว็บเซิร์ฟเวอร์, ฐานข้อมูล, คณิตศาสตร์และสถิติ, GUI ไปจนถึงการจำลองทางวิทยาศาสตร์ รวมถึงแพ็กเกจนับพัน ช่วยขยายขอบเขตการพัฒนาแบบ general-purpose
- มี Typed Racket, contracts, ระบบอ็อบเจ็กต์, และ DrRacket IDE มาให้พร้อม ทำให้สามารถผสมผสานโค้ดเชิงฟังก์ชันกับองค์ประกอบเชิงวัตถุและ gradual typing ได้ตามต้องการ
- Racket ไม่ใช่แค่ภาษาในสาย Lisp เท่านั้น แต่ใกล้เคียงกับสภาพแวดล้อมการพัฒนาที่มุ่งให้สร้างภาษาที่เหมาะกับแต่ละโดเมนปัญหา พร้อมเชื่อมต่อการรัน, การแก้ไข, และการรองรับจากเครื่องมือต่าง ๆ
Racket สำหรับการเขียนโปรแกรมเชิงภาษา
- Racket เป็นภาษาโปรแกรมที่นำเสนอทั้ง “Racket, the Programming Language” และ “Racket, the Language-Oriented Programming Language” ไปพร้อมกัน
- สามารถใช้งาน Racket version 9.2 ได้แล้ว
- เป็นผลิตภัณฑ์ที่พัฒนาเต็มที่และรองรับ การเขียนโปรแกรมกราฟิกข้ามแพลตฟอร์ม บน Windows, macOS, Linux มาตั้งแต่ระยะแรก
- ความสามารถด้านการพัฒนาพื้นฐานครอบคลุมตั้งแต่การจัดการแพ็กเกจ, GUI, ไบนารีแบบสแตนด์อโลน, ไปจนถึงอินเทอร์เฟซภายนอก
ขอบเขตการพัฒนาแอปพลิเคชันทั่วไป
- Racket มี ชุดไลบรารี ที่ครอบคลุมตั้งแต่แอปพลิเคชันเว็บเซิร์ฟเวอร์ไปจนถึงคณิตศาสตร์และซอฟต์แวร์จำลองทางวิทยาศาสตร์
- เอกสารหลักและขอบเขตของไลบรารีมีดังนี้
- ชุดเครื่องมือ GUI ข้ามแพลตฟอร์ม และ เว็บเซิร์ฟเวอร์ รวมอยู่ในระบบนิเวศหลัก
- แพ็กเกจเพิ่มเติมนับพันรายการ สามารถติดตั้งได้ด้วยคำสั่งเดียว
- ตัวอย่างเช่น 3D graphics, Bluetooth socket connector, color maps, data structures, educational software, games, quantum-random number generator, scientific simulations, web script testing
- ตัวอย่าง
#lang racket/guiแสดงการสร้างเกมทายตัวเลขขนาดเล็กด้วย dialect สำหรับ GUI และใช้งานความสามารถของภาษาหลายส่วนร่วมกัน
ภาษาที่ขยายได้ด้วย macro
- โปรแกรมเมอร์ Racket สามารถนิยามลูปของตนเองและไวยากรณ์ใหม่ได้ด้วย macro
- ไวยากรณ์ใหม่ถูกเพิ่มเข้ามาได้เหมือนกับ procedure, method, หรือ class โดยเพียงสร้างกฎที่เขียนไวยากรณ์แบบกำหนดเองให้กลับมาเป็น expression หรือ definition ของ Racket
- macro ขนาดเล็กช่วยลด โค้ดซ้ำแบบแพตเทิร์นเดิม ที่จัดการด้วยวิธีอื่นได้ยาก
- สามารถนิยามไวยากรณ์
time-itเพื่อวัดเวลาการทำงานของงานได้ - สามารถหลีกเลี่ยงการใช้
lambdaแบบซ้ำ ๆ ได้ - macro ถูก export จากโมดูลได้เหมือนฟังก์ชันทั่วไป
- สามารถนิยามไวยากรณ์
- ระบบ macro ทั้งหมดสามารถสร้างโครงสร้างที่ macro หลายตัวทำงานร่วมกันได้
- แม้ Racket จะเป็นภาษาฟังก์ชัน แต่ก็มีภาษาย่อยสำหรับ classes and objects, mixins and traits มาตั้งแต่ต้น
- ระบบคลาสที่คล้าย Java ถูกสร้างเป็น ไลบรารีที่อิง macro จึงทำงานได้โดยไม่ต้องมีการรองรับแยกต่างหากจากแกนภาษาหลัก
#lang และภาษาเฉพาะโดเมน
- Racket มุ่งเป็น ภาษาสำหรับสร้างภาษา เพื่อให้โปรแกรมเมอร์สามารถเขียนแต่ละโมดูลด้วยภาษาที่เหมาะสมได้
- ตัวอย่าง
#lang typed/racketใช้ union type ของStringและNumber, occurrence typing, และการกรองลิสต์ - ตัวอย่าง
#lang scribble/baseเป็นภาษาสำหรับสร้างเอกสาร PDF หรือ HTML - ตัวอย่าง
#lang datalogใช้ไวยากรณ์ Datalog เพื่อกำหนดและสืบค้นความสัมพันธ์parentและancestor - ภาษาใหม่สามารถสร้างในหน้าต่าง IDE หนึ่ง แล้วรันโมดูลของภาษานั้นในอีกหน้าต่าง IDE ได้ โดยไม่ต้องมีการตั้งค่า, ไฟล์โปรเจ็กต์, หรือเครื่องมือภายนอก
- ผู้ใช้ Racket มักใช้ไวยากรณ์วงเล็บเป็นหลัก แต่ก็สามารถสร้าง ไวยากรณ์ผิวหน้าที่มีอยู่เดิม ซึ่งต้องใช้เครื่องหมายจุลภาคและวงเล็บปีกกาแบบ Datalog ได้เช่นกัน
- เมื่อใช้ parsing packages ก็สามารถแมปไวยากรณ์ใด ๆ เข้ากับภาษาที่อิงวงเล็บ และคอมไพล์เป็น Racket ปกติผ่านระบบ macro ของ Racket ได้
DrRacket และระบบนิเวศการพัฒนา
- Racket มี IDE ของตัวเองคือ DrRacket และมีฟีเจอร์วาดลูกศรไปยังตำแหน่งที่นิยามเมื่อเอาเมาส์ไปชี้บน identifier
- แม้จะใช้ภาษาอื่นทางเลือกอย่าง Typed Racket ก็ยังใช้ความสามารถด้านการแก้ไขของ DrRacket ได้
- macro ของ Racket สามารถบันทึกและส่งต่อ ข้อมูลต้นฉบับของซอร์ส ได้เพียงพอ แม้ใน macro ที่ซับซ้อนหรือ macro ที่สร้างภาษาใหม่ ทำให้ DrRacket ทำงานได้ราวกับเข้าใจความสามารถของภาษาใหม่เหล่านั้น
- การรองรับด้านการพัฒนาหลักมีดังนี้
- ทรัพยากรในระบบนิเวศประกอบด้วยดาวน์โหลด, ซอร์สโค้ด, รายงานบั๊ก, nightly snapshot builds, และคลังแพ็กเกจ
- สื่อการเรียนรู้และเอกสารประกอบมี Quick Introduction, The Racket Guide, The Racket Reference, All Documentation
- ช่องทางชุมชนมี Discourse, Discord, Slack, Reddit, mailing lists, Mastodon, Twitter, Blog, Wiki, YouTube และยังมีเอกสาร Team กับ Contributing ให้ใช้งานด้วย
1 ความคิดเห็น
ความเห็นใน Hacker News
ยินดีที่ได้เห็น Racket ขึ้นมาหน้าแรก ตั้งแต่ปี 1982 งานเขียนโปรแกรมเพื่อการวิจัยที่ผมใช้หลัก ๆ คือ Common Lisp แต่ช่วงนี้กลับหยิบ Racket มาใช้บ่อยกว่า
มีหลายอย่างใน Racket ที่ผมไม่ชอบ ซึ่งก็คือแทบทุกอย่างยกเว้นคอมไพเลอร์ ระบบจัดการแพ็กเกจ GUI IDE การผูกคีย์กับ Emacs และความเป็นภาษาที่เขียนแล้วสนุก
ผมไม่ได้สนใจระบบนิเวศฝั่งงานวิจัยภาษาโปรแกรมนัก นั่นน่าจะเป็นส่วนที่อาจารย์วิทยาการคอมพิวเตอร์ที่นำโครงการให้ความสำคัญมากที่สุด แต่ก็ยังอยากให้พวกเขาไปได้ดี
เลยรู้สึกเหมือนตัวเองแอบอาศัยโปรเจกต์ Racket อยู่ คือสนุกกับแค่ส่วนเล็ก ๆ ที่ชอบ แล้วเมินที่เหลือ แทบไม่ได้มีส่วนช่วยอะไรเลย ยกเว้นหนังสือ Racket เล่มเล็ก ๆ ที่ผมเขียน อาจพอนับเป็นข้อยกเว้นได้
ฟีเจอร์พวกนี้มีประโยชน์และสำคัญมาก ผมชอบ Lisp แต่ในงานก็จะใช้ภาษาเฉพาะตอนที่มันเป็นเครื่องมือที่เหมาะที่สุดกับงานนั้น ฟีเจอร์เหล่านี้ทำให้ Racket เป็น Lisp เดียวที่ผมพอจะให้เหตุผลในการใช้งานจริงได้
ด้วยชุมชน เครื่องมือ และสื่อการเรียนรู้ Racket จึงเป็นภาษาที่ผมรู้สึกแนะนำคนอื่นได้ง่ายในเชิงส่วนตัว ผมก็ใช้ทั้ง CL และ Clojure มามากและมีสิ่งที่ชอบในนั้น แต่แต่ละตัวมีข้อเสียใหญ่พอที่ผมไม่ค่อยอยากแนะนำให้คนอื่น
ผมเองก็ไม่ค่อยเข้ากับฝั่งวิจัยของภาษา หรือฟีเจอร์
langและก็ไม่ค่อยชอบ HtDP เท่าไร แต่ผมมองว่านั่นเป็นแค่โปรเจกต์ที่ผมไม่สนใจซึ่งสร้างขึ้นด้วยภาษาที่ผมชอบ ไม่ใช่ข้อเสียของตัวภาษาเอง เพราะแทบไม่ต้องไปเจอมันจริง ๆแค่นี้ก็นับว่าเป็น การมีส่วนร่วมที่ยอดเยี่ยม แล้ว :)
ตัวภาษาเองก็มีฟีเจอร์เมตาโปรแกรมมิง แต่ภาษาสมัยใหม่เดี๋ยวนี้ก็มีเมตาโปรแกรมมิงกันแทบหมด
จากประสบการณ์ของผมในชุมชน ส่วนใหญ่ก็เป็นคนที่คุยเรื่องปัญหาใช้งานจริง
แม้ Racket จะถูกใช้ในงานวิจัยภาษาโปรแกรมหรืองานวิจัยอื่น ๆ จนมีการอ้างถึงในบทความวิชาการและงานประชุม แต่ก็ไม่ได้ครอบงำวงสนทนา
เช่น: https://racket.discourse.group/t/levin-tree-search-with-cont...
เพียงแต่ Clojure มีชุมชนที่ใหญ่และแข็งแรงกว่า แต่ก็แลกมากับการใช้ JVM ที่ทำให้การตั้งค่ายุ่งยากขึ้นอีกนิด และมีรายละเอียดจุกจิกให้ต้องใส่ใจมากกว่าเล็กน้อย
Racket เป็น ภาษาที่ใช้งานได้จริงมาก ถ้ามันดูเหมือนของเฉพาะทางเชิงวิชาการ ลองดูว่า Bogdan Popa ใช้ Racket ทำอะไรบ้าง: https://defn.io/
ส่วนตัวผมจะใช้ Racket ถ้าต้องการไบนารีที่มี native GUI และมันก็ค่อนข้างดีสำหรับการพาร์สพวก JSON, XML, รูปแบบไฟล์ข้อความต่าง ๆ
หนังสือที่อ่านควบคู่กันอย่าง How to Design Programs, https://htdp.org/2023-8-14/Book/index.html ก็ดีเหมือนกัน มันไม่ใช่หนังสือสอน Racket แบบตรง ๆ แต่ใช้ภาษาเพื่อการศึกษาไม่กี่ตัวที่สร้างด้วย Racket และมีแนวคิดที่คุ้มค่าจะกลับมาทบทวนเป็นครั้งคราว
ระบบแมโครอาจดูแปลกสำหรับคนที่มาจาก CL หรือที่คล้ายกัน แต่พอคุ้นแล้ว ผมกลับรู้สึกว่าทำเมตาโปรแกรมมิงได้โดยยังรักษาสติไว้ได้ค่อนข้างง่าย
มีแหล่งข้อมูลที่มีประโยชน์อีกสองสามแห่ง:
https://www.greghendershott.com/fear-of-macros/
https://beautifulracket.com/
ผมชอบภาษา Racket มากจริงๆ แต่ workflow ที่ถูกบังคับให้ใช้กลับเป็นสิ่งที่ยอมรับได้ยาก เวลาเขียนโค้ดด้วย Python ผมจะเขียนใน editor แล้วรันจาก shell
แต่กับ Racket มันทำแบบนั้นได้ไม่ค่อยดีเพราะเวลาเริ่มต้นนานเกินไป เลยมีคนบอกว่าควรโต้ตอบผ่าน virtual machine ที่รันค้างไว้กับ REPL แทน
แต่ถ้าทำแบบนั้น โค้ดที่กำลังทำอยู่ก็จะไม่ได้เริ่มจาก "สถานะสะอาด" แต่เริ่มจากสถานะที่ virtual machine มีอยู่ ณ ตอนนั้น สำหรับอะไรอย่าง Jupyter notebook นี่เป็น workflow ที่ยอดเยี่ยม แต่ผมคิดว่ามันไม่ค่อยเหมาะกับโปรแกรมขนาดใหญ่
การใช้
#langเป็นracket/baseแทนracketก็สร้างความต่างได้มากเช่นกัน รายละเอียดอยู่ที่ https://docs.racket-lang.org/style/Language_and_Performance....เรื่องที่บอกว่าไม่ได้เริ่มจาก “สถานะสะอาด” นั้น ดูจะใกล้กับ REPL แบบ Common Lisp มากกว่าจะเป็น Racket ใน Racket ปกติเวลาจะโหลดไฟล์หรือโมดูลใหม่ มักต้องรีสตาร์ต Racket จึงได้สภาพแวดล้อมใหม่ คนจำนวนมากบ่นเรื่องนี้ แต่ผมกลับชอบแนวทางสถานะสะอาดของ Racket มากกว่า CL
https://docs.racket-lang.org/drracket/drracket-files.html#(p...
และน่าจะปฏิเสธข้อเสนอการกู้คืนได้ด้วย
“เมื่อ DrRacket เริ่มทำงานครั้งแรก มันจะตรวจสอบว่ามีไฟล์สำรองที่ยังคงอยู่หรือไม่ และถ้ามีก็จะเสนอให้กู้คืนไฟล์สำรอง”
ตอนเรียนที่ University of British Columbia วิชา intro computer science สอนด้วย Racket ผมคิดว่ามันเป็นภาษาที่ยอดเยี่ยม และแม้นักศึกษาที่เคยมีประสบการณ์เขียนโปรแกรมมาก่อน ส่วนใหญ่ก็แทบไม่เคยแตะ Lisp มาก่อนเลย จึงทำให้ทุกคนอยู่บน เส้นเริ่มต้นเดียวกัน
ไลบรารีที่ช่วยให้สร้างเกมง่ายๆ หรือ visualization ได้สะดวกก็น่าประทับใจมาก
ตอนเป็น TA ผมเจอนักศึกษาปี 2 จำนวนไม่น้อยที่ยังทำ for loop ไม่เป็น และตามอัลกอริทึมพื้นฐานไม่ทันอย่างมาก
ผมเพิ่งเริ่มเห็นคุณค่าของภาษาเชิงฟังก์ชันอย่างลึกซึ้งจริงๆ ก็หลังจากเรียนวิชาทฤษฎีการคำนวณตอนปี 4
ผมไม่รู้ว่าจะรวม “ภาษา” ทั้งหมดของ Racket เหล่านี้เข้ามาในแอปเดียวกันอย่างไร เห็นภาษาพวก
typed/racket,racket/gui,scribble/baseแต่ถ้าจะสร้างแอป GUI ด้วยโค้ดที่มี type พร้อมทั้งสร้าง PDF ไปด้วย ควรทำอย่างไรก็ยังนึกภาพไม่ออกผมลองทำตาม tutorial ของ Racket มาหลายรอบแล้ว แต่ก็ยังสับสนว่าจะผูก “ภาษา” ที่ดูไม่เกี่ยวกันเหล่านี้เข้าด้วยกันอย่างไร
โดยส่วนตัวผมรู้สึกว่าแต่ละบทใน tutorial อธิบายแต่ “ภาษา” ที่ไม่เกี่ยวข้องกัน และไม่เคยแสดงให้เห็นเลยว่ามันทำงานร่วมกันอย่างไร บทหนึ่งพูดถึง web server แต่ไม่พูดถึง class system ส่วนอีกบทหนึ่งก็พูดถึงอีก “ภาษา” ที่รองรับ class แต่ไม่ได้เขียน web server ในนั้น
#langว่าเป็น compiler directive ชนิดหนึ่งที่มีผลกับขอบเขตของไฟล์นั้นก็ได้ จริงๆ แล้วมันทำได้มากกว่านั้นมาก แต่ใช้เป็นจุดเริ่มต้นก็โอเค ถ้าอยากเพิ่ม type ให้แอป กลยุทธ์ที่ดีคือค่อยๆ ทำทีละไฟล์นอกจากบรรทัด
#langแล้ว คุณยัง import ไลบรารีด้วยrequireได้ ดังนั้นจะใส่ทั้งโค้ด GUI และโค้ด web server ไว้ในไฟล์เดียวกันก็ได้ และ#langเองก็ไม่ได้จำกัดว่าต้องมีแค่ภาษาเดียวเสมอไป ถ้าไม่ชนกันก็เพิ่มต่อในบรรทัดนั้นได้"racket"และถ้าสนใจ type มาก ก็อาจมีส่วนใหญ่พอสมควรที่เป็น"typed/racket"จริงอยู่ที่ทุกภาษามีฐานร่วมกันและทำงานร่วมกันได้ในระดับหนึ่ง แต่แทบไม่มีโอกาสเลยที่คุณจะแบ่งโปรแกรมออกเป็นห้าส่วนเท่าๆ กันแล้วใช้คนละภาษากับแต่ละส่วน เอกสารน่าจะเขียนด้วย scribble
การใช้ภาษาต่างกันอาจทำให้มี programming model ที่ต่างกันโดยพื้นฐาน และนี่ก็เป็นสิ่งที่ทำให้การพัฒนาอย่าง Typed Racket เป็นไปได้ แต่ไม่ควรกลายเป็นอุปสรรคต่อการเริ่มต้น
สรุปคือใช้ Racket ไปก่อนก็พอ ถ้าคุณรู้สึกว่าจำเป็นต้องมีความสามารถหรือรูปแบบการเขียนโปรแกรมแบบอื่นจริงๆ ค่อยไปดูตอนนั้นว่ามีภาษาที่มีให้ใช้อยู่แล้วหรือไม่ แน่นอนว่านี่เป็นเพียงความเห็นของผม
เว็บไซต์นี้อย่าง Hacker News เขียนด้วย Arc และรันอยู่บน Racket: https://en.wikipedia.org/wiki/Arc_(programming_language)
ปัญหาใหญ่ที่สุดของ Racket ไม่ใช่ตัวภาษาหรือ ecosystem: https://news.ycombinator.com/item?id=27531508
ต่อให้จะรับเรื่องในลิงก์นั้นแบบตรงตัวทั้งหมด และถือว่า Felleisen มีพฤติกรรมแย่แบบ Torvalds ในปฏิสัมพันธ์ส่วนตัวบางครั้งจริง งานของเขา รวมถึง How To Design Programs ก็ส่งผลเชิงบวกอย่างมากต่อชีวิตฉันและชีวิตของคนอื่น ๆ ดังนั้นฉันคงไม่บอกให้คนเลิกใช้สิ่งเหล่านั้น
ในชุมชนก็มีพวก “เนิร์ดประหลาด” ที่มีความเห็นแรง ๆ อยู่ด้วย จึงยิ่งดูมีตัวตนเด่นและอาจน่ารำคาญกว่าเดิม แต่พื้นที่ทางสังคมจำนวนมากที่ไม่มีแรงจูงใจด้านเงินมาคอยคุมระเบียบก็มักจะเป็นแบบนี้อยู่แล้ว
Racket เป็นภาษาที่ฉันชอบที่สุด เร็ว ใช้งานได้จริง มีรากฐานที่แข็งแรง และ โมเดล concurrency ก็ดีมากด้วย โดยอิงจากแนวคิดที่ยืมมาจาก Concurrent ML แล้วนำมาขยายต่อ
ระบบเอกสารก็ยอดเยี่ยมและผสานเข้ากับ ecosystem ของแพ็กเกจ ทำให้แพ็กเกจส่วนใหญ่มีเอกสารคุณภาพสูงที่อ้างอิงถึงกันได้ ความเข้ากันได้ย้อนหลัง ก็ยอดเยี่ยมเช่นกัน ซึ่งฉันมองว่าดีกว่า Python ที่ใช้ในงานหลักตอนนี้มาก
เพราะอย่างนั้น เวลามีคนบอกว่า Racket เป็นเชิงวิชาการเกินไปหรือไม่ practical พอ ฉันมักรู้สึกว่าคนเหล่านั้นยังลงลึกไม่พอ หรือไม่ก็เคยเจอแค่ภาษาเพื่อการศึกษามาก่อนตอนเป็นนักเรียน
แน่นอนว่ามันไม่ได้สมบูรณ์แบบ ปัญหาคือชุมชนยังเล็ก การใช้หน่วยความจำพื้นฐานของ runtime สูง และถ้าจะทำ parallel processing ก็ต้องเปิด Racket VM แยกสำหรับแต่ละ system thread เป็นต้น ถึงอย่างนั้น เรื่องพวกนี้ก็น่าจะดีขึ้นเมื่อเวลาผ่านไป
สิ่งที่ฉันทำด้วย Racket ในช่วงไม่กี่ปีที่ผ่านมา ได้แก่ เว็บไซต์อีคอมเมิร์ซ[1], แอปแจ้งเตือน native สำหรับ macOS/iOS ที่ขึ้น App Store[2, 3, 4], เดสก์ท็อปไคลเอนต์ข้ามแพลตฟอร์มสำหรับ Apache Kafka[5, 6, 7], และ
#langสำหรับ Lua[8] นอกจากนี้ยังมีอย่างอื่นอีก[9][10][11] ฉันคิดว่าสิ่งเหล่านี้ค่อนข้าง practical มาก[1]: https://defn.io/2019/08/20/racket-ecommerce/
[2]: https://defn.io/2020/01/02/ann-remember/
[3]: https://defn.io/2024/04/09/ann-remember-for-ios/
[4]: https://github.com/bogdanp/remember
[5]: https://defn.io/2022/11/20/ann-franz/
[6]: https://defn.io/2023/10/15/ann-franz-for-windows/
[7]: https://defn.io/2023/08/10/ann-franz-source-available/
[8]: https://defn.io/2022/11/12/ann-racket-lua/
[9]: https://docs.racket-lang.org/http-easy/index.html
[10]: https://docs.racket-lang.org/deta/index.html
[11]: https://docs.racket-lang.org/gui-easy/index.html
เขายังแอ็กทีฟมากในฟอรัมชุมชนและให้คำตอบที่เป็นประโยชน์ไว้มากจริง ๆ
ฉันคิดว่าเขาเป็นฮีโร่ที่ไม่ค่อยมีใครพูดถึงของภาษานี้ เลยอยากเอ่ยถึงไว้เป็นพิเศษ คุณพูดได้เลยว่าไลบรารีของเขากำลังขับเคลื่อนโค้ดที่ทำให้ชีวิตของผู้ใช้ที่ไม่รู้อะไรเลยง่ายขึ้นมาก :)
https://docs.racket-lang.org/http-easy/index.html
https://docs.racket-lang.org/gui-easy/index.html
https://racket.discourse.group
อาจเป็นเพราะสาขาหลักที่ Python ถูกใช้งานในปัจจุบันก็ได้ การเปลี่ยนผ่าน Numeric/Numpy ราวปี 2000 นั้นต่างออกไปโดยสิ้นเชิง
การที่อะไร ๆ พังทุกไม่กี่ปีก็อาจพอรับได้สำหรับยูนิคอร์นสตาร์ตอัปหรือบริษัทที่เคลื่อนตัวเร็วและ “ทำของพัง” ตามตัวอักษร แต่ก็ยังมีโปรแกรมที่มีคุณค่าสำหรับคนและองค์กรที่ไม่มีเวลาจะเขียนอัลกอริทึมที่โตเต็มที่ใหม่ทุกสองสามปี หรือไม่ได้มองว่านั่นเป็นเรื่องสำคัญลำดับต้น
ผมใช้ Racket เป็นครั้งคราวและชอบมันอยู่เหมือนกัน แต่ก็ได้รู้ว่า Lisp บางตัว โดยเฉพาะ Common Lisp และอาจรวมถึง Guile ด้วย ถูกประเมินค่าต่ำกว่าที่ควรอย่างน่าประหลาด
อยากถามคนที่รู้ลึกกว่านี้ว่า มีฟีเจอร์ของ Racket อะไรบ้างที่ตอนแรกอาจดูไม่ค่อยใช้งานได้จริง ไม่ค่อยเกี่ยวข้อง หรือไม่ค่อยมีประโยชน์ แต่พอได้ลองใช้จริงแล้วกลับมีประโยชน์กับการเขียนโปรแกรมอย่างคาดไม่ถึง?
ราว 20 ปีก่อน ผมเคยทำงานกับซอฟต์แวร์เชิงพาณิชย์ด้านความปลอดภัยอีเมลที่ใช้ MzScheme เป็นภาษาแกน ก่อนที่มันจะกลายมาเป็น PLT Scheme โค้ดเป็นแบบข้ามแพลตฟอร์ม ทำงานได้บน Solaris, Linux และ HP-UX โดยมีโค้ดเฉพาะระบบปฏิบัติการเขียนด้วย C ราว 1,000 บรรทัด
กฎการกรองถูกคอมไพล์เป็น Scheme โดยตรง ตัวโค้ดทั้งหมดรวมถึง UI แบบเว็บมีประมาณ 30,000 บรรทัด และมีนักพัฒนาเพียง 5-6 คนเท่านั้น
ต่อมาหลังจากย้ายถิ่นฐาน ผมได้เข้าทำงานในบริษัทที่มีผลิตภัณฑ์คล้ายกันแต่ความสามารถน้อยกว่า ซึ่งผลิตภัณฑ์นั้นมีโค้ด C++ หลายแสนบรรทัดและมีนักพัฒนามากกว่า