![\"Rust](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/Screenshot-2025-05-30-at-10.49.08-AM.png\")
<\/figure>\n\n\n\nDeveloper appreciation for Rust is also unbeatable. How do I know that? Well, the StackOverflow Developer Survey provides amazing proof:<\/p>\n\n\n\n
- \n
- Rust continues to be the most admired language<\/a> in the developer community, and has been for many years in a row (eight years? nine years? No one remembers!).<\/li>\n\n\n\n
- Those already working with Rust don\u2019t want to switch<\/a> to other programming languages.<\/li>\n<\/ul>\n\n\n\n
As a regular participant in Rust developer conferences, I can testify that this appreciation for Rust is evident. Rustaceans love Rust and have created one of the friendliest communities to participate in.<\/p>\n\n\n\n
On the other hand, the StackOverflow survey reports<\/a> a decline in median yearly salary over the last couple of years, but this trend is also seen with other mainstream programming languages. Despite growing adoption among top and mid-size IT companies, we have yet to see Rust adopted by myriad smaller companies, which could bring more Rust vacancies to the job market and make it less competitive than it is these days (see this engaging discussion<\/a> for context).<\/p>\n\n\n\n
If we look at the language, features, and ecosystem, we immediately see where the numbers come from. Rust has been developed to provide memory safety and performance simultaneously. Unique choices made by the language designers ensure that you have fewer memory access errors in your code, making security breaches less likely. The price you pay for that doesn\u2019t come with performance penalties. So, what\u2019s the price then? Well, it\u2019s the time you, as a developer, spend persuading the Rust compiler that your code is truly safe. Once the compiler has agreed with you, you\u2019re safe. Memory safety and performance are extremely valuable: together, they provide a much smoother experience for those who use software solutions (which these days means everyone). Rust\u2019s standard library, other cornerstone libraries, and tooling also enhance the developer experience. For example, developing high-performance concurrent applications in Rust is not a big deal, as the ecosystem is mature and well-equipped to support such tasks.<\/p>\n\n\n\n
Developers also appreciate the wide spectrum of technology domains and industries where Rust knowledge is applicable. The most recent Rust Annual Survey<\/a> identifies the following such areas:<\/p>\n\n\n\n
- \n
- Server-side and other backend applications.<\/li>\n\n\n\n
- Cloud computing applications, services, and infrastructure.<\/li>\n\n\n\n
- Distributed systems.<\/li>\n\n\n\n
- Computer networking.<\/li>\n\n\n\n
- Computer security.<\/li>\n\n\n\n
- Embedded development.<\/li>\n\n\n\n
- Game development.<\/li>\n\n\n\n
- Web frontends (including WebAssembly).<\/li>\n\n\n\n
- And many others.<\/li>\n<\/ul>\n\n\n\n
Of course, Rust is not the only programming language used in these areas. There are competitors in each of them. Rust is often compared to C++ or Go because they share many areas but differ in various aspects, including memory safety guarantees, performance promises, availability of tooling and libraries, language simplicity, and industry adoption. While Rust might be lagging in the last three categories, it works on par with C++ in terms of performance and makes it much easier to avoid memory access pitfalls and build error-free applications.<\/p>\n\n\n\n
Understanding Rust’s core concepts<\/h2>\n\n\n\n
Let\u2019s get a bird\u2019s-eye view of Rust and its features. Rust is neither an object-oriented nor a functional programming language. It doesn\u2019t feature classes and doesn\u2019t directly support object-oriented patterns. It can operate with functions as first-class values, but this ability is limited compared to full-blown functional languages (such as Haskell or OCaml).<\/p>\n\n\n\n
Writing code with functions, values, and types<\/h3>\n\n\n\n
Programs in Rust are structured as collections of functions combined in modules. Functions manipulate values. Values are statically typed, meaning every value or expression should have an assigned type at compile time. Rust provides both primitive and compound types (arrays and structs), and its standard library also provides many additional types for collections of values. Rust supports generic types, which makes it possible to avoid mentioning specific types and provide more general definitions. Rust also provides traits as collections of methods (i.e. functions) that can be implemented for specific types. Traits allow Rust to achieve the same levels of software abstraction as object-oriented languages that support inheritance and polymorphism.<\/p>\n\n\n\n
Memory management<\/h3>\n\n\n\n
Rust\u2019s approach to memory management is based on the following principle: the Rust compiler must know the precise locations in the code where memory is allocated, where and how it\u2019s accessed, and where it\u2019s no longer needed<\/strong>. This knowledge allows for controlling memory access and freeing allocated memory automatically by inserting the corresponding instructions directly into the generated code, thus avoiding many common pitfalls other languages might be susceptible to. This approach differs from automatic memory management (as in JavaScript, Python, Java, or C#), where memory fragments that are no longer needed are detected at runtime and garbage is collected. As a result, Rust saves the time required to execute the corresponding algorithms at runtime and achieves both memory safety and performance.<\/p>\n\n\n\n
To be able to infer knowledge about memory access, Rust sets limits on what can be done with memory and defines strict rules that ensure correctness:<\/p>\n\n\n\n
- \n
- Every memory fragment must be owned by a single variable \u2013 Rust\u2019s ownership model<\/em> is based on this.<\/li>\n\n\n\n
- Mutating a memory fragment requires exclusive access (as opposed to just reading the memory).<\/li>\n\n\n\n
- Rust allows creating mutable and immutable references to memory fragments (borrowing them) but uses a borrow checker<\/em> to enforce correctness (for example, prohibiting more than one mutable reference).<\/li>\n\n\n\n
- The Rust compiler computes and checks lifetimes<\/em> for every variable in a program from the place it\u2019s created to the place it\u2019s dropped (where it becomes no longer accessible).<\/li>\n<\/ul>\n\n\n\n
The compiler’s requirements can be too strict. This can be a common frustration, especially when learning the language: The Rust compiler may fail to accept a logically correct code fragment.<\/p>\n\n\n\n
To make these concepts a little easier to catch, let\u2019s discuss Rust\u2019s equivalent of the following Python program:<\/p>\n\n\n\n
def print_list(numbers):\n for number in numbers:\n print(str(number) + \" \", end=\"\")\n print()\n\n\ndef add_one(numbers):\n numbers.append(1)\n\n\ndef main():\n numbers = [1, 1, 1]\n print_list(numbers)\n add_one(numbers)\n print_list(numbers)\n\n\nif __name__ == '__main__':\n main()<\/pre>\n\n\n\n
So, we have a memory fragment (Python\u2019s list) with three elements. We print it, add one more element, and print it again. We never mention any type here. Python doesn\u2019t need any sign of memory management in the program, although the memory must be allocated and freed at some point. Moreover, we pass around the
numbers<\/code> list easily without thinking about memory access control. <\/p>\n\n\n\nThe same code in Rust is different, not only in syntax but in the whole approach to types and memory management:<\/p>\n\n\n\n
\/\/ Here we take a vector by reference (&).\n\/\/ We are not allowed to mutate elements.\n\/\/ We don't take ownership; we just borrow.\nfn print_vec(numbers: &Vec<i32>) {\n for number in numbers {\n print!(\"{} \", number);\n }\n println!()\n}\n\n\n\/\/ Here we take a vector by mutable reference (&mut).\n\/\/ We are now allowed to mutate elements and the vector itself.\n\/\/ We still don't take ownership; we just borrow.\nfn add_one(numbers: &mut Vec<i32>) {\n numbers.push(1)\n}\n\n\nfn main() {\n let mut numbers = vec![1,1,1];\n \/\/ We pass a reference\n print_vec(&numbers);\n \/\/ We pass a mutable reference\n add_one(&mut numbers);\n \/\/ We pass a reference again\n print_vec(&numbers);\n}<\/pre>\n\n\n\nIt\u2019s instructive to explore these two code fragments and find similarities and differences between them by yourself. Even without understanding Rust, you might get a general feeling for it just by looking at this code.<\/p>\n\n\n\n
Despite passing references around, the numbers variable still owns the allocated memory. Rust defaults to read-only memory access, requiring explicit specification for write access. Rust also ensures the memory is freed after the last usage in the second call to
print_vec<\/code>. <\/p>\n\n\n\nHere\u2019s a variation of the add_one function that takes over ownership of a vector and renders the whole program incorrect:<\/p>\n\n\n\n
fn add_one_incorrect(mut numbers: Vec<i32>) {\n\u00a0\u00a0\u00a0numbers.push(1)\n}<\/pre>\n\n\n\nWhat\u2019s the problem? Well, after calling the
add_one_incorrect<\/code> function, the numbers variable no longer owns the memory; its lifetime has ended, so we can\u2019t print anything! The screenshot below shows that we\u2019re in trouble:<\/p>\n\n\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/Screenshot-2024-09-18-at-18.19.01.png\")
<\/figure>\n\n\n\nBefore introducing the incorrect version, Rust\u2019s borrow checker could ensure that passing references didn\u2019t bring any problems. After introducing an error, it\u2019s no longer feasible. The language’s behavior here exemplifies how memory access is under strict control.<\/p>\n\n\n\n
Concurrency<\/h3>\n\n\n\n
Concurrency is the ability of a system to execute multiple tasks or processes simultaneously or in overlapping periods to improve efficiency and performance. This can involve parallel execution on multiple processors or interleaved execution on a single processor, allowing a system to handle multiple operations simultaneously and manage multiple tasks more effectively.<\/p>\n\n\n\n
Rustaceans often describe Rust\u2019s concurrency as fearless. Several factors contribute to this perception:<\/p>\n\n\n\n
- \n
- The ownership model adds more control over sharing data between concurrent threads.<\/li>\n\n\n\n
- Embracing immutable data structures simplifies the implementation of concurrent algorithms and contributes to thread safety.<\/li>\n\n\n\n
- Message passing via channels adopted in Rust dramatically reduces the complexities of shared-state concurrency.<\/li>\n\n\n\n
- Rust\u2019s approach to lifetimes and memory management generally makes code that works with concurrency primitives such as locks, semaphores, or barriers more elegant and safe.<\/li>\n\n\n\n
- In many cases, Rust\u2019s approach to asynchronous programming makes it possible to avoid using complex concurrency patterns and enables you to write concise and clear code.<\/li>\n<\/ul>\n\n\n\n
Although concurrency is not the first thing beginners learn when approaching Rust, it is still easier to grasp than in many other programming languages. More importantly, Rust helps you write less error-prone concurrent code.<\/p>\n\n\n\n
How to get started with Rust<\/h2>\n\n\n\n
There are only two things that need to be installed on your computer to get started with Rust:<\/p>\n\n\n\n
- \n
- Rust toolchain \u2013 a collection of tools that includes the Rust compiler and other utilities.<\/li>\n\n\n\n
- A code editor or IDE (integrated development environment). <\/li>\n<\/ol>\n\n\n\n
The first step is easy \u2013 just go to rustup.rs<\/a> and run a command they suggest or download an installer, depending on your operating system.<\/p>\n\n\n\n
The second step requires making a choice. Your options include using a code editor configured to provide Rust support (for example, Visual Studio Code supports Rust but requires some setup) or using a dedicated Rust IDE (such as RustRover<\/a>, a JetBrains IDE, which is free for anyone learning Rust).<\/p>\n\n\n
\n\n Get RustRover for free<\/a>\n <\/div>\n <\/div>\n\n\n\n\n\n\n\nIf you choose RustRover, you don\u2019t need to configure anything. You can launch it, create a new project (using the New Project<\/em> button on the welcome screen), and run the Hello, world!<\/em> program generated by default (use the green triangle icon in the gutter to run the main function):<\/p>\n\n\n\n
![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/image-18.png\")
<\/figure>\n\n\n\nIf you encounter any trouble, refer to RustRover\u2019s Quick Start Guide<\/a>. <\/p>\n\n\n\n
Anything beyond really simple stuff requires adding external dependencies. Rust projects rely on Cargo, a package manager. In Rust, packages are called crates<\/strong>. The dependencies are specified in the
Cargo.toml<\/code> file, for example:<\/p>\n\n\n\n[package]\nname = \"hello\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\nchrono = \"0.4.38\"<\/pre>\n\n\n\n
After adding the
chrono<\/code> crate to our dependencies, we can use the functionality it provides in our code, for example:<\/p>\n\n\n\nuse chrono::{DateTime, Local};\n\nfn main() {\n println!(\"Hello, world!\");\n let local: DateTime<Local> = Local::now();\n println!(\"Today is {}\", local.format(\"%A\"));\n}<\/pre>\n\n\n\nIn this program, we get the current (local) date and time, format it as a day of the week, and then print a result. For example, running this program gives me:<\/p>\n\n\n\n
Hello, world!\nToday is Thursday<\/pre>\n\n\n\n
Learning basic syntax, data types, and control structures (if-conditionals, loops, etc.) in Rust is a parallel process to learning about the available crates and what they provide. Once you can run Rust programs, you\u2019ll be ready to work with external dependencies. Let\u2019s talk about the resources that simplify learning Rust.<\/p>\n\n\n\n
Learning path and resources<\/h2>\n\n\n\n
If you’ve ever learned a foreign language, you know that various skills are required, such as reading, writing, listening, and speaking. There are also different types of activities to develop these skills. Teachers always encourage you to read texts, watch videos, listen to podcasts, speak whenever possible, post on social media, etc. Learning programming languages is no different. When learning how to code in Rust (or any other programming language), you:<\/p>\n\n\n\n
- \n
- Read books, documentation, blog posts, release announcements, and social media discussions (which is all vital to staying informed and in context).<\/li>\n\n\n\n
- Watch videos from tech video bloggers.<\/li>\n\n\n\n
- Explore code samples (which necessarily includes reading and modifying them!).<\/li>\n\n\n\n
- Write code to complete exercises.<\/li>\n\n\n\n
- Follow hands-on tutorials.<\/li>\n\n\n\n
- Develop simple projects from scratch (this is extremely important \u2013 project-based learning is always helpful for developing independent coding skills).<\/li>\n\n\n\n
- Maybe even contribute to open-source projects (there\u2019s always something easy enough for beginners \u2013 just ask!).<\/li>\n<\/ul>\n\n\n\n
Note that there should be a balance between reading about programming and writing code. It\u2019s impossible to master a programming language without actually writing code. At the same time, avoiding books or other extended materials can lead to a relatively shallow understanding of the internal details; any complex case could become extremely hard to resolve without external help (which is fine but can slow you down on your path to becoming a professional developer).<\/p>\n\n\n\n
When you write code, it’s important to both replicate externally crafted exercises and follow your own (or borrowed) ideas for developing simple applications. Ensure that your exercises are not limited to grasping algorithms but also teach language features and library functionalities. When developing simple applications, you learn to choose a language feature or a library that best suits your goal. This is an essential skill in itself.<\/p>\n\n\n\n
So, the key to successful learning is combining all the approaches. Here I have a collection of resources that can help you with that.<\/p>\n\n\n\n
Rust books<\/h3>\n\n\n\n
There are many good books available for learning Rust:<\/p>\n\n\n
\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/image-19.png\")
<\/figure><\/div>\n\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/image-20.png\")
<\/figure><\/div>\n\n\n- \n
- The Rust Programming Language<\/em><\/a> is an official, regularly updated book for those learning Rust. It is known as The Book<\/em> within the community. I also recommend another version<\/a> of this book that adds more interactivity, such as quizzes, visualizations, and exercises. This version was developed by Brown University researchers Will Crichton, Gavin Gray, and Shriram Krishnamurthi. There\u2019s also an interview<\/a> with Will Crichton, who discusses this experiment to enhance Rust learners’ experience.<\/li>\n\n\n\n
- Rust in Action<\/em><\/a> by Tim McNamara (mostly known as timClicks<\/a> \u2013 my advice is to follow him everywhere).<\/li>\n\n\n\n
- Hands-on Rust<\/em><\/a> by Herbert Wolverson \u2013 the book that is especially appealing to those who appreciate project-based learning (you can also find a lot of free videos by Herbert about various Rust concepts; I can\u2019t recommend them enough).<\/li>\n\n\n\n
- Rust for Rustaceans<\/em><\/a> by Jon Gjengset, a Rust book that many community members highly praise. <\/li>\n\n\n\n
- Code Like a Pro in Rust<\/em><\/a> by Brenden Matthews.<\/li>\n\n\n\n
- Learn Rust in a Month of Lunches<\/em><\/a> by David MacLeod.<\/li>\n\n\n\n
- After a few months of learning Rust, you should check out Mara Bos’s Rust Atomics and Locks<\/a><\/em>. It\u2019s a masterpiece in explaining the low-level concepts behind Rust concurrency.<\/li>\n<\/ul>\n\n\n\n
Rust tutorials<\/h3>\n\n\n\n
For those who prefer more hands-on approach to learning, there are also tutorials and courses with exercises:<\/p>\n\n\n\n
- \n
- Comprehensive Rust<\/a> is a Rust tutorial developed internally at Google but available to everyone. It is the best resource for those who want to learn all the necessary details quickly.<\/li>\n\n\n\n
- Rustlings<\/a> (and its variation for an in-IDE learning experience<\/a>, a Rust course<\/a> from JetBrains Academy<\/a>).<\/li>\n\n\n\n
- 100 exercises to learn Rust<\/a> \u2013 a fantastic course with exercises developed by Luca Palmieri<\/a> (yet another Rustacean to keep an eye on).<\/li>\n\n\n\n
- Eleftheria Batsou presented a nice set of simple project ideas<\/a> for you to work on while learning Rust.<\/li>\n\n\n\n
- Folks at codecrafters.io<\/a> composed this list of projects<\/a> that you can use to get hands-on experience with Rust.<\/li>\n\n\n\n
- You can join Herbert Wolverson\u2019s Rust training at ArdanLabs<\/a> to master Rust fundamentals and learn about the core concepts behind it.<\/li>\n<\/ul>\n\n\n\n
Rust on YouTube<\/h3>\n\n\n\n
For Rustaceans who like learning on YouTube, I recommend following several channels there:<\/p>\n\n\n\n
- \n
- Let\u2019s Get Rusty<\/a> \u2013 I don\u2019t know how it works, but it\u2019s hard to stop watching these videos.<\/li>\n\n\n\n
- Jeremy Chone<\/a> is great at explaining complex concepts.<\/li>\n\n\n\n
- Chris Biscardi<\/a> talks about game development in Rust with the Bevy framework, among other things. Creating a game is an excellent project for anyone!<\/li>\n\n\n\n
- Jon Gjengset<\/a> \u2013 For the first couple of years of your Rust journey, it can be hard to follow his in-depth technical streams, but I recommend watching them early! <\/li>\n<\/ul>\n\n\n\n
Rust community<\/h3>\n\n\n\n
- \n
- The Rust community on Reddit<\/a> is worth following.<\/li>\n\n\n\n
- Rust Community Discord server<\/a> is the place where you can ask questions as a beginner.<\/li>\n\n\n\n
- This Week in Rust<\/a> is the most important community resource for reading Rust-related news. I read it every week without exception.<\/li>\n<\/ul>\n\n\n\n
Of course, many more learning resources are available, but it\u2019s impossible to list all of them. The good news is that you never stop learning Rust because the language is constantly evolving.<\/p>\n\n\n\n
Common challenges and how to overcome them<\/h2>\n\n\n\n
Learning Rust can be challenging. However, you can overcome these difficulties and master the language with the right strategies. Here are some tips to help you along the way:<\/p>\n\n\n\n
- \n
- Understand the ownership model.<\/strong> Rust’s ownership model, which includes concepts like ownership, borrowing, and lifetimes, is often the most challenging aspect for beginners. Start with small examples and practice frequently. Focus on understanding why Rust enforces these rules rather than how to get around compiler errors. <\/li>\n\n\n\n
- Take your time with the borrow checker.<\/strong> The borrow checker can be frustrating, as it\u2019s strict and may lead to confusing compiler errors. When you encounter borrow checker issues, take a step back and analyze what Rust is trying to prevent. Experiment with approaches like referencing or cloning data (but try not to clone everything!). Don\u2019t be afraid to ask for help on forums like Reddit or the Rust Community Discord server. It\u2019s really useful to understand what precisely a borrow checker is. See, for example, this great explanation<\/a> by Nell Shamrell-Harrington.<\/li>\n\n\n\n
- Leverage Rust\u2019s excellent documentation.<\/strong> Rust is a relatively new language, so some things might not be as straightforward as in more established languages. Use the Rust documentation, which is known for being comprehensive and well-written. The Rust community also contributes to great resources like the Rust by Example<\/a> guide.<\/li>\n\n\n\n
- Start with simple projects. <\/strong>Rust’s complexity can make even simple projects feel overwhelming at first. Start by implementing basic programs and gradually move to more complex ones. Examples of simple projects include building a command-line tool with clap<\/a>, writing simple file parsers, or creating a basic web server using a framework like Rocket<\/a>.<\/li>\n\n\n\n
- Learn your code editor or IDE.<\/strong> Writing Rust code manually can be error-prone. Tools can help you with code completion, linting, and formatting.<\/li>\n\n\n\n
- Participate in the Rust community.<\/strong> Learning a new language can feel isolating. Engage with the Rust community by contributing to open-source projects, joining Rust-focused chat rooms, or participating in forums. Rust\u2019s community is known for being very welcoming and helpful to newcomers.<\/li>\n\n\n\n
- Learn from mistakes. <\/strong>Rust\u2019s compiler is strict, and it can feel like you\u2019re constantly fighting with it. View each compiler error as a learning opportunity. Rust\u2019s error messages are often very descriptive and guide you toward the correct solution. Over time, you\u2019ll find that these errors help you write better, safer code.<\/li>\n\n\n\n
- Be patient.<\/strong> It\u2019s easy to get discouraged with Rust. Remember that Rust is designed to be safe and efficient, which requires you to learn some complex concepts. Take breaks when necessary, and don\u2019t be afraid to revisit topics multiple times until you\u2019re confident that you\u2019ve fully grasped them.<\/li>\n\n\n\n
- Join Rust learning groups. <\/strong>Many developers are learning Rust, and joining a group can provide support and motivation. Look for local meetups or online study groups, or even partner with a friend to learn together.<\/li>\n<\/ol>\n\n\n\n
Mastering Rust takes time, but the payoff is worth it. Rust\u2019s features, like its memory safety guarantees and performance, make it a powerful language for systems programming, web development, and more. Stick with it; you\u2019ll find that Rust can be fun and rewarding.<\/p>\n\n\n\n
Building real-world applications with Rust <\/h2>\n\n\n\n
Let\u2019s now briefly examine Rust\u2019s suitability for building real-world applications. We\u2019ll focus on several relevant technology domains, as case studies in these areas highlight Rust’s strengths and demonstrate its practical applicability.<\/p>\n\n\n\n
Rust in web development<\/h3>\n\n\n\n
The Rust ecosystem is perfectly suitable for backend web development. Many frameworks and libraries perform general web development tasks, such as HTTP request routing, JSON and form handling, templating, database access, authentication and authorization, logging and tracing, etc., with production-ready performance. I recommend looking at the AreWeWebYet?<\/a> website for details and useful links. As a spoiler, the answer is positive. <\/p>\n\n\n
\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/image-21.png\")
<\/figure><\/div>\n\n\nMost web frameworks for Rust are easy to start with, and their documentation is awesome, partly thanks to the competition between them. For example, the Actix Web<\/a> community provides a nice and up-to-date collection of examples<\/a>. My colleague Khalid Abuhakmeh wrote a tutorial for beginners<\/a> on building a simple HTML web application that uses Rocket, another web framework for Rust, as a backend. Luca Palmieri, whom I mentioned earlier, authored a book, Zero To Production in Rust<\/em><\/a>, that helps you become a web backend developer, and he also works on Pavex<\/a>, an emerging and promising web framework. One exciting thing about the latter project is that Luca carefully documents design choices in a series of progress reports<\/a>. It\u2019s constantly engaging to see why things are designed the way they are and not in some other way. Check out this web framework comparison<\/a> to understand how actively Rust web frameworks are developing.<\/p>\n\n\n\n
Rust is also active on the web frontend, though it may not be 100% ready for production. Still, the overall progress in Rust for WebAssembly and frameworks such as egui<\/a> or Dioxus<\/a> is impressive.<\/p>\n\n\n\n
Integrating Rust with other programming languages<\/h3>\n\n\n\n
I wonder if Rust designers envisioned Rust becoming a language of choice for those who develop tooling and libraries for other programming languages, especially Python and JavaScript. Rust can provide better performance, and it\u2019s attractive enough for developers from other language ecosystems to learn and apply. <\/p>\n\n\n\n
The PyO3<\/a> project enables developers to implement native Python modules in Rust and to access Python in Rust binaries. By leveraging PyO3, you can provide an extremely efficient Rust implementation of a Python library for Python developers. Rust and JavaScript can be connected similarly via WebAssembly and wasm-bindgen<\/a>. <\/p>\n\n\n\n
Astral<\/a> and its founder, Charlie Marsh, prove that it\u2019s possible to develop Python tooling that works at the speed of light (well, we all know that that\u2019s a marketing claim, of course, but the result is truly fascinating). <\/p>\n\n\n\n
![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/image-27.png\")
<\/figure>\n\n\n\nDeno<\/a>, a JavaScript runtime developed in Rust, delivers very good performance. This is not the only example from the JavaScript ecosystem. There\u2019s even a curated collection of JavaScript tooling<\/a> implemented in Rust. <\/p>\n\n\n\n
Implementing interoperability between Rust and other programming languages is also possible.<\/p>\n\n\n\n
Systems and embedded programming in Rust<\/h3>\n\n\n\n
Undoubtedly, Rust shines in systems programming. Speakers from Google and Microsoft confirm<\/a> that introducing Rust into their codebases lessens the number of security vulnerabilities, increases performance, and also keeps or sometimes improves the productivity of software developer teams. Amazon not only supports Rust development on AWS<\/a> but also uses it directly to implement their own infrastructure<\/a>. Cloudflare, a company that builds content delivery networks and other networking infrastructure, relies on Rust<\/a> in a lot of low-level projects and contributes their frameworks<\/a> to the Rust ecosystem. Ferrous Systems, a company that backs the development of rust-analyzer, also develops Ferrocene<\/a>, a certified Rust toolchain for mission-critical applications. Together with other developments, this enables Rust to be used in the automotive and aerospace industries. For example, there are reports about Volvo<\/a> and Renault<\/a> using Rust for their in-vehicle software.<\/p>\n\n\n\n
Conclusion and next steps<\/h2>\n\n\n\n
It\u2019s a great time to start your Rust journey. Rust is a good industrial-level language with a wealth of learning materials and a beginner-friendly community. While there are some challenges, given the unique core concepts, there are also ways to overcome them. Once you are there, the job market and various application domains are open. <\/p>\n\n\n\n
I hope that the learning path and resources I\u2019ve presented will help you on your way. I can only recommend setting a learning goal beforehand: find an open-source project you want to contribute to or develop an idea for your project early. You\u2019ll be amazed how quickly you can get close to fulfilling that goal.<\/p>\n\n\n\n
Be encouraged and stay on the path of learning Rust!<\/p>\n","protected":false},"author":1335,"featured_media":511228,"comment_status":"closed","ping_status":"closed","template":"","categories":[],"tags":[2019,743,530],"cross-post-tag":[],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/ru\/wp-json\/wp\/v2\/rust\/511126"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/ru\/wp-json\/wp\/v2\/rust"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/ru\/wp-json\/wp\/v2\/types\/rust"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/ru\/wp-json\/wp\/v2\/users\/1335"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/ru\/wp-json\/wp\/v2\/comments?post=511126"}],"version-history":[{"count":10,"href":"https:\/\/blog.jetbrains.com\/ru\/wp-json\/wp\/v2\/rust\/511126\/revisions"}],"predecessor-version":[{"id":678617,"href":"https:\/\/blog.jetbrains.com\/ru\/wp-json\/wp\/v2\/rust\/511126\/revisions\/678617"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/ru\/wp-json\/wp\/v2\/media\/511228"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/ru\/wp-json\/wp\/v2\/media?parent=511126"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/ru\/wp-json\/wp\/v2\/categories?post=511126"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/ru\/wp-json\/wp\/v2\/tags?post=511126"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/ru\/wp-json\/wp\/v2\/cross-post-tag?post=511126"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
- Take your time with the borrow checker.<\/strong> The borrow checker can be frustrating, as it\u2019s strict and may lead to confusing compiler errors. When you encounter borrow checker issues, take a step back and analyze what Rust is trying to prevent. Experiment with approaches like referencing or cloning data (but try not to clone everything!). Don\u2019t be afraid to ask for help on forums like Reddit or the Rust Community Discord server. It\u2019s really useful to understand what precisely a borrow checker is. See, for example, this great explanation<\/a> by Nell Shamrell-Harrington.<\/li>\n\n\n\n
- Rust Community Discord server<\/a> is the place where you can ask questions as a beginner.<\/li>\n\n\n\n
- Jeremy Chone<\/a> is great at explaining complex concepts.<\/li>\n\n\n\n
- Rustlings<\/a> (and its variation for an in-IDE learning experience<\/a>, a Rust course<\/a> from JetBrains Academy<\/a>).<\/li>\n\n\n\n
- Rust in Action<\/em><\/a> by Tim McNamara (mostly known as timClicks<\/a> \u2013 my advice is to follow him everywhere).<\/li>\n\n\n\n
- The Rust Programming Language<\/em><\/a> is an official, regularly updated book for those learning Rust. It is known as The Book<\/em> within the community. I also recommend another version<\/a> of this book that adds more interactivity, such as quizzes, visualizations, and exercises. This version was developed by Brown University researchers Will Crichton, Gavin Gray, and Shriram Krishnamurthi. There\u2019s also an interview<\/a> with Will Crichton, who discusses this experiment to enhance Rust learners’ experience.<\/li>\n\n\n\n
- Every memory fragment must be owned by a single variable \u2013 Rust\u2019s ownership model<\/em> is based on this.<\/li>\n\n\n\n
- Those already working with Rust don\u2019t want to switch<\/a> to other programming languages.<\/li>\n<\/ul>\n\n\n\n