ที่มา: InfoQ

ในปี 2023 เรามีเหตุผลนับพันที่จะเรียนรู้เกี่ยวกับสนิม

เมื่อวันที่ 7 สิงหาคม Rust Foundation ได้เผยแพร่ผลลัพธ์ของรายงานการสำรวจสนิมปี 2022 รายงานแสดงให้เห็นว่าอัตราการยอมรับของ Rust ยังคงเพิ่มขึ้นอย่างต่อเนื่อง มากกว่า 90% ของผู้ตอบแบบสำรวจระบุว่าพวกเขาเป็นผู้ใช้ Rust; Rust ใช้สำหรับ งานเขียนโค้ดส่วนใหญ่ใน เพิ่มขึ้นอย่างมาก 51.8% จากปีที่แล้ว

ไม่ต้องสงสัยเลยว่า Rust กลายเป็นจุดสนใจของนักพัฒนามากขึ้นเรื่อยๆ ด้วยความปลอดภัยของหน่วยความจำที่ยอดเยี่ยมและประสิทธิภาพการทำงานพร้อมกัน อย่างไรก็ตาม มันเป็นเรื่องยากที่จะเพิกเฉยต่อ Go ซึ่งเป็นผู้เล่นที่ค่อนข้าง "เก๋า" ซึ่งครั้งหนึ่งเคยได้รับเลือกให้เป็นภาษาโปรแกรมแห่งปี

ภาษา Go ถือกำเนิดขึ้นในปี 2009 ได้รับความสนใจอย่างมากเนื่องจากรูปแบบการทำงานพร้อมกันที่ไม่เหมือนใครและข้อดีด้านประสิทธิภาพที่ทรงพลัง เป็นที่น่าสังเกตว่า เช่นเดียวกับภาษา Rust ผู้สร้างภาษา Go ก็ "เกลียด" C++ และ Go ก็เป็นภาษาหลักในระบบคลาวด์

ในแบบสำรวจนักพัฒนาซอฟต์แวร์ Stack Overflow 2022 จาก 70,000 คำตอบสำหรับคำถาม "ภาษาโปรแกรมที่ทำให้ผู้คนรักและเกลียดชัง" เห็นได้ชัดว่าโปรแกรมเมอร์ชอบ Rust มากกว่า 86% บอกว่าชอบ Rust และ 64% บอกว่าชอบ Go เมื่อเผชิญกับสถานะที่ร้อนแรงของ Rust นักพัฒนาบางคนถามจิตวิญญาณของพวกเขาว่า: Go ยังคุ้มค่าที่จะเรียนรู้ในปี 2023 หรือไม่

นอกจากนี้ ในช่วงสองวันที่ผ่านมา ไม่ว่าจะเลือก Rust หรือ Go ก็กลายเป็นประเด็นร้อนใน Hacker News:

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

นักพัฒนาอีกคนที่ไม่เห็นด้วยกล่าวว่า "ฉันพัฒนาใน Go มาเกือบสิบปีแล้ว แต่เมื่อเร็ว ๆ นี้ฉันก็ลองใช้ Rust เช่นกัน ฉันคิดว่าปัจจุบันมีการตั้งค่าที่จำเป็นและทำให้เข้าใจผิดสำหรับ Rust จากประสบการณ์ของฉันใน From experience ที่สตาร์ทอัพต่าง ๆ รวมถึงของฉัน ปัจจุบัน Go เป็นตัวเลือกที่ดีที่สุดสำหรับการพัฒนาแบ็กเอนด์ หมายเหตุ ประสิทธิภาพ ฟังก์ชันการทำงาน หรืออื่นๆ... ทั้งสองภาษามีความคล้ายคลึงกันมาก!"

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

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

ไปเทียบกับสนิม: ความคล้ายคลึงกัน

Rust และ Go มีหลายอย่างที่เหมือนกัน ซึ่งเป็นเหตุผลว่าทำไมผู้คนจึงมักเปรียบเทียบทั้งสองสิ่งนี้ พวกเขามีเป้าหมายอะไรเหมือนกัน?

Rust เป็นภาษาการเขียนโปรแกรมหลายกระบวนทัศน์แบบสแตติกระดับต่ำโดยเน้นที่ความปลอดภัยและประสิทธิภาพมากขึ้น

—กินส์ ไดมานิส

และ:

Go เป็นภาษาโปรแกรมแบบโอเพ่นซอร์สที่ทำให้ง่ายต่อการสร้างซอฟต์แวร์ที่เรียบง่าย เชื่อถือได้ และมีประสิทธิภาพ

—golang.org

ความปลอดภัยของหน่วยความจำ

ทั้ง Go และ Rust เป็นหนึ่งใน ภาษาโปรแกรมสมัยใหม่ที่เน้นความปลอดภัยของหน่วยความจำ กว่าทศวรรษของการพัฒนาภาษาเก่าเช่น C และ C++ เป็นที่ชัดเจนว่าสาเหตุหลักประการหนึ่งของข้อผิดพลาดและจุดบกพร่องคือการเข้าถึงหน่วยความจำที่ไม่ปลอดภัย/ไม่ถูกต้อง

ดังนั้น Rust และ Go ต่างให้โซลูชันที่แตกต่างกัน แต่เป้าหมายของทั้งสองอย่างคือการฉลาดและปลอดภัยยิ่งขึ้นในแง่ของการจัดการหน่วยความจำ และเพื่อช่วยให้นักพัฒนาเขียนโปรแกรมที่ถูกต้องด้วยประสิทธิภาพที่ยอดเยี่ยม

สั่งงานได้รวดเร็ว กะทัดรัด

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

ภาษาสำหรับวัตถุประสงค์ทั่วไป

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

รูปแบบการเขียนโปรแกรมเชิงปฏิบัติ

ไม่มีทั้งภาษาที่ใช้งานมากเกินไป (เช่น Scala หรือ Elixir) และไม่ใช่ภาษาเชิงวัตถุอย่างสมบูรณ์ (เช่น Java และ C#) ในทางตรงกันข้าม แม้ว่าทั้ง Go และ Rust จะมีฟังก์ชันของการเขียนโปรแกรมเชิงฟังก์ชันและเชิงวัตถุ แต่พวกเขา เน้นการวางแนวทางปฏิบัติ เสมอ นั่นคือ แก้ปัญหาด้วยวิธีที่เหมาะสมที่สุด แทนที่จะบังคับให้ทุกคนใช้ วิธีเฉพาะเจาะจงผ่าน "อุดมการณ์" วิธีการทำสิ่งต่างๆ **แต่ถ้าคุณชอบรูปแบบการเขียนโปรแกรมเชิงฟังก์ชันจริงๆ ก็มีตัวเลือกเครื่องมือที่เกี่ยวข้องเพิ่มเติมในฝั่ง Rust ซึ่งเป็นข้อดีอย่างหนึ่งของ Rust over Go **

เราสามารถโต้แย้งได้อย่างแน่นอนเกี่ยวกับสิ่งที่ก่อให้เกิดภาษา "เชิงวัตถุ" อย่างแท้จริง แต่พูดตามตรง รูปแบบของการเขียนโปรแกรมเชิงวัตถุที่ผู้ใช้ C++, Java หรือ C# คาดหวังนั้นไม่มีอยู่ใน Go หรือ Rust

—แจ็ค มอตต์

การพัฒนาครั้งใหญ่

ทั้ง Rust และ Go มีคุณสมบัติที่เป็นประโยชน์มากมายสำหรับการเขียนโปรแกรมขนาดใหญ่ ดังนั้นทั้งคู่จึงสามารถปรับให้เข้ากับความต้องการในโลกแห่งความเป็นจริงของทีมพัฒนาขนาดใหญ่และฐานรหัสขนาดใหญ่ **ตัวอย่างเช่น โปรแกรมเมอร์ C ถกเถียงกันมานานหลายปีเกี่ยวกับตำแหน่งที่จะใส่วงเล็บ และควรจะเยื้องโค้ดด้วยแท็บหรือเว้นวรรคหรือไม่ แต่ Rust และ Go ใช้เครื่องมือจัดรูปแบบมาตรฐานอยู่แล้ว (Go มี gofmt, Rust It is rustfmt) แก้ปัญหาเหล่านี้ได้อย่างสมบูรณ์ ปัญหา. พวกเขาเขียนโค้ดของคุณใหม่โดยอัตโนมัติโดยใช้สไตล์ที่สอดคล้องกัน

ไม่ใช่ว่ารูปแบบเฉพาะนี้มีความละเอียดอ่อน แต่โปรแกรมเมอร์ของ **Rust and Go นั้นเน้นการปฏิบัติมากกว่าและค่อนข้างจะเลือกมาตรฐานเดียวกันในการดำเนินการ **

สไตล์ของ gofmt อาจไม่ถูกใจทุกคน แต่ gofmt มีบางอย่างสำหรับทุกคน

—ร็อบ ไพค์

ข้อดีอีกอย่างของสองภาษานี้สะท้อนให้เห็นใน build ไปป์ไลน์ ทั้งสองมีเครื่องมือการจัดการการสร้างและการพึ่งพามาตรฐานที่ยอดเยี่ยมในตัวและมีประสิทธิภาพ ซึ่งหมายความว่าโปรแกรมเมอร์ไม่ต้องต่อสู้กับระบบการสร้างของบุคคลที่สามที่ซับซ้อน และไม่ต้องเรียนรู้ระบบใหม่ทุกๆ 2-3 ปี

ฉันใช้ Java และ Ruby ในช่วงต้นอาชีพของฉัน ดังนั้นการเขียนโค้ด Go และ Rust จึงค่อนข้างน่ากลัวและอยู่นอกเหนือการควบคุมของฉัน แต่เมื่อฉันเข้า Google และเห็นบริการที่เขียนด้วย Go ฉันรู้สึกโล่งใจมากเพราะฉันพบว่ามันสร้างและเรียกใช้ได้ง่าย

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

—แซม โรส

**ขึ้นสนิมหรือไป? **

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

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

ย้อนกลับไปที่การพูดคุยของผู้ใหญ่ มาดูกันว่า Rust และ Go มีจุดแข็งและจุดอ่อนอย่างไรภายใต้การวิเคราะห์อย่างเป็นเหตุเป็นผล

ไปเทียบกับสนิม: ประสิทธิภาพ

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

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

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

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

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

• ความเรียบง่าย

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

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

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

—Rust ความประทับใจแรกเริ่มของโปรแกรมเมอร์เกี่ยวกับ Go

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

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

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

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

— นางอายโคร

• การทำงาน

Rust รองรับความซับซ้อนมากกว่าภาษาโปรแกรมอื่นๆ หลายภาษา ดังนั้นขอบเขตการใช้งานที่เกี่ยวข้องจึงมีขนาดใหญ่กว่าด้วย

—เทวาธอน

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

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

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

**แม้ว่า Rust และ Go จะยืมฟีเจอร์บางอย่างจากกันและกัน (เช่น ยาชื่อสามัญ) แต่ก็ยุติธรรมที่จะบอกว่าฟีเจอร์ของ Rust ยังคงเหนือกว่า และฟีเจอร์ของ Go ค่อนข้างขาดไป **

• การทำงานพร้อมกัน

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

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

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

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

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

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

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

—Rust ความประทับใจแรกเริ่มของโปรแกรมเมอร์เกี่ยวกับ Go

แม้ว่าการนำโปรแกรมที่ทำงานพร้อมกันมาใช้ใน Rust อาจไม่ใช่เรื่องง่าย แต่ก็ยังสามารถทำได้อย่างสมบูรณ์ และ** โปรแกรมเหล่านี้ยังได้รับประโยชน์จากการรับประกันความปลอดภัยของหน่วยความจำที่ออกแบบมาอย่างรอบคอบของ Rust **ยกตัวอย่างคลาส Mutex ของไลบรารีมาตรฐาน: ใน Go เราอาจลืมรับ mutex ก่อนที่จะเข้าถึงบางอย่าง แต่ใน Rust ไม่จำเป็นต้องกังวลเกี่ยวกับเรื่องนี้เลย

Go มุ่งเน้นไปที่การทำงานพร้อมกันเป็นหนึ่งในแนวคิดหลัก นี่ไม่ได้หมายความว่าเราไม่สามารถบรรลุผลพร้อมกันที่คล้ายกับ Go in Rust แต่ความยากในการนำไปใช้นั้นเป็นการทดสอบสำหรับโปรแกรมเมอร์ Go มุ่งเน้นไปที่การทำงานพร้อมกันเป็นหนึ่งในแนวคิดหลัก นี่ไม่ได้หมายความว่าเราไม่สามารถบรรลุผลพร้อมกันที่คล้ายกับ Go in Rust แต่ความยากในการนำไปใช้นั้นเป็นการทดสอบสำหรับโปรแกรมเมอร์

—— เดฟ เชนีย์

• ความปลอดภัย

ดังที่ได้กล่าวไว้ก่อนหน้านี้ ทั้ง Go และ Rust มีวิธีป้องกันข้อผิดพลาดในการเขียนโปรแกรมทั่วไปโดยเฉพาะ โดยเฉพาะปัญหาที่เกี่ยวข้องกับการจัดการหน่วยความจำ แต่ **Rust ไปไกลกว่านั้น อาจกล่าวได้ว่ามันไม่มีความพยายามเพื่อให้แน่ใจว่าทุกคนจะไม่ทำผิดพลาดด้านความปลอดภัยที่ไม่คาดคิด **

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

— ทำไมถึงเลือกสนิม

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

สำหรับฉัน ข้อได้เปรียบที่ใหญ่ที่สุดของ Rust คือคอมไพเลอร์กลายเป็นผู้ช่วยที่ดีของฉัน มันจะไม่พลาดบั๊กที่ตรวจพบ (เอาจริงๆ บางครั้งฉันรู้สึกเหมือนมีเวทมนตร์)

—Grzegorz Nosek

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

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

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

จากมุมมองอื่น ภาษาใหม่ที่ไม่เปลี่ยนแปลงวิธีการเขียนโปรแกรมจะเรียกว่าภาษาใหม่ได้หรือไม่ และเมื่อใช้ภาษาอื่น Rust สอนให้เราคิดอย่างปลอดภัย ซึ่งสำคัญไม่แพ้กัน

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

— แมทธิว เอ็นด์เลอร์

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

หากคุณเป็นโปรแกรมเมอร์ C หรือ C++ และใช้เวลาหลายสัปดาห์ในการค้นหาจุดบกพร่องด้านความปลอดภัยของหน่วยความจำในภาษา คุณจะต้องหลงรัก Rust ดังนั้น "การต่อสู้กับตัวตรวจสอบการยืม" จึงกลายเป็น "คอมไพเลอร์ยังเป็นไปได้ไหม เจ๋ง!"

— เกรเซกอร์ซ โนเซก

• ไต่ขึ้น

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

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

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

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

—นางอายโคร

ความชัดเจนและความชัดเจนมีความสำคัญมากกว่าความสง่างามเสมอเมื่อต้องพูดถึงการพัฒนาซอฟต์แวร์ขนาดใหญ่ **ข้อจำกัดของ Go ทำให้สามารถปรับให้เข้ากับความต้องการขององค์กรและองค์กรขนาดใหญ่ได้มากกว่าภาษาที่ซับซ้อนและทรงพลังอย่างเช่น Rust **

Rust vs. Go: ความแตกต่าง

แม้ว่าทั้ง Rust และ Go เป็นภาษาสมัยใหม่ที่ได้รับความนิยมและใช้กันอย่างแพร่หลาย แต่ก็ไม่ได้เป็นคู่แข่งกันจริงๆ เพราะพวกเขากำหนดเป้าหมายกรณีการใช้งานที่แตกต่างกันอย่างสิ้นเชิง**

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

ดังนั้นเราสามารถเริ่มต้นด้วยแนวทางของ Rust and Go และตีความสาระสำคัญที่เกี่ยวข้องได้หรือไม่? ลองมาลองดูกัน

• เก็บขยะ

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

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

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

— ปิงแคป

• ใกล้เคียงกับฮาร์ดแวร์

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

**เป้าหมายของ Rust คือการอนุญาตให้โปรแกรมเมอร์ "เข้าใกล้ฮาร์ดแวร์" และได้รับการควบคุมมากขึ้น ขณะที่ Go จะลบรายละเอียดทางสถาปัตยกรรมออกไป ทำให้โปรแกรมเมอร์เข้าใกล้ปัญหามากขึ้น **

ทั้งสองภาษามีขอบเขตการใช้งานที่แตกต่างกัน Go เก่งในการเขียนไมโครเซอร์วิสและงาน "DevOps" ทั่วไป แต่ไม่ใช่ภาษาการเขียนโปรแกรมระบบ Rust แข็งแกร่งกว่าในงานที่เน้นการทำงานพร้อมกัน ความปลอดภัย และ/หรือประสิทธิภาพ และมีกราฟการเรียนรู้ที่สูงชันกว่า Go

— แมทธิว เอ็นด์เลอร์

• แสดงก่อน

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

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

สนิมทำงานได้เร็วกว่า Go ในเกณฑ์มาตรฐาน Rust นั้นเร็วกว่าจริง ๆ ในบางกรณีตามลำดับความสำคัญ แต่ก่อนที่คุณจะเลือก Rust ขอให้ชัดเจน: Go นั้นไม่ได้ล้าหลังกว่าเกณฑ์มาตรฐานส่วนใหญ่ และยังคงรักษาความได้เปรียบด้านประสิทธิภาพเหนือภาษาต่างๆ เช่น Java, C#, Java และ Python

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

— แอนดรูว์ เลเดอร์

• ความถูกต้อง

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

ทั้ง Go และ Rust ช่วยคุณในการเขียนโปรแกรมที่ถูกต้อง แต่ด้วยวิธีที่แตกต่างกัน: **Go มีเฟรมเวิร์กการทดสอบในตัวที่ยอดเยี่ยม ในขณะที่ Rust มุ่งเน้นไปที่การกำจัดบั๊กรันไทม์ผ่านตัวตรวจสอบการยืม **

ความเห็นของฉันคือ: สำหรับโค้ดที่ต้องออกพรุ่งนี้ ให้ใช้ Go ถ้าเป็นโค้ดที่ต้องรันอย่างเสถียรในอีก 5 ปีข้างหน้า ให้เลือก Rust

— เกรเซกอร์ซ โนเซก

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

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

Go รวดเร็วและทรงพลัง แต่หัวใจหลักคือช่วยให้นักพัฒนาหลีกทางและมุ่งเน้นไปที่ความเรียบง่ายและความสามัคคี ในทางกลับกัน หากคุณต้องการบีบเฮดรูมประสิทธิภาพทุกออนซ์ Rust เป็นตัวเลือกที่เหมาะสม

—แอนดรูว์ เลเดอร์

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

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

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