รายงานการวิจัย: 30,000 คำเพื่อทำความเข้าใจภาษา Rust

星球君的朋友们

Odaily资深作者

2021-06-23 06:18

บทความนี้มีประมาณ 43880 คำ การอ่านทั้งหมดใช้เวลาประมาณ 63 นาที

Rust เป็นภาษาที่ได้รับความนิยมสูงสุดในรายการภาษา StackOverflow เป็นเวลาห้าปีติดต่อกัน

สรุปโดย AI

ขยาย

บทความนี้มาจากบทความนี้มาจากสมาคมจื๋อเสวี่ย

ผู้เขียน Zhang Handong ทำซ้ำโดยได้รับอนุญาต

ไดเร็กทอรีเนื้อหา:
เวินเชียน

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

ไลบรารีฐานระบบนิเวศสนิมและห่วงโซ่เครื่องมือ

สินค้าคงคลังแอปพลิเคชันอุตสาหกรรมสนิม
บริการข้อมูล
เมฆพื้นเมือง
ระบบปฏิบัติการ
การเรียนรู้ของเครื่อง
เกม
เกม
การพัฒนาลูกค้า
บล็อกเชน/สกุลเงินดิจิทัล

รับหุ้นของบริษัทต่างๆ ที่ใช้ Rust ในการผลิต

ภายในประเทศ
ภายในประเทศ
npm

เกี่ยวกับผู้เขียน

บรรณาธิการ mdnice

เวินเชียน

ภาษา Rust เป็นภาษาการเขียนโปรแกรมระดับระบบสำหรับวัตถุประสงค์ทั่วไป ซึ่งเป็นที่รู้จักว่าปราศจาก GC และรับประกันความปลอดภัยของหน่วยความจำ ความปลอดภัยในการทำงานพร้อมกัน และประสิทธิภาพสูง ได้รับการพัฒนาเป็นการส่วนตัวโดย Graydon Hoare ตั้งแต่ปี 2008 และได้รับการสนับสนุนจาก Mozilla ในปี 2009 เวอร์ชัน 0.1.0 เปิดตัวครั้งแรกในปี 2010 สำหรับการพัฒนาเครื่องยนต์ Servo เวอร์ชัน 1.0 เปิดตัวเมื่อวันที่ 15 พฤษภาคม 2015

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

ภาษายอดนิยมในรายการภาษา StackOverflow [1]

เมื่อวันที่ 9 กุมภาพันธ์ พ.ศ. 2564 มีการประกาศมูลนิธิสนิม Huawei, AWS, Google, Microsoft, Mozilla, Facebook และบริษัทยักษ์ใหญ่ชั้นนำอื่นๆ ในอุตสาหกรรมเทคโนโลยีได้เข้าร่วม Rust Foundation ในฐานะสมาชิกแพลตินัมเพื่อส่งเสริมและพัฒนาภาษา Rust ในระดับโลก

แล้วอะไรคือเสน่ห์ของภาษา Rust ที่ทำให้นักพัฒนาและบริษัทยักษ์ใหญ่สนใจได้?

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

บรรณาธิการ mdnice

ทำความรู้จักกับภาษาสนิม

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

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

อย่างไรก็ตาม ตามความเชื่อดั้งเดิม คุณไม่สามารถมีเค้กและกินมันด้วยได้ ภาษาเช่น Java ให้การรับประกันความปลอดภัยที่ยอดเยี่ยมแก่เรา แต่ต้องแลกกับการเสียสละการควบคุมเลเยอร์พื้นฐาน ด้วยเหตุนี้ สำหรับแอปพลิเคชันการเขียนโปรแกรมระบบจำนวนมาก ตัวเลือกเดียวที่เป็นไปได้จริงคือการใช้ภาษาอย่างเช่น C หรือ C++ ที่ให้การควบคุมอย่างละเอียดสำหรับการจัดการทรัพยากร อย่างไรก็ตาม การได้มาซึ่งการควบคุมนี้มีค่าใช้จ่ายสูง ตัวอย่างเช่น เมื่อเร็ว ๆ นี้ Microsoft รายงานว่า 70% ของข้อบกพร่องด้านความปลอดภัยที่พวกเขาแพตช์เกิดจากการละเมิดความปลอดภัยของหน่วยความจำ33[2] และเป็นปัญหาที่สามารถตัดออกได้โดยระบบที่มีการพิมพ์อย่างเข้มงวด ในทำนองเดียวกัน Mozilla รายงานว่าข้อบกพร่องที่สำคัญส่วนใหญ่ที่พบใน Firefox เกี่ยวข้องกับหน่วยความจำ16 [3]

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

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

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

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

สนิมมีระดับต่ำพอที่จะสามารถปรับแต่งได้เช่น C เพื่อประสิทธิภาพสูงสุดหากจำเป็น

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

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

ภาษา Rust ยังรองรับการเขียนโปรแกรมแบบอะซิงโครนัสด้วยการทำงานพร้อมกันสูงและค่าใช้จ่ายเป็นศูนย์ ภาษา Rust ควรเป็นภาษาระดับระบบแรกที่รองรับการเขียนโปรแกรมแบบอะซิงโครนัส

บรรณาธิการ mdnice

Rust vs C

Rust vs Cpp

Rust vs Go

ประสิทธิภาพสูงเทียบได้กับ C/Cpp

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

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

สนิมนั้นเร็วกว่า C ในบางด้าน ตามทฤษฎีแล้ว ภาษา C สามารถทำอะไรก็ได้ แต่ในทางปฏิบัติ ความสามารถนามธรรมของ C ค่อนข้างต่ำ ไม่ทันสมัย และประสิทธิภาพการพัฒนาค่อนข้างต่ำ C สามารถสร้างได้เร็วกว่า Rust ด้วยวิธีการเหล่านี้ ตราบเท่าที่นักพัฒนามีเวลาและความพยายามอย่างไม่จำกัด

เนื่องจากภาษา C เพียงพอที่จะแสดงถึงประสิทธิภาพสูง เรามาพูดถึงความเหมือนและความแตกต่างระหว่าง C และ Rust กันดีกว่า หากคุณคุ้นเคยกับ C/Cpp คุณสามารถประเมิน Cpp และ Rust ตามการเปรียบเทียบนี้ได้

ทั้ง Rust และ C เป็นนามธรรมโดยตรงกับฮาร์ดแวร์

ทั้ง Rust และ C ต่างก็เป็นนามธรรมของฮาร์ดแวร์โดยตรง และทั้งคู่ก็เปรียบได้ว่าเป็น "แอสเซมเบลอร์แบบพกพา""ทั้ง Rust และ C สามารถควบคุมเค้าโครงหน่วยความจำของโครงสร้างข้อมูล ขนาดจำนวนเต็ม การจัดสรรหน่วยความจำสแต็กและฮีป การกำหนดแอดเดรสทางอ้อมของตัวชี้ ฯลฯ และโดยทั่วไปสามารถแปลเป็นรหัสเครื่องที่เข้าใจได้ และคอมไพเลอร์แทบไม่แทรก"。

มายากล"แม้ว่า Rust จะมีโครงสร้างในระดับที่สูงกว่า C เช่น ตัววนซ้ำ คุณลักษณะ และพอยน์เตอร์อัจฉริยะ พวกมันได้รับการออกแบบมาให้ปรับให้เหมาะสมตามการคาดการณ์สำหรับรหัสเครื่องอย่างง่าย (หรือที่เรียกว่า"）。

สิ่งที่เป็นนามธรรมเป็นศูนย์รูปแบบหน่วยความจำของประเภท Rust นั้นเรียบง่าย เช่น สตริงที่เติบโตได้ String และ Vec

เท่ากับ {ไบต์*, ความจุ, ความยาว} Rust ไม่มีแนวคิดใด ๆ เช่นการย้ายหรือคัดลอกตัวสร้างใน Cpp ดังนั้นการผ่านวัตถุจึงรับประกันได้ว่าจะไม่ซับซ้อนไปกว่าการส่งผ่านพอยน์เตอร์หรือ memcpy

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

แทนที่จะจัดการข้อยกเว้นแบบเดิม Rust ใช้การจัดการข้อผิดพลาดตามค่าส่งคืน แต่คุณสามารถใช้ความตื่นตระหนก (Panic) เพื่อจัดการกับพฤติกรรมที่ผิดปกติได้ เช่นใน Cpp สามารถปิดใช้งานได้ในขณะคอมไพล์ (panic = abort) แต่ถึงอย่างนั้น Rust ก็ไม่ชอบยุ่งกับข้อยกเว้น Cpp หรือ longjmp

แบ็กเอนด์ LLVM เดียวกัน

Rust มีการผสานรวมกับ LLVM ที่ยอดเยี่ยม ดังนั้นจึงรองรับการปรับเวลาลิงก์ให้เหมาะสม รวมถึง ThinLTO และแม้แต่อินไลน์ข้ามขอบเขตของภาษา C/C++/Rust นอกจากนี้ยังมีการรองรับ Profile-guided Optimization (PGO) แม้ว่า rustc จะสร้าง LLVM IR แบบละเอียดมากกว่าเสียงดังกราว แต่ตัวเพิ่มประสิทธิภาพยังคงจัดการได้ดี

ภาษา C รวบรวมได้เร็วกว่าด้วย GCC มากกว่าด้วย LLVM และตอนนี้บางคนในชุมชน Rust กำลังพัฒนาส่วนหน้าของ Rust ของ GCC

ในทางทฤษฎี เนื่องจาก Rust มีกฎที่ไม่เปลี่ยนรูปและนามแฝงที่เข้มงวดกว่า C จึงควรมีการปรับปรุงประสิทธิภาพการทำงานที่ดีกว่าภาษา C แต่ในทางปฏิบัติ จะไม่มีผลกระทบดังกล่าว การปรับให้เหมาะสมนอกเหนือจาก C อยู่ในระหว่างดำเนินการใน LLVM ดังนั้น Rust จึงยังไม่เต็มศักยภาพ

ทั้งสองอนุญาตให้ปรับให้เหมาะสมด้วยตนเอง โดยมีข้อยกเว้นเล็กน้อยบางประการ

โค้ดของ Rust นั้นอยู่ในระดับต่ำและสามารถคาดเดาได้มากพอที่จะสามารถปรับแต่งรหัสแอสเซมบลีที่ปรับให้เหมาะสมได้ด้วยมือ

Rust รองรับ SIMD พร้อมการควบคุมแบบอินไลน์และการโทรอย่างละเอียด

สนิมและ C มีความคล้ายคลึงกันมากพอที่เครื่องมือวิเคราะห์บางอย่างสำหรับ C มักใช้กับสนิม

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

แต่ในคุณสมบัติระดับล่างบางอย่าง Rust ไม่มีทางเลือกที่ดีเป็นพิเศษ
ไปที่. Goto ไม่มีให้ใน Rust แต่คุณสามารถใช้ป้ายกำกับตัวแบ่งลูปแทนได้ ในภาษา C โดยทั่วไปจะใช้ goto เพื่อล้างหน่วยความจำ แต่ Rust ไม่ต้องการ goto เนื่องจากฟังก์ชัน deterministic destructor อย่างไรก็ตาม มีส่วนขยาย goto ที่ไม่ได้มาตรฐานซึ่งมีประโยชน์สำหรับการเพิ่มประสิทธิภาพ
การจัดสรรหน่วยความจำสแต็ก alloca และอาร์เรย์ความยาวตัวแปร C99 สามารถประหยัดพื้นที่หน่วยความจำและลดจำนวนการจัดสรรหน่วยความจำ แต่สิ่งเหล่านี้ยังเป็นที่ถกเถียงกันแม้ใน C ดังนั้น Rust จึงอยู่ห่างจากสิ่งเหล่านี้

ค่าใช้จ่ายบางส่วนของ Rust เมื่อเทียบกับ C

หากไม่ได้รับการปรับให้เหมาะกับมือ Rust ก็มีค่าใช้จ่ายบางส่วนเนื่องจากสิ่งที่เป็นนามธรรม
การขาดการแปลงประเภทโดยนัยของ Rust และการทำดัชนีเฉพาะการใช้งานทำให้นักพัฒนาจำกัดการใช้ประเภทนี้ แม้แต่ประเภทข้อมูลที่มีขนาดเล็กกว่า การใช้ usize เป็นดัชนีบนแพลตฟอร์ม 64 บิตนั้นง่ายต่อการปรับให้เหมาะสมโดยไม่ต้องกังวลเกี่ยวกับลักษณะการทำงานที่ไม่ได้กำหนด แต่บิตเพิ่มเติมอาจสร้างแรงกดดันให้กับรีจิสเตอร์และหน่วยความจำมากขึ้น ในขณะที่ C คุณสามารถเลือกประเภท 32 บิตได้
สตริงในสนิมจะมีตัวชี้และความยาวเสมอ แต่หลายฟังก์ชันในโค้ด C ยอมรับเฉพาะพอยน์เตอร์โดยไม่คำนึงถึงขนาด
ด้วยการทำซ้ำเช่นสำหรับ i ใน 0...len {arr[i]} ประสิทธิภาพจะขึ้นอยู่กับเครื่องมือเพิ่มประสิทธิภาพ LLVM ที่สามารถพิสูจน์ความยาวที่ตรงกันได้ บางครั้งก็ทำไม่ได้ และการตรวจสอบขอบเขตยังขัดขวางการทำให้เป็นเวกเตอร์อัตโนมัติอีกด้วย
ภาษา C นั้นค่อนข้างฟรี โดยมีเทคนิคการใช้งานที่ "ชาญฉลาด" มากมายสำหรับหน่วยความจำ แต่ไม่ฟรีใน Rust แต่ Rust ยังคงควบคุมการจัดสรรหน่วยความจำได้มาก และสามารถทำสิ่งพื้นฐาน เช่น การรวมหน่วยความจำ การรวมการจัดสรรหลายรายการเป็นหนึ่งเดียว การจัดสรรพื้นที่ล่วงหน้า และอื่นๆ
หากไม่มีความคุ้นเคยกับการตรวจสอบการยืมของ Rust อาจใช้ Clone เพื่อหลบหนีโดยใช้ข้อมูลอ้างอิง
I/O ในไลบรารีมาตรฐานของ Rust ไม่ถูกแคช ดังนั้นจึงจำเป็นต้องรวมไว้ด้วย BufWriter นี่คือสาเหตุที่บางคนบอกว่าโค้ดที่เขียนด้วย Rust ไม่เร็วเท่า Python เพราะ 99% ของเวลาถูกใช้ไปกับ I/O

ขนาดไฟล์ปฏิบัติการ

ทุกระบบปฏิบัติการมีไลบรารี C มาตรฐานในตัวซึ่งมีโค้ดประมาณ 30MB ไฟล์ปฏิบัติการในภาษา C สามารถใช้ไลบรารี่เหล่านี้ได้ "ฟรี""Hello World "ที่มีขนาดเล็ก

โปรแกรมปฏิบัติการระดับ C ไม่สามารถพิมพ์อะไรได้เลย มันแค่เรียก printf ที่ระบบปฏิบัติการให้มา

ไม่เช่นนั้นกับ Rust ซึ่งไฟล์เรียกทำงานของ Rust จะรวมไลบรารี่มาตรฐานของตัวเอง (300KB ขึ้นไป) โชคดีที่นี่เป็นค่าใช้จ่ายเพียงครั้งเดียวที่สามารถลดได้"no-std"สำหรับการพัฒนาแบบฝัง สามารถปิดไลบรารี่มาตรฐานได้โดยใช้",สนิมจะเกิด"เปลือย

รหัส."ในแต่ละฟังก์ชัน รหัสสนิมมีขนาดเท่ากับ C แต่มี a"อัตราเงินเฟ้อทั่วไป

ปัญหา. ฟังก์ชันทั่วไปได้ปรับเวอร์ชันให้เหมาะสมสำหรับแต่ละประเภทที่ใช้งาน ดังนั้นจึงเป็นไปได้ที่จะมีฟังก์ชันเดียวกัน 8 เวอร์ชัน และไลบรารี่ของ Cargo-bloat[4] จะช่วยค้นหาปัญหาเหล่านี้

การทำงานกับการอ้างอิงใน Rust นั้นง่ายมาก คล้ายกับ JS/npm ตอนนี้แนะนำให้ใช้แพ็คเกจขนาดเล็กและวัตถุประสงค์เดียว แต่จะเพิ่มขึ้น คำสั่ง cargo-tree มีประโยชน์มากสำหรับการตัดทอนพวกมัน

โดยที่ Rust เต้น C เล็กน้อย
หากต้องการซ่อนรายละเอียดการใช้งาน ไลบรารี C มักจะส่งคืนพอยน์เตอร์โครงสร้างข้อมูลแบบทึบ และตรวจสอบให้แน่ใจว่าแต่ละอินสแตนซ์ของโครงสร้างมีสำเนาเดียว ใช้ค่าใช้จ่ายในการจัดสรรฮีปและทิศทางตัวชี้ ความเป็นส่วนตัวในตัวของ Rust กฎการเป็นเจ้าของคนเดียว และแบบแผนการเข้ารหัสทำให้ไลบรารีสามารถเปิดเผยออบเจกต์ของตนได้โดยไม่อ้อมค้อม เพื่อให้ผู้เรียกสามารถตัดสินใจได้ว่าจะวางออบเจกต์เหล่านี้ไว้บนฮีปหรือบนสแต็ก วัตถุบนสแต็กสามารถปรับให้เหมาะสมที่สุดในเชิงรุกหรือทั่วถึง
ตามค่าเริ่มต้น Rust สามารถอินไลน์ฟังก์ชันจากไลบรารีมาตรฐาน การขึ้นต่อกัน และหน่วยคอมไพล์อื่นๆ
สนิมจัดเรียงฟิลด์โครงสร้างใหม่เพื่อปรับรูปแบบหน่วยความจำให้เหมาะสม
สตริงมีข้อมูลขนาด ทำให้ตรวจสอบความยาวได้อย่างรวดเร็ว และอนุญาตให้สร้างสตริงย่อยแบบแทนที่
คล้ายกับเทมเพลต C++ ฟังก์ชันทั่วไปใน Rust เป็นแบบ monomorphized ทำให้เกิดสำเนาประเภทต่างๆ ดังนั้นฟังก์ชันอย่างการเรียงลำดับและคอนเทนเนอร์อย่าง HashMap จึงได้รับการปรับให้เหมาะกับประเภทที่สอดคล้องกันเสมอ ด้วย C คุณต้องเลือกระหว่างการแก้ไขมาโครหรือฟังก์ชันที่มีประสิทธิภาพน้อยกว่าที่จัดการตัวแปร void* และรันไทม์
ตัววนซ้ำของ Rust สามารถรวมกันเป็นสายโซ่ที่ปรับเข้าด้วยกันเป็นหน่วยเดียว ดังนั้นแทนที่จะเรียกเป็นชุดเพื่อเขียนหลายครั้งไปยังบัฟเฟอร์เดียวกัน คุณสามารถเรียกมันว่า .buy().use().break().change().mail().upgrade().
ในทำนองเดียวกัน ผ่านอินเทอร์เฟซการอ่านและเขียน รับข้อมูลสตรีมที่ไม่ได้บัฟเฟอร์ ดำเนินการตรวจสอบ CRC บนสตรีม จากนั้นแปลงรหัส บีบอัด และเขียนไปยังเครือข่าย ทั้งหมดในการโทรครั้งเดียว แม้ว่าจะเป็นไปได้ที่จะทำใน C แต่หากไม่มีชื่อสามัญและลักษณะเฉพาะก็จะทำได้ยากมาก
ไลบรารีมาตรฐานของ Rust มีคอนเทนเนอร์คุณภาพสูงในตัวและโครงสร้างข้อมูลที่ได้รับการปรับปรุง ซึ่งสะดวกต่อการใช้งานมากกว่า C
serde ของ Rust เป็นหนึ่งในโปรแกรมแยกวิเคราะห์ JSON ที่เร็วที่สุดในโลก และประสบการณ์ในการใช้งานนั้นดีมาก

ข้อดีที่ชัดเจนของรัสต์เหนือซี

ส่วนใหญ่สองจุด:
Rust กำจัดการแย่งชิงข้อมูล, ปลอดภัยต่อเธรดโดยเนื้อแท้, และปลดปล่อยประสิทธิภาพการทำงานแบบมัลติเธรด นี่คือจุดที่ Rust เหนือกว่าภาษาต่างๆ เช่น C/Cpp อย่างชัดเจน
ภาษา Rust รองรับการเขียนโปรแกรมพร้อมกันสูงแบบอะซิงโครนัส

Rust รองรับการประเมินเวลาคอมไพล์อย่างปลอดภัย

ความปลอดภัยของเธรด

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

มีไลบรารีมากมายอยู่แล้วในระบบนิเวศของ Rust เช่น data parallelism, thread pools, คิว, งาน, โครงสร้างข้อมูลที่ปราศจากการล็อค เป็นต้น ด้วยความช่วยเหลือของส่วนประกอบดังกล่าวและเครือข่ายความปลอดภัยที่แข็งแกร่งของระบบประเภท การทำงานพร้อมกัน/การขนานกันของโปรแกรม Rust จึงค่อนข้างง่าย ในบางกรณี คุณสามารถใช้ par_iter แทน iter ได้ และตราบใดที่มันคอมไพล์ มันก็น่าจะใช้ได้! นี่ไม่ใช่การเร่งความเร็วเชิงเส้นเสมอไป (กฎของอัมดาห์ลนั้นโหดร้าย) แต่มักจะเป็นการเร่งความเร็ว 2-3 เท่าโดยใช้งานค่อนข้างน้อย

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

มีความแตกต่างที่น่าสนใจระหว่าง Rust และ C เมื่อพูดถึงเรื่องความปลอดภัยของเธรด

Rust มีอภิธานศัพท์ที่ใช้อธิบายลักษณะเฉพาะของความปลอดภัยของเธรด เช่น Send and Sync, guards and cells

สำหรับไลบรารี C ไม่มีสิ่งที่เรียกว่า "สามารถจัดสรรบนเธรดหนึ่งและว่างในเธรดอื่นได้ แต่ไม่สามารถใช้จากทั้งสองเธรดพร้อมกันได้"

Rust อธิบายถึงความปลอดภัยของเธรดในแง่ของประเภทข้อมูล ซึ่งครอบคลุมถึงฟังก์ชันทั้งหมดที่ใช้งาน

สำหรับภาษา C ความปลอดภัยของเธรดเกี่ยวข้องกับเฉพาะฟังก์ชันและค่าสถานะการกำหนดค่าเท่านั้น

การรับประกันของ Rust มีให้ในเวลาคอมไพล์ อย่างน้อยที่สุดก็ไม่มีเงื่อนไข

สำหรับภาษา C เป็นเรื่องปกติที่จะพูดว่า "เป็นเธรดที่ปลอดภัยเฉพาะเมื่อตั้งค่าตัวเลือก turboblub เป็น 7"

พร้อมกันแบบอะซิงโครนัส

ภาษา Rust รองรับรูปแบบการเขียนโปรแกรมแบบอะซิงโครนัสแบบอะซิงโครนัส/รอแบบอะซิงโครนัส

โมเดลการเขียนโปรแกรมนี้อิงตามแนวคิดที่เรียกว่า Future หรือที่เรียกว่า Promise ใน JavaScript อนาคตแสดงถึงค่าที่ยังไม่ได้แก้ไขซึ่งคุณสามารถดำเนินการต่างๆ ได้ก่อนที่จะได้รับการแก้ไขเพื่อให้ได้ค่านั้น ในหลายภาษา ยังไม่ได้ดำเนินการกับ Future มากนัก การใช้งานนี้รองรับคุณสมบัติหลายอย่าง เช่น ตัวรวม (Combinator) โดยเฉพาะอย่างยิ่งบนพื้นฐานนี้เพื่อให้ได้ไวยากรณ์ async/await ตามหลักสรีรศาสตร์

ฟิวเจอร์สสามารถเป็นตัวแทนของทุกสิ่ง และมีประโยชน์อย่างยิ่งสำหรับการแสดงอะซิงโครนัส I/O: เมื่อคุณส่งคำขอเครือข่าย คุณจะได้รับออบเจกต์ในอนาคตทันที และเมื่อคำขอเครือข่ายเสร็จสมบูรณ์ มันจะส่งคืนค่าใด ๆ ที่ตอบสนอง อาจมี ; คุณยังสามารถหมายถึงสิ่งต่าง ๆ เช่น "หมดเวลา" "หมดเวลา" คืออนาคตที่ได้รับการแก้ไขหลังจากช่วงเวลาหนึ่ง แม้แต่งานที่ไม่ใช่ I/O หรือจำเป็นต้องวางไว้ในเธรดพูลเพื่อเรียกใช้ CPU มาก งานยังสามารถแสดงด้วย Future ซึ่งจะได้รับการแก้ไขหลังจากเธรดพูลทำงานเสร็จสิ้น

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

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

มันยังช่วยให้เราสร้างขอบเขตนามธรรมที่ชัดเจนระหว่างส่วนต่าง ๆ ของโปรแกรม ไลบรารี Future อื่น ๆ ส่วนใหญ่มี event loop (event loop) ซึ่งเป็นวิธีกำหนดเวลา Future ของคุณเพื่อดำเนินการ I/O แต่ความจริงแล้ว คุณไม่สามารถควบคุมสิ่งนี้ได้

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

และข้อได้เปรียบที่แท้จริงที่สำคัญที่สุดของโมเดลนี้คือช่วยให้เราสามารถนำสเตทแมชชีนประเภทนี้ไปใช้ในอนาคตได้อย่างสมบูรณ์แบบโดยมีค่าใช้จ่ายเป็นศูนย์อย่างแท้จริง นั่นคือ เมื่อ Future code ที่คุณเขียนถูกคอมไพล์เป็น local local (native) code มันจะเหมือนกับ state machine ใน state machine แต่ละจุดหยุด I/O จะมีตัวแปร (variant) แต่ตัวแปรแต่ละตัวจะบันทึก รัฐจำเป็นต้องดำเนินการต่อ

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

ในระบบนิเวศของ Rust ปัจจุบัน มีระบบนิเวศรันไทม์ของ tokio[5] ที่ครบกำหนดแล้วซึ่งสนับสนุน I/O แบบอะซิงโครนัส เช่น epoll หากคุณต้องการใช้ io_uring คุณสามารถใช้ Glommio[6] หรือรอการสนับสนุนของ tokio สำหรับ io_uring คุณยังสามารถใช้ async_executor[7] และ async-io[8] ที่จัดเตรียมโดย smol runtime เพื่อสร้างรันไทม์ของคุณเอง

การคำนวณเวลาคอมไพล์

สนิมสามารถรองรับการประเมินเวลาคอมไพล์คงที่คล้ายกับ Cpp นี่มันเหนือกว่าซีชัดๆ

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

บรรณาธิการ mdnice

ความน่าเชื่อถือ

ในเดือนมิถุนายน 2020 นักวิชาการ 5 คนจาก 3 มหาวิทยาลัยเผยแพร่ผลการวิจัยในการประชุมนานาชาติ ACM SIGPLAN (PLDI'20) ซึ่งดำเนินการตรวจสอบข้อบกพร่องด้านความปลอดภัยในโครงการโอเพ่นซอร์สอย่างครอบคลุมโดยใช้ภาษา Rust ในช่วงไม่กี่ปีที่ผ่านมา การศึกษานี้ตรวจสอบระบบซอฟต์แวร์ 5 ระบบที่พัฒนาโดยใช้ภาษา Rust, ไลบรารี่ของ Rust ที่ใช้กันอย่างแพร่หลาย 5 รายการ และฐานข้อมูลช่องโหว่ 2 รายการ การตรวจสอบเกี่ยวข้องกับการใช้รหัสที่ไม่ปลอดภัยทั้งหมด 850 รายการ ข้อบกพร่องด้านความปลอดภัยของหน่วยความจำ 70 รายการ และข้อบกพร่องด้านความปลอดภัยของเธรด 100 รายการ

ในการสืบสวนของพวกเขา นักวิจัยไม่ได้พิจารณาเฉพาะจุดบกพร่องที่รายงานในฐานข้อมูลช่องโหว่ทั้งหมดและจุดบกพร่องที่รายงานต่อสาธารณะในซอฟต์แวร์เท่านั้น แต่ยังพิจารณาบันทึกในที่เก็บรหัสซอฟต์แวร์โอเพ่นซอร์สทั้งหมดด้วย ผ่านการวิเคราะห์ด้วยตนเอง พวกเขากำหนดประเภทของ BUG ที่การแก้ไขที่ส่ง และจัดประเภทเป็นปัญหาด้านความปลอดภัยของหน่วยความจำ/ความปลอดภัยของเธรดที่สอดคล้องกัน ปัญหาที่ตรวจสอบทั้งหมดถูกจัดไว้ในพื้นที่เก็บข้อมูล Git สาธารณะ: https://github.com/system-pclub/rust-study[9]

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

จำเป็นต้องสร้างเครื่องมือตรวจจับข้อบกพร่องใหม่สำหรับปัญหาทั่วไปในภาษา Rust

แล้วความปลอดภัยของ Rust ที่อยู่เบื้องหลังรายงานการสำรวจนี้รับประกันได้อย่างไร? สนิมไม่ปลอดภัยและทำไมถึงไม่ปลอดภัย

ความเป็นเจ้าของ: กลไกความปลอดภัยของหน่วยความจำภาษาสนิม

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

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

ปัญหาความไม่ปลอดภัยของหน่วยความจำที่แก้ไขโดยกลไกการเป็นเจ้าของรวมถึง:
มีการอ้างอิงตัวชี้ว่าง
การใช้หน่วยความจำที่ไม่ได้กำหนดค่าเริ่มต้น
Use-after-free นั่นคือ การใช้ตัวชี้ห้อย
บัฟเฟอร์ล้น เช่น อาร์เรย์อยู่นอกขอบเขต

การปล่อยพอยน์เตอร์ที่ปล่อยไปแล้วหรือพอยน์เตอร์ที่ไม่ได้จัดสรรอย่างผิดกฎหมาย นั่นคือการรีลีสซ้ำ

โปรดทราบว่าการรั่วไหลของหน่วยความจำไม่ใช่ปัญหาด้านความปลอดภัยของหน่วยความจำ ดังนั้น Rust จึงไม่สามารถแก้ปัญหาการรั่วไหลของหน่วยความจำได้เช่นกัน

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

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

ระบบการเป็นเจ้าของยังรวมถึงกลไก RAII ที่ยืมมาจาก C++ สมัยใหม่ ซึ่งเป็นรากฐานที่สำคัญของการจัดการหน่วยความจำที่ปราศจาก GC แต่ปลอดภัยของ Rust

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

การหักเงินประเภทท้องถิ่น

เพื่อให้หน่วยความจำมีความปลอดภัย Rust ยังมีคุณสมบัติเฉพาะดังต่อไปนี้:
Affine Type ซึ่งใช้เพื่อแสดงความหมายของ Move ในการเป็นเจ้าของ Rust

ยืมวงจรชีวิต

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

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

สนิมที่ไม่ปลอดภัย: แบ่งขอบเขตความปลอดภัย

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

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

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

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

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

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

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

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

ต่อไปนี้เป็นข้อกำหนดง่ายๆ 5 ข้อสำหรับการใช้ Unsafe ที่ฉันได้สรุปไว้ เพื่อให้ทุกคนสามารถแลกเปลี่ยนกันได้:
ใช้ Safe Rust ถ้าคุณสามารถใช้ Safe Rust;
สนิมที่ไม่ปลอดภัยสามารถใช้เพื่อประสิทธิภาพได้
เมื่อใช้ Unsafe Rust ตรวจสอบให้แน่ใจว่าไม่ได้สร้าง UB และพยายามตัดสินขอบเขตความปลอดภัย และสรุปว่าเป็นวิธีที่ปลอดภัย
หากไม่สามารถสรุปได้ว่าปลอดภัย จะต้องทำเครื่องหมายว่าไม่ปลอดภัยและแนบเอกสารเงื่อนไขสำหรับการสร้าง UB มาด้วย

สำหรับรหัสที่ไม่ปลอดภัย คุณสามารถมุ่งเน้นไปที่การตรวจทาน

อย่างไรก็ตาม มีคณะทำงานด้านความปลอดภัยของสนิมในระบบนิเวศชุมชนของสนิม ซึ่งมีชุดเครื่องมือต่างๆ เช่น การตรวจสอบสินค้า [11] และดูแลปัญหาด้านความปลอดภัยที่พบในชุมชนระบบนิเวศของสนิมที่บันทึกไว้ในไลบรารีฐานข้อมูลความปลอดภัย `RustSecurity` [12]. สะดวกในการตรวจสอบปัญหาความปลอดภัยของไลบรารีที่ต้องพึ่งพาในโครงการ Rust

บรรณาธิการ mdnice

กำลังผลิต

ประสิทธิภาพของภาษาโปรแกรมสามารถประเมินได้จากสามด้านต่อไปนี้:
เส้นโค้งการเรียนรู้
ความสามารถด้านวิศวกรรมภาษา
นิเวศวิทยาโดเมน

เส้นโค้งการเรียนรู้

เส้นโค้งการเรียนรู้จะสูงหรือต่ำขึ้นอยู่กับระดับของแต่ละบุคคล ต่อไปนี้เป็นรายชื่อสถานที่ที่ควรให้ความสนใจสำหรับการเรียนรู้พื้นฐานต่างๆ ของ Rust
นักพัฒนาที่ไม่มีพื้นฐานเป็นศูนย์โดยสมบูรณ์: เชี่ยวชาญโครงสร้างความรู้ของระบบคอมพิวเตอร์พื้นฐาน เข้าใจสิ่งที่เป็นนามธรรมของภาษา Rust และเลเยอร์ฮาร์ดแวร์/ระบบปฏิบัติการ เข้าใจแนวคิดหลักของภาษา Rust และโหมดนามธรรม และเลือกฟิลด์ที่เกี่ยวข้องของภาษา Rust สำหรับ การฝึกอบรมภาคปฏิบัติ ปรับปรุงความสามารถและความเข้าใจเชิงลึกของภาษา Rust ผ่านการฝึกฝน ในขณะที่เชี่ยวชาญความรู้ด้านโดเมน
รากฐานภาษา C: เนื่องจากนักพัฒนาภาษา C ไม่มีความเข้าใจที่ดีเกี่ยวกับสิ่งที่เป็นนามธรรมของภาษาระดับสูง พวกเขาจึงมุ่งเน้นไปที่การทำความเข้าใจและการเรียนรู้กลไกความเป็นเจ้าของของ Rust ซึ่งรวมถึงความหมายของความเป็นเจ้าของ วงจรชีวิต และการตรวจสอบการยืม ทำความเข้าใจรูปแบบเชิงนามธรรมของภาษา Rust ประเภทและคุณลักษณะส่วนใหญ่ และ OOP และคุณลักษณะภาษาเชิงฟังก์ชันของ Rust เอง
รากฐานของ C++: นักพัฒนา C++ มีความเข้าใจเป็นอย่างดีเกี่ยวกับความเป็นเจ้าของภาษา Rust และมุ่งเน้นไปที่รูปแบบนามธรรมและคุณลักษณะของภาษาที่ใช้งานได้ของ Rust
มีพื้นฐาน Java/Python/Ruby: มุ่งเน้นที่การทำความเข้าใจและการเอาชนะกลไกความเป็นเจ้าของของ Rust รูปแบบนามธรรม และคุณลักษณะของภาษาการเขียนโปรแกรมเชิงฟังก์ชัน
ปูพื้นฐาน: นักพัฒนาภาษา Go เข้าใจรูปแบบนามธรรมและลักษณะเฉพาะของ Rust ได้ง่ายขึ้น แต่ Go ก็เป็นภาษา GC เช่นกัน ดังนั้นกลไกการเป็นเจ้าของและคุณลักษณะของภาษาที่ใช้งานได้จึงเป็นจุดเน้นของการเรียนรู้ของพวกเขา

มีรากฐานของ Haskell: นักพัฒนาของ Haskell มีความเข้าใจเป็นอย่างดีเกี่ยวกับคุณลักษณะการทำงานของภาษา Rust และเอาชนะกลไกการเป็นเจ้าของและคุณลักษณะของภาษา OOP เป็นหลัก

ดังนั้น สำหรับนักพัฒนาที่มีพื้นฐานมาบ้างแล้ว แนวคิดหลักหลายประการที่ควรเชี่ยวชาญในการเรียนรู้ภาษา Rust คือ:

1. กลไกความเป็นเจ้าของสนิม รวมถึงความหมายของความเป็นเจ้าของ วงจรชีวิต และการตรวจสอบการยืม

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

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

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

3. คุณสมบัติภาษา OOP คุ้นเคยกับคุณสมบัติทั่วไปสี่ประการของการเขียนโปรแกรมเชิงวัตถุ (OOP): ออบเจ็กต์ การห่อหุ้ม การสืบทอด และความหลากหลาย คุณจะเข้าใจคุณลักษณะบางอย่างของ Rust ได้ดียิ่งขึ้น เช่น impl, pub, trait เป็นต้น

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

ความสามารถด้านวิศวกรรมภาษา

รัสต์พร้อมแล้วสำหรับการพัฒนาผลิตภัณฑ์ที่มีความแข็งแรงระดับอุตสาหกรรม

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

เพื่อให้แน่ใจว่ารองรับระบบฮาร์ดเรียลไทม์ Rust ยืมตัวทำลายเชิงกำหนด, RAII และพอยน์เตอร์อัจฉริยะจาก C++ สำหรับการจัดการหน่วยความจำอัตโนมัติและเชิงกำหนด ดังนั้นจึงหลีกเลี่ยงการแนะนำ GC ดังนั้นจึงไม่มีปัญหา "หยุดชั่วคราว" แม้ว่ารายการเหล่านี้จะยืมมาจาก C++ แต่ก็มีความกระชับในการใช้งานมากกว่า C++

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

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

สำหรับข้อยกเว้น Rust ถือว่าปัญหาเหล่านี้เป็นปัญหาที่ไม่สามารถแก้ไขได้อย่างมีเหตุผล และจัดเตรียมกลไก thread panic เมื่อมีข้อยกเว้นเกิดขึ้น เธรดสามารถออกได้อย่างปลอดภัย

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

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

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

เพื่อให้ผสานเข้ากับระบบนิเวศที่มีอยู่ได้เป็นอย่างดี Rust รองรับกลไก FFI ที่สะดวกและไม่มีค่าใช้จ่าย เข้ากันได้กับ C-ABI และแบ่งภาษา Rust ออกเป็น Safe Rust และ Unsafe Rust จากระดับสถาปัตยกรรมภาษา ในหมู่พวกเขา Unsafe Rust เชี่ยวชาญในการจัดการกับระบบภายนอก เช่น เคอร์เนลของระบบปฏิบัติการ เหตุผลของการแบ่งนี้คือการตรวจสอบและติดตามของคอมไพเลอร์ Rust นั้นมีจำกัด เป็นไปไม่ได้ที่จะตรวจสอบสถานะความปลอดภัยของอินเทอร์เฟซภาษาภายนอกอื่น ๆ ดังนั้นผู้พัฒนาจึงสามารถรับประกันได้เท่านั้น Unsafe Rust ให้คีย์เวิร์ดที่ไม่ปลอดภัยและบล็อกที่ไม่ปลอดภัย ซึ่งแยกรหัสที่ปลอดภัยออกจากรหัสที่ไม่ปลอดภัยที่เข้าถึงอินเทอร์เฟซภายนอกอย่างชัดเจน และยังให้ความสะดวกแก่นักพัฒนาในการแก้ไขจุดบกพร่อง Safe Rust หมายความว่าผู้พัฒนาจะไว้วางใจคอมไพเลอร์เพื่อความปลอดภัยในขณะคอมไพล์ ในขณะที่ Unsafe Rust หมายความว่าคอมไพเลอร์จะเชื่อมั่นในความสามารถของผู้พัฒนาในการรับรองความปลอดภัย

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

เพื่อให้นักพัฒนาสามารถทำงานร่วมกันได้ง่ายขึ้น Rust ได้จัดเตรียมตัวจัดการแพ็คเกจ Cargo[13] ที่มีประโยชน์มาก รหัสสนิมถูกรวบรวมและแจกจ่ายตามแพ็คเกจ (ลัง) Cargo มีคำสั่งมากมายเพื่ออำนวยความสะดวกให้นักพัฒนาในการสร้าง สร้าง แจกจ่าย และจัดการแพ็คเกจของตนเอง Cargo ยังมีกลไกปลั๊กอินซึ่งสะดวกสำหรับนักพัฒนาในการเขียนปลั๊กอินแบบกำหนดเองเพื่อตอบสนองความต้องการที่มากขึ้น ตัวอย่างเช่น สามารถใช้เครื่องมือ rustfmt และ clippy อย่างเป็นทางการเพื่อจัดรูปแบบโค้ดโดยอัตโนมัติและค้นหา "กลิ่นไม่ดี" ในโค้ดตามลำดับ อีกตัวอย่างหนึ่ง เครื่องมือสนิมสามารถช่วยนักพัฒนาแก้ไขรหัสที่ผิดพลาดโดยอัตโนมัติตามคำแนะนำของคอมไพเลอร์ นอกจากนี้ Cargo ยังรองรับชุมชนโอเพ่นซอร์สและ Git และสนับสนุนการเผยแพร่แพ็คเกจที่เขียนด้วยคลิกเดียวไปยังเว็บไซต์ crates.io เพื่อให้ผู้อื่นใช้งานได้

เพื่อให้นักพัฒนาสามารถเรียนรู้เกี่ยวกับ Rust ได้ง่ายขึ้น ทีมงานอย่างเป็นทางการของ Rust ได้ดำเนินการดังต่อไปนี้:
แยกคณะทำงานชุมชนโดยเฉพาะ เขียน Rust Book อย่างเป็นทางการ และเอกสารอื่นๆ ที่มีความลึกต่างกัน เช่น เอกสารคอมไพเลอร์ หนังสือ nomicon เป็นต้น แม้กระทั่งจัดกิจกรรมการสอนชุมชนฟรีใน Rust Bridge ส่งเสริมการสร้างบล็อกของชุมชนอย่างจริงจัง และอื่นๆ อีกมากมาย
เอกสารประกอบของภาษา Rust รองรับรูปแบบ Markdown ดังนั้นเอกสารประกอบของไลบรารีมาตรฐานของ Rust จึงเต็มไปด้วยการแสดงออก ความชัดเจนของเอกสารสำหรับแพ็คเกจของบุคคลที่สามจำนวนมากในระบบนิเวศได้รับการปรับปรุงเช่นกัน
มีเครื่องมือ Playground ออนไลน์ที่มีประโยชน์มากสำหรับนักพัฒนาในการเรียนรู้ ใช้ และแบ่งปันโค้ด
ภาษา Rust ได้รับการบูทตั้งแต่เนิ่นๆ ซึ่งสะดวกสำหรับผู้เรียนในการทำความเข้าใจกลไกภายในโดยการอ่านซอร์สโค้ด และแม้แต่มีส่วนร่วมในส่วนสนับสนุน
ทีมหลักของ Rust ได้ปรับปรุง Rust อย่างต่อเนื่อง โดยมุ่งมั่นที่จะปรับปรุงความเป็นมิตรของ Rust พยายามลดภาระทางจิตใจของผู้เริ่มต้น และทำให้ช่วงการเรียนรู้ช้าลง ตัวอย่างเช่น การแนะนำคุณสมบัติ NLL เพื่อปรับปรุงระบบตรวจสอบการยืมช่วยให้นักพัฒนาสามารถเขียนโค้ดที่ใช้งานง่ายยิ่งขึ้น
แม้ว่าจะยืมเนื้อหาจำนวนมากที่เกี่ยวข้องกับระบบประเภทจาก Haskell แต่ทีม Rust จะจงใจเลิกใช้วิชาการเมื่อออกแบบและส่งเสริมฟีเจอร์ภาษาเพื่อให้ผู้คนสามารถเข้าถึงแนวคิดของ Rust ได้มากขึ้น
ตามระบบประเภท จะให้การสนับสนุนกระบวนทัศน์การเขียนโปรแกรมแบบผสม ให้ความสามารถในการแสดงออกเชิงนามธรรมที่ทรงพลังและรัดกุม และปรับปรุงประสิทธิภาพการพัฒนาของนักพัฒนาอย่างมาก

เพื่ออำนวยความสะดวกแก่นักพัฒนาของ Rust ในการปรับปรุงประสิทธิภาพการพัฒนา ชุมชนของ Rust ยังให้การสนับสนุน IDE ที่มีประสิทธิภาพอีกด้วย VSCode/Vim/Emacs + ตัววิเคราะห์สนิมได้กลายเป็นมาตรฐานสำหรับการพัฒนาสนิม แน่นอนว่า IDEA/Clion ของตระกูล JetBrains ก็ให้การสนับสนุน Rust เช่นกัน

บรรณาธิการ mdnice

สนิมและโอเพ่นซอร์ส

ในฐานะที่เป็นโครงการโอเพ่นซอร์ส ภาษา Rust ยังเป็นไข่มุกที่ส่องประกายในซอฟต์แวร์โอเพ่นซอร์สสมัยใหม่อีกด้วย

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

ทีม Rust ประกอบด้วยสมาชิก Mozilla และสมาชิกที่ไม่ใช่ Mozilla และปัจจุบันมีผู้มีส่วนร่วมมากกว่า 1,900 รายในโครงการ Rust ทีม Rust แบ่งออกเป็นกลุ่มหลักและกลุ่มงานโดเมนอื่น ๆ สำหรับเป้าหมายของ Rust 2018 ทีม Rust จะแบ่งออกเป็นกลุ่มทำงานแบบฝังตัว กลุ่มงาน CLI กลุ่มงานเครือข่าย และกลุ่มงาน WebAssembly เช่นกัน เช่นคณะทำงานระบบนิเวศและคณะทำงานชุมชน เป็นต้น

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

หลังจากการก่อตั้ง Rust Foundation ทีมงานของ Rust ยังสำรวจโซลูชันการกำกับดูแลแบบโอเพ่นซอร์สใหม่ๆ อย่างต่อเนื่อง

บรรณาธิการ mdnice

จุดอ่อนของภาษาสนิม

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

บรรณาธิการ mdnice

ไลบรารีฐานระบบนิเวศสนิมและห่วงโซ่เครื่องมือ

ระบบนิเวศของ Rust มีมากขึ้นเรื่อย ๆ ไลบรารีและเฟรมเวิร์กพื้นฐานจำนวนมากจะถูกเผยแพร่ไปยัง crates.io[14] ในรูปแบบของ crate ถึงตอนนี้มี 62,981 กล่องบน crates.io และยอดดาวน์โหลดทั้งหมดถึง 7,654,973,261 ครั้ง.

จำแนกตามสถานการณ์การใช้งานแพ็คเกจ สถานการณ์ยอดนิยมของ Crates.io มีดังนี้:
Command Line Tools (3133 กล่อง)
ห้องสมุด no-std (2778 ลัง)
เครื่องมือพัฒนา (การทดสอบ/ดีบัก/การกรอง/การตรวจจับประสิทธิภาพ ฯลฯ 2652 กล่อง)
การเขียนโปรแกรมเว็บ (1776 ลัง)
การรวม API (บรรจุภัณฑ์ api เฉพาะสำหรับ Rust เช่น http api, ffi ที่เกี่ยวข้องกับ api เป็นต้น 1738 ลัง)
การเขียนโปรแกรมเครือข่าย (1615 ลัง)
โครงสร้างข้อมูล (1572 ลัง)
Embedded Development (1508 กล่อง)
เทคโนโลยีการเข้ารหัส (1498 กล่อง)
การพัฒนาแบบอะซิงโครนัส (1487 ลัง)
อัลกอริทึม (1200 กล่อง)

คอมพิวเตอร์ทางวิทยาศาสตร์ (รวมถึงฟิสิกส์ ชีววิทยา เคมี ภูมิศาสตร์ การเรียนรู้ของเครื่อง ฯลฯ จำนวน 1,100 กล่อง)

นอกจากนี้ยังมีหมวดหมู่อื่นๆ เช่น WebAssembly, การเข้ารหัส, การประมวลผลข้อความ, การทำงานพร้อมกัน, GUI, เอ็นจิ้นเกม, การแสดงภาพ, เอ็นจิ้นเทมเพลต, พาร์เซอร์, การรวมระบบปฏิบัติการ และไลบรารีมากมาย

ไลบรารีและห่วงโซ่เครื่องมือพื้นฐานที่รู้จักกันดีที่ใช้กันทั่วไป

ในหมู่พวกเขา มีห้องสมุดพื้นฐานที่ยอดเยี่ยมมากมายเกิดขึ้น ซึ่งสามารถดูได้จากหน้าแรกของ crates.io นี่คือบางส่วน:
การทำให้เป็นซีเรียลไลเซชัน/ดีซีเรียลไลเซชัน: Serde[15]
การพัฒนาบรรทัดคำสั่ง: clap[16]/structopt[17]
การพัฒนา Async/เว็บ/เครือข่าย: tokio [18] / tracing [19] / async-trait [20] / tower [21] / async-std [22] tonic [23] / actix-web [24] / smol [25 ] ]/surf[26]/async-graphql[27]/warp/[28] tungstenite[29]/encoding_rs[30]/loom[31]/Rocket[32]
การพัฒนา FFi: libc [33]/ winapi [34]/ bindgen [35]/ pyo3 [36]/ num_enum [37]/ jni [38]/rustler_sys[39]/ cxx [40]/ cbindgen [41]/ autocxx- บินเกน [42]
การพัฒนา API: jsonwebtoken [43]/ เครื่องมือตรวจสอบ [44]/ tarpc [45]/ nats [46]/ โทนิค[47]/ protobuf [48]/ ไฮเปอร์ [49]/ httparse [50]/ reqwest [51] / url [ 52]
Parsers: nom[53]/pest[54]/csv[55]/combine[56]/wasmparser[57]/ron[58]/larrpop[59]
WebAssembly: wasm-bindgen[67]/ wasmer [68]/ wasmtime [69]/ yew [70]
การเข้ารหัส: openssl [60] / ring [61] / hmac [62] / rustls [63] / orion [64] / themis [65] / RustCrypto [66]
การพัฒนาฐานข้อมูล: diesel [71]/ sqlx [72]/rocksdb [73]/ mysql [74]/ elasticsearch [75]/ rbatis [76]
การทำงานพร้อมกัน: crossbeam [77]/ parking_lot [78]/ crossbeam-channel [79]/ rayon [80]/ concurrent-queue[81]/ threadpool [82] / flume [83]
การพัฒนาสมองกลฝังตัว: Embedded-hal [84]/ cortex-m [85]/ bitvec [86]/ cortex-m-rtic [87]/ Embedded-dma [88]/ cross [89]/ Knurling Tools[90]
การทดสอบ: static_assertions [91] / ความแตกต่าง [92] / การตรวจสอบด่วน [93] / ตามอำเภอใจ [94] / mockall [95] / เกณฑ์ [96] / proptest [97] / tarpaulin [98] / fake-rs [99]
การพัฒนามัลติมีเดีย:rust-av[100]/ image[101]/ svg[102]/rusty_ffmpeg[103]/ Symphonia[104]/"rapier") / Rustcraft[115] Nestadia[116]/ naga[117]/ Bevy Retro[118]/ Texture Generator[119] / building_blocks[120] / rpg-cli [121]/ macroquad[122]
การพัฒนา TUI/GUI: winit [123]/ gtk [124]/ egui [125]/ imgui [126]/ yew [127]/ cursive [128]/ iced [129]/ fontdue [130]/ tauri [131]/ ดรูอิด [132]

บรรณาธิการ mdnice

สินค้าคงคลังแอปพลิเคชันอุตสาหกรรมสนิม

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

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

บรรณาธิการ mdnice

บริการข้อมูล

ด้านการบริการข้อมูลประกอบด้วยฐานข้อมูล คลังข้อมูล สตรีมข้อมูล ข้อมูลขนาดใหญ่ ฯลฯ

คำสำคัญ: ฐานข้อมูล / ระบบกระจาย / CNCF

แนะนำ

TiKV [133] เป็นฐานข้อมูลคีย์-ค่าธุรกรรมแบบกระจายแบบโอเพ่นซอร์ส โดยมุ่งเน้นที่การจัดหาสถาปัตยกรรมสตอเรจที่เชื่อถือได้ คุณภาพสูง และใช้งานได้จริงสำหรับฐานข้อมูลรุ่นต่อไป เริ่มแรกพัฒนาโดยทีม PingCAP TiKV ได้เปิดตัวและนำไปใช้ใน Zhihu, Yidian, Shopee, Meituan, JD Cloud, Zhuanzhuan และองค์กรชั้นนำอื่น ๆ ในหลายอุตสาหกรรม

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

ในเดือนสิงหาคม 2018 CNCF ประกาศว่าได้รับการยอมรับให้เป็นโครงการ Sandbox บนคลาวด์ ในเดือนพฤษภาคม 2019 ได้รับการเลื่อนตำแหน่งจาก Sandbox เป็นโครงการบ่มเพาะ

รหัสและขนาดทีม

โครงการ TiKV มีรหัสสนิมประมาณ 300,000 บรรทัด (รวมถึงรหัสทดสอบ)

TiKV เป็นโครงการโอเพ่นซอร์สระดับโลก และสามารถดูขนาดทีมได้จากรายชื่อผู้ร่วมให้ข้อมูล [134] องค์กร TiKV ยังรวมถึงโครงการ Go/Cpp บางโครงการ ซึ่งไม่รวมอยู่ในนั้น จะนับเฉพาะจำนวนกำลังคนที่เกี่ยวข้องกับโครงการ Rust เท่านั้น
การพัฒนาหลัก: ประมาณ 20 คน

การสนับสนุนจากชุมชน: มากกว่า 300 คน

รอบโครงการ

TiKV เป็นที่เก็บข้อมูลพื้นฐานของ TiDB ตามวิวัฒนาการของ TiDB TiDB ได้รับการพัฒนาสำหรับ Go และ TiKV ได้รับการพัฒนาสำหรับ Rust

ในเดือนมกราคม พ.ศ. 2559 ได้รับการออกแบบและพัฒนาให้เป็นเครื่องมือจัดเก็บข้อมูลพื้นฐานของ TiDB

เวอร์ชันแรกเปิดตัวเป็นโอเพ่นซอร์สในเดือนเมษายน 2559

เมื่อวันที่ 16 ตุลาคม 2017 TiDB เปิดตัวเวอร์ชัน GA (TiDB 1.0) และ TiKV เปิดตัว 1.0

เมื่อวันที่ 27 เมษายน 2018 TiDB เปิดตัวเวอร์ชัน 2.0 GA และ TiKV เปิดตัวเวอร์ชัน 2.0

เมื่อวันที่ 28 มิถุนายน 2019 TiDB เปิดตัวเวอร์ชัน 3.0 GA และ TiKV เปิดตัวเวอร์ชัน 3.0

เมื่อวันที่ 28 พฤษภาคม 2020 TiDB เปิดตัวเวอร์ชัน 4.0 GA และ TiKV เปิดตัว 4.0

เมื่อวันที่ 7 เมษายน 2021 TiDB เปิดตัวเวอร์ชัน 5.0 GA และ TiKV เปิดตัวเวอร์ชัน 5.0

ความคิดเห็น

เพื่อนๆ บางคนอาจกังวลเกี่ยวกับประสิทธิภาพการพัฒนาของ Rust มากกว่า และต้องการหาปริมาณโดยเฉพาะอย่างยิ่งเพื่อเปรียบเทียบประสิทธิภาพการพัฒนาของภาษาอื่นๆ เช่น C/Cpp/Go

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

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

คำสำคัญ: คลังข้อมูลเรียลไทม์ / การเป็นผู้ประกอบการ / รอบนางฟ้า

แนะนำ

TensorBase[135] เป็นโครงการผู้ประกอบการที่เปิดตัวโดย Dr. Jin Mingjian ในเดือนสิงหาคม 2020 เริ่มต้นจากมุมมองใหม่ที่ทันสมัย โดยใช้วัฒนธรรมและวิธีการแบบโอเพ่นซอร์ส สร้างคลังข้อมูลแบบเรียลไทม์ขึ้นใหม่ภายใต้ Rust เพื่อตอบสนองความต้องการของยุคนี้ ข้อมูลมหาศาล การจัดเก็บและวิเคราะห์ข้อมูล โครงการ TensorBase ได้รับการลงทุนแบบ Angel Round จากบริษัทร่วมทุนที่มีชื่อเสียงระดับโลก

รหัสและขนาดทีม

เนื่องจาก TensorBase สร้างขึ้นบน Apache Arrow[136] และ Arrow DataFusion[137] สถิติโค้ดจึงไม่รวมการขึ้นต่อกันของทั้งสองโปรเจ็กต์

บรรทัดรหัสหลักของ TensorBase มีมากกว่า 54,000 บรรทัด

ขนาดทีม:
การพัฒนาหลัก: 1 คน

การสนับสนุนจากชุมชน: 13 คน

เนื่องจากเป็นโครงการใหม่ ชุมชนโอเพ่นซอร์สยังอยู่ระหว่างการก่อสร้าง

รอบโครงการ

TensorBase เผยแพร่ตามเวลา ไม่ใช่เวอร์ชันความหมาย รอบการวนซ้ำคาดว่าจะเป็นเวอร์ชันหลักในหนึ่งปีและเวอร์ชันรองในเดือนมกราคม

จากที่วางจำหน่ายอย่างเป็นทางการในวันที่ 20 เมษายน 2021 ถึง 16 มิถุนายนล่าสุด

คำสำคัญ: Dataflow/ Distributed System/ Entrepreneurship

แนะนำ

Timely Dataflow[138] เป็นการนำ Rust สมัยใหม่มาใช้โดยอ้างอิงจากเอกสาร Timely Dataflow จาก Microsoft: "Naiad: A Timely Dataflow System" [139] เป็นผลิตภัณฑ์โอเพ่นซอร์สของบริษัท clockworks.io[140]

การประมวลผลที่ซับซ้อนบนข้อมูลการสตรีมในระบบแบบกระจายเป็นเรื่องยากมาก เช่น การวนซ้ำหลายครั้งหรือการคำนวณส่วนเพิ่ม Storm, Streaming Spark และ MillWheel ยังไม่ได้รับการปรับให้เข้ากับความต้องการที่ซับซ้อนของแอพพลิเคชั่นต่างๆ ด้วยการแนะนำแนวคิดของการประทับเวลา Naiad ให้โมเดลระดับต่ำมากที่สามารถใช้เพื่ออธิบายการประมวลผลสตรีมที่ซับซ้อนตามอำเภอใจ

ระบบกระแสข้อมูลครอบคลุมทุกอย่าง และ MapReduce และ Spark ถือได้ว่าเป็นตัวแทน โฟลว์ข้อมูลแบบทันท่วงทีให้นามธรรมตามเวลาอย่างสมบูรณ์ รวมการประมวลผลแบบสตรีมและการคำนวณแบบวนซ้ำ สามารถใช้ Dataflow แบบทันเวลาเมื่อคุณต้องการการประมวลผลแบบขนานของข้อมูลการสตรีมและการควบคุมการวนซ้ำ

รหัสและขนาดทีม

ขนาดรหัสสนิมประมาณ 13,000 บรรทัด

ขนาดทีม:
นักพัฒนาหลัก: 4 คน

การสนับสนุนจากชุมชน: มากกว่า 30 คน

รอบโครงการ

7 กันยายน 2017 รุ่น 0.3.0

28 มิถุนายน 2018 เวอร์ชัน 0.6.0

16 กันยายน 2018 รุ่น 0.7.0

3 ธันวาคม 2018 เวอร์ชัน 0.8.0

31 มีนาคม 2019 เวอร์ชัน 0.9.0

10 กรกฎาคม 2019 เวอร์ชัน 0.10.0

10 มีนาคม 2021 เวอร์ชัน 0.12.0

โดยพื้นฐานแล้ว เวอร์ชันเล็กๆ จะออกทุกๆ 3 เดือน นอกจาก Timely Dataflow แล้ว ทีมงานยังดูแล Differential Dataflow[141] ที่สร้างขึ้นบน Timely Dataflow ซึ่งจะทำซ้ำพร้อมกันกับ Timely Dataflow

คำสำคัญ: โครงการฐานข้อมูล/เอกสารวิชาการ

แนะนำ

Noria [142] เป็นระบบสตรีมข้อมูลแบบใหม่ที่ได้รับการออกแบบให้เป็นแบ็กเอนด์ที่จัดเก็บข้อมูลที่รวดเร็วสำหรับเว็บแอปพลิเคชันที่ใช้งานหนัก โดยอ้างอิงจากวิทยานิพนธ์ระดับปริญญาเอกของ MIT Jon Gjengset [143] ซึ่งอ้างอิงโดย OSDI'18 Paper [145] คล้ายกับฐานข้อมูล แต่รองรับการคำนวณล่วงหน้าและการแคชผลลัพธ์ของคิวรีเชิงสัมพันธ์ เพื่อเพิ่มความเร็วในการสืบค้น Noria จะเก็บผลลัพธ์ที่แคชไว้โดยอัตโนมัติเป็นข้อมูลพื้นฐาน โดยจัดเก็บไว้ในตารางพื้นฐานแบบถาวร Noria ใช้กระแสข้อมูลที่มีสถานะเป็นบางส่วนเพื่อลดโอเวอร์เฮดของหน่วยความจำและรองรับกระแสข้อมูลแบบไดนามิก รันไทม์ และการเปลี่ยนแปลงการสืบค้น

รหัสและขนาดทีม

จำนวนบรรทัดของรหัสสนิมประมาณ 59,000 บรรทัด

ขนาดทีม:
ผู้ร่วมให้ข้อมูลหลัก: 2 คน

ผู้สนับสนุนชุมชน: 21

รอบโครงการ

เนื่องจากเป็นโครงการวิจัยเชิงวิชาการส่วนบุคคล วงจรการเปิดตัวจึงไม่ชัดเจนนัก

รอบโครงการตั้งแต่วันที่ 30 กรกฎาคม 2016 ถึง 30 เมษายน 2020 โดยมีการคอมมิตทั้งหมดมากกว่า 5,000 รายการ

เวกเตอร์ (ท่อต่างประเทศ/โอเพ่นซอร์ส/ข้อมูล)

คำสำคัญ: Data Pipeline / Distributed Systems / Entrepreneurship

Vector[146] เป็นไปป์ไลน์ข้อมูลความสามารถในการสังเกตการณ์แบบ end-to-end (โบรกเกอร์และผู้รวบรวมข้อมูล) ที่มีประสิทธิภาพสูงซึ่งสร้างโดย Timer เป็นโอเพ่นซอร์สและเร็วกว่าทางเลือกทั้งหมดในพื้นที่ (Logstash, Fluentd เป็นต้น) ถึง 10 เท่า ปัจจุบัน บริษัทต่างๆ เช่น Douban, checkbox.ai, fundamentei, BlockFi, Fly.io ฯลฯ ใช้ Vector คลิกที่นี่ [147] สำหรับรายงานประสิทธิภาพอย่างเป็นทางการ และที่นี่ [148] สำหรับบริษัทที่ใช้ Vector ในการผลิต

รหัสและขนาดทีม

จำนวนรหัสประมาณ 180,000 บรรทัดของรหัสสนิม

ขนาดทีม:
การพัฒนาหลัก: 9 คน

การสนับสนุนจากชุมชน: 140 คน

รอบโครงการ

ในวันที่ 22 มีนาคม 2019 เวอร์ชันเริ่มต้นได้รับการปล่อยตัว

ในวันที่ 10 มิถุนายน 2019 เวอร์ชัน 0.2.0 ได้รับการปล่อยตัว

2 กรกฎาคม 2019 รุ่น 0.3.0 เปิดตัว

25 กันยายน 2019 รุ่น 0.4.0 เปิดตัว

ในวันที่ 11 ตุลาคม 2019 เวอร์ชัน 0.5.0 ได้รับการปล่อยตัว

ในวันที่ 13 ธันวาคม 2019 เวอร์ชัน 0.6.0 ได้รับการปล่อยตัว

ในวันที่ 12 มกราคม 2020 เวอร์ชัน 0.7.0 ได้เปิดตัว

ในวันที่ 26 กุมภาพันธ์ 2020 เวอร์ชัน 0.8.0 ได้เปิดตัว

21 เมษายน 2020 เวอร์ชัน 0.9.0 เปิดตัว

ในวันที่ 23 กรกฎาคม 2020 เวอร์ชัน 0.10.0 ได้เปิดตัว

ในวันที่ 12 มีนาคม 2021 เวอร์ชัน 0.11.0 ~ 0.12 จะเปิดตัว

22 เมษายน 2021 เวอร์ชัน 0.13.0 เปิดตัว

3 มิถุนายน 2021 เวอร์ชัน 0.14.0 เปิดตัว

Arrow-rs (ต่างประเทศ/โอเพ่นซอร์ส/มาตรฐานข้อมูลขนาดใหญ่)

คำสำคัญ: ข้อมูลขนาดใหญ่/มาตรฐานรูปแบบข้อมูล/Apach

arrow-rs[149] เป็นการนำ Apache Arrow ไปใช้ใน Rust Apache Arrow เป็นมาตรฐานรูปแบบข้อมูลการจัดเก็บคอลัมน์ในหน่วยความจำที่เหมาะสำหรับระบบข้อมูลขนาดใหญ่ที่แตกต่างกัน มีวิสัยทัศน์ที่ยิ่งใหญ่มาก: เพื่อจัดหาแพลตฟอร์มการพัฒนาสำหรับการวิเคราะห์ในหน่วยความจำ ช่วยให้ข้อมูลสามารถเคลื่อนย้ายและประมวลผลได้เร็วขึ้นระหว่างระบบข้อมูลขนาดใหญ่ที่แตกต่างกัน

Arrow ได้แนะนำ Rust[150] ตั้งแต่เวอร์ชัน 2.0 และตั้งแต่เวอร์ชัน 4.0 การใช้งาน Rust ได้ย้ายไปยังคลังข้อมูลอิสระ arrow-rs

การใช้งาน Rust ของ Arrow นั้นประกอบด้วยโปรเจกต์ต่างๆ มากมาย รวมถึงลังและไลบรารีแต่ละรายการต่อไปนี้:
arrow[151], ไลบรารีหลักของ arrow-rs ซึ่งรวมอยู่ใน arrow-rs
arrow-flight [152] หนึ่งในองค์ประกอบ arrow-rs ซึ่งรวมอยู่ใน arrow-rs
ไม้ปาร์เก้[153] หนึ่งในองค์ประกอบลูกศร-rs รวมอยู่ในลูกศร-rs ในระบบนิเวศของข้อมูลขนาดใหญ่ Parquet เป็นรูปแบบการจัดเก็บไฟล์ที่ได้รับความนิยมมากที่สุด
DataFusion [154] ซึ่งเป็นเอ็นจินการดำเนินการสืบค้นข้อมูลในหน่วยความจำที่ปรับขนาดได้ ใช้ Arrow เป็นรูปแบบ

Ballista [155] ซึ่งเป็นแพลตฟอร์มการประมวลผลแบบกระจายที่ขับเคลื่อนโดย Apache Arrow และ DataFusion รวมอยู่ใน DataFusion

รหัสและขนาดทีม

เมื่อรวมส่วนประกอบที่เกี่ยวข้องของ arrow-rs จำนวนของรหัสสนิมคือประมาณ 180,000 บรรทัด

ขนาดทีม:
ผู้พัฒนาหลัก: ประมาณ 10 คน

การสนับสนุนจากชุมชน: มากกว่า 550 คน

รอบโครงการ

โครงการ DataFusion เริ่มสร้างในปี 2559 และต่อมาได้เข้าสู่โครงการ Apache Arrow

เริ่มต้นด้วย arrow-rs 4.0:

ในวันที่ 18 เมษายน 2021 เวอร์ชัน 4.0 ได้รับการปล่อยตัว

ในวันที่ 18 พฤษภาคม 2021 เวอร์ชัน 4.1 ได้เปิดตัว

ในวันที่ 30 พฤษภาคม 2021 เวอร์ชัน 4.2 ได้รับการปล่อยตัว

ในวันที่ 11 มิถุนายน 2021 เวอร์ชัน 4.3 ได้เปิดตัว

InfluxDB IOx (ฐานข้อมูลต่างประเทศ / โอเพ่นซอร์ส / อนุกรมเวลา)

คำสำคัญ: ฐานข้อมูลอนุกรมเวลา/กระจาย

InfluxDB IOx[156] เครื่องมือจับเวลารุ่นต่อไปของ InfluxDB ถูกเขียนใหม่โดยใช้ Rust + Aarow

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

เนื่องจากดัชนีและข้อมูลถูกจัดเก็บแยกกัน ฟังก์ชันนำเข้าและส่งออกข้อมูลที่มีประสิทธิภาพจึงทำได้ยาก

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

รหัสและขนาดทีม

ขนาดรหัส InfluxDB IOx คือรหัสสนิมประมาณ 160,000 บรรทัด

ขนาดทีม:
การพัฒนาหลัก: 5 คน

การสนับสนุนจากชุมชน: 24 คน

รอบโครงการ

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

แต่เมื่อพิจารณาจากสถานะของกิจกรรม GitHub แล้ว สถานะการพัฒนายังคงใช้งานอยู่มาก งานพัฒนาที่สำคัญคาดว่าจะเริ่มในปี 2564

คำสำคัญ: ฐานข้อมูลอนุกรมเวลา

แนะนำ

CeresDB เป็นฐานข้อมูลอนุกรมเวลาฟิวชั่น TP/AP ที่พัฒนาโดย Ant Group ซึ่งตอบสนองความต้องการในการจัดเก็บข้อมูลอนุกรมเวลาจำนวนมหาศาล การเจาะลึกแบบสอบถามหลายมิติ และการวิเคราะห์ตามเวลาจริงในจังหวะการเงิน การตรวจสอบ IOT และอื่น ๆ สถานการณ์ มีแผนโอเพ่นซอร์ส แต่ยังไม่เป็นโอเพ่นซอร์ส

ขนาดทีม

ปัจจุบันมีประมาณ 8-10 คนในการพัฒนาฐานข้อมูล

ข้อมูลอื่นไม่เป็นที่รู้จัก

Tantivy (ต่างประเทศ/โอเพ่นซอร์ส/ค้นหาข้อความเต็ม)

คำสำคัญ: ค้นหาข้อความแบบเต็ม / ลูซีน

tantivy[157] เป็นไลบรารีเสิร์ชเอ็นจิ้นแบบเต็มที่ได้รับแรงบันดาลใจจาก Apache Lucene ซึ่งใช้งานใน Rust

Tantivy เยี่ยมมาก นี่คือแอปที่สร้างขึ้นบน Rust + Tantivy + AWS: ให้บริการการค้นหาเว็บนับพันล้านรายการและสร้างกลุ่มคำทั่วไป [158]

รหัสและขนาดทีม

ขนาดรหัสประมาณ 50,000 บรรทัดของรหัสสนิม

ขนาดทีม:
การพัฒนาหลัก: 1 คน

การสนับสนุนชุมชน: 85 คน

รอบโครงการ

โครงการนี้ก่อตั้งขึ้นในปี 2559 และรอบการวนซ้ำคือค่าเฉลี่ยของการเปิดตัวเวอร์ชันย่อยหนึ่งเวอร์ชันต่อเดือน ปัจจุบันมีการเผยแพร่เป็นเวอร์ชัน 0.15.2

คำค้น : Zhihu/ลูซีน

แนะนำ

Rucene[159] เป็นเสิร์ชเอ็นจิ้นแบบ Rust-based แบบโอเพ่นซอร์สโดยทีม Zhihu Rucene ไม่ใช่แอปพลิเคชันที่สมบูรณ์ แต่เป็นไลบรารีโค้ดและ API ที่สามารถใช้เพื่อเพิ่มความสามารถในการค้นหาข้อความแบบเต็มให้กับแอปพลิเคชันได้อย่างง่ายดาย เป็นพอร์ต Rust ของโครงการ Apache Lucene 6.2.1

รหัสและขนาดทีม

ขนาดรหัสประมาณ 100,000 บรรทัดของรหัสสนิม

ขนาดทีม:
การพัฒนาหลัก: 4 คน

การสนับสนุนจากชุมชน: 0 คน

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

บรรณาธิการ mdnice

เมฆพื้นเมือง

ฟิลด์เนทีฟบนคลาวด์ประกอบด้วย: การประมวลผลที่เป็นความลับ, ไร้เซิร์ฟเวอร์, แพลตฟอร์มการคำนวณแบบกระจาย, คอนเทนเนอร์, WebAssembly, เครื่องมือการดำเนินการและการบำรุงรักษา ฯลฯ

StratoVirt (ในประเทศ/โอเพ่นซอร์ส/คอนเทนเนอร์)

คำสำคัญ: คอนเทนเนอร์ / การจำลองเสมือน / ไร้เซิร์ฟเวอร์

StratoVirt[160] เป็นแพลตฟอร์มการจำลองเสมือนแบบใช้สนิมเจเนอเรชั่นใหม่ที่พัฒนาโดยทีม Huawei OpenEuler

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

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

รหัสและขนาดทีม

ขนาดรหัสประมาณ 27,000 บรรทัดของรหัสสนิม