ภาพรวมคอร์ส: Ruby for Java Developers

ภาพรวมคอร์ส

th/course_overview.md

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

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

repo นี้มี 15 หัวข้อและ 2 ภาคผนวก ส่วนใน /th ตอนนี้ ผมแปลเอกสาร Markdown ครบ ทั้งคอร์สแล้ว เพื่อให้คุณอ่านภาพรวม คู่มือ และโน้ตประกอบได้ต่อเนื่องเป็นภาษาไทย แม้ ไฟล์ Ruby ที่รันได้จริงยังคงอยู่ฝั่ง en/ ก็ตาม

สิ่งที่ผมอยากให้คอร์สนี้ทำได้

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

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

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

ผมประกอบแต่ละหัวข้ออย่างไร

แต่ละหัวข้อใช้ชิ้นส่วนการสอนชุดเล็ก ๆ คล้ายกัน:

• overview.md: อธิบายว่าทำไมหัวข้อนี้จึงสำคัญ
• shortnote.md: สรุปแก่นของหัวข้อแบบสั้นและชัด
• cheatsheet.md: โพยสั้น ๆ ไว้เปิดดูตอนเขียนโค้ด
• worked_examples.md: ตัวอย่างที่อธิบายวิธีคิดไปพร้อมกับโค้ด
• guide.md: ลำดับการเรียนที่ผมแนะนำ
• ไฟล์ Ruby ที่รันได้จริง และชุดทดสอบ RSpec

จังหวะการเรียนที่ผมตั้งใจไว้ค่อนข้างตรงไปตรงมา:

1. อ่าน overview.md และ shortnote.md
2. อ่าน worked_examples.md
3. รันชุดทดสอบ แล้วเปิดดู example.rb
4. ทำ basic_exercise.rb
5. ทำ adv_exercise.rb
6. ค่อยกลับมาเปิดไฟล์คำตอบหลังจากพยายามเองจริง

แม้แต่ class เล็ก ๆ ก็เริ่มน่าสนใจทันที เมื่อคุณต้องตั้งชื่อมัน เขียนชุดทดสอบให้มัน และ ตัดสินใจว่าพฤติกรรมควรอยู่ตรงไหน

คอร์สนี้ค่อย ๆ พาไปอย่างไร

ผมชอบมอง 15 หัวข้อเป็น 4 ช่วง

ช่วงที่ 1: วางพื้นให้คิดแบบ Ruby

หัวข้อ 1 ถึง 5 ครอบคลุมเรื่องเหล่านี้:

• expression-oriented Ruby
• methods, keyword arguments และ blocks
• Enumerable และการแปลงข้อมูลใน collections
• strings, symbols, ranges และ regex
• guard clauses, nil safety และ exceptions

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

ช่วงที่ 2: การออกแบบ object แบบ Ruby

หัวข้อ 6 ถึง 9 พาไปสู่เรื่องต่อไปนี้:

• classes, modules และ composition
• duck typing และ polymorphism
• dynamic Ruby แบบใช้ด้วยความยับยั้งชั่งใจ
• capstone ขนาดเล็ก

ช่วงนี้ผมไม่ได้ถามอีกแล้วว่า Ruby ทำอะไรได้บ้าง แต่ถามว่าพฤติกรรมควรอยู่ตรงไหน objects ควรร่วมมือกันอย่างไร และการขยับการออกแบบเพียงเล็กน้อยเปลี่ยนความรู้สึกของ โค้ดได้แค่ไหน

ช่วงที่ 3: Ruby ในงานที่มีบริบทจริง

หัวข้อ 10 ถึง 12 เอา Ruby ไปชนกับงานที่ใช้งานได้จริง:

• การออกแบบเกมแบบค่อย ๆ ขยาย
• การทำงานกับ CSV และ service สำหรับค้นข้อมูล
• การใช้งาน SQLite, การค้นข้อมูล และ prepared statements

ผมให้ความสำคัญกับช่วงนี้มาก เพราะมันบังคับให้ภาษาไปเจอกับ state, files, persistence และรูปแบบข้อมูลนำเข้า แรงกดดันด้านการออกแบบจึงเริ่มคล้ายงานจริงมากขึ้น

ช่วงที่ 4: การแปลงข้อมูลในระดับที่นามธรรมขึ้น

หัวข้อ 13 ถึง 15 พาไปสู่ปัญหาที่นามธรรมขึ้น:

• recursion และ closures
• การแปลงข้อมูลทีละขั้นด้วย map, zip และ lambdas
• การออกแบบแบบใช้ accumulator ด้วย reduce และ each_with_object

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

เมื่อเรียนจบ ผมอยากให้คุณสบายใจกับเรื่องอะไรบ้าง

เมื่อจบคอร์ส ผมคาดหวังว่าคุณจะสบายใจกับเรื่องต่อไปนี้:

• Ruby ในฐานะภาษาแบบ expression-oriented และ object-based
• methods, keyword arguments, blocks และ Enumerable
• strings, symbols, ranges, hashes และ regular expressions
• โค้ดที่รับมือ nil และ exceptions ได้ โดยยังมีเจตนาชัด
• การออกแบบ object ขนาดเล็กผ่าน state, composition และ object ที่รับเข้ามาร่วมงาน
• duck typing, mixins และ polymorphism ที่ยึดพฤติกรรมเป็นหลัก
• dynamic Ruby features เช่น public_send และ define_method แบบใช้ด้วยความระวัง
• domain model ขนาดเล็กที่โชว์จุดแข็งของ Ruby โดยไม่ปล่อยให้ความแพรวพราวนำหน้าความชัด

วิธีใช้แบบฝึกหัดที่ผมอยากให้คุณลอง

ชุดทดสอบใน repo นี้ตรวจพฤติกรรมของโค้ดก็จริง แต่เป้าหมายทางการสอนกว้างกว่านั้น ระหว่างที่คุณทำหัวข้อหนึ่ง ๆ ผมอยากให้คุณหยุดถามตัวเองบ้างว่า:

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

Ruby เป็นภาษาที่ให้ทางเลือกหลายแบบ หนึ่งในเป้าหมายหลักของผมในคอร์สนี้คือช่วยให้คุณ เลือกได้ดีขึ้น

ลำดับหัวข้อ

1. พื้นฐาน Ruby และการเขียนแบบ expression-oriented
2. การออกแบบ API ที่ยืดหยุ่นด้วย keyword arguments และ blocks
3. การแปลงข้อมูลด้วย collections และ Enumerable
4. การจัดการข้อความด้วย strings, symbols, ranges และ regex
5. การไหลของโค้ด, nil safety และ exceptions
6. state, validation, modules และ composition
7. duck typing, mixins และ service ที่ขยายต่อได้
8. dynamic Ruby features และ metaprogramming แบบมีวินัย
9. capstone ขนาดเล็ก: ระบบยืมหนังสือขนาดเล็ก
10. การออกแบบเกมแบบค่อย ๆ ขยาย: rock-paper-scissors
11. งานกับไฟล์ CSV: อ่าน เขียน และ service สำหรับค้นข้อมูลขนาดเล็ก
12. งานกับ SQLite: การทำงานพื้นฐาน, การค้นข้อมูล และ prepared statements
13. การเดินข้อมูลแบบ recursive และ closures ผ่านปัญหา tree ขนาดเล็ก
14. Ruby แบบ functional ด้วย map, zip, lambdas และ composition
15. การออกแบบแบบใช้ accumulator ด้วย reduce และ each_with_object

ทำไมผมจึงใส่ภาคผนวกไว้ด้วย

ภาคผนวก A ว่าด้วยด้านปฏิบัติการของโปรเจกต์ Ruby: เครื่องมือ, วงจรชีวิตของโปรเจกต์ และนิสัยการทำงานในฐานโค้ดจริง

ภาคผนวก B ว่าด้วยการใช้ VS Code กับงาน Ruby แบบใช้งานจริง สำหรับคนที่อยากเรียนผ่าน เครื่องมือที่มองเห็นภาพมากขึ้น

ผมไม่ได้มองภาคผนวกเป็นของแถม เพราะการเรียน Ruby ใน repo แบบนี้ ไม่ได้มีแค่เรื่อง ภาษาอย่างเดียว แต่มีเรื่องวิธีทำงานรอบ ๆ ภาษานั้นอยู่ด้วย

หมายเหตุสำหรับคนสอน

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

• ชื่อ method นี้ทำหน้าที่ของมันพอหรือยัง
• guard clause ทำให้ตรงนี้ชัดขึ้นไหม
• พฤติกรรมนี้ควรอยู่บน object นี้จริงหรือไม่
• เวอร์ชันแบบ Ruby นี้งามขึ้นจริง หรือแค่สั้นลง

คำถามพวกนี้แหละที่ทำให้คอร์สนี้เป็นมากกว่าคู่มือไวยากรณ์ และเป็นจุดที่ผู้เรียนเริ่มฟังดู เหมือน Ruby programmers มากขึ้น แทนที่จะยังแปลจาก Java อยู่ตลอดเวลา