top of page
  • Writer's pictureKids Code

Code Savvy Presents: Rust Programming Language

Updated: Jan 23

Curated by Chris Eckhardt of


Rust is a powerful, flexible language that aims to accomplish the trifecta of memory safety, performance, and “fearless concurrency.” It has a wide range of uses, from embedded applications, systems programming, networking, command line tools, WebAssembly, game engines, and more. A strong community, thorough documentation, and great developer experience have made it one of the most loved modern programming languages.

Rust is a statically-typed language, which means that the type of a value is checked at compile-time, rather than runtime. This can make Rust programs faster and more memory-efficient than programs written in dynamically-typed languages. It enforces ownership, borrowing, and lifetimes of values, which allow it guarantee memory safety without the performance impacts of garbage collection. This makes it easier to write safe, highly-performant, concurrent applications.

Rust also has a number of features that make it well-suited for systems programming. It has a low-level control over system resources, such as memory and threads, and it has a foreign function interface (FFI) that allows Rust code to call C code.

Overall, Rust is a modern, flexible, and efficient programming language that is well-suited for a wide range of applications. It has a strong and growing community, with a number of libraries and tools available to support the development of Rust programs.


There are many ways that people use the Rust programming language, but some common use cases include:

  • Systems programming: Rust is often used for low-level systems programming tasks, such as operating system kernels, device drivers, and embedded systems. Its focus on safety, concurrency, and performance make it well-suited for these types of tasks.

  • Web development: Rust has a number of libraries and frameworks available for building web applications, including Rocket, Actix, and Axum. Its fast performance and strong safety guarantees make it a good choice for building high-concurrency, high-performance web applications. It also has strong support for compilation into WebAssembly.

  • Command-line tools: Rust's strong support for building and distributing standalone binaries make it a good choice for building command-line tools. Its fast performance and stability make it well-suited for tasks that need to be efficient and reliable.

  • Data processing: Rust's strong support for concurrency and parallelism make it a good choice for data processing tasks that can be parallelized. Its fast performance and low memory overhead make it well-suited for tasks that require processing large amounts of data.


Rust is an actively developed language, with a number of innovations and improvements being made on an ongoing basis. Some notable features of Rust include:

  • Ownership model: Rust uses dedicated syntax and a “borrow checker” built into the compiler to ensure memory safety without sacrificing speed.

  • Powerful type system: Rust’s strong type system helps ensure that all errors are handled and classes of bugs are eliminated, leading to more reliable and performant code. For example, Rust does not have a null value; its “Option” type allows you to represent values that may not exist while ensuring that those cases are handled properly.

  • Robust error handling: Rust has made a number of improvements to its error handling system in recent years, including the introduction of the ? operator and the Result type. These improvements make it easier to write code that handles errors in a consistent and reliable way.

  • Async/await: Rust has introduced async/await as a way to write asynchronous code that is easy to read and write. Async/await allows you to write asynchronous code using familiar, synchronous-style control flow, making it easier to write asynchronous code that is easy to reason about.

  • Macro system: Rust has a robust macro system, which allows you to define custom code generation rules using Rust code. This makes it easier to write code that is more flexible and reusable and avoids writing large amounts of boilerplate code.

  • Thorough documentation: Rust has a number of documentation tools and resources, including the Rustdoc tool, which makes it easier to generate high-quality documentation for your Rust code. The Rust community has a reputation for thorough, helpful documentation and support.

Overall, Rust is an actively developed language that is continuously improving and innovating. These improvements make it easier to write safe, efficient, and reliable code in Rust.

It is a versatile language that can be used for a wide range of applications. Rust’s focus on safety, concurrency, and performance make it a good choice for tasks that require these characteristics.

If you’d like to learn even more about Rust and the community that is being built around it here in Minnesota, please take a moment to check out our latest episode of Code Savvy Presents… and don’t forget to subscribe!

43 views0 comments

Recent Posts

See All
bottom of page