สนิมคืออะไร? การพัฒนาซอฟต์แวร์ที่ปลอดภัยรวดเร็วและง่ายดาย

รวดเร็วปลอดภัยเขียนง่าย - เลือกสองข้อ นั่นเป็นสถานะของการพัฒนาซอฟต์แวร์มาเป็นเวลานานแล้ว ภาษาที่เน้นความสะดวกและปลอดภัยมักจะช้า (เช่น Python) ภาษาที่เน้นประสิทธิภาพมักจะใช้งานยากและง่ายต่อการใช้งาน (เช่น C และ C ++)

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

วิดีโอที่เกี่ยวข้อง: การพัฒนาซอฟต์แวร์ที่ปลอดภัยยิ่งขึ้นด้วย Rust

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

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

ข้อดีของภาษาการเขียนโปรแกรมสนิม

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

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

สนิมเป็นไปอย่างรวดเร็ว

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

สนิมเป็นหน่วยความจำที่ปลอดภัย

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

สนิมมีค่าใช้จ่ายต่ำ

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

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

สนิมมีความยืดหยุ่น

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

สนิมใช้งานง่าย

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

ทุกสิ่งที่จำเป็นในการผลิต Rust ไบนารีมาในแพ็คเกจเดียวกัน คอมไพเลอร์ภายนอกเช่น GCC จำเป็นเฉพาะในกรณีที่คุณกำลังรวบรวมส่วนประกอบอื่น ๆ นอกระบบนิเวศ Rust (เช่นไลบรารี C ที่คุณรวบรวมจากแหล่งที่มา) ผู้ใช้ Microsoft Windows ไม่ใช่พลเมืองชั้นสองเช่นกัน ห่วงโซ่เครื่องมือ Rust นั้นมีความสามารถเช่นเดียวกับใน Linux และ MacOS

สนิมเป็นแบบข้ามแพลตฟอร์ม

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

Rust มีคุณสมบัติด้านภาษาที่ทรงพลัง

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

Rust มีไลบรารีมาตรฐานที่มีประโยชน์

ส่วนหนึ่งของภารกิจที่ใหญ่กว่าของ Rust คือการสนับสนุนให้นักพัฒนา C และ C ++ ใช้ Rust แทนภาษาเหล่านั้นทุกครั้งที่ทำได้ แต่ผู้ใช้ C และ C ++ คาดว่าจะมีไลบรารีมาตรฐานที่เหมาะสมพวกเขาต้องการที่จะสามารถใช้คอนเทนเนอร์คอลเลกชันและตัวทำซ้ำดำเนินการปรับแต่งสตริงจัดการกระบวนการและเธรดดำเนินการเครือข่ายและไฟล์ I / O และอื่น ๆ Rust ทำทุกอย่างและอื่น ๆ ในไลบรารีมาตรฐาน เนื่องจาก Rust ถูกออกแบบมาให้ข้ามแพลตฟอร์มไลบรารีมาตรฐานจึงมีเฉพาะสิ่งที่สามารถย้ายข้ามแพลตฟอร์มได้อย่างน่าเชื่อถือ ฟังก์ชันเฉพาะแพลตฟอร์มเช่น epoll ของ Linux จะต้องได้รับการสนับสนุนผ่านฟังก์ชันในไลบรารีของบุคคลที่สามเช่น libc, mio ​​หรือ tokio 

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

Rust มีไลบรารีของบุคคลที่สามหรือ "ลัง" มากมาย

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

Rust มีการรองรับ IDE ที่ดี 

อีกครั้งมีนักพัฒนาเพียงไม่กี่คนที่ต้องการใช้ภาษาที่มีการสนับสนุนน้อยหรือไม่มีเลยใน IDE ที่พวกเขาเลือก นั่นเป็นเหตุผลที่ Rust เพิ่งเปิดตัว Rust Language Server ซึ่งให้ข้อเสนอแนะแบบสดจากคอมไพเลอร์ Rust ไปยัง IDE เช่น Microsoft Visual Studio Code

ข้อเสียของภาษาการเขียนโปรแกรมสนิม

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

สนิมเป็นของใหม่

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

ตัวอย่างเช่นการดำเนินการแบบอะซิงโครนัสยังแสดงได้ไม่ดีในไวยากรณ์ของภาษา งานอยู่ระหว่างการดำเนินการ async ผ่านasyncและawaitคีย์เวิร์ด

สนิมเป็นเรื่องยากที่จะเรียนรู้

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

สนิมมีความซับซ้อน

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

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

แผนที่ถนนภาษาสนิม

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

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