ภาคผนวก G - Rust ถูกสร้างขึ้นมาอย่างไร และ “Nightly Rust”
ภาคผนวกนี้จะอธิบายถึงกระบวนการพัฒนา Rust และสิ่งนั้นส่งผลต่อคุณในฐานะนักพัฒนา Rust อย่างไร
ความเสถียรโดยไม่หยุดนิ่ง
ในฐานะภาษาการโปรแกรม Rust ให้ความสำคัญกับความเสถียรของโค้ดของคุณ_อย่างยิ่งยวด_ เราต้องการให้ Rust เป็นรากฐานอันมั่นคงดั่งหินผาที่คุณสามารถนำไปต่อยอดได้ และหากทุกสิ่งเปลี่ยนแปลงอยู่ตลอดเวลา สิ่งนั้นย่อมเป็นไปไม่ได้ ในขณะเดียวกัน หากเราไม่สามารถทดลองกับฟีเจอร์ใหม่ๆ ได้เลย เราอาจตรวจไม่พบข้อบกพร่องสำคัญจนกระทั่งปล่อยเวอร์ชันใหม่ออกไปแล้ว ซึ่งถึงตอนนั้นเราก็ไม่สามารถแก้ไขอะไรได้อีก
ทางออกของปัญหานี้คือสิ่งที่เราเรียกว่า “ความเสถียรโดยไม่หยุดนิ่ง” (stability without stagnation) และหลักการชี้นำของเราคือ: คุณไม่ควรต้องหวาดกลัวการอัปเกรดไปยัง Rust เวอร์ชันเสถียรรุ่นใหม่เลย การอัปเกรดแต่ละครั้งควรราบรื่นและสร้างภาระน้อยที่สุด แต่ในขณะเดียวกันก็ต้องนำพาฟีเจอร์ใหม่ ลดข้อผิดพลาดลง และช่วยให้คอมไพล์ได้เร็วขึ้นด้วย
ชู ชู! ช่องทางการเผยแพร่และการนั่งรถไฟ
การพัฒนา Rust ดำเนินไปตาม_ตารางเวลารถไฟ_ (train schedule) กล่าวคือ การพัฒนาทั้งหมดจะเกิดขึ้นบนแบรนช์ main ของรีพอซิทอรี Rust การปล่อยเวอร์ชันจะเป็นไปตามโมเดลขบวนรถไฟปล่อยซอฟต์แวร์ (software release train model) ซึ่งคล้ายกับที่ Cisco IOS และโครงการซอฟต์แวร์อื่นๆ เคยนำมาใช้ โดยมี_ช่องทางการเผยแพร่_ (release channel) อยู่สามช่องทางสำหรับ Rust:
- Nightly
- Beta
- Stable
นักพัฒนา Rust ส่วนใหญ่จะใช้ช่องทางการเผยแพร่แบบเสถียร (stable) เป็นหลัก แต่ผู้ที่ต้องการทดลองฟีเจอร์ใหม่เชิงทดลองก็สามารถเลือกใช้ nightly หรือ beta ได้
นี่คือตัวอย่างการทำงานของกระบวนการพัฒนาและการปล่อยเวอร์ชัน: สมมติว่าทีมงาน Rust กำลังพัฒนาเพื่อเตรียมปล่อยเวอร์ชัน Rust 1.5 (การปล่อยเวอร์ชันดังกล่าวเกิดขึ้นจริงในเดือนธันวาคม 2015 แต่เราขอยกมาเป็นตัวอย่างเพื่อให้เห็นภาพหมายเลขเวอร์ชันที่สมจริง) เมื่อมีฟีเจอร์ใหม่เพิ่มเข้ามาใน Rust และมีคอมมิตใหม่รวมเข้าสู่แบรนช์ main ในแต่ละคืน ก็จะมีการสร้าง Rust เวอร์ชัน nightly ใหม่ขึ้นมา ทุกๆ วันจึงถือเป็นวันปล่อยเวอร์ชัน และเวอร์ชันเหล่านี้จะถูกสร้างขึ้นผ่านโครงสร้างพื้นฐานการเผยแพร่ของเราโดยอัตโนมัติ ดังนั้นเมื่อเวลาผ่านไป ช่องทางการปล่อยเวอร์ชันของเราจึงมีลักษณะดังนี้ คืนละหนึ่งจุด:
nightly: * - - * - - *
เมื่อครบทุกๆ หกสัปดาห์ ก็จะถึงเวลาเตรียมการปล่อยเวอร์ชันใหม่! แบรนช์ beta ของรีพอซิทอรี Rust จะแตกกิ่งออกมาจากแบรนช์ main ที่ nightly ใช้งานอยู่ ตอนนี้จึงมีช่องทางการปล่อยเวอร์ชันอยู่สองส่วน:
nightly: * - - * - - *
|
beta: *
ผู้ใช้ Rust ส่วนใหญ่ไม่ได้นำรุ่น beta ไปใช้งานจริง แต่จะใช้ทดสอบร่วมกับระบบ CI ของตน เพื่อช่วยให้ทีม Rust ค้นพบข้อผิดพลาดถดถอย (regression) ที่อาจเกิดขึ้น ในระหว่างนั้น การปล่อยเวอร์ชัน nightly ก็ยังคงเกิดขึ้นทุกคืนต่อไป:
nightly: * - - * - - * - - * - - *
|
beta: *
สมมติว่าพบข้อผิดพลาดถดถอย นับเป็นโชคดีที่เรามีเวลาทดสอบรุ่น beta ก่อนที่ข้อผิดพลาดนั้นจะหลุดรอดเข้าไปในเวอร์ชันเสถียร! การแก้ไขจะถูกนำไปใช้กับแบรนช์ main เพื่อให้ nightly ได้รับการแก้ไข จากนั้นจึงแบ็กพอร์ต (backport) การแก้ไขนั้นกลับมายังแบรนช์ beta แล้วจึงสร้างรุ่น beta ใหม่ออกมา:
nightly: * - - * - - * - - * - - * - - *
|
beta: * - - - - - - - - *
หกสัปดาห์หลังจากสร้าง beta รุ่นแรกขึ้นมา ก็ถึงเวลาสำหรับการปล่อยเวอร์ชันเสถียร! แบรนช์ stable จะถูกสร้างขึ้นมาจากแบรนช์ beta:
nightly: * - - * - - * - - * - - * - - * - * - *
|
beta: * - - - - - - - - *
|
stable: *
ไชโย! Rust 1.5 เสร็จสมบูรณ์แล้ว! อย่างไรก็ดี เรายังลืมไปอีกสิ่งหนึ่ง: เนื่องจากเวลาผ่านไปหกสัปดาห์แล้ว เราจึงจำเป็นต้องมี beta ตัวใหม่สำหรับ Rust เวอร์ชัน_ถัดไป_ นั่นคือ 1.6 ด้วย ดังนั้นหลังจาก stable แตกกิ่งออกมาจาก beta แล้ว beta เวอร์ชันถัดไปก็จะแตกกิ่งออกมาจาก nightly ใหม่อีกครั้ง:
nightly: * - - * - - * - - * - - * - - * - * - *
| |
beta: * - - - - - - - - * *
|
stable: *
เราเรียกสิ่งนี้ว่า “โมเดลรถไฟ” (train model) เพราะทุกๆ หกสัปดาห์ ตัวเวอร์ชันจะ “เคลื่อนออกจากสถานี” ทว่ายังคงต้องเดินทางผ่านช่องทาง beta ก่อนที่จะมาถึงจุดหมายในฐานะการปล่อยเวอร์ชันเสถียร
Rust ปล่อยเวอร์ชันใหม่ออกมาทุกหกสัปดาห์อย่างสม่ำเสมอ หากคุณทราบวันปล่อยเวอร์ชันของ Rust รอบหนึ่ง คุณก็จะทราบวันปล่อยเวอร์ชันรอบถัดไปได้ทันที: นั่นคืออีกหกสัปดาห์ถัดมา ข้อดีของการกำหนดตารางปล่อยเวอร์ชันทุกหกสัปดาห์เช่นนี้คือ รถไฟขบวนถัดไปกำลังจะมาถึงในอีกไม่ช้า หากมีฟีเจอร์ใดที่พัฒนาไม่ทันรอบนี้ ก็ไม่ต้องกังวล: เพราะรอบถัดไปจะตามมาในเวลาอันสั้น! สิ่งนี้ช่วยลดแรงกดดันที่จะรีบยัดเยียดฟีเจอร์ที่ยังไม่ผ่านการขัดเกลาเข้ามาในช่วงใกล้ถึงกำหนดเส้นตาย
ด้วยกระบวนการนี้ คุณจึงสามารถทดลองใช้บิลด์ถัดไปของ Rust ได้เสมอ และพิสูจน์ด้วยตนเองว่าการอัปเกรดเป็นเรื่องง่าย: หากรุ่น beta ทำงานไม่ตรงตามที่คาดไว้ คุณสามารถรายงานให้ทีมงานทราบ เพื่อแก้ไขปัญหาก่อนที่เวอร์ชันเสถียรรอบถัดไปจะปล่อยออกมา! ความเสียหายหรือการพังของโค้ดในรุ่น beta นั้นเกิดขึ้นค่อนข้างน้อย แต่ rustc ก็ยังคงเป็นซอฟต์แวร์ชิ้นหนึ่ง และย่อมมีบั๊กเกิดขึ้นได้เสมอ
ช่วงเวลาบำรุงรักษา
โปรเจกต์ Rust จะสนับสนุนเฉพาะเวอร์ชันเสถียรล่าสุดเท่านั้น เมื่อมีการปล่อยเวอร์ชันเสถียรรุ่นใหม่ออกมา เวอร์ชันเก่าก็จะสิ้นสุดอายุการใช้งาน (end of life หรือ EOL) ทันที ซึ่งหมายความว่าแต่ละเวอร์ชันจะได้รับการสนับสนุนเป็นระยะเวลาหกสัปดาห์
ฟีเจอร์ที่ยังไม่เสถียร
ยังมีเงื่อนไขสำคัญอีกประการหนึ่งในโมเดลการปล่อยเวอร์ชันนี้: นั่นคือฟีเจอร์ที่ยังไม่เสถียร (unstable features) Rust ใช้เทคนิคที่เรียกว่า “แฟล็กฟีเจอร์” (feature flags) ในการกำหนดว่าฟีเจอร์ใดจะเปิดใช้งานในการปล่อยเวอร์ชันแต่ละครั้ง หากฟีเจอร์ใหม่อยู่ระหว่างการพัฒนาอย่างต่อเนื่อง ฟีเจอร์นั้นจะถูกผสานเข้าสู่แบรนช์ main จึงปรากฏอยู่ใน nightly แต่อยู่เบื้องหลัง_แฟล็กฟีเจอร์_ หากคุณในฐานะผู้ใช้งานต้องการทดลองใช้ฟีเจอร์ที่อยู่ระหว่างพัฒนานี้ คุณก็สามารถทำได้ แต่จะต้องใช้ Rust รุ่น nightly และระบุแอตทริบิวต์กำกับในซอร์สโค้ดด้วยแฟล็กที่เหมาะสมเพื่อเปิดใช้งาน
หากคุณใช้งาน Rust รุ่น beta หรือรุ่นเสถียร คุณจะไม่สามารถใช้งานแฟล็กฟีเจอร์ใดๆ ได้เลย นี่คือกุญแจสำคัญที่เปิดโอกาสให้เราได้นำฟีเจอร์ใหม่ๆ ไปทดลองใช้งานจริงในทางปฏิบัติ ก่อนที่เราจะประกาศให้ฟีเจอร์เหล่านั้นเสถียรอย่างถาวร ผู้ที่ต้องการทดลองเทคโนโลยีล้ำสมัยก็สามารถเลือกใช้งานได้ ส่วนผู้ที่ต้องการความมั่นคงปลอดภัยอันแข็งแกร่งดั่งหินผาก็สามารถใช้เวอร์ชันเสถียรและมั่นใจได้ว่าโค้ดจะไม่พัง นี่คือความเสถียรโดยไม่หยุดนิ่ง
หนังสือเล่มนี้จะครอบคลุมเฉพาะฟีเจอร์ที่เสถียรแล้วเท่านั้น เนื่องจากฟีเจอร์ที่อยู่ระหว่างการพัฒนายังคงเปลี่ยนแปลงได้เสมอ และย่อมมีความแตกต่างระหว่างช่วงเวลาที่เขียนหนังสือเล่มนี้กับช่วงเวลาที่ฟีเจอร์เหล่านั้นเปิดให้ใช้งานในบิลด์เสถียรจริง คุณสามารถค้นหาเอกสารประกอบสำหรับฟีเจอร์เฉพาะของ nightly ได้จากช่องทางออนไลน์
Rustup และบทบาทของ nightly Rust
Rustup ช่วยให้การสลับเปลี่ยนช่องทางการปล่อยเวอร์ชันต่างๆ ของ Rust เป็นเรื่องง่าย ทั้งในระดับส่วนกลางของทั้งระบบหรือแบบเจาะจงเฉพาะโปรเจกต์ โดยค่าเริ่มต้น คุณจะมี Rust เวอร์ชันเสถียรติดตั้งอยู่แล้ว ตัวอย่างเช่น หากต้องการติดตั้ง nightly:
$ rustup toolchain install nightly
คุณยังสามารถดู_ทูลเชน_ (toolchain) ทั้งหมด (การปล่อยเวอร์ชันของ Rust และคอมโพเนนต์ที่เกี่ยวข้อง) ที่คุณติดตั้งไว้ได้ด้วย rustup นี่คือตัวอย่างบนคอมพิวเตอร์ Windows ของหนึ่งในผู้เขียนหนังสือเล่มนี้:
> rustup toolchain list
stable-x86_64-pc-windows-msvc (default)
beta-x86_64-pc-windows-msvc
nightly-x86_64-pc-windows-msvc
ดังที่คุณเห็น ทูลเชนเสถียรจะเป็นค่าเริ่มต้น ผู้ใช้ Rust ส่วนใหญ่ใช้เวอร์ชันเสถียรเกือบตลอดเวลา คุณอาจต้องการใช้เวอร์ชันเสถียรเป็นหลัก แต่ใช้ nightly กับโปรเจกต์ใดโปรเจกต์หนึ่งโดยเฉพาะ เนื่องจากคุณสนใจฟีเจอร์ล้ำสมัย เมื่อต้องการทำเช่นนั้น คุณสามารถใช้คำสั่ง rustup override ในไดเรกทอรีของโปรเจกต์นั้น เพื่อตั้งให้ทูลเชน nightly เป็นทูลเชนที่ rustup ควรใช้เมื่อคุณอยู่ในไดเรกทอรีดังกล่าว:
$ cd ~/projects/needs-nightly
$ rustup override set nightly
ตอนนี้ ทุกครั้งที่คุณเรียก rustc หรือ cargo ภายใน ~/projects/needs-nightly rustup จะทำให้แน่ใจว่าคุณกำลังใช้งาน nightly Rust แทนที่จะเป็นค่าเริ่มต้นอย่าง Rust เวอร์ชันเสถียรของคุณ สิ่งนี้มีประโยชน์มากเมื่อคุณมีโปรเจกต์ Rust จำนวนมาก!
กระบวนการ RFC และทีมงานต่างๆ
แล้วคุณจะเรียนรู้เกี่ยวกับฟีเจอร์ใหม่เหล่านี้ได้อย่างไร? โมเดลการพัฒนาของ Rust ดำเนินตาม_กระบวนการ Request For Comments (RFC)_ หากคุณอยากเห็นการปรับปรุงหรือเพิ่มฟีเจอร์ใน Rust คุณสามารถเขียนเอกสารข้อเสนอที่เรียกว่า RFC ขึ้นมาได้
ใครๆ ก็สามารถเขียน RFC เพื่อร่วมพัฒนา Rust ได้ และข้อเสนอเหล่านี้จะได้รับการตรวจสอบและพิจารณาหารือโดยทีมงานของ Rust ซึ่งประกอบด้วยทีมย่อยเฉพาะทางหลายทีม คุณสามารถดูรายชื่อทีมทั้งหมดได้บนเว็บไซต์ของ Rust ซึ่งครอบคลุมทีมงานสำหรับแต่ละภาคส่วนของโปรเจกต์: ไม่ว่าจะเป็นการออกแบบภาษา การพัฒนาคอมไพเลอร์ โครงสร้างพื้นฐาน เอกสารประกอบ และอื่นๆ ทีมงานที่เกี่ยวข้องจะอ่านข้อเสนอและความคิดเห็นต่างๆ พร้อมร่วมแสดงความคิดเห็นเพิ่มเติม จนกระทั่งเกิดฉันทามติว่าจะยอมรับหรือปฏิเสธฟีเจอร์ดังกล่าว
หากฟีเจอร์นั้นได้รับการยอมรับ ก็จะมีการเปิดประเด็นปัญหา (issue) บนที่เก็บโค้ดของ Rust และเปิดให้มีผู้นำไปพัฒนาต่อไป ซึ่งผู้ที่ลงมือพัฒนาอาจไม่ใช่ผู้ที่เสนอแนวคิดตั้งแต่แรกก็ได้! เมื่อโค้ดพัฒนาเสร็จสมบูรณ์ ก็จะถูกผสานเข้าสู่แบรนช์ main ภายใต้เกตฟีเจอร์ (feature gate) ดังที่เราได้อธิบายไว้ในส่วน“ฟีเจอร์ที่ยังไม่เสถียร”
เมื่อเวลาผ่านไประยะหนึ่ง และนักพัฒนา Rust ที่ใช้งานรุ่น nightly ได้มีโอกาสทดลองใช้งานฟีเจอร์ใหม่แล้ว สมาชิกในทีมจะนำฟีเจอร์นั้นมาหารือกันอีกครั้ง เพื่อประเมินผลการทำงานบน nightly และตัดสินใจว่ามันควรเข้าไปอยู่ใน Rust เวอร์ชันเสถียรหรือไม่ หากมีมติให้ดำเนินการต่อ เกตฟีเจอร์ก็จะถูกปลดออก และถือว่าฟีเจอร์นั้นเข้าสู่สถานะเสถียรแล้ว! พร้อมออกเดินทางไปกับขบวนรถไฟสู่การปล่อย Rust เวอร์ชันเสถียรรอบถัดไป