Báo cáo nghiên cứu: 30.000 từ để hiểu ngôn ngữ Rust
Bài viết này đến từBài viết này đến từXã hội Jue Xue
, tác giả Zhang Handong, sao chép với sự cho phép.
Thư mục nội dung:
văn thiên
Làm quen với ngôn ngữ Rust
Hiệu suất cao tương đương với C/Cpp
độ tin cậy
Lực lượng sản xuất
Rỉ sét và mã nguồn mở
Điểm yếu của ngôn ngữ Rust
Thư viện cơ sở sinh thái Rust và chuỗi công cụ
Hàng tồn kho ứng dụng công nghiệp rỉ sét
dịch vụ dữ liệu
đám mây bản địa
hệ điều hành
học máy
trò chơi
trò chơi
phát triển khách hàng
Chuỗi khối/Tiền kỹ thuật số
Thống kê các công ty sử dụng Rust trong sản xuất
nội địa
nội địa
npm
Giới thiệu về tác giả
trình soạn thảo mdnice
văn thiên
Ngôn ngữ Rust là ngôn ngữ lập trình cấp hệ thống có mục đích chung được biết đến là không có GC và đảm bảo an toàn bộ nhớ, an toàn đồng thời và hiệu suất cao. Nó đã được Graydon Hoare phát triển riêng từ năm 2008 và được Mozilla tài trợ vào năm 2009. Phiên bản 0.1.0 được phát hành lần đầu tiên vào năm 2010 để phát triển động cơ Servo. Phiên bản 1.0 được phát hành vào ngày 15 tháng 5 năm 2015.
Kể từ khi phát hành, tính đến hôm nay năm 2021, sau sáu năm phát triển, Rust đã không ngừng vươn lên và dần trưởng thành, ổn định.Từ năm 2016 đến năm 2021, Rust đã trở thành
Ngôn ngữ phổ biến nhất trong danh sách ngôn ngữ StackOverflow [1].
Vào ngày 9 tháng 2 năm 2021, Rust Foundation đã được công bố. Huawei, AWS, Google, Microsoft, Mozilla, Facebook và những gã khổng lồ hàng đầu khác trong ngành công nghệ đã tham gia Rust Foundation với tư cách là thành viên bạch kim để quảng bá và phát triển ngôn ngữ Rust trên phạm vi toàn cầu.
Vậy sức hấp dẫn của ngôn ngữ Rust là gì mà có thể khiến các nhà phát triển và các công ty khổng lồ quan tâm đến vậy?
Lưu ý: Dữ liệu được liệt kê trong bài viết này đều từ nội dung công khai trên Internet.
trình soạn thảo mdnice
Làm quen với ngôn ngữ Rust
Ngôn ngữ lập trình thiết kế từ lâu đã tồn tại xung đột giữa hai nguyện vọng dường như không thể hòa giải.
An toàn (an toàn). Chúng tôi muốn một hệ thống loại mạnh giúp loại bỏ tĩnh rất nhiều lỗi. Chúng tôi muốn quản lý bộ nhớ tự động. Chúng tôi muốn đóng gói dữ liệu để chúng tôi có thể thực thi các biểu diễn đối tượng bất biến của các biến riêng tư và đảm bảo rằng chúng sẽ không bị hỏng bởi mã không đáng tin cậy.
điều khiển. Ít nhất là đối với các chương trình lập trình hệ thống như trình duyệt web, hệ điều hành hoặc công cụ trò chơi, trong đó các ràng buộc về hiệu suất hoặc tài nguyên là một vấn đề quan trọng, chúng tôi muốn hiểu biểu diễn dữ liệu ở mức byte. Chúng tôi muốn tối ưu hóa việc sử dụng thời gian và không gian của các chương trình của mình bằng các kỹ thuật lập trình cấp thấp. Chúng tôi muốn sử dụng kim loại trần khi cần thiết.
Tuy nhiên, theo quan điểm truyền thống, bạn không thể vừa ăn bánh vừa ăn. Các ngôn ngữ như Java mang lại cho chúng tôi sự đảm bảo an ninh tuyệt vời, nhưng với cái giá phải trả là hy sinh quyền kiểm soát đối với các lớp bên dưới. Kết quả là, đối với nhiều ứng dụng lập trình hệ thống, lựa chọn thực tế duy nhất là sử dụng một ngôn ngữ như C hoặc C++ cung cấp khả năng kiểm soát chi tiết đối với việc quản lý tài nguyên. Tuy nhiên, có được sự kiểm soát này có chi phí cao. Ví dụ: Microsoft gần đây đã báo cáo rằng 70% lỗi bảo mật mà họ đã vá là do vi phạm an toàn bộ nhớ33[2] và là những sự cố có thể được loại trừ bằng một hệ thống được nhập mạnh. Tương tự như vậy, Mozilla đã báo cáo rằng phần lớn các lỗi nghiêm trọng mà họ tìm thấy trong Firefox đều liên quan đến bộ nhớ16 [3].
Sẽ không hay sao nếu một người bằng cách nào đó có thể có cả hai thứ tốt nhất: lập trình hệ thống bảo mật trong khi kiểm soát các lớp bên dưới. Do đó, ngôn ngữ Rust ra đời.
Trang web chính thức giới thiệu về Rust như sau: một ngôn ngữ cho phép mọi người xây dựng phần mềm đáng tin cậy và hiệu quả.
Có ba ưu điểm chính của ngôn ngữ Rust đáng được mọi người chú ý:
hiệu suất cao. Rust cực kỳ nhanh và cực kỳ hiệu quả về bộ nhớ. Không có thời gian chạy và không có bộ sưu tập rác, nó có khả năng thực hiện các dịch vụ đặc biệt đòi hỏi khắt khe, có thể chạy trên các thiết bị nhúng và có thể dễ dàng tích hợp với các ngôn ngữ khác.
độ tin cậy. Mô hình sở hữu và hệ thống kiểu phong phú của Rust đảm bảo an toàn bộ nhớ và an toàn luồng, cho phép bạn loại bỏ tất cả các loại lỗi tại thời điểm biên dịch.
Lực lượng sản xuất. Rust có tài liệu tuyệt vời, trình biên dịch thân thiện và thông báo lỗi rõ ràng. Nó cũng tích hợp công cụ quản lý gói và công cụ xây dựng hạng nhất, tự động hoàn thành thông minh và hỗ trợ nhiều trình soạn thảo để kiểm tra kiểu và mã định dạng tự động, v.v.
Rust ở mức thấp đủ để nó có thể được tối ưu hóa như C để có hiệu suất tối đa nếu cần.
Mức độ trừu tượng càng cao, quản lý bộ nhớ càng thuận tiện, thư viện có sẵn càng phong phú, mã chương trình Rust càng nhiều, càng nhiều việc phải làm nhưng nếu không kiểm soát có thể dẫn đến phình chương trình.
Tuy nhiên, các chương trình Rust cũng được tối ưu hóa tốt, đôi khi tốt hơn C, rất tốt cho việc viết mã tối thiểu ở mức từng byte theo con trỏ, trong khi Rust có khả năng kết hợp hiệu quả nhiều chức năng hoặc thậm chí cả thư viện. được đặt lại với nhau.
Ngôn ngữ Rust cũng hỗ trợ lập trình không đồng bộ với tính đồng thời cao và chi phí bằng 0. Ngôn ngữ Rust phải là ngôn ngữ cấp hệ thống đầu tiên hỗ trợ lập trình không đồng bộ.
trình soạn thảo mdnice
Rust vs C
Rust vs Cpp
Rust vs Go
Hiệu suất cao tương đương với C/Cpp
Các chương trình viết bằng Rust sẽ có tốc độ thời gian chạy và mức sử dụng bộ nhớ tương tự như các chương trình viết bằng C, nhưng hai ngôn ngữ có phong cách lập trình tổng thể khác nhau và rất khó để khái quát về hiệu suất của chúng.
Nói chung:
Trừu tượng là một con dao hai lưỡi. Ngôn ngữ Rust có mức độ trừu tượng cao hơn ngôn ngữ C và tính trừu tượng sẽ ẩn một số mã không được tối ưu hóa, điều đó có nghĩa là hiệu suất của việc triển khai mã Rust mặc định không phải là tốt nhất. Vì vậy, mã Rust của bạn phải được tối ưu hóa để đạt được hiệu suất giống như C. Rỉ sét không an toàn là một bản xuất hiệu suất cao.
Rust theo mặc định là an toàn cho luồng, loại bỏ các cuộc chạy đua dữ liệu và làm cho việc lập trình đồng thời đa luồng trở nên thiết thực hơn.
Rust thực sự nhanh hơn C theo một số cách. Về lý thuyết, ngôn ngữ C có thể làm bất cứ điều gì. Nhưng trên thực tế, khả năng trừu tượng hóa của C tương đối thấp, không hiện đại và hiệu quả phát triển tương đối thấp. C có thể được tạo ra nhanh hơn Rust theo những cách này, miễn là các nhà phát triển có thời gian và nỗ lực vô hạn.
Bởi vì ngôn ngữ C đủ để thể hiện hiệu suất cao, hãy nói về những điểm tương đồng và khác biệt giữa C và Rust. Nếu bạn đã quen thuộc với C/Cpp, bạn cũng có thể đánh giá Cpp và Rust dựa trên so sánh này.
Cả Rust và C đều là phần trừu tượng trực tiếp của phần cứng
Cả Rust và C đều là phần trừu tượng hóa phần cứng trực tiếp và cả hai đều có thể được coi là "trình biên dịch di động"."Cả Rust và C đều có thể kiểm soát bố cục bộ nhớ của cấu trúc dữ liệu, kích thước số nguyên, phân bổ bộ nhớ ngăn xếp và bộ nhớ heap, địa chỉ gián tiếp con trỏ, v.v. và thường có thể được dịch sang mã máy dễ hiểu và trình biên dịch hiếm khi chèn"。
ảo thuật"Mặc dù Rust có các cấu trúc cấp cao hơn C, chẳng hạn như trình vòng lặp, đặc điểm và con trỏ thông minh, nhưng chúng được thiết kế để tối ưu hóa có thể đoán trước thành mã máy đơn giản (hay còn gọi là"）。
trừu tượng chi phí bằng không
Chính xác là {byte*, dung lượng, độ dài}. Rust không có bất kỳ khái niệm nào như di chuyển hoặc sao chép hàm tạo trong Cpp, vì vậy việc truyền đối tượng được đảm bảo không phức tạp hơn việc truyền con trỏ hoặc memcpy .
Kiểm tra mượn rỉ chỉ đơn giản là phân tích tĩnh của trình biên dịch về các tham chiếu trong mã. Thông tin trọn đời đã được trích xuất hoàn toàn từ rất lâu trước khi ngôn ngữ trung gian cấp trung (MIR) được tạo.
Thay vì xử lý ngoại lệ truyền thống, Rust sử dụng xử lý lỗi dựa trên giá trị trả về. Nhưng bạn cũng có thể sử dụng hoảng loạn (Panic) để xử lý hành vi bất thường như trong Cpp. Nó có thể bị vô hiệu hóa tại thời điểm biên dịch (hoảng loạn = hủy bỏ), nhưng ngay cả khi đó, Rust không muốn gây rối với các ngoại lệ Cpp hoặc longjmp.
Cùng một chương trình phụ trợ LLVM
Rust có khả năng tích hợp tuyệt vời với LLVM, do đó, nó hỗ trợ tối ưu hóa thời gian liên kết, bao gồm cả ThinLTO và thậm chí nội tuyến qua các ranh giới ngôn ngữ C/C++/Rust. Ngoài ra còn có hỗ trợ cho Tối ưu hóa theo hướng dẫn hồ sơ (PGO). Mặc dù Rustc tạo LLVM IR dài dòng hơn clang, trình tối ưu hóa vẫn xử lý tốt.
Ngôn ngữ C được biên dịch với GCC nhanh hơn so với LLVM và hiện tại một số người trong cộng đồng Rust đang phát triển giao diện người dùng Rust của GCC.
Về lý thuyết, vì Rust có tính bất biến và quy tắc răng cưa chặt chẽ hơn C, nên nó sẽ có khả năng tối ưu hóa hiệu suất tốt hơn ngôn ngữ C, nhưng trên thực tế, nó không có tác dụng như vậy. Tối ưu hóa ngoài C hiện đang được tiến hành trong LLVM, vì vậy Rust vẫn chưa phát huy hết tiềm năng của nó.
Cả hai đều cho phép tối ưu hóa thủ công, với một số ngoại lệ nhỏ
Mã của Rust ở mức thấp và đủ dự đoán để có thể điều chỉnh bằng tay theo mã hợp ngữ mà nó tối ưu hóa.
Rust hỗ trợ SIMD, với khả năng kiểm soát tốt đối với các quy ước nội tuyến và gọi điện.
Rust và C tương tự nhau đến mức một số công cụ phân tích cho C thường có thể được sử dụng cho Rust.
Nói chung, nếu hiệu suất là cực kỳ quan trọng và tối ưu hóa thủ công là cần thiết để vắt kiệt từng chút hiệu suất cuối cùng, thì tối ưu hóa Rust không khác gì tối ưu hóa C.
Nhưng trong một số tính năng cấp thấp hơn, Rust không có lựa chọn thay thế đặc biệt tốt.
đi đến. Goto không được cung cấp trong Rust nhưng thay vào đó bạn có thể sử dụng nhãn ngắt vòng lặp. Trong ngôn ngữ C, goto thường được sử dụng để dọn sạch bộ nhớ, nhưng Rust không cần goto vì hàm hủy xác định của nó. Tuy nhiên, có một tiện ích mở rộng goto không chuẩn rất hữu ích để tối ưu hóa hiệu suất.
Cấp phát bộ nhớ ngăn xếp và các mảng có độ dài thay đổi C99 có thể tiết kiệm dung lượng bộ nhớ và giảm số lần cấp phát bộ nhớ. Nhưng những điều này gây tranh cãi ngay cả trong C, vì vậy Rust tránh xa chúng.
Một số chi phí của Rust so với C
Nếu không được tối ưu hóa bằng tay, Rust cũng có một số chi phí do tính trừu tượng của nó.
Việc Rust thiếu chuyển đổi loại ẩn và lập chỉ mục chỉ sử dụng hạn chế các nhà phát triển sử dụng loại này, ngay cả đối với các loại dữ liệu nhỏ hơn. Sử dụng usize làm chỉ mục trên nền tảng 64 bit sẽ dễ dàng tối ưu hóa hơn mà không phải lo lắng về hành vi không xác định, nhưng các bit bổ sung có thể gây thêm áp lực lên các thanh ghi và bộ nhớ. Trong khi ở C, bạn có thể chọn loại 32 bit.
Chuỗi trong Rust luôn mang theo con trỏ và độ dài. Nhưng nhiều chức năng trong mã C chỉ chấp nhận con trỏ bất kể kích thước.
Với các lần lặp như for i in 0...len {arr[i]}, hiệu suất phụ thuộc vào việc trình tối ưu hóa LLVM có thể chứng minh độ dài phù hợp hay không. Đôi khi, nó không thể và việc kiểm tra giới hạn cũng ức chế quá trình tự động hóa.
Ngôn ngữ C tương đối miễn phí, với nhiều kỹ thuật sử dụng bộ nhớ "thông minh", nhưng không quá miễn phí trong Rust. Nhưng Rust vẫn cung cấp nhiều quyền kiểm soát đối với việc phân bổ bộ nhớ và có thể thực hiện những việc cơ bản như tổng hợp bộ nhớ, hợp nhất nhiều phân bổ thành một, phân bổ trước không gian, v.v.
Nếu không quen với việc kiểm tra khoản vay của Rust, Clone có thể được sử dụng để trốn thoát bằng cách sử dụng tham chiếu.
I/O trong thư viện tiêu chuẩn của Rust không được lưu trong bộ đệm, vì vậy nó cần được gói bằng BufWriter. Đây là lý do tại sao một số người nói rằng mã được viết bằng Rust không nhanh bằng Python, vì 99% thời gian được dành cho I/O.
kích thước tập tin thực thi
Mọi hệ điều hành đều có một số thư viện C tiêu chuẩn tích hợp sẵn, có khoảng 30MB mã. Các tệp thực thi bằng ngôn ngữ C có thể sử dụng các thư viện này "miễn phí"."Hello World "nhỏ
Một tệp thực thi cấp C thực sự không thể in bất cứ thứ gì, nó chỉ gọi printf do hệ điều hành cung cấp.
Với Rust thì không như vậy, trong đó các tệp thực thi Rust đóng gói thư viện chuẩn của riêng chúng (300KB trở lên). May mắn thay, đây chỉ là chi phí hoạt động một lần có thể giảm bớt."no-std"Để phát triển nhúng, có thể tắt thư viện chuẩn bằng cách sử dụng", Rust sẽ tạo ra"trần trụi
mã số."Trên cơ sở từng chức năng, mã Rust có cùng kích thước với C, nhưng có"lạm phát chung
Vấn đề. Các chức năng chung có các phiên bản được tối ưu hóa cho từng loại mà chúng được sử dụng, do đó có thể có 8 phiên bản của cùng một chức năng và thư viện cargo-bloat[4] giúp tìm ra các sự cố này.
Làm việc với các phụ thuộc trong Rust rất dễ dàng. Tương tự như JS/npm, các gói nhỏ và đơn mục đích hiện được khuyến nghị, nhưng chúng vẫn phát triển. Lệnh cargo-tree rất hữu ích để cắt bớt chúng.
Trường hợp Rust hơi đánh bại C
Để ẩn các chi tiết triển khai, các thư viện C thường trả về các con trỏ cấu trúc dữ liệu mờ và đảm bảo rằng mỗi phiên bản của cấu trúc có chính xác một bản sao. Nó tiêu tốn chi phí phân bổ heap và định hướng con trỏ. Quyền riêng tư, quy tắc sở hữu đơn và quy ước mã hóa tích hợp sẵn của Rust cho phép các thư viện hiển thị các đối tượng của họ mà không cần chỉ dẫn để người gọi có thể quyết định đặt chúng trên đống hay trên ngăn xếp. Các đối tượng trên ngăn xếp có thể được tối ưu hóa mạnh mẽ hoặc triệt để.
Theo mặc định, Rust có thể nội tuyến các hàm từ thư viện chuẩn, các phần phụ thuộc và các đơn vị biên dịch khác.
Rust sắp xếp lại các trường cấu trúc để tối ưu hóa bố cục bộ nhớ.
Chuỗi mang thông tin kích thước, giúp kiểm tra độ dài nhanh chóng. và cho phép tạo chuỗi con tại chỗ.
Tương tự như các mẫu C++, các hàm chung trong Rust được đơn hình hóa, tạo ra các bản sao của các loại khác nhau, vì vậy các hàm như sắp xếp và vùng chứa như HashMap luôn được tối ưu hóa cho loại tương ứng. Với C, bạn phải chọn giữa việc sửa đổi macro hoặc các hàm kém hiệu quả hơn để xử lý khoảng trống* và kích thước biến thời gian chạy.
Các trình lặp của Rust có thể được kết hợp thành các chuỗi được tối ưu hóa cùng nhau dưới dạng một đơn vị. Vì vậy, thay vì một loạt lệnh gọi để ghi nhiều lần vào cùng một bộ đệm, bạn có thể gọi nó.buy().use().break().change().mail().upgrade().
Tương tự, thông qua giao diện Đọc và Ghi, nhận một số dữ liệu luồng không có bộ đệm, thực hiện kiểm tra CRC trên luồng, sau đó chuyển mã, nén và ghi vào mạng, tất cả chỉ trong một cuộc gọi. Mặc dù có thể làm điều đó trong C, nhưng nếu không có đặc điểm chung và đặc điểm chung, thì sẽ rất khó thực hiện.
Thư viện tiêu chuẩn Rust tích hợp sẵn các bộ chứa chất lượng cao và cấu trúc dữ liệu được tối ưu hóa, sử dụng thuận tiện hơn C.
Rust's serde là một trong những trình phân tích cú pháp JSON nhanh nhất trên thế giới và trải nghiệm sử dụng nó rất tốt.
Ưu điểm rõ ràng của Rust so với C
Chủ yếu là hai điểm:
Rust loại bỏ các cuộc chạy đua dữ liệu, vốn đã an toàn cho luồng và giải phóng năng suất đa luồng, đây là điểm mà Rust rõ ràng vượt trội so với các ngôn ngữ như C/Cpp.
Ngôn ngữ Rust hỗ trợ lập trình đồng thời cao không đồng bộ.
Rust hỗ trợ đánh giá thời gian biên dịch an toàn.
chủ đề an toàn
Ngay cả trong các thư viện của bên thứ ba, Rust thực thi sự an toàn của luồng đối với tất cả mã và dữ liệu, ngay cả khi tác giả của mã đó không chú ý đến sự an toàn của luồng. Mọi thứ tuân theo một đảm bảo an toàn luồng cụ thể hoặc không cho phép sử dụng luồng chéo. Khi bạn viết mã không an toàn cho luồng, trình biên dịch sẽ xác định chính xác nơi không an toàn.
Đã có nhiều thư viện trong hệ sinh thái Rust, chẳng hạn như song song dữ liệu, nhóm luồng, hàng đợi, tác vụ, cấu trúc dữ liệu không khóa, v.v. Với sự trợ giúp của các thành phần như vậy và mạng lưới an toàn mạnh mẽ của hệ thống loại, việc xử lý đồng thời/song song các chương trình Rust khá dễ dàng. Trong một số trường hợp, bạn có thể sử dụng par_iter thay vì iter và miễn là nó biên dịch, nó sẽ hoạt động! Đây không phải lúc nào cũng là một sự tăng tốc tuyến tính (luật của Amdahl rất tàn bạo), nhưng nó thường là một sự tăng tốc gấp 2-3 lần với tương đối ít công việc.
Phần mở rộng: Định luật Amdahl, một quy tắc ngón tay cái trong khoa học máy tính, được đặt theo tên của Gene Amdahl. Nó thể hiện khả năng cải thiện hiệu quả của bộ xử lý sau khi tính toán song song.
Có một sự khác biệt thú vị giữa Rust và C khi ghi lại sự an toàn của luồng.
Rust có một bảng chú giải các thuật ngữ được sử dụng để mô tả các khía cạnh cụ thể của an toàn luồng, chẳng hạn như Gửi và Đồng bộ hóa, bộ bảo vệ và ô.
Đối với thư viện C, không có chuyện "nó có thể được phân bổ trên một luồng và được giải phóng trên luồng kia, nhưng nó không thể được sử dụng từ cả hai luồng cùng một lúc".
Rust mô tả sự an toàn của luồng theo kiểu dữ liệu, khái quát hóa cho tất cả các chức năng sử dụng chúng.
Đối với ngôn ngữ C, an toàn luồng chỉ liên quan đến các chức năng và cờ cấu hình riêng lẻ.
Đảm bảo của Rust thường được cung cấp tại thời điểm biên dịch, ít nhất là vô điều kiện.
Đối với ngôn ngữ C, người ta thường nói "đây chỉ an toàn cho luồng nếu tùy chọn turboblub được đặt thành 7".
đồng thời không đồng bộ
Ngôn ngữ Rust hỗ trợ mô hình lập trình không đồng bộ async/await.
Mô hình lập trình này dựa trên một khái niệm có tên là Tương lai, còn được gọi là Lời hứa trong JavaScript. Tương lai đại diện cho một giá trị chưa được giải quyết mà bạn có thể thực hiện các thao tác khác nhau trước khi nó được giải quyết để có được giá trị đó. Trong nhiều ngôn ngữ, không có nhiều công việc đã được thực hiện trên Tương lai.Việc triển khai này hỗ trợ nhiều tính năng như bộ kết hợp (Combinator), đặc biệt trên cơ sở này để đạt được cú pháp async/await thuận tiện hơn.
Tương lai có thể đại diện cho tất cả mọi thứ và đặc biệt hữu ích để đại diện cho I/O không đồng bộ: khi bạn thực hiện một yêu cầu mạng, bạn sẽ nhận được một đối tượng Tương lai ngay lập tức và sau khi yêu cầu mạng hoàn tất, nó sẽ trả về bất kỳ giá trị nào mà phản hồi có thể chứa ; Bạn cũng có thể hiểu những thứ như "hết giờ", "hết thời gian chờ" thực sự là một Tương lai được giải quyết sau một thời gian nhất định; thậm chí công việc không phải là I/O hoặc cần được đặt trong nhóm luồng để chạy sử dụng nhiều CPU công việc cũng có thể được đại diện bởi một Tương lai, tương lai này sẽ được giải quyết sau khi nhóm luồng hoàn thành công việc.
Vấn đề với Tương lai là cách nó được thể hiện trong hầu hết các ngôn ngữ là cách tiếp cận dựa trên gọi lại này, nơi bạn chỉ định chức năng gọi lại nào sẽ chạy sau khi Tương lai được giải quyết. Nghĩa là, Tương lai chịu trách nhiệm tìm ra khi nào nó được giải quyết, nó sẽ chạy bất kể lệnh gọi lại của bạn là gì; và tất cả những bất tiện cũng được tích hợp vào mô hình này và rất khó sử dụng vì đã có rất nhiều công việc được thực hiện bởi nhiều nhà phát triển và nhận thấy rằng họ phải viết rất nhiều mã phân bổ và sử dụng công văn động; trên thực tế, mỗi cuộc gọi lại mà bạn cố gắng gửi đi phải có không gian lưu trữ độc lập của riêng nó, chẳng hạn như các đối tượng thùng, phân bổ bộ nhớ heap, các phân bổ này và công văn động.ở khắp mọi nơi. Cách tiếp cận này không thỏa mãn nguyên tắc trừu tượng thứ hai với chi phí bằng không và nếu bạn định sử dụng nó, nó sẽ chậm hơn rất nhiều so với việc bạn tự viết nó, vậy tại sao bạn lại sử dụng nó.
Sơ đồ này khác ở Rust. Thay vì các cuộc gọi lại lập lịch trình cho Tương lai, một thành phần được gọi là người thực thi sẽ thăm dò Tương lai. Tương lai có thể trả về "chưa sẵn sàng (Pending)" hoặc có thể trả về "Sẵn sàng (Ready)" sau khi được giải quyết. Mô hình này có nhiều ưu điểm. Một trong những lợi thế là bạn có thể hủy bỏ một Tương lai rất dễ dàng, bởi vì việc hủy bỏ một Tương lai chỉ yêu cầu bạn ngừng nắm giữ Tương lai. Với cách tiếp cận dựa trên cuộc gọi lại, không dễ dàng hủy bỏ và dừng nó thông qua lập lịch trình.
Đồng thời, nó cũng cho phép chúng ta thiết lập một ranh giới trừu tượng thực sự rõ ràng giữa các phần khác nhau của chương trình.Hầu hết các thư viện Future khác đều có một vòng lặp sự kiện (event loop), đây cũng là cách để lên lịch cho Future của bạn thực hiện I/O , nhưng thực tế Bạn không có bất kỳ quyền kiểm soát nào đối với việc này.
Tuy nhiên, trong Rust, ranh giới giữa các thành phần rất rõ ràng, người thực thi chịu trách nhiệm lập lịch trình cho Tương lai của bạn, lò phản ứng xử lý tất cả I/O và sau đó là mã thực của bạn. Vì vậy, người dùng cuối có thể tự quyết định sử dụng bộ truyền động nào, sử dụng lò phản ứng nào họ muốn sử dụng và do đó có nhiều quyền kiểm soát hơn, điều này thực sự quan trọng trong các ngôn ngữ lập trình hệ thống.
Và lợi thế thực sự quan trọng nhất của mô hình này là nó cho phép chúng ta triển khai loại máy trạng thái này trong tương lai một cách hoàn hảo với chi phí thực bằng không. Nghĩa là, khi mã Tương lai bạn viết được biên dịch thành mã cục bộ (gốc) thực tế, nó giống như một máy trạng thái; trong máy trạng thái này, mỗi điểm tạm dừng I/O có một biến thể (biến thể), Thay vào đó, mỗi biến thể sẽ lưu trạng thái cần thiết để tiếp tục thực hiện.
Và điều thực sự hữu ích về sự trừu tượng hóa Tương lai này là chúng ta có thể xây dựng các API khác trên đó. Máy trạng thái có thể được xây dựng bằng cách áp dụng các phương thức tổ hợp này cho Futures và chúng hoạt động giống như bộ điều hợp cho Iterator (ví dụ: bộ lọc, bản đồ). Nhưng phương pháp này có một số nhược điểm, đặc biệt là khả năng đọc rất kém, chẳng hạn như các cuộc gọi lại lồng nhau. Đó là lý do tại sao cần thực hiện cú pháp bất đồng bộ async/await.
Trong hệ sinh thái Rust hiện tại, đã có một hệ sinh thái thời gian chạy tokio[5] trưởng thành hỗ trợ I/O không đồng bộ, chẳng hạn như epoll. Nếu bạn muốn dùng io_uring cũng có thể dùng Glommio[6], hoặc đợi bên tokio hỗ trợ io_uring. Thậm chí, bạn có thể sử dụng async_executor[7] và async-io[8] do thời gian chạy smol cung cấp để xây dựng thời gian chạy của riêng bạn.
tính toán thời gian biên dịch
Rust có thể hỗ trợ đánh giá hằng số thời gian biên dịch tương tự như Cpp. Điều này rõ ràng vượt trội so với C.
Tại sao nên thận trọng khi hỗ trợ đánh giá thời gian biên dịch trong Rust? Vì các đánh giá thời gian biên dịch Rust phải an toàn nên có nhiều cân nhắc. Đánh giá thời gian biên dịch Rust không miễn phí và dễ bị lạm dụng như Cpp.
trình soạn thảo mdnice
độ tin cậy
Tháng 6/2020, 5 học giả đến từ 3 trường đại học đã công bố kết quả nghiên cứu tại Hội thảo quốc tế ACM SIGPLAN (PLDI'20), tiến hành điều tra toàn diện các lỗ hổng bảo mật trong các dự án mã nguồn mở sử dụng ngôn ngữ Rust trong thời gian qua. Nghiên cứu này xem xét năm hệ thống phần mềm được phát triển bằng ngôn ngữ Rust, năm thư viện Rust được sử dụng rộng rãi và hai cơ sở dữ liệu lỗ hổng. Cuộc điều tra liên quan đến tổng cộng 850 cách sử dụng mã không an toàn, 70 lỗi an toàn bộ nhớ và 100 lỗi an toàn luồng.
Trong cuộc điều tra của họ, các nhà nghiên cứu đã xem xét không chỉ các lỗi được báo cáo trong tất cả các cơ sở dữ liệu dễ bị tổn thương và các lỗi được báo cáo công khai trong phần mềm, mà còn xem xét các bản ghi cam kết trong tất cả các kho lưu trữ mã phần mềm nguồn mở. Thông qua phân tích thủ công, họ xác định loại LỖI mà bản gửi sửa chữa và phân loại nó thành vấn đề an toàn luồng/an toàn bộ nhớ tương ứng. Tất cả các vấn đề đã điều tra được sắp xếp vào một kho lưu trữ Git công cộng: https://github.com/system-pclub/rust-study[9]
Giải trình kết quả khảo sát:
Mã an toàn của ngôn ngữ Rust rất hiệu quả để kiểm tra các vấn đề về an toàn bộ nhớ không gian và thời gian.Tất cả các vấn đề về an toàn bộ nhớ trong phiên bản ổn định đều liên quan đến mã không an toàn.
Mặc dù các vấn đề về an toàn bộ nhớ đều liên quan đến mã không an toàn, nhưng một số lượng lớn các vấn đề cũng liên quan đến mã an toàn. Một số vấn đề thậm chí bắt nguồn từ lỗi mã hóa trong mã an toàn hơn là mã không an toàn.
Các vấn đề về an toàn luồng, dù là chặn hay không chặn, đều có thể xảy ra trong mã an toàn, ngay cả khi mã tuân thủ đầy đủ các quy tắc của ngôn ngữ Rust.
Một số lượng lớn các vấn đề là do các lập trình viên không hiểu đúng các quy tắc vòng đời của ngôn ngữ Rust.
Cần xây dựng các công cụ phát hiện lỗi mới cho các sự cố điển hình bằng ngôn ngữ Rust.
Vậy tính bảo mật của Rust đằng sau báo cáo khảo sát này được đảm bảo như thế nào? Rỉ sét không an toàn và tại sao không an toàn?
Quyền sở hữu: Cơ chế an toàn bộ nhớ ngôn ngữ Rust
Thiết kế của Rust chủ yếu dựa trên nghiên cứu học thuật về lập trình hệ thống an toàn. Đặc biệt, điểm khác biệt nhất trong thiết kế của Rust so với các ngôn ngữ chính thống khác là việc áp dụng hệ thống kiểu độc quyền (thường được gọi trong tài liệu học thuật là hệ thống kiểu affine hoặc cấu trúc con36[10]).
Cơ chế sở hữu là ngữ nghĩa và mô hình lập trình an toàn được thể hiện bởi ngôn ngữ Rust với sự trợ giúp của hệ thống loại để mang ý tưởng "an toàn bộ nhớ" của nó.
Các vấn đề về mất an toàn bộ nhớ do cơ chế sở hữu giải quyết bao gồm:
Một con trỏ null được tham chiếu.
Sử dụng bộ nhớ chưa khởi tạo.
Sử dụng sau khi miễn phí, nghĩa là sử dụng con trỏ lơ lửng.
Tràn bộ đệm, chẳng hạn như một mảng nằm ngoài giới hạn.
Phát hành bất hợp pháp các con trỏ đã được phát hành hoặc các con trỏ chưa được phân bổ, nghĩa là phát hành lặp lại.
Lưu ý rằng rò rỉ bộ nhớ không phải là vấn đề an toàn bộ nhớ, vì vậy Rust cũng không giải quyết được rò rỉ bộ nhớ.
Để đảm bảo an toàn cho bộ nhớ, ngôn ngữ Rust đã thiết lập một mô hình quản lý bộ nhớ an toàn nghiêm ngặt:
hệ thống sở hữu. Mỗi bộ nhớ được phân bổ có một con trỏ có quyền sở hữu độc quyền đối với nó. Chỉ khi con trỏ bị hủy, bộ nhớ tương ứng mới có thể được giải phóng tương ứng.
Vay mượn và trọn đời. Mọi biến đều có vòng đời của nó và khi vượt quá vòng đời, biến đó sẽ tự động được giải phóng. Nếu đó là mượn, bạn có thể ngăn chặn các con trỏ lơ lửng, nghĩa là các tình huống sử dụng sau khi miễn phí, bằng cách đánh dấu các tham số thời gian tồn tại để kiểm tra trình biên dịch.
Hệ thống sở hữu cũng bao gồm cơ chế RAII vay mượn từ C++ hiện đại, là nền tảng quản lý bộ nhớ an toàn nhưng không có GC của Rust.
Sau khi mô hình quản lý bộ nhớ an toàn được thiết lập, nó có thể được thể hiện bằng hệ thống loại. Rust mượn các tính năng sau từ hệ thống loại của Haskell:
không có con trỏ rỗng
bất biến theo mặc định
sự biểu lộ
hàm bậc cao
kiểu dữ liệu đại số
khớp mẫu
chung
đặc điểm và các loại liên quan
khấu trừ loại cục bộ
Để đạt được sự an toàn cho bộ nhớ, Rust cũng có các tính năng độc đáo sau:
Loại Affine, được sử dụng để thể hiện ngữ nghĩa Di chuyển trong quyền sở hữu Rust.
Vay mượn, vòng đời.
Với sức mạnh của hệ thống loại, trình biên dịch Rust có thể kiểm tra loại tại thời điểm biên dịch để xem liệu nó có đáp ứng mô hình bộ nhớ an toàn hay không và có thể phát hiện các vấn đề về mất an toàn bộ nhớ tại thời điểm biên dịch, ngăn chặn hiệu quả sự xuất hiện của hành vi không xác định.
Nguyên nhân bên trong của lỗi an toàn bộ nhớ và lỗi an toàn đồng thời là như nhau, cả hai đều do truy cập bộ nhớ không đúng cách. Tương tự như vậy, Rust cũng giải quyết vấn đề về an toàn đồng thời với một hệ thống loại mạnh có quyền sở hữu. Trình biên dịch Rust sẽ kiểm tra và phân tích tất cả các vấn đề cạnh tranh dữ liệu trong mã đồng thời đa luồng tại thời điểm biên dịch thông qua phân tích kiểm tra tĩnh.
Rỉ sét không an toàn: phân chia ranh giới bảo mật
Để tích hợp tốt với hệ sinh thái hiện có, Rust hỗ trợ cơ chế FFI rất thuận tiện và không tốn phí, tương thích với C-ABI và chia ngôn ngữ Rust thành Safe Rust và Unsafe Rust từ cấp độ kiến trúc ngôn ngữ.
Trong số đó, Unsafe Rust chuyên xử lý các hệ thống bên ngoài, chẳng hạn như nhân hệ điều hành. Sở dĩ có sự phân chia này là do khả năng kiểm tra, theo dõi của trình biên dịch Rust còn hạn chế, không thể kiểm tra trạng thái bảo mật của các giao diện ngôn ngữ bên ngoài khác nên chỉ có thể đảm bảo bởi chính nhà phát triển.
Mục tiêu cuối cùng của Rust không phải là loại bỏ hoàn toàn những điểm nguy hiểm đó, vì đến một lúc nào đó, chúng ta cần có khả năng truy cập bộ nhớ và các tài nguyên khác. Trên thực tế, mục tiêu của Rust là loại bỏ tất cả các yếu tố không an toàn. Khi nghĩ về bảo mật, bạn cần nghĩ về "bề mặt tấn công" hoặc phần nào của chương trình mà chúng ta có thể tương tác. Một cái gì đó giống như trình phân tích cú pháp là một bề mặt tấn công lớn bởi vì:
Những kẻ tấn công thường có thể truy cập chúng;
Dữ liệu do kẻ tấn công cung cấp có thể ảnh hưởng trực tiếp đến logic phức tạp thường được yêu cầu để phân tích cú pháp.
Bạn có thể chia nhỏ hơn nữa bằng cách chia nhỏ bề mặt tấn công truyền thống thành một "bề mặt tấn công" (phần có thể ảnh hưởng trực tiếp đến mã chương trình) và một "lớp bảo mật", là mã mà bề mặt tấn công phụ thuộc vào, nhưng là không thể truy cập được và có thể có Lỗi tiềm ẩn. Trong C, chúng giống nhau: mảng trong C hoàn toàn không trừu tượng, vì vậy nếu bạn đọc một số lượng mục thay đổi, bạn cần đảm bảo rằng tất cả các bất biến không đổi, vì không an toàn khi xếp lớp, nơi có thể xảy ra lỗi .
Do đó, Rust cung cấp từ khóa không an toàn và khối không an toàn, giúp phân biệt rõ ràng mã an toàn với mã không an toàn khi truy cập vào các giao diện bên ngoài, đồng thời mang lại sự thuận tiện cho các nhà phát triển trong việc gỡ lỗi. Rust an toàn có nghĩa là các nhà phát triển sẽ tin tưởng trình biên dịch để đảm bảo an toàn tại thời điểm biên dịch, trong khi Rust không an toàn có nghĩa là trình biên dịch sẽ tin tưởng vào khả năng đảm bảo an toàn của nhà phát triển.
Ở đâu có người, ở đó có bọ. Thông qua thiết kế tinh tế của ngôn ngữ Rust, những phần mà máy có thể kiểm tra và điều khiển được giao cho trình biên dịch thực hiện, còn những phần mà máy không thể kiểm soát được sẽ được giao cho chính các nhà phát triển.
Điều Safe Rust đảm bảo là trình biên dịch tối đa hóa độ an toàn của bộ nhớ tại thời điểm biên dịch và ngăn hành vi không xác định xảy ra.
Rỉ sét không an toàn được sử dụng để nhắc nhở các nhà phát triển rằng mã được phát triển tại thời điểm này có thể gây ra hành vi không xác định, hãy cẩn thận! Con người và trình biên dịch chia sẻ cùng một "mô hình bảo mật", tin tưởng lẫn nhau và hài hòa với nhau, để loại bỏ tối đa khả năng lỗi của con người.
Unsafe Rust, là ranh giới bảo mật của Rust. Bản chất của thế giới là Không an toàn. Bạn không thể tránh nó. Có người nói do có Unsafe Rust nên chưa chắc đã an toàn hơn C/C++? Unsafe Rust thực sự giống như C/C++, nó phụ thuộc vào mọi người để đảm bảo an toàn cho nó. Nhưng nó có yêu cầu cao hơn đối với con người.
Nó cũng cung cấp cho các nhà phát triển một ranh giới Không an toàn, đây thực sự là một ranh giới bảo mật. Nó đánh dấu rõ ràng các bãi mìn trong mã của bạn. Nếu bạn xem lại mã nhóm, bạn có thể tìm thấy sự cố nhanh hơn. Điều này tự nó là một loại bảo mật. Ngược lại với C++, mọi dòng mã bạn viết là Không an toàn, bởi vì nó không có ranh giới rõ ràng (khối không an toàn) như Rust.
Sau đây là năm thông số kỹ thuật đơn giản để sử dụng Không an toàn mà tôi đã tóm tắt để mọi người có thể cân nhắc:
Sử dụng Safe Rust nếu bạn có thể sử dụng Safe Rust;
Rỉ sét không an toàn có thể được sử dụng để thực hiện;
Khi sử dụng Rỉ sét không an toàn, hãy đảm bảo không tạo UB và cố gắng đánh giá ranh giới bảo mật của nó và trừu tượng hóa nó thành một phương thức An toàn;
Nếu không thể trừu tượng hóa là An toàn thì cần đánh dấu là Không an toàn và kèm theo tài liệu điều kiện để tạo UB;
Đối với mã Unsafe, bạn có thể tập trung vào xem xét.
Tuy nhiên, có một nhóm làm việc về bảo mật Rust trong hệ sinh thái cộng đồng Rust, nhóm này cung cấp một loạt công cụ như kiểm toán hàng hóa [11] và duy trì các vấn đề bảo mật được tìm thấy trong cộng đồng sinh thái Rust được ghi lại trong thư viện cơ sở dữ liệu bảo mật `RustSecurity` [12]. Thật thuận tiện để kiểm tra các vấn đề bảo mật của các thư viện phụ thuộc trong các dự án Rust.
trình soạn thảo mdnice
Lực lượng sản xuất
Năng suất của ngôn ngữ lập trình có thể được đánh giá theo ba khía cạnh sau:
đường cong học tập.
Khả năng Kỹ thuật Ngôn ngữ.
sinh thái miền.
đường cong học tập
Đường cong học tập cao hay thấp, tùy thuộc vào trình độ cá nhân. Sau đây là danh sách những nơi cần được chú ý để học Rust cơ bản khác nhau.
Các nhà phát triển hoàn toàn dựa trên con số không: nắm vững cấu trúc kiến thức của hệ thống máy tính cơ bản, hiểu tính trừu tượng của ngôn ngữ Rust và lớp phần cứng/hệ điều hành, hiểu các khái niệm cốt lõi của ngôn ngữ Rust và chế độ trừu tượng của nó, đồng thời chọn một lĩnh vực ngôn ngữ Rust có thể áp dụng cho nâng cao trình độ và hiểu biết sâu sắc về ngôn ngữ Rust thông qua thực hành, đồng thời nắm vững kiến thức lĩnh vực.
Nền tảng ngôn ngữ C: Vì các nhà phát triển ngôn ngữ C không hiểu rõ về tính trừu tượng của ngôn ngữ cấp cao nên họ tập trung vào việc hiểu và nắm vững cơ chế sở hữu của Rust, bao gồm ngữ nghĩa của quyền sở hữu, vòng đời và kiểm tra mượn. Hiểu các mẫu trừu tượng của ngôn ngữ Rust, chủ yếu là các loại và đặc điểm; cũng như OOP và các tính năng ngôn ngữ chức năng của chính Rust.
Nền tảng C++: Các nhà phát triển C++ hiểu rõ về quyền sở hữu ngôn ngữ Rust và tập trung vào các mẫu trừu tượng và các tính năng ngôn ngữ chức năng của Rust.
Có nền tảng Java/Python/Ruby: tập trung vào việc hiểu và khắc phục cơ chế sở hữu của Rust, các mẫu trừu tượng và các tính năng của ngôn ngữ lập trình chức năng.
Nền tảng của Go: Các nhà phát triển ngôn ngữ Go hiểu các mẫu trừu tượng về đặc điểm và loại của Rust dễ dàng hơn, nhưng Go cũng là một ngôn ngữ GC, vì vậy cơ chế sở hữu và các tính năng của ngôn ngữ chức năng là trọng tâm của việc học của họ.
Có nền tảng Haskell: Các nhà phát triển Haskell hiểu rõ về các tính năng chức năng của ngôn ngữ Rust và chủ yếu khắc phục cơ chế sở hữu và các tính năng của ngôn ngữ OOP.
Do đó, đối với các nhà phát triển có nền tảng nhất định, một số khái niệm chính cần nắm vững khi học ngôn ngữ Rust là:
1. Cơ chế sở hữu rỉ sét, bao gồm ngữ nghĩa sở hữu, vòng đời và kiểm tra mượn
Cơ chế sở hữu là tính năng cốt lõi của ngôn ngữ Rust. Nó đảm bảo an toàn bộ nhớ mà không cần cơ chế thu gom rác. Do đó, đối với các nhà phát triển đã quen với GC, hiểu được quyền sở hữu Rust là phần quan trọng nhất. Hãy nhớ ba điểm sau:
Mỗi giá trị trong Rust có một biến được gọi là chủ sở hữu của nó.
Một giá trị có một và chỉ một chủ sở hữu.
Khi chủ sở hữu (biến) vượt ra ngoài phạm vi, giá trị này sẽ bị loại bỏ. Điều này cũng liên quan đến các khái niệm như vòng đời và kiểm tra khoản vay, đây là một vấn đề tương đối khó giải quyết.
2. Phương thức trừu tượng của ngôn ngữ Rust, chủ yếu là từ loại và đặc điểm. Đặc điểm vay mượn từ Typeclass trong Haskell. Nó là một sự trừu tượng hóa hành vi của loại và có thể được so sánh phổ biến với các giao diện trong các ngôn ngữ lập trình khác. Nó cho trình biên dịch biết ngôn ngữ chức năng nào mà một loại phải cung cấp. Cần tuân thủ tính nhất quán khi sử dụng và không thể xác định các triển khai xung đột.
3. Đặc điểm ngôn ngữ OOP. Quen thuộc với bốn tính năng phổ biến của lập trình hướng đối tượng (OOP): đối tượng, đóng gói, kế thừa và đa hình, bạn có thể hiểu rõ hơn về một số tính năng của Rust như impl, pub, trait, v.v.
4. Đặc điểm ngôn ngữ chức năng. Thiết kế của ngôn ngữ Rust chịu ảnh hưởng sâu sắc của lập trình hàm, nhìn thấy các tính năng của hàm, những người không giỏi toán có thể nản lòng, bởi vì đặc điểm lớn nhất của ngôn ngữ lập trình hàm là viết quá trình tính toán dưới dạng một chuỗi các hàm lồng nhau gọi càng nhiều càng tốt Trong Rust, thành thạo các lần đóng và trình vòng lặp là một phần quan trọng trong việc viết mã Rust hiệu suất cao theo phong cách ngôn ngữ chức năng.
Năng lực kỹ thuật ngôn ngữ
Rust đã sẵn sàng để phát triển các sản phẩm có độ bền công nghiệp.
Để đảm bảo an toàn, Rust giới thiệu một hệ thống loại mạnh và hệ thống quyền sở hữu, không chỉ đảm bảo an toàn cho bộ nhớ mà còn đảm bảo an toàn đồng thời mà không làm giảm hiệu suất.
Để đảm bảo hỗ trợ cho các hệ thống thời gian thực cứng, Rust mượn các hàm hủy xác định, RAII và con trỏ thông minh từ C++ để quản lý bộ nhớ tự động và xác định, do đó tránh được việc giới thiệu GC, do đó sẽ không có vấn đề "tạm dừng thế giới". Mặc dù các mục này được vay mượn từ C++, nhưng chúng ngắn gọn hơn để sử dụng so với C++.
Để đảm bảo tính mạnh mẽ của chương trình, Rust đã kiểm tra lại cơ chế xử lý lỗi. Nhìn chung có ba loại tình huống bất thường trong quá trình phát triển hàng ngày: lỗi, lỗi và ngoại lệ. Tuy nhiên, trong một ngôn ngữ hướng quy trình như C, các nhà phát triển chỉ có thể xử lý lỗi thông qua các câu lệnh như trả về giá trị và goto, và không có cơ chế xử lý lỗi thống nhất. Mặc dù các ngôn ngữ cấp cao như C ++ và Java giới thiệu các cơ chế xử lý ngoại lệ, nhưng chúng không cung cấp cụ thể cú pháp có thể phân biệt hiệu quả giữa logic thông thường và logic lỗi mà chỉ xử lý chúng trên toàn cầu, khiến các nhà phát triển coi tất cả các tình huống bất thường là ngoại lệ. Nó không có lợi cho sự phát triển của một hệ thống mạnh mẽ. Và xử lý ngoại lệ cũng sẽ mang lại chi phí hoạt động tương đối lớn.
Ngôn ngữ Rust cung cấp các phương pháp xử lý đặc biệt cho ba loại tình huống bất thường này, cho phép các nhà phát triển lựa chọn theo tình huống.
Đối với các trường hợp lỗi, các công cụ xác nhận có sẵn.
Đối với lỗi, Rust cung cấp phương pháp xử lý lỗi theo lớp dựa trên giá trị trả về. Ví dụ: Tùy chọn có thể được sử dụng để xử lý các tình huống có thể có giá trị null, trong khi Kết quả được sử dụng đặc biệt để xử lý các lỗi có thể được giải quyết hợp lý và cần được truyền bá.
Đối với các trường hợp ngoại lệ, Rust coi chúng là các vấn đề không thể giải quyết một cách hợp lý và cung cấp cơ chế hoảng loạn luồng.Khi một trường hợp ngoại lệ xảy ra, luồng có thể thoát ra một cách an toàn.
Thông qua một thiết kế tinh tế như vậy, các nhà phát triển có thể xử lý hợp lý các tình huống bất thường ở mức độ chi tiết tốt hơn và cuối cùng viết ra một hệ thống mạnh mẽ hơn.
Để cung cấp khả năng kiến trúc linh hoạt, Rust sử dụng các đặc điểm làm cơ sở cho sự trừu tượng hóa với chi phí bằng không. Các đặc điểm được định hướng theo thành phần hơn là kế thừa, mang lại cho các nhà phát triển sự linh hoạt để kiến trúc các hệ thống liên kết chặt chẽ và liên kết lỏng lẻo. Rust cũng cung cấp các generic để thể hiện sự trừu tượng hóa kiểu, Kết hợp với các đặc điểm của đặc điểm, Rust có khả năng đa hình tĩnh và tái sử dụng mã. Các đặc điểm chung và đặc điểm cho phép bạn sử dụng linh hoạt các mẫu thiết kế khác nhau để định hình lại kiến trúc hệ thống.
Để cung cấp khả năng mở rộng ngôn ngữ mạnh mẽ và hiệu quả phát triển, Rust giới thiệu cơ chế siêu lập trình dựa trên macro. Rust cung cấp hai loại macro, macro khai báo và macro thủ tục. Hình thức khai báo macro tương tự như khai báo macro thay thế của C, điểm khác biệt là Rust sẽ kiểm tra mã sau khi mở rộng macro, có lợi hơn về mặt bảo mật. Các macro thủ tục cung cấp cho Rust khả năng mạnh mẽ trong việc sử dụng lại mã và tạo mã.
Để tích hợp tốt với hệ sinh thái hiện có, Rust hỗ trợ cơ chế FFI rất tiện lợi và không tốn phí, tương thích với C-ABI và chia ngôn ngữ Rust thành Safe Rust và Unsafe Rust từ cấp độ kiến trúc ngôn ngữ. Trong số đó, Unsafe Rust chuyên xử lý các hệ thống bên ngoài, chẳng hạn như nhân hệ điều hành. Sở dĩ có sự phân chia này là do khả năng kiểm tra, theo dõi của trình biên dịch Rust còn hạn chế, không thể kiểm tra trạng thái bảo mật của các giao diện ngôn ngữ bên ngoài khác nên chỉ có thể đảm bảo bởi chính nhà phát triển. Unsafe Rust cung cấp các từ khóa không an toàn và các khối không an toàn, giúp phân biệt rõ ràng mã an toàn với mã không an toàn khi truy cập vào các giao diện bên ngoài, đồng thời cung cấp sự thuận tiện cho các nhà phát triển trong việc gỡ lỗi. Rust an toàn có nghĩa là các nhà phát triển sẽ tin tưởng trình biên dịch để đảm bảo an toàn tại thời điểm biên dịch, trong khi Rust không an toàn có nghĩa là trình biên dịch sẽ tin tưởng vào khả năng đảm bảo an toàn của nhà phát triển.
Ở đâu có người, ở đó có bọ. Thông qua thiết kế tinh tế của ngôn ngữ Rust, những phần mà máy có thể kiểm tra và điều khiển được giao cho trình biên dịch thực hiện, còn những phần mà máy không thể kiểm soát được sẽ được giao cho chính các nhà phát triển. Điều Safe Rust đảm bảo là trình biên dịch tối đa hóa độ an toàn của bộ nhớ tại thời điểm biên dịch và ngăn hành vi không xác định xảy ra. Rỉ sét không an toàn được sử dụng để nhắc nhở các nhà phát triển rằng mã được phát triển tại thời điểm này có thể gây ra hành vi không xác định, hãy cẩn thận! Con người và trình biên dịch chia sẻ cùng một "mô hình bảo mật", tin tưởng lẫn nhau và hài hòa với nhau, để loại bỏ tối đa khả năng lỗi của con người.
Để giúp các nhà phát triển cộng tác với nhau dễ dàng hơn, Rust cung cấp một trình quản lý gói rất hữu ích Cargo[13]. Rust code được biên dịch và phân phối dựa trên gói (crate), Cargo cung cấp nhiều lệnh để tạo điều kiện cho các nhà phát triển tạo, xây dựng, phân phối và quản lý các gói của riêng họ. Cargo cũng cung cấp cơ chế plug-in, thuận tiện cho các nhà phát triển viết các plug-in tùy chỉnh để đáp ứng nhiều nhu cầu hơn. Ví dụ: các công cụ Rustfmt và clippy chính thức có thể được sử dụng để tự động định dạng mã và tìm "mùi hôi" trong mã tương ứng. Ví dụ khác, công cụ Rustfix thậm chí có thể giúp các nhà phát triển tự động sửa mã lỗi dựa trên các đề xuất của trình biên dịch. Cargo cũng tự nhiên chấp nhận cộng đồng nguồn mở và Git, đồng thời hỗ trợ xuất bản các gói bằng văn bản chỉ bằng một cú nhấp chuột lên trang web crates.io để người khác sử dụng.
Để giúp các nhà phát triển học Rust dễ dàng hơn, nhóm Rust chính thức đã thực hiện những nỗ lực sau:
Tách một nhóm làm việc cộng đồng tận tâm, viết Sách Rust chính thức và các tài liệu khác ở các độ sâu khác nhau, chẳng hạn như tài liệu trình biên dịch, sách kinh tế, v.v. Thậm chí tổ chức một sự kiện giảng dạy cộng đồng miễn phí Rust Bridge, khuyến khích mạnh mẽ việc viết blog cộng đồng, v.v.
Tài liệu của ngôn ngữ Rust hỗ trợ định dạng Markdown, vì vậy tài liệu thư viện tiêu chuẩn Rust rất phong phú về cách diễn đạt. Tính biểu cảm của tài liệu cho nhiều gói của bên thứ ba trong hệ sinh thái cũng đã được cải thiện.
Cung cấp một công cụ Sân chơi trực tuyến rất hữu ích cho các nhà phát triển để tìm hiểu, sử dụng và chia sẻ mã.
Ngôn ngữ Rust đã được khởi động từ rất sớm, thuận tiện cho người học hiểu cơ chế bên trong của nó bằng cách đọc mã nguồn và thậm chí tham gia đóng góp.
Nhóm nòng cốt của Rust đã liên tục cải thiện Rust, cam kết cải thiện tính thân thiện của Rust, cố gắng giảm bớt gánh nặng tinh thần cho những người mới bắt đầu và làm chậm quá trình học tập. Ví dụ: giới thiệu tính năng NLL để cải thiện hệ thống kiểm tra khoản vay cho phép các nhà phát triển viết mã trực quan hơn.
Mặc dù đã mượn rất nhiều nội dung liên quan đến hệ thống loại từ Haskell, nhưng nhóm Rust sẽ cố tình phi hàn lâm khi thiết kế và quảng bá các tính năng ngôn ngữ để làm cho khái niệm về Rust dễ tiếp cận hơn với mọi người.
Dựa trên hệ thống loại, nó cung cấp hỗ trợ cho các mô hình lập trình hỗn hợp, cung cấp khả năng biểu đạt trừu tượng mạnh mẽ và ngắn gọn, đồng thời cải thiện đáng kể hiệu quả phát triển của các nhà phát triển.
Để tạo điều kiện cho các nhà phát triển Rust nâng cao hiệu quả phát triển, cộng đồng Rust cũng cung cấp hỗ trợ IDE mạnh mẽ. VSCode/Vim/Emacs + Rust Analyzer đã trở thành tiêu chuẩn để phát triển Rust. Tất nhiên, IDEA/Clion của gia đình JetBrains cũng hỗ trợ mạnh mẽ cho Rust.
trình soạn thảo mdnice
Rỉ sét và mã nguồn mở
Là một dự án nguồn mở, ngôn ngữ Rust cũng là một viên ngọc sáng trong phần mềm nguồn mở hiện đại.
Tất cả các ngôn ngữ ra đời trước Rust chỉ được sử dụng để phát triển thương mại, nhưng ngôn ngữ Rust đã thay đổi tình trạng này. Đối với ngôn ngữ Rust, cộng đồng mã nguồn mở Rust cũng là một phần của ngôn ngữ này. Đồng thời, ngôn ngữ Rust cũng thuộc về cộng đồng.
Nhóm Rust bao gồm các thành viên Mozilla và không phải Mozilla, và cho đến nay đã có hơn 1.900 người đóng góp cho dự án Rust. Nhóm Rust được chia thành nhóm cốt lõi và các nhóm làm việc miền khác.Đối với các mục tiêu của Rust 2018, nhóm Rust được chia thành nhóm làm việc nhúng, nhóm làm việc CLI, nhóm làm việc mạng và nhóm làm việc WebAssembly. như nhóm công tác hệ sinh thái và nhóm công tác cộng đồng, v.v.
Các thiết kế trong các trường này trước tiên sẽ trải qua quy trình RFC. Đối với một số thay đổi không cần trải qua quy trình RFC, bạn chỉ cần gửi Yêu cầu kéo tới thư viện dự án Rust. Mọi quy trình đều minh bạch với cộng đồng, cộng tác viên có thể tham gia phản biện, tất nhiên quyền quyết định cuối cùng thuộc về nhóm nòng cốt và các nhóm công tác lĩnh vực liên quan. Sau đó, để hợp lý hóa quy trình FCP, MCP cũng được giới thiệu.
Sau khi thành lập Rust Foundation, nhóm Rust cũng không ngừng khám phá các giải pháp quản trị nguồn mở mới.
trình soạn thảo mdnice
Điểm yếu của ngôn ngữ Rust
Mặc dù Rust có nhiều ưu điểm nhưng chắc chắn nó cũng có một số nhược điểm.
Quá trình biên dịch Rust diễn ra chậm. Mặc dù các quan chức của Rust đã và đang cải thiện tốc độ biên dịch Rust, bao gồm hỗ trợ biên dịch gia tăng, giới thiệu phần phụ trợ biên dịch mới (cẩu cẩu), biên dịch song song và các biện pháp khác, nhưng tốc độ này vẫn còn chậm. Và quá trình biên dịch gia tăng hiện có lỗi.
Đường cong học tập là dốc.
Thiếu nhiều công cụ phát hiện sự cố mất an toàn bộ nhớ dành riêng cho ngôn ngữ Rust.
trình soạn thảo mdnice
Thư viện cơ sở sinh thái Rust và chuỗi công cụ
Hệ sinh thái Rust ngày càng phong phú, nhiều thư viện và framework cơ bản sẽ được phát hành cho crates.io[14] dưới dạng thùng, tính đến thời điểm hiện tại đã có 62.981 thùng trên crates.io và tổng số lượt tải xuống đã đạt 7,654,973,261 lượt.
Được phân loại theo các kịch bản sử dụng gói, các kịch bản phổ biến nhất của Crates.io như sau:
Công cụ dòng lệnh (3133 thùng)
thư viện no-std (2778 thùng)
Công cụ phát triển (kiểm tra/gỡ lỗi/linting/phát hiện hiệu suất, v.v., 2652 thùng)
Lập trình web (1776 thùng)
Liên kết API (đóng gói api cụ thể cho Rust, chẳng hạn như api http, api liên quan đến ffi, v.v., 1738 thùng)
Lập trình mạng (1615 thùng)
Cấu trúc dữ liệu (1572 thùng)
Phát triển nhúng (1508 thùng)
Công nghệ mã hóa (1498 thùng)
Phát triển không đồng bộ (1487 thùng)
Thuật toán (1200 thùng)
Điện toán khoa học (bao gồm vật lý, sinh học, hóa học, địa lý, máy học, v.v., 1100 thùng)
Ngoài ra, còn có các danh mục khác như WebAssugging, mã hóa, xử lý văn bản, đồng thời, GUI, công cụ trò chơi, trực quan hóa, công cụ mẫu, trình phân tích cú pháp, liên kết hệ điều hành và nhiều thư viện.
Các thư viện và chuỗi công cụ cơ bản nổi tiếng thường được sử dụng
Trong số đó, nhiều thư viện cơ bản xuất sắc đã xuất hiện, bạn có thể xem trên trang chủ của crates.io. Ở đây có một ít:
Tuần tự hóa/Giải tuần tự hóa: Serde[15]
Phát triển dòng lệnh: clap[16]/structopt[17]
Async/Web/Phát triển mạng: 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]
Phát triển FFi: libc [33]/ winapi [34]/ bindgen [35]/ pyo3 [36]/ num_enum [37]/ jni [38]/rustler_sys[39]/ cxx [40]/ cbindgen [41]/ autocxx- ràng buộc [42]
Phát triển API: jsonwebtoken [43]/ trình xác thực [44]/ tarpc [45]/ nats [46]/ tonic[47]/ protobuf [48]/ hyper [49]/ httparse [50]/ reqwest [51] / url [ 52]
Trình phân tích cú pháp: nom[53]/pest[54]/csv[55]/combine[56]/wasmparser[57]/ron[58]/lalrpop[59]
WebAssembly: wasm-bindgen[67]/ wasmer [68]/ wasmtime [69]/ yew [70]
Mật mã: openssl [60] / ring [61] / hmac [62] / Rustls [63] / orion [64] / themis [65] / RustCrypto [66]
Phát triển cơ sở dữ liệu: diesel [71]/ sqlx [72]/ rocksdb [73]/ mysql [74]/ elaticsearch [75]/ rbatis [76]
Đồng thời: thanh ngang [77]/ parking_lot [78]/ kênh thanh ngang [79]/ rayon [80]/ concurrent-queue[81]/ luồng [82] / ống dẫn [83]
Phát triển nhúng: nhúng-hal [84]/ cortex-m [85]/ bitvec [86]/ cortex-m-rtic [87]/ embedded-dma [88]/ chéo [89]/ Knurling Tools[90]
Kiểm tra: static_assertions [91] / sự khác biệt [92] / kiểm tra nhanh [93] / tùy ý [94] / mockall [95] / tiêu chí [96] / proptest [97] / bạt [98] / fake-rs [99]
Phát triển đa phương tiện: 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]
Phát triển TUI/GUI: winit [123]/ gtk [124]/ egui [125]/ imgui [126]/ yew [127]/ chữ thảo [128]/ iced [129]/ fontdue [130]/ tauri [131]/ ma túy [132]
trình soạn thảo mdnice
Hàng tồn kho ứng dụng công nghiệp rỉ sét
Rust là ngôn ngữ lập trình cấp hệ thống cấp cao có mục đích chung và các trường ứng dụng của nó về cơ bản có thể bao gồm các trường ứng dụng của C/Cpp/Java/Go/Python cùng một lúc.
Hãy cùng điểm danh những dự án Rust trong và ngoài nước thuộc các lĩnh vực khác nhau. Bằng cách cung cấp dữ liệu liên quan đến số lượng mã, quy mô nhóm và chu kỳ dự án, tôi hy vọng rằng mọi người có thể hiểu trực quan hơn về ứng dụng và hiệu quả phát triển trong lĩnh vực Rust.
trình soạn thảo mdnice
dịch vụ dữ liệu
Lĩnh vực dịch vụ dữ liệu bao gồm cơ sở dữ liệu, kho dữ liệu, luồng dữ liệu, dữ liệu lớn, v.v.
Từ khóa: cơ sở dữ liệu / hệ thống phân tán / CNCF
giới thiệu
giới thiệu
TiKV [133] là cơ sở dữ liệu Khóa-Giá trị giao dịch phân tán nguồn mở, tập trung vào việc cung cấp kiến trúc lưu trữ đáng tin cậy, chất lượng cao và thiết thực cho cơ sở dữ liệu thế hệ tiếp theo. Ban đầu được phát triển bởi nhóm PingCAP, TiKV đã được ra mắt và áp dụng tại Zhihu, Yidian, Shopee, Meituan, JD Cloud, Zhuanzhuan và các doanh nghiệp hàng đầu khác trong nhiều ngành.
TiKV sử dụng thuật toán đồng thuận Raft để đạt được tính nhất quán giữa nhiều bản sao dữ liệu. Công cụ lưu trữ RocksDB được sử dụng cục bộ để lưu trữ dữ liệu. Đồng thời, TiKV hỗ trợ phân đoạn và di chuyển dữ liệu tự động. Các giao dịch liên ngân hàng của TiKV ban đầu đề cập đến mô hình giao dịch Google Percolator và đã thực hiện một số tối ưu hóa để cung cấp khả năng cách ly ảnh chụp nhanh và cách ly ảnh chụp nhanh với khóa, đồng thời hỗ trợ các giao dịch phân tán.
Vào tháng 8 năm 2018, CNCF đã thông báo rằng nó đã được chấp nhận là một dự án gốc trên nền tảng đám mây sandbox. Vào tháng 5 năm 2019, nó đã được thăng cấp từ sandbox thành một dự án ươm tạo.
Mã và quy mô nhóm
Dự án TiKV chứa khoảng 300.000 dòng mã Rust (bao gồm cả mã kiểm tra).
TiKV là một dự án nguồn mở toàn cầu và quy mô nhóm có thể được xem từ danh sách những người đóng góp [134]. Tổ chức TiKV cũng bao gồm một số dự án Go/Cpp, điều này không được tính, chỉ tính số lượng nhân lực tham gia dự án Rust.
Phát triển chính: khoảng 20 người.
Cộng đồng đóng góp: hơn 300 người.
chu kỳ dự án
TiKV là kho lưu trữ cơ bản của TiDB sau quá trình phát triển của TiDB. TiDB được phát triển cho Go và TiKV được phát triển cho Rust.
Vào tháng 1 năm 2016, nó được thiết kế và phát triển làm công cụ lưu trữ cơ bản của TiDB.
Phiên bản đầu tiên được phát hành dưới dạng mã nguồn mở vào tháng 4 năm 2016.
Vào ngày 16 tháng 10 năm 2017, TiDB đã phát hành phiên bản GA (TiDB 1.0) và TiKV phát hành 1.0.
Vào ngày 27 tháng 4 năm 2018, TiDB đã phát hành phiên bản 2.0 GA và TiKV phát hành phiên bản 2.0.
Vào ngày 28 tháng 6 năm 2019, TiDB đã phát hành phiên bản 3.0 GA và TiKV phát hành phiên bản 3.0.
Vào ngày 28 tháng 5 năm 2020, TiDB đã phát hành phiên bản 4.0 GA và TiKV phát hành 4.0.
Vào ngày 07 tháng 4 năm 2021, TiDB đã phát hành phiên bản 5.0 GA và TiKV phát hành phiên bản 5.0.
bình luận
Một số bạn có thể quan tâm hơn đến hiệu quả phát triển của Rust và muốn định lượng nó, đặc biệt là để so sánh hiệu quả phát triển của các ngôn ngữ khác như C/Cpp/Go.
Cá nhân tôi nghĩ rằng rất khó để định lượng hiệu quả phát triển, đặc biệt là so với các ngôn ngữ khác. Chúng ta cũng có thể xem xét vấn đề này từ một góc độ khác, chẳng hạn như từ góc độ quản lý vòng lặp dự án linh hoạt. Nếu một ngôn ngữ có thể đáp ứng nhu cầu lặp lại phát triển nhanh hàng ngày và giúp hoàn thành quá trình phát triển sản phẩm, thì điều đó đủ để giải thích hiệu quả phát triển của ngôn ngữ này.
Điều này được hiểu rằng số lượng nhà phát triển Go trong PingCAP gấp bốn đến năm lần so với số lượng nhà phát triển Rust và tất nhiên khối lượng công việc gần như giống nhau. Từ dữ liệu trên, chúng ta có thể thấy rằng dự án Rust (TiKV) vẫn có thể theo kịp nhịp lặp đi lặp lại của dự án Go (TiDB), điều này cho thấy hiệu quả phát triển của Rust vẫn đủ để đáp ứng nhu cầu phát triển hiện đại.
Từ khóa: kho dữ liệu thời gian thực / khởi nghiệp / vòng quay thiên thần
giới thiệu
giới thiệu
TensorBase[135] là một dự án kinh doanh do Tiến sĩ Jin Mingjian khởi xướng vào tháng 8 năm 2020. Bắt đầu từ quan điểm hiện đại mới, sử dụng các phương pháp và văn hóa nguồn mở, nó xây dựng lại kho dữ liệu thời gian thực dưới Rust để phục vụ kỷ nguyên dữ liệu lớn. Lưu trữ và phân tích dữ liệu. Dự án TensorBase đã nhận được khoản đầu tư vòng thiên thần từ một công ty tăng tốc đầu tư mạo hiểm nổi tiếng thế giới.
Mã và quy mô nhóm
Bởi vì TensorBase được xây dựng dựa trên Apache Arrow[136] và Arrow DataFusion[137], số liệu thống kê mã loại trừ sự phụ thuộc của hai dự án này.
Các dòng mã lõi của TensorBase có hơn 54000 dòng.
Kích thước nhóm:
Phát triển chính: 1 người.
Cộng đồng đóng góp: 13 người.
Bởi vì nó là một dự án mới, cộng đồng mã nguồn mở vẫn đang được xây dựng.
chu kỳ dự án
TensorBase xuất bản trên cơ sở thời gian, không phải là phiên bản ngữ nghĩa. Chu kỳ lặp lại dự kiến sẽ là một phiên bản chính trong một năm và một phiên bản phụ vào tháng Giêng.
Từ ngày phát hành chính thức vào ngày 20 tháng 4 năm 2021 đến ngày 16 tháng 6, hãy giữ nhịp điệu này.
từ khóa: Luồng dữ liệu/ Hệ thống phân tán/ Khởi nghiệp
giới thiệu
giới thiệu
Luồng dữ liệu kịp thời [138] là một triển khai Rust hiện đại dựa trên tài liệu Luồng dữ liệu kịp thời này của Microsoft: "Naiad: Hệ thống luồng dữ liệu kịp thời" [139]. Nó là một sản phẩm mã nguồn mở của công ty clockworks.io[140].
Rất khó thực hiện xử lý phức tạp trên luồng dữ liệu trong một hệ thống phân tán, chẳng hạn như nhiều lần lặp hoặc tính toán gia tăng. Storm, Streaming Spark và MillWheel không thích ứng tốt với nhu cầu phức tạp của các ứng dụng khác nhau. Bằng cách giới thiệu khái niệm về dấu thời gian, Naiad cung cấp một mô hình mức rất thấp có thể được sử dụng để mô tả tính toán luồng phức tạp tùy ý.
Hệ thống luồng dữ liệu bao gồm tất cả và MapReduce và Spark có thể được coi là đại diện. Luồng dữ liệu kịp thời cung cấp một khái niệm trừu tượng hoàn toàn dựa trên thời gian, thống nhất tính toán luồng và tính toán lặp. Timely Dataflow có thể được sử dụng khi bạn cần xử lý song song luồng dữ liệu và điều khiển lặp.
Mã và quy mô nhóm
Kích thước mã Rust là khoảng 13000 dòng.
Kích thước nhóm:
Nhà phát triển chính: 4 người.
Cộng đồng đóng góp: hơn 30 người.
chu kỳ dự án
Ngày 7 tháng 9 năm 2017, phiên bản 0.3.0.
Ngày 28 tháng 6 năm 2018, phiên bản 0.6.0.
Ngày 16 tháng 9 năm 2018, phiên bản 0.7.0.
Ngày 3 tháng 12 năm 2018, phiên bản 0.8.0.
Ngày 31 tháng 3 năm 2019, phiên bản 0.9.0.
Ngày 10 tháng 7 năm 2019, phiên bản 0.10.0.
Ngày 10 tháng 3 năm 2021, phiên bản 0.12.0.
Về cơ bản, một phiên bản nhỏ được phát hành ba tháng một lần. Ngoài Luồng dữ liệu kịp thời, nhóm cũng duy trì Luồng dữ liệu khác biệt[141] được xây dựng trên Luồng dữ liệu kịp thời, lặp lại đồng bộ với Luồng dữ liệu kịp thời.
Từ khóa: cơ sở dữ liệu/ dự án nghiên cứu khoa học
giới thiệu
giới thiệu
Noria [142] là một hệ thống luồng dữ liệu phát trực tuyến mới được thiết kế như một phụ trợ lưu trữ nhanh cho các ứng dụng web nặng dựa trên luận án tiến sĩ [143] của MIT Jon Gjengset [144], cũng được tham chiếu bởi OSDI'18 Paper [145]. Nó tương tự như cơ sở dữ liệu, nhưng hỗ trợ tính toán trước và lưu vào bộ nhớ đệm các kết quả truy vấn quan hệ để tăng tốc độ truy vấn. Noria tự động giữ các kết quả được lưu trong bộ nhớ cache dưới dạng dữ liệu cơ bản, được lưu trữ trong các bảng cơ bản liên tục. Noria sử dụng luồng dữ liệu có trạng thái một phần để giảm chi phí bộ nhớ và hỗ trợ luồng dữ liệu động, thời gian chạy và thay đổi truy vấn.
Mã và quy mô nhóm
Số dòng mã Rust là khoảng 59000 dòng.
Kích thước nhóm:
Cộng tác viên chính: 2 người
Cộng tác viên cộng đồng: 21
chu kỳ dự án
Bởi vì nó là một dự án nghiên cứu học thuật cá nhân, chu kỳ phát hành không quá rõ ràng.
Chu kỳ dự án từ 30/07/2016 đến 30/04/2020, với tổng số hơn 5.000 lượt commit.
Vector (đường dẫn dữ liệu/nguồn mở/nước ngoài)
từ khóa: Đường ống dữ liệu / Hệ thống phân tán / Khởi nghiệp
Vector[146] là một kênh dẫn dữ liệu có khả năng quan sát từ đầu đến cuối (người môi giới và người tổng hợp) hiệu suất cao được xây dựng bởi Timer. Đó là nguồn mở và nhanh hơn gấp 10 lần so với tất cả các lựa chọn thay thế trong không gian (Logstash, Fluentd, v.v.). Hiện tại các công ty như Douban, checkbox.ai, fundamentei, BlockFi, Fly.io,… sử dụng Vector. Nhấp vào đây [147] để xem báo cáo hiệu suất chính thức và tại đây [148] để biết các công ty sử dụng Vector trong sản xuất.
Mã và quy mô nhóm
Lượng mã khoảng 180.000 dòng mã Rust.
Kích thước nhóm:
Phát triển chính: 9 người
Cộng đồng đóng góp: 140 người
chu kỳ dự án
Vào ngày 22 tháng 3 năm 2019, phiên bản đầu tiên đã được phát hành.
Vào ngày 10 tháng 6 năm 2019, phiên bản 0.2.0 đã được phát hành
Ngày 2 tháng 7 năm 2019, phiên bản 0.3.0 được phát hành
Ngày 25 tháng 9 năm 2019, phiên bản 0.4.0 được phát hành
Vào ngày 11 tháng 10 năm 2019, phiên bản 0.5.0 đã được phát hành
Vào ngày 13 tháng 12 năm 2019, phiên bản 0.6.0 đã được phát hành
Vào ngày 12 tháng 1 năm 2020, phiên bản 0.7.0 đã được phát hành
Vào ngày 26 tháng 2 năm 2020, phiên bản 0.8.0 đã được phát hành
Ngày 21 tháng 4 năm 2020, phiên bản 0.9.0 được phát hành
Vào ngày 23 tháng 7 năm 2020, phiên bản 0.10.0 đã được phát hành
Vào ngày 12 tháng 3 năm 2021, phiên bản 0.11.0 ~ 0.12 sẽ được phát hành
Ngày 22 tháng 4 năm 2021, phiên bản 0.13.0 được phát hành
Ngày 3 tháng 6 năm 2021, phiên bản 0.14.0 được phát hành
Arrow-rs (nước ngoài/mã nguồn mở/tiêu chuẩn dữ liệu lớn)
Từ khóa: dữ liệu lớn/chuẩn định dạng dữ liệu/Apach
arrow-rs[149] là một triển khai Rust của Mũi tên Apache. Apache Arrow là một tiêu chuẩn định dạng dữ liệu lưu trữ cột trong bộ nhớ phù hợp với các hệ thống dữ liệu lớn không đồng nhất. Nó có một tầm nhìn rất lớn: cung cấp một nền tảng phát triển cho phân tích trong bộ nhớ, cho phép dữ liệu di chuyển và xử lý nhanh hơn giữa các hệ thống dữ liệu lớn không đồng nhất.
Arrow đã giới thiệu Rust[150] kể từ phiên bản 2.0 và kể từ phiên bản 4.0, việc triển khai Rust đã chuyển sang arrow-rs kho độc lập.
Việc triển khai Rust của Arrow thực sự bao gồm một số dự án khác nhau, bao gồm các thùng và thư viện riêng lẻ sau:
arrow[151], thư viện lõi của arrow-rs, được bao gồm trong arrow-rs.
arrow-flight [152], một trong các thành phần của arrow-rs, được bao gồm trong arrow-rs.
sàn gỗ [153], một trong các thành phần của arrow-rs, được bao gồm trong arrow-rs. Trong hệ sinh thái dữ liệu lớn, Parquet là định dạng lưu trữ tệp phổ biến nhất.
DataFusion [154], một công cụ thực thi truy vấn trong bộ nhớ có thể mở rộng, sử dụng Mũi tên làm định dạng của nó.
Ballista [155], một nền tảng điện toán phân tán được cung cấp bởi Apache Arrow và DataFusion, được bao gồm trong DataFusion.
Mã và quy mô nhóm
Cộng các thành phần liên quan của arrow-rs, lượng mã Rust vào khoảng 180.000 dòng.
Kích thước nhóm:
Lập trình viên chính: khoảng 10 người
Đóng góp của cộng đồng: hơn 550 người
chu kỳ dự án
Dự án DataFusion bắt đầu được xây dựng vào năm 2016 và sau đó được đưa vào dự án Mũi tên Apache.
Bắt đầu với arrow-rs 4.0:
Vào ngày 18 tháng 4 năm 2021, phiên bản 4.0 đã được phát hành.
Vào ngày 18 tháng 5 năm 2021, phiên bản 4.1 đã được phát hành.
Vào ngày 30 tháng 5 năm 2021, phiên bản 4.2 đã được phát hành.
Vào ngày 11 tháng 6 năm 2021, phiên bản 4.3 đã được phát hành.
InfluxDB IOx (cơ sở dữ liệu chuỗi thời gian/mã nguồn mở/nước ngoài)
Từ khóa: cơ sở dữ liệu chuỗi thời gian / phân tán
InfluxDB IOx[156], công cụ tính thời gian thế hệ tiếp theo của InfluxDB, được viết lại bằng Rust + Aarow.
Thiết kế hiện tại chủ yếu có các vấn đề nghiêm trọng sau:
Không thể giải quyết vấn đề giãn dòng thời gian
Trong môi trường gốc trên đám mây, các yêu cầu quản lý bộ nhớ tương đối nghiêm ngặt, điều đó có nghĩa là mmap không còn được áp dụng nữa và InfluxDB cần hỗ trợ chế độ vận hành không có đĩa cục bộ
Vì chỉ mục và dữ liệu được lưu trữ riêng biệt nên khó đạt được các chức năng nhập và xuất dữ liệu hiệu quả
Ba vấn đề trên là cốt lõi của thiết kế hiện tại, vì vậy việc viết lại là lựa chọn tốt hơn để hỗ trợ các nhu cầu hiện tại.
Mã và quy mô nhóm
Kích thước mã IOx của InfluxDB là khoảng 160.000 dòng mã Rust.
Kích thước nhóm:
Phát triển chính: 5 người
Cộng đồng đóng góp: 24 người
chu kỳ dự án
Dự án bắt đầu vào tháng 11 năm 2019, nhưng tính đến hôm nay dự án vẫn còn rất sớm, nó chưa sẵn sàng để thử nghiệm, cũng như không có bất kỳ bản dựng hay tài liệu nào.
Nhưng đánh giá từ trạng thái hoạt động của GitHub, trạng thái phát triển vẫn rất tích cực. Công việc phát triển chính dự kiến sẽ bắt đầu vào năm 2021.
từ khóa: cơ sở dữ liệu chuỗi thời gian
giới thiệu
giới thiệu
CeresDB là cơ sở dữ liệu chuỗi thời gian hợp nhất TP/AP do Ant Group phát triển, đáp ứng nhu cầu lưu trữ dữ liệu chuỗi thời gian khổng lồ, truy vấn đa chiều và phân tích thời gian thực trong định thời gian tài chính, giám sát, IOT, v.v. kịch bản. Có một kế hoạch nguồn mở, nhưng nó vẫn chưa phải là nguồn mở.
kích thước nhóm
Hiện tại, có khoảng 8-10 người trong việc phát triển cơ sở dữ liệu.
Thông tin khác là không rõ.
Tantivy (nước ngoài/mã nguồn mở/tìm kiếm toàn văn)
từ khóa: tìm kiếm toàn văn / lucene
tantivy[157] là một thư viện công cụ tìm kiếm toàn văn lấy cảm hứng từ Apache Lucene, được triển khai trong Rust.
Tantivy thật tuyệt, đây là một ứng dụng được xây dựng trên Rust + Tantivy + AWS: Phục vụ một tỷ lượt tìm kiếm trên web và tạo ra một đám mây các từ phổ biến [158].
Mã và quy mô nhóm
Kích thước mã khoảng 50000 dòng mã Rust.
Kích thước nhóm:
Phát triển chính: 1 người
Cộng đồng đóng góp: 85 người
chu kỳ dự án
Dự án được thành lập vào năm 2016 và chu kỳ lặp lại trung bình là một bản phát hành phiên bản phụ mỗi tháng. Nó hiện được phát hành cho phiên bản 0.15.2.
từ khóa: Zhihu / lucene
giới thiệu
giới thiệu
Rucene[159] là một công cụ tìm kiếm dựa trên Rust được mã nguồn mở bởi nhóm Zhihu. Rucene không phải là một ứng dụng hoàn chỉnh mà là một thư viện mã và API có thể dễ dàng sử dụng để thêm khả năng tìm kiếm toàn văn cho ứng dụng. Nó là một cổng Rust của dự án Apache Lucene 6.2.1.
Mã và quy mô nhóm
Kích thước mã khoảng 100.000 dòng mã Rust.
Kích thước nhóm:
Phát triển chính: 4 người
Đóng góp cộng đồng: 0 người
Có thể là do dự án nội bộ của công ty là nguồn mở và hiện tại không có phiên bản ngữ nghĩa cụ thể nào được lặp lại. Nó được sử dụng trong môi trường sản xuất ở Zhihu.
trình soạn thảo mdnice
đám mây bản địa
Các trường gốc trên đám mây bao gồm: điện toán bí mật, Serverless, nền tảng điện toán phân tán, bộ chứa, WebAssembly, công cụ vận hành và bảo trì, v.v.
StratoVirt (trong nước/mã nguồn mở/vùng chứa)
Từ khóa: container / ảo hóa / Serverless
StratoVirt[160] là một nền tảng ảo hóa dựa trên Rust thế hệ tiếp theo do nhóm Huawei OpenEuler phát triển.
Strato, được lấy từ tầng bình lưu, có nghĩa là tầng bình lưu trong bầu khí quyển của trái đất, bầu khí quyển có thể bảo vệ trái đất khỏi môi trường bên ngoài và tầng bình lưu là lớp ổn định nhất trong khí quyển; tương tự, công nghệ ảo hóa nằm trên nền tảng hệ điều hành Lớp cách ly không chỉ có thể bảo vệ nền tảng hệ điều hành khỏi bị phá hoại bởi các ứng dụng độc hại cấp trên mà còn cung cấp môi trường hoạt động ổn định và đáng tin cậy cho các ứng dụng thông thường; cái tên Strato có nghĩa là lớp bảo vệ mỏng và nhẹ giúp bảo vệ hoạt động trơn tru của các dịch vụ trên nền tảng nền tảng openEuler. Đồng thời, Strato cũng mang tầm nhìn và tương lai của dự án: trọng lượng nhẹ, linh hoạt, an toàn và khả năng bảo vệ trọn vẹn.
StratoVirt là một nền tảng ảo hóa cấp doanh nghiệp dành cho các trung tâm dữ liệu đám mây trong ngành điện toán. Nền tảng này hiện thực hóa một kiến trúc thống nhất hỗ trợ các máy ảo, bộ chứa và các kịch bản không có máy chủ. Nền tảng này có các cuộc cạnh tranh công nghệ quan trọng về trọng lượng nhẹ, độ ồn thấp, khả năng cộng tác giữa phần mềm và phần cứng, và an ninh.Ưu điểm. StratoVirt bảo lưu khả năng và giao diện của việc lắp ráp thành phần trong thiết kế kiến trúc và giao diện. StratoVirt có thể linh hoạt lắp ráp các tính năng nâng cao theo yêu cầu cho đến khi nó phát triển để hỗ trợ ảo hóa tiêu chuẩn và tìm thấy sự cân bằng tốt nhất giữa các yêu cầu về tính năng, kịch bản ứng dụng cũng như sự nhẹ nhàng và khéo léo.
Mã và quy mô nhóm
Kích thước mã khoảng 27000 dòng mã Rust.
Kích thước nhóm:
Nhà phát triển chính: 4 người.
Cộng đồng đóng góp: 15 người.
chu kỳ dự án
23-09-2020, phát hành phiên bản 0.1.0.
25-03-2021, phát hành phiên bản 0.2.0.
28-05-2021, phát hành phiên bản 0.3.0.
Pháo nổ (ngoại/hàng)
