Building a DNS Server in Rust: Part 1 of 2

Unknown — Fri, 28 Feb 2025 00:00:00 +0000

Introduction: Why Build a DNS Server?</h2>
Imagine typing a web address into your browser, and behind the scenes, a digital detective springs into action translating that friendly URL into the cryptic IP address where the website lives. This is the magic of DNS (Domain Name System), a cornerstone of the internet’s functionality. Inspired by the hands-on learning approach championed by Code Crafters, this tutorial will guide you through building your own DNS server from scratch using Rust! You’ll not only deepen your understanding of how the web operates but also gain practical experience with Rust’s networking capabilities. Let’s dive in and unravel the mystery behind how the internet finds what you’re looking for!

Choosing a Rust Database Crate in 2023: Diesel, SQLx, or Tokio-Postgres?

Unknown — Tue, 12 Sep 2023 00:00:00 +0000

Introduction</h2>
Since its launch in 2015, Rust has established itself as a major player in the programming world, consistently topping charts as one of the most beloved languages among developers. Its promise of performance, robustness, and safety has made it a top choice for everything from system-level software to web development.
One of the pillars in application and web development is the ability to interact seamlessly with databases. Whether you are working on a small-scale utility tool, a web API, or an enterprise-grade application, odds are you'll need to store, retrieve, or manipulate data in a database. That is where Rust's rich ecosystem of libraries, commonly referred to as 'crates', comes into play.
In this article we focus on three crates that standout for an relational SQL database: `Diesel</code>, SQLx</code>, and Tokio-Postgres</code>. Each of these offers a distinct set of features, optimizations, and trade-offs, making them popular for different scenarios and requirements.`
`If you are a Rust developer wondering which database crate to choose for your next project, you've come to the right place. This article will dive into these three top contenders, comparing them on various factors such as:`
`Ease of use</li> Performance</li> Features</li>`Community support</li> </ul> By the end, you'll have the information you need to make an informed decision for your next Rust project. Why Database Crates Matter</h2> In today's interconnected, data-driven world, the database is often considered the backbone of any software application. As developers, our interaction with databases is so frequent that the quality of the tools we use for this interaction can significantly impact not just the development process, but also the performance and reliability of the application itself. That is why choosing the database crate is crucial. Importance in Application Development</h3> Type Safety</h4> Rust is known for its strong emphasis on type safety and is therefore statically typed</a>, and a great database crate extends this safety. A mistake in a database query can lead to runtime errors or, worse, data corruption. Compile-time SQL verification minimizes these risks, and speed up the feedback cycle. Performance</h4> Database operations can often be a bottleneck in application performance. A well-optimized database library can make efficient use of resources, enabling your application to run faster and handle more users. This is what we expect from a Rust application. Developer Productivity</h4> A great database library provides a clean, understandable API that aligns with the language's idioms. This not only makes it easier to write code but also makes it more maintainable. Scalability</h4> As your application grows, so does the complexity of your database operations. Quality database libraries offer features like connection pooling (i.e. process that maintains a set of open connections to a database, handing them out for repeated use), batch operations, and async support, which are vital for scalability. Ecosystem Compatibility</h4> The ideal database crate should play well with other libraries and frameworks you may be using. For instance, a web framework like Actix has a great set of code examples</a>, for both Diesel and Tokio-Postgres, making your development process smoother. Common Challenges in Database Interaction</h3> Connection Management</h4> Managing database connections effectively is a common challenge. Opening too many can stress the database, while too few can lead to underutilization. As developers we need to strike a balance and the crate should assist in this. Query Complexity</h4> Queries can become increasingly complex. A bad library can make these queries hard to maintain and debug, leading to reduced performance and increased likelihood of errors. Database Migrations</h4> Managing schema changes or transitioning from one database system to another can be cumbersome. Some database crates offer built-in support for migrations, easing this process. Asynchronous Programming</h4> (Web) Applications frequently rely on asynchronous I/O operations. While Rust’s async/await syntax is powerful, not all database libraries support it, which can lead to complications in asynchronous applications. In the sections that follow, we will take a closer look at how Diesel, SQLx, and Tokio-Postgres measure up against these challenges and needs, giving you the insights you require to make the best choice for your project. Diesel: A safe, extensible ORM and Query Builder for Rust</h2> Diesel is a safe, extensible Object-Relational Mapping (ORM) and query-building library for Rust. The library takes full advantage of Rust's strong typing and ownership model, making it easier for developers to write robust database applications without worrying about SQL injection vulnerabilities or other common pitfalls. As an ORM, Diesel provides abstractions that allow developers to interact with a database in a more idiomatic Rust manner, rather than raw SQL queries. Key Features</h3> DSL for Query Generation Diesel provides a Domain Specific Language (DSL) for creating SQL queries. This DSL allows you to construct queries in a type-safe, Rust-idiomatic way, reducing errors and increasing code readability. Note that the DSL of Diesel is only relevant when working with Diesel. It must be said that the DSL makes it more convenient to write reusable components</a>. Besides the DSL you can always fallback to Raw SQL. Note that it takes some time to get familiarized with DSL.</li> </ul> </li> Strong Type System One of Diesel's major highlights is its strong type system that ties into Rust's native type system. This adds an additional layer of safety, ensuring that you are less likely to make mistakes when writing queries.</li> </ul> </li> Asynchronous Support (with diesel-async) While Diesel itself is synchronous, you can integrate it with the async runtime by using third-party extensions like diesel-async</code>.</li> </ul> </li> Compatibility with Connection Poolers While the library itself doesn't offer built-in connection pooling, it is designed to work seamlessly with third-party connection poolers like bb8</code> and deadpool</code>. This makes it flexible and adaptable to various use-cases.</li> </li> </ul> </li> Data Migration Tools Diesel's robust type system and built-in migration support make it a good fit for data migration tasks.</li> </ul> </li> </ol> Community and Ecosystem</h3> Diesel enjoys a robust community and is one of the more mature database libraries in the Rust ecosystem. It has a high number of contributors and maintainers (see Diesel overview</a>), and it is widely used in both open-source and commercial projects. The ecosystem around Diesel is rich, with various plugins and extensions to support features like JSON serialization and integration with other popular Rust libraries. SQLx: The Rust SQL Toolkit</h2> SQLx is a modern and versatile SQL client for Rust, offering a unique feature set geared towards maintainability and robustness. One of its standout features is the support for compile-time SQL verification. This means that your SQL queries are checked at compile-time for syntax and even some level of semantic correctness, reducing the runtime errors related to database queries. Key Features</h3> Asynchronous Support SQLx is natively designed with asynchronous programming in mind, fully supporting Rust's async/await</code> syntax. This makes it an ideal choice for modern web applications that require non-blocking IO.</li> </ul> </li> Raw SQL with Compile-time Checks Unlike many ORMs that try to abstract SQL away, SQLx embraces it. You write raw SQL queries, which are then verified at compile-time for correctness. This combines the power and flexibility of SQL with the safety guarantees of Rust.</li> </ul> </li> Built-in Connection Pooling Connection management is simplified with SQLx's built-in support for database connection pooling called PgPool</code>, saving you from having to integrate third-party pooling libraries and optimizing database interactions for you.</li> </ul> </li> </ol> Community and Ecosystem</h3> SQLx has rapidly gained traction in the Rust community, thanks to its modern approach to database interaction. Its GitHub repository is active, with contributions from a variety of developers (see SQLx overview</a>). There is also an active community around it, discussing improvements, best practices, and providing help and support. The ecosystem around SQLx is growing. Tokio-postgres: A native, asynchronous PostgreSQL client.</h2> Tokio-Postgres is a Rust library designed for working directly with PostgreSQL databases in an asynchronous manner. Unlike Diesel and SQLx, which offer various levels of abstraction and ORM capabilities, Tokio-Postgres is oriented towards a more direct, low-level interaction with the database. This makes it a suitable choice for those who require fine-grained control over their SQL queries and database operations. Key Features</h3> Asynchronous Support Fully integrated with the Tokio runtime, Tokio-Postgres is designed for asynchronous database operations. This enables highly concurrent, non-blocking applications.</li> </ul> </li> Raw SQL Execution Tokio-Postgres allows for raw SQL query execution, giving developers maximum control over their database interactions.</li> </ul> </li> Compatibility with Connection Poolers While the library itself doesn't offer built-in connection pooling, it is designed to work seamlessly with third-party connection poolers like bb8</code> and deadpool</code>. This makes it flexible and adaptable to various use-cases.</li> </ul> </li> </ol> Community and Ecosystem</h3> Tokio-Postgres benefits from being a part of the larger Tokio ecosystem, which is widely adopted for asynchronous programming in Rust. The library has a somewhat specialized use-case, but it is well-maintained and has a solid community of users and contributors. Although not as extensive as the ecosystems around Diesel or SQLx, there is community support for extending its functionalities through third-party libraries and poolers. Feature Matrix Comparison</h2> Feature</th> diesel</code></th> sqlx</code></th> tokio-postgres</code></th></tr></thead> Asynchronous support</td> Yes with diesel-async</code></td> Yes</td> Yes</td></tr> Synchronous support</td> Yes</td> No</td> Yes (postgres</code>)</td></tr> ORM (Object Relational Mapping)</td> Yes</td> No</td> No</td></tr> Compile-time SQL verification</td> Yes</td> Yes</td> No</td></tr> Raw SQL execution</td> Yes</td> Yes</td> Yes</td></tr> Connection pooling</td> Via bb8</code> or deadpool</code></td> Built-in</td> Via bb8</code> or deadpool</code></td></tr> Macros for query generation</td> Yes</td> Yes</td> No</td></tr> Supports multiple databases</td> Yes</td> Yes</td> No (PostgreSQL specific)</td></tr> Integrated migration tools</td> Yes</td> Yes</td> No</td></tr> Query Interface</td> DSL & Raw SQL</td> Raw SQL with Macros</td> Raw SQL</td></tr> </tbody></table> In this context: DSL (Domain Specific Language): diesel</code> offers a Rust-based DSL to construct queries, which allows for more type safety and is more idiomatic to Rust. You can also use raw SQL if desired.</li> Raw SQL with Macros: sqlx</code> primarily uses raw SQL but provides macros to enable compile-time verification.</li> Raw SQL: tokio-postgres</code> and postgres</code> are more focused on raw SQL without much abstraction.</li> </ul> It is worth noting that while the above mentions the primary query interfaces for each crate, many of these libraries offer a blend of features, and developers can often choose between raw SQL or more abstracted query generation based on their needs. Making Your Choice</h2> After diving into each of these prominent Rust database crates, the next step is to decide which one aligns most closely with your project’s specific needs. While all three libraries offer a robust set of features, the best choice will depend on a variety of factors, such as performance requirements, type safety, level of control, and the kind of community support you're looking for. Performance</h3> If your primary concern is high-performance, non-blocking IO, you might lean towards SQLx or Tokio-Postgres, both of which are designed for asynchronous operations. Diesel, while robust and feature-rich, operates synchronously by default, although there are third-party extensions for async support. Type Safety</h3> When it comes to type safety, Diesel's strong integration with Rust's type system offers arguably the most robust compile-time checks. SQLx also provides compile-time SQL verification, making it a good choice for projects where type safety is a priority. Level of Control</h3> If you need fine-grained control over your SQL queries and prefer to work at a lower level, Tokio-Postgres might be the way to go. Diesel and SQLx provide various levels of abstraction and ORM capabilities, which could be seen as either an advantage or a limitation, depending on your project's needs. Community Support</h3> Community engagement is another crucial factor. A well-supported library often translates into better documentation, more third-party extensions, and quicker help when you run into issues. Diesel and SQLx have larger communities and more active repositories compared to Tokio-Postgres. However, Tokio-Postgres benefits from being part of the larger Tokio ecosystem, which is itself widely adopted. Project Maturity</h3> Finally, consider the maturity of your selected library. More established projects like Diesel have been battle-tested in a variety of environments, which may give you more confidence in their stability. SQLx, while newer, has rapidly gained maturity and traction. Tokio-Postgres, being more specialized, might not have the same breadth of usage but is stable and reliable for its intended use-cases. Conclusion</h2> Choosing a database library is often a trade-off between various factors such as performance, type safety, level of abstraction, and community support. Your project's specific needs will guide your choice, and fortunately, whether you choose Diesel for its powerful ORM capabilities, SQLx for its asynchronous support and type safety, or Tokio-Postgres for low-level control, you're in good hands. My Two Cents</h3> My go-to choice has to be SQLx, and for good reason. Not only does it offer native support for asynchronous programming, but it also comes with built-in connection pooling, elevating its efficiency to the next level. Moreover SQLx has compile-time SQL verification, ensuring that your queries are bulletproof before they even hit the runtime. To top it all off, it seamlessly integrates with the Actix Web framework, making it an unparalleled tool in my development arsenal. References</h2> Diesel overview</h3> Snapshot Date: September 8, 2023</li> GitHub Repository: Diesel GitHub</a> Stars: 10900+</li> Contributors: 308</li> </ul> </li> Documentation: Diesel Documentation</a></li> </ul> SQLx overview</h3> Snapshot Date: September 8, 2023</li> GitHub Repository: SQLx GitHub</a> Stars: 9700+</li> Contributors: 322</li> </ul> </li> Documentation: SQLx Documentation</a></li> </ul> Tokio-postgres overview</h3> Snapshot Date: September 8, 2023</li> GitHub Repository: Tokio-postgres GitHub</a> Stars: 3000+</li> Contributors: 120</li> </ul> </li> Documentation: Tokio-postgres Documentation</a></li> </ul> 24 - Navigating the Evolving Landscape of Rust: Your Biweekly Compass Unknown — Wed, 30 Aug 2023 00:00:00 +0000 Our newsletter offers the latest updates, best practices, and community insights. From new guidelines on Cargo.lock files to optimized compile times.</q></blockquote> Hello, Rust Enthusiasts! Welcome to another enriching edition of Rust Trends, your biweekly compass for navigating the ever-evolving Rust ecosystem. As Rust continues to solidify its position in the world of programming, we are here to keep you updated on the latest developments, best practices, and community dialogues. In this issue, we delve deep into the much-discussed change in Rust's guidance on committing Cargo.lock</code> files — a shift that reflects the language's growing maturity and diverse user base. We also bring you insights on how Rust compile times are optimized, a topic that resonates with every Rustacean out there. Whether you are a seasoned developer or a newcomer eager to explore, we have curated content that caters to all levels of expertise. So, fasten your seat belts as we embark on another exciting journey through the Rust universe! Let's get started! Updated Best Practices for Committing Cargo.lock Files</h2> </a> The Rust Cargo team has updated its guidance on committing Cargo.lock</code> files. Previously, the team advised committing this file for packages with binaries but not for libraries. The new recommendation is more flexible, suggesting that developers should do what is best for their individual projects. This change is aimed at accommodating the evolving needs of the Rust community, especially as the language gains mainstream adoption. The cargo new</code> command will also no longer ignore Cargo.lock</code> for libraries starting from nightly-2023-08-24. The team emphasizes the importance of regular testing against the latest dependencies, regardless of whether the Cargo.lock</code> file is committed. The update addresses several issues: Background: The old guidelines helped maintain high quality in Rust's package ecosystem but also had downsides like making it harder to bisect code history.</li> Why the Change: Rust's growing mainstream adoption and the need for a better onboarding experience for new developers have necessitated this change.</li> Wider Ecosystem: Advances in CI and tools like Dependabot have provided alternative ways to manage dependencies, making the old guidance less relevant.</li> </ul> For more details and to provide feedback, you can read the full blog post on the Rust Blog</a> and the updated Cargo Book</a> Speeding Up Rust Compile Times: Insights from August 2023</h2> </a> The Rust programming language is known for its focus on safety and performance, but compile times can sometimes be a bottleneck for developers. Nicholas Nethercote, a contributor to the Rust compiler, recently published an article</a> detailing various improvements made to speed up the Rust compiler as of August 2023. Here's a summary of key takeaways to help you speed up your Rust compile times. Hash Algorithm Update for Incremental Compilation In the realm of incremental compilation, a notable enhancement was introduced through pull request #107925</a>. This update modified the hashing algorithm responsible for detecting changes in code fragments. Specifically, the algorithm was transitioned from SipHash-2-4 to SipHash-1-3. As a result, the average wall-time for compilation was reduced by 1.63%. This optimization is particularly beneficial for incremental builds, where the hash function plays a crucial role in identifying code changes that require recompilation. LLVM Version Upgrades Boost Rust Compiler Efficiency The Low-Level Virtual Machine (LLVM) plays a pivotal role in the Rust compiler's back-end, handling tasks like code optimization and generation. Two separate pull requests (#109474</a> and an update to LLVM 17) were responsible for upgrading the LLVM version used by the Rust compiler. These upgrades led to a reduction in average wall-time by 1.19% and 1.91%, respectively. The enhancements are attributed to both the increased efficiency of LLVM itself and the superior quality of the code it produces. Streamlining Code Checks for Faster Compilation Lints in Rust are essentially code checks that help identify issues like syntax errors or potential bugs. A specific update, made through pull request #113734</a>, optimized the way these code checks (lints) are executed. This led to a 1.05% reduction in the average time it takes to compile a project. Just like some of the other updates, this one also particularly benefits incremental builds, where only parts of the code that have changed are recompiled. Enhancements in Codegen Units and Parallelization The Rust compiler has been fine-tuned to better utilize parallelization, particularly in its back-end operations. A minimum size for Codegen Units (CGUs) has been introduced in non-incremental builds. This change helps in reducing both peak memory (up to 19%) usage and the size of the compiled binary. However, the author points out that perfecting this aspect is challenging, given the multiple metrics that sometimes conflict with each other. Final Thoughts While the improvements may seem incremental, they add up over time and contribute to a more efficient compilation process. The article also touches on other areas like runtime benchmarking and future improvements, making it a comprehensive read for anyone interested in Rust compiler performance. Navigating the Serde Controversy: A Lesson in Community Trust and Security for Rust Developers</h2> </a> What Happened: The Serde project, a popular serialization library in Rust, faced backlash from the community for shipping precompiled binaries. The issue arose when the project's maintainers decided to include precompiled binaries in the package, which is against the norms of the Rust ecosystem. The binaries were intended to speed up the build process, but they raised concerns about security and trust within the community. The situation led to a heated debate, with some developers even considering forking the project (source: BleepingComputer</a>). How It Was Recovered: The Serde project took immediate action to address the concerns raised by the community. An issue was opened on GitHub to discuss the matter transparently. They acknowledged the community's concerns and decided to revert the changes that included precompiled binaries. The issue was marked as resolved, and the project moved forward with its regular development cycle, ensuring to maintain the trust and security standards expected in the Rust ecosystem (GitHub Issue #2538</a>) The proposed forking by some community members would have been a poor outcome, leading to fragmentation and potential confusion. Personally, I am very pleased with how the situation was handled and resolved, reinforcing the importance of community trust and collaboration. This incident serves as a lesson for the Rust community about the importance of maintaining trust and security while making changes that could potentially affect many projects. Release Note: Serde release v1.0.184</a>: Restore from-source serde_derive build on all platforms - eventually we'd like to use a first-class precompiled macro if such a thing becomes supported by cargo / crates.io Snippets</h2> Rust 1.72.0 stable is out</a></li> Best Rust Web Frameworks to Use in 2023</a></li> Rust Malware Staged on Crates.io</a></li> </ul> We are thrilled to have you as part of our growing community of Rust enthusiasts! If you found value in this newsletter, don't keep it to yourself — share it with your network and let's grow the Rust community together. 👉 Take Action Now: Share: Forward this email to share this newsletter with your colleagues and friends. </li> Engage: Have thoughts or questions? Reply to this email. </li> Subscribe: Not a subscriber yet? Click here</a> to never miss an update from Rust Trends. </li> </ul> 🔗 Stay Connected: Feel free to connect with our editor, Bob Peters, on LinkedIn</a> for more Rust insights and updates. 23 - Rust Revelations: Python Bridges, Survey Insights, and Macro Magic Unknown — Wed, 16 Aug 2023 00:00:00 +0000 Discover Rust Trends! Dive into Python-Rust synergy, 2022 Rust Survey highlights, and macro insights. Stay ahead with Rust's latest advancements.</q></blockquote> Hello, Rust Enthusiasts! Welcome to another edition of 'Rust Trends'! As the world of programming evolves, so does our passion for bringing you the latest insights, techniques, and breakthroughs. In this issue, we explore the powerful synergy between Python and Rust, delve into the results of the 2022 Rust Survey, and demystify the world of macros. Whether you're a seasoned Rustacean or just starting your journey, there's something here for everyone. Let's dive in! Bridging Python and Rust: A Synergy of Power and Performance</h2> </a> Python is renowned for its simplicity and versatility in the programming world, while Rust is celebrated for its speed and memory safety. But what happens when you bring these two titans together? The fusion of Python's ease-of-use with Rust's performance offers a promising landscape for developers seeking the best of both worlds. Infoworld's comprehensive guide</a> highlights the seamless integration of Rust within Python applications and the benefits of this convergence. Whether you're looking to harness Rust's capabilities within your Python scripts or invoking the vast Python ecosystem from Rust, this article has got you covered. Dive in to discover practical methods, code snippets, and insights to elevate your next project by leveraging the combined strengths of Python and Rust! Other resources are: PyO3 github repository</a> and its user guide</a></li> Let's Get Rusty: Calling Rust code from Python</a></li> </ul> Demystifying Macros with Cargo Expand</h2> </a> Ever wondered about the actual code generated by Rust macros? Enter cargo expand</code>. This invaluable tool permits you to glimpse the outcome of macro expansions, revealing the intricate, and at times boilerplate-intensive, code that's produced. Dive into Rust Macros: For an exploration, don't miss our latest blog post: Rust Macros Revealed!</a> Crafting Your Own Macros: Intrigued to craft macros of your own? Dive deeper with the comprehensive guide on creating macros</a> in Rust. Or for a visual learner's treat, check out this insightful YouTube tutorial on Declarative Rust macros</a> and Procedural Rust macros</a>. 2022 Annual Rust Survey Results Highlights</h2> </a> For the 6th year in a row, the Rust Project conducted a survey on the Rust programming language with 9,433 total survey completions. Here are the key highlights. Participation: In 2022, Rust saw 9,433 total survey completions, a significant increase in survey views, and a slight decrease in total responses. Community Growth: The survey was offered in 11 languages, indicating the growing global nature of the Rust community. The majority of respondents were from the United States, Germany, and China. Rust Usage: Over 90% of respondents identified as Rust users. 47% use Rust daily, and 30% can write production-ready code in Rust. Professional Use: 29.7% of respondents use Rust for most of their coding work, a 51.8% increase from the previous year. The top reasons for using Rust include writing "bug-free software", performance, and security. Future Concerns: 26% are concerned about proper support for Rust developers, 38% worry about Rust becoming too complex, and 34% have no worries about Rust's future. For a detailed analysis and more insights, check out the full post: 2022 Annual Rust Survey Results</a> Like any programming language, Rust has room for refinement. Yet, I truly believe its potential is vast and its future is promising, with a wide array of applications on the horizon. Snippets</h2> Looking for a Rust PodCast, what about Rustacean-Station</a></li> Getting started with serverless Rust in AWS Lambda</a></li> </ul> Push yourself to explore the uncharted territories of Rust. Venturing beyond your usual limits can substantially enrich your evolution as a coder. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> Rust Macros Revealed! Unknown — Sun, 06 Aug 2023 00:00:00 +0000 Macros in Rust</h2> In the world of programming, repetition is often seen as a bad thing. Rust macros provide a way to avoid repetitive code, allowing you to define reusable code templates. Unlike functions, macros don't operate on values; instead, they operate on the code itself. Macros in Rust work like meta-programming. They are a way to define reusable chunks of code that get "expanded" or "transformed" into more detailed code at compile time. This is like giving the compiler a recipe to generate specific chunks of code on the fly. For instance, you might have used the println!()</code> macro. The !</code> indicates it's a macro. With macros, you can achieve functionalities that functions can't offer, like variadic arguments or pattern-based code generation. Another example of a macros are expressions like #[tokio::main]</code>, called an attribute macro. Why Use cargo expand</code>?</h3> When working with macros, you might wonder what the actual code generated by these macros looks like. This is where cargo expand</code> comes in handy. It allows you to see the result of all the macro expansions, giving you a peek into the detailed, often boilerplate-heavy, code that gets generated. Using cargo expand</code> with Your Code</h3> Consider the simple Actix Web server</a> code provided below: use actix_web::{web, App, HttpServer, Responder, HttpResponse}; async fn health_check() -> impl Responder { HttpResponse::Ok() } #[tokio::main] async fn main() -> Result<(), std::io::Error> { HttpServer::new(|| { App::new() .route("/health_check", web::get().to(health_check)) }) .bind("127.0.0.1:8000")? .run() .await } </code></pre> Here, the #[tokio::main]</code> is an attribute macro provided by the Tokio crate</a>. Tokio is an asynchronous runtime for the Rust programming language. It provides the building blocks needed for writing network applications. The attribute macro sets up the necessary boilerplate to run asynchronous code in the main function. But what does this boilerplate look like? To find out, you'd first need to install cargo expand</a>: $ cargo install cargo-expand </code></pre> Then, in the root of your Rust project, run: $ cargo expand </code></pre> The output will be the code after all macros, including #[tokio::main]</code>, have been expanded. This "expanded" version will show you the underlying boilerplate introduced by the macro, revealing all the magic that happens behind the scenes. #![feature(prelude_import)] #[prelude_import] use std::prelude::rust_2021::*; #[macro_use] extern crate std; use actix_web::{web, App, HttpServer, Responder, HttpResponse}; async fn health_check() -> impl Responder { HttpResponse::Ok() } fn main() -> Result<(), std::io::Error> { let body = async { HttpServer::new(|| { App::new().route("/health_check", web::get().to(health_check)) }) .bind("127.0.0.1:8000")? .run() .await }; #[allow(clippy::expect_used, clippy::diverging_sub_expression)] { return tokio::runtime::Builder::new_multi_thread() .enable_all() .build() .expect("Failed building the Runtime") .block_on(body); } } </code></pre> Let's break down the transformation that has occurred due to the #[tokio::main] macro: Async Block: The entire async part of the original main function has been encapsulated inside an async block, and this block is assigned to the body</code> variable:</li> </ol> let body = async { ... }; </code></pre> This body</code> variable holds the asynchronous logic, but by itself, it doesn't execute anything. It merely describes the asynchronous computation. Tokio Runtime Setup: For the asynchronous code to be executed, a runtime is required. This runtime manages the low-level details of task scheduling, IO, etc. The expanded code sets up this runtime explicitly:</li> </ol> tokio::runtime::Builder::new_multi_thread() .enable_all() .build() .expect("Failed building the Runtime") </code></pre> Here, a multi-threaded Tokio runtime is being built with all features enabled. Blocking on Async: The following line:</li> </ol> .block_on(body); </code></pre> Tells the runtime to execute the async block (body</code>) and block the current thread until this asynchronous computation has finished. Clippy Allowance: The line #[allow(clippy::expect_used, clippy::diverging_sub_expression)]</code> is a hint to the Clippy linting tool to ignore certain potential warnings about the subsequent code. This is added to ensure the generated code doesn't trigger linting warnings.</li> </ol> Summary:</h3> In essence, the #[tokio::main]</code> macro abstracts away the complexities of setting up the Tokio runtime and managing the transition between synchronous and asynchronous code. By using this macro, developers can focus on the core asynchronous logic without getting bogged down by boilerplate. The expanded version reveals all the "magic" that happens behind the scenes to make the async main function work seamlessly. In essence, cargo expand</code> offers an invaluable tool for anyone diving deep into Rust's powerful macro system, helping developers demystify and understand the inner workings of their code. You can try it your self on #[derive()]</code> Traits. By adding #[derive(Debug)]</code> to one of your custom structs or enums. Use cargo expand</code> to see what code is generated, and then use the println!("{:?}", instance_of_your_struct);</code> to print the debug representation. Similarly, explore with #[derive(PartialEq)]</code> and test it by comparing two instances of your struct with ==</code> and !=</code>. Happy coding! 22 - Exploring Rust: From Simulations to Safety Standards Unknown — Wed, 02 Aug 2023 00:00:00 +0000 Dive into the world of Rust programming, exploring its applications in simulations, safety-critical systems, and parallel computing.</q></blockquote> Hello, Rust Enthusiasts! Welcome to another edition of "Rust Trends", your biweekly update on the dynamic world of Rust programming. In this issue, we delve into the fascinating applications of Rust, from creating an ant colony simulation to ensuring the highest safety standards in electronic systems with Rust and Ferrocene. We also explore the power of parallel computing with Rayon, a data-parallelism library for Rust. So, sit back, grab your favorite beverage, and let's embark on this exciting exploration of Rust's capabilities and advancements. Whether you're a seasoned Rustacean or a curious newcomer, there's something for everyone in this edition. Let's get started! Rust Ants Colony Simulation: A Unique Pet Project</h2> </a> In the world of Rust programming, there's always something new and exciting to explore. Today, we're introducing a fascinating pet project (pun intended) that's been buzzing in the Rust community: the Rust Ants Colony Simulation</a>. This project, is an ant colony simulation implemented in Rust. Despite its current inefficiency, which allows it to handle only about 500 ants on an older laptop, it's a captivating exploration of Rust's capabilities. The simulation is built using Rust and the Bevy game engine</a>, showcasing the versatility of Rust in different domains. You can find the timelapse video on Youtube</a>. Thought-Provoking Insights Rust in Game Development: Rust's performance characteristics make it a suitable choice for game development. The use of the Bevy game engine in this project is a testament to this. How might Rust evolve as a language for game development in the future?</li> Simulation Efficiency: The current implementation can handle about 500 ants. This opens up discussions about optimization in Rust. What strategies could be employed to increase the efficiency of such a simulation?</li> </ul> Ferrocene: Elevating Safety Standards with the Rust Compiler</h2> </a> In the realm of coding, safety is paramount, especially when it comes to applications like autonomous driving systems, medical equipment, or industrial control systems. Enter Ferrocene</a>, a unique variant of the Rust compiler, designed with a singular purpose - to ensure the highest level of safety in electrical and electronic systems. Ferrocene is not just any Rust compiler. It's currently undergoing a rigorous qualification process under two globally recognized standards - ISO 26262 and IEC 61508. ISO 26262 is a critical standard for the functional safety of electrical and electronic systems in production automobiles, a key requirement for applications like autonomous vehicle software. IEC 61508, on the other hand, is a comprehensive standard for functional safety of electrical, electronic, and programmable electronic safety-related systems, essential for industries like healthcare and manufacturing. For two years, the Ferrocene project has been in development, meticulously crafted to meet these stringent safety standards. The result? A release candidate that's currently available and poised to make a significant impact in the field of safety-critical applications, from medical devices that monitor patient health to industrial systems that control complex manufacturing processes. The ultimate goal of Ferrocene is to provide a version of the Rust compiler that not only meets but surpasses these safety standards. It's about elevating the bar for safety in the digital world, ensuring that safety-critical applications can rely on a robust and secure foundation. With Ferrocene, the future of safe coding in critical applications looks promising. Join Ferrous Systems announcement party on October 4th, 2023, online</a>. Fearless concurrency with Rayon</h2> </a> Rayon is a powerful data-parallelism library for Rust that allows developers to easily convert sequential computations into parallel ones. It's incredibly lightweight and ensures data-race freedom, providing a safe environment for parallel execution. The beauty of Rayon lies in its simplicity. To convert a sequential iterator into a parallel one, you typically just replace your iter()</code> call with par_iter()</code>, and Rayon handles the rest. This makes it straightforward to leverage the power of parallel computing in your Rust applications. Rayon also offers the join</code> and scope</code> functions for creating parallel tasks manually, providing more flexibility when needed. Moreover, it supports custom thread pools</code>, giving you even more control over your parallel computations. One of the key features of Rayon is its guarantee of data-race freedom. This means that if your code compiles, it will typically behave the same way it did before, but faster. Parallel iterators, in particular, are guaranteed to produce the same results as their sequential counterparts. To use Rayon, you simply add it as a dependency in your Cargo.toml file and bring the necessary traits into scope using the Rayon prelude. Rayon currently requires Rustc 1.59.0 or greater. Rayon also supports WebAssembly through an adapter and some project configuration. This allows you to bring the power of Rayon to web applications. Key Takeaways: Rayon allows easy conversion of sequential computations into parallel ones in Rust.</li> It guarantees data-race freedom, ensuring safe parallel execution.</li> Rayon supports custom thread pools and manual task creation for greater flexibility.</li> It's compatible with WebAssembly, extending its use to web applications.</li> </ol> Thought-Provoking Questions: How can the simplicity of converting sequential iterators to parallel ones with Rayon change the way we approach programming in Rust?</li> What impact does the guarantee of data-race freedom have on the reliability of parallel computing in Rust?</li> How can the WebAssembly support in Rayon broaden its application in web development?</li> </ol> For more information, check out the Rayon GitHub page</a>. For a Youtube explainer checkout this video from Let's Gets Rusty</a>. Push yourself to explore the uncharted territories of Rust. Venturing beyond your usual limits can substantially enrich your evolution as a coder. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 21 - Rust Unleashed: Powering Frontend, Backend, and Static Sites Unknown — Wed, 19 Jul 2023 00:00:00 +0000 Step into the future of web development!</q></blockquote> Hello, Rustaceans! Welcome to this week's edition of "Rust Unleashed: Powering Frontend, Backend, and Static Sites". We've handpicked a series of articles and updates from the ever-evolving world of Rust programming. In this edition, we're focusing on the power of Rust in both frontend and backend web development, and its growing influence in the realm of static site generation. We'll be exploring the latest advancements, sharing expert insights, and showcasing real-world applications of Rust in these areas. So, grab your favorite cup of coffee, get comfortable, and let's dive into this exciting journey into the world of Rust! Leptos: A Cutting-Edge Rust Framework for the Modern Web</h2> </a> Leptos</a> is a full-stack, fully typed Rust framework designed for modern web development. It combines the best paradigms of contemporary web development with the power of Rust. Key Features</h3> Interactive Web Applications: Leptos simplifies the process of building interactive web applications in Rust. It enables developers to create full-stack apps that start working immediately and are progressively enhanced with client-side interactivity. Simple Tooling: With Leptos, developers can kickstart projects quickly using straightforward tooling with minimal configuration. Reactive Signals: Leptos makes it easy to manage state without fighting the borrow checker, thanks to reactive signals. Server Functions: Leptos allows developers to write "server functions" that work across both the server and client, reducing the boilerplate of setting up new API endpoints. Type Safety: With Rust's type safety, developers can rest easy knowing that their entire app is protected. Performance</h3> Leptos boasts high performance, scoring 92% on the js-framework-benchmark</a> official results for Chrome 113, outperforming popular frameworks like Vue, Svelte, and React. UI Patterns and Language Integration</h3> Leptos enables developers to build websites and apps using self-contained components with reactive state management. It also seamlessly integrates Rust backend code with the user interface, allowing for the creation of "full-stack components". Tool Integration</h3> Leptos integrates perfectly with tools like Tailwind, allowing developers to build on design patterns shared across the web. It also offers great tooling like hot-reloading template updates and a dedicated Leptos language server and VSCode extension</a>, designed to streamline the Leptos coding experience and maintain a consistent code style throughout the project. For more information or to get started with Leptos, visit their official website</a>. If you're looking for an alternative to Leptos, consider Sycamore</a>. Unlock Your Coding Potential: Watch this Epic Leptos Tutorial on YouTube</h2> </a> Code to the Moon, a popular YouTube channel, recently published an insightful tutorial</a> on building a ChatBot. This walkthrough uses the open-source language model, Leptos, and a crate from Rustformers known as LLM</a>. LLM, or Large Language Model, is a pivotal model in Natural Language Processing (NLP) that predicts the likelihood of a sentence or a sequence of words, the same way ChatGPT</a> works. It plays a crucial role in various NLP tasks, including speech recognition, machine translation, and text generation. In this tutorial, LLM powers the ChatBot's ability to generate human-like text responses. The tutorial employs a specific LLM called Wizard-Vicuna</a>, an open-source language model that forms the heart of the ChatBot project. The performance of open-source language models like Wizard-Vicuna is rapidly improving, making them increasingly feasible for use on personal computer hardware. This walkthrough not only guides you through the process of building a ChatBot but also offers valuable insights and tips. It's an excellent resource for anyone interested in Rust, Leptos, Rustformers, or chatbot development in general. Enjoy the journey of learning and creating with this tutorial! Zola: The One-Stop Static Site Engine</h2> Zola</a> is a comprehensive static site generator that provides all the tools you need in a single executable, eliminating the need for additional dependencies. It offers features such as Markdown to HTML conversion, Sass compilation, syntax highlighting, and table of contents generation, which traditionally require a development environment or JavaScript libraries. Designed for speed and scalability, Zola can generate an average site in less than a second. It renders your entire site as static files, making it capable of handling high traffic levels without the need for server or database management. Zola's user-friendly design includes an intuitive command-line interface and a flexible template engine. This allows you to focus on creating content for your blog, knowledge base, landing page, or a combination of these. Zola also enhances your Markdown writing with shortcodes and internal links, simplifying content creation. Deploying your website to Github Pages</a>, a fast</a>, free-of-charge web hosting service, is easily accomplished with Zola. For more information or to get started with Zola, visit their official website</a>. Discover the benefits of this all-in-one static site generator today. </div> </a> </div> </div> Encourage yourself to discover new aspects of Rust. Stepping outside your comfort zone can enhance your growth as a programmer. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 20 - Master Rust in Just 2 Months: Google Debunks Learning Curve Myth Unknown — Wed, 05 Jul 2023 00:00:00 +0000 Learn from Google and improve your journey to learn Rust faster</q></blockquote> Hello, Rustaceans! Welcome to this week's edition of the Rust Trends newsletter. We've curated a collection of insightful articles for you, overflowing with the latest updates and discoveries from the Rust programming landscape. In this edition, we spotlight Google's recent exploration into Rust, debunking myths and confirming truths about the language. We also delve into the challenges and triumphs experienced by Google developers as they navigate Rust, from compiler speed to code quality. So, prepare your favorite brew, settle in, and let's embark on this enlightening journey into the world of Rust! Fast-Track Your Rust Skills: Google shatters 6-month learning myth</h2> </a> Google's recent exploration into Rust has debunked a major myth: Rust does not take more than six months to learn. In fact, developers can become productive in Rust in just two months or less, a timeline comparable to adopting other languages. In the same study, Google confirmed a few truths and debunked other rumors about Rust. Slow build speeds were identified as the top challenge, confirming complaints about the Rust compiler's speed. However, the quality of Rust's compiler error messages and the high quality of Rust code were both confirmed, with over 85% of developers confident in their Rust code's correctness. The study also revealed that the top challenges for Google developers using Rust were Macros, Ownership and borrowing, and Async programming, rather than writing unsafe code and handling C/C++ interop. These insights provide a more nuanced understanding of the Rust experience, helping both current and prospective Rust developers navigate the language more effectively. To read the full article click here</a> Crate Mastery: Discover the websites every Rust programmer needs</h2> Whether you are a beginner just starting out or an experienced programmer looking to stay updated, these websites are sure to be invaluable tools in your journey. The first website, Blessed.rs</a>, offers an overview of popular and well-maintained Rust crates. It's a fantastic starting point for beginners, providing a curated list of reliable crates to explore and learn from. Our second recommendation is Lib.rs</a>, another excellent resource for discovering and evaluating Rust crates. This site provides crates sorted by category, new trending and popular, helping you make informed decisions about which crates to use in your projects. We believe these resources will greatly assist you in navigating the Rust ecosystem, enhancing your understanding and efficiency. Zero-cost abstractions</h2> Rust's core principle of 'zero-cost abstractions' is a powerful concept that extends beyond programming. It is the idea that you can have high-level abstractions that make programming easier, without sacrificing the low-level control that is necessary for performance. In Rust, iterators are a zero-cost abstraction. They allow you to work with sequences of elements in a high-level, abstract way, without sacrificing performance. let sum = vec![1, 2, 3, 4].iter().sum(); println!("{}", sum); // Prints 10 </code></pre> In this code, we are using the iter() method to create an iterator over a vector, and the sum() method to add up the elements. This is a high-level, easy-to-read way of working with sequences, but it is also efficient: the Rust compiler can optimize this code to be as fast as the equivalent low-level loop. One of the great benefits of Rust! </div> </div> </div> Do not hesitate to explore new possibilities in Rust. Pushing yourself out of your comfort zone can be a great way to learn and grow as a programmer. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 19 - Are we Embedded yet? Unknown — Wed, 21 Jun 2023 00:00:00 +0000 This edition is to check in on the state of Rust for Embedded Systems</q></blockquote> Hello, Rustaceans! Welcome to this week's edition of the Rust Trends newsletter. We have an exciting lineup of articles prepared for you, packed with valuable insights and updates from the world of Rust programming. In this edition, we focus on embedded systems and the roadblocks that stand in the way of Rust adoption. We will also introduce you to a hex viewer written in Rust, for your binary data analysis needs. So grab your favorite beverage, sit back, and let's dive right in! Embedded Systems and the 5 Roadblocks to Rust Adoption</h2> Rust has been making progress as a language for adoption in the embedded systems world. However, several significant roadblocks hinder its widespread acceptance. This article on Embedded.com</a> highlights 5 roadblocks to Rust adoption in embedded systems. These are the takeaways: Rust faces roadblocks in embedded systems adoption due to limited commercial support from microcontroller vendors, leaving developers to figure things out on their own.</li> The learning curve for Rust is steeper than other languages, leading to higher training costs and longer development times for teams interested in using it for embedded systems.</li> Conservative adoption of technologies in the embedded industry, coupled with the investment in existing workflows and talent, makes switching to Rust less appealing for many companies.</li> Rust's integration with existing toolchains and development processes in embedded systems may require significant rework, potentially leading to lost insights and additional development time.</li> The lack of a formal specification and standardization in Rust poses challenges for commercial support and consistency, particularly in safety-critical applications with long product lifetimes.</li> </ol> Moreover, the author mentions, "I hate to say it, but an experienced professional can do the same things in C or C++ that a Rust programmer can do just as safely." I strongly disagree with this statement. The reason why embedded firmware has so many vulnerabilities is that languages like C and C++ do not provide inherent protection against making mistakes in the first place. As humans, we are prone to errors, and in my opinion, enforcing programming practices that ensure the correct approach is the only truly safe way forward. The key food for thought is: How can the industry strike a balance between risk aversion and embracing new technologies to drive progress? Embedded Rust: the lay of the land</h2> For starters a nice overview for Embedded Rust is the repository Awesome Embedded Rust</a>. The official Embedded Rust Book</a> and a great blogpost by the Mbedded Ninja</a>. Moreover several microcontroller vendors have started providing support (un) officially for the Rust programming language. Here are a few notable ones: Nordic Semiconductor support for Rust for their nrf52, and nrf53 series of microcontrollers. They provide a Rust-enabled software hardware abstraction layer called nrf-hal</a>, which allows developers to write firmware using Rust for their microcontrollers. </li> STMicroelectronics Rust support for their STM32 microcontroller family. They offer a Rust-specific hardware abstraction layer (HAL) called stm32-rs</a>, enabling developers to write embedded software in Rust for STM32 microcontrollers. </li> NXP Semiconductors Rust support for their i.MX RT series of microcontrollers. They offer the imxrt-rs crate</a>, which is a Rust API for programming i.MX RT microcontrollers, allowing developers to leverage the Rust language for embedded development. </li> Espressif official support for the popular ESP32 controllers. They offer esp-rs crate</a> and the ESP32 book</a>. </li> Infineon official support for Rust for their (Automotive) Microcontrollers</a>. </li> </ul> It's important to note that the availability and extent of Rust support may vary among different microcontroller vendors and their specific microcontroller families. It's always recommended to consult the official documentation and resources provided by the respective vendors for the most up-to-date information on Rust support. Hex Viewer: Empowering Binary Data Analysis with Rust</h2> Hex editors play a crucial role in low-level data analysis and manipulation. Every embedded system developer should have one in their toolkit. Hexyl</a>, a powerful hex viewer for the terminal, is written entirely in Rust. It utilizes colored output to differentiate various categories of bytes, offering an efficient and intuitive approach to working with binary data. An example of a well-known hack that involved the use of a hex editor: Is the case of the "Pac-Man Kill Screen" in the classic arcade game Pac-Man. In the original Pac-Man arcade machine, a bug caused the game to reach an unplayable level 256, known as the "kill screen." This bug occurred due to an integer overflow issue, where the game's code was unable to handle a higher level number. In order to bypass this issue and reach the kill screen intentionally, some skilled players and hackers used a hex editor to modify the game's code. By locating the specific section of code responsible for the level counter and adjusting it, they were able to bypass the limitations and continue playing beyond level 256. If you want to learn more about it watch this youtube movie</a>. Do not hesitate to explore new possibilities in Rust. Pushing yourself out of your comfort zone can be a great way to learn and grow as a programmer. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> Ps. Did someone forward this email to you? Sign up here for our newsletter. 18 - Lightning fast search, and the state of Rust and ML Unknown — Wed, 07 Jun 2023 00:00:00 +0000 A search engine written in Rust, a comprehensive overview of Rust and ML, and the state of the Rust Ecosystem</q></blockquote> Welcome to the new edition of Rust Trends! First things first, we must address the elephant in the virtual room. You may have noticed a slight delay in our newsletter delivery recently. Well, let’s just say that the Rust community has gained a new recruit, and we couldn’t be more thrilled (and sleep-deprived) about it! Yes, dear readers, a tiny Rustacean has entered the world, and we were temporarily distracted by the cuteness overload. I became a father for the first time. Let’s dive into today’s topics and discover the latest and greatest in the world of Rust programming! A Lightning-Fast Search Engine written in Rust!</h2> Are you tired of sluggish search functionality in your website projects? Look no further! Meilisearch is an open-source, lightning-fast search engine designed specifically for developers and written in Rust. Meilisearch empowers developers to deliver seamless and efficient search experiences in their applications. Let’s dive into the exciting world of Meilisearch! GitHub Repository: Link to Meilisearch on GitHub</a> Built with a focus on speed and simplicity, Meilisearch utilizes highly efficient indexing and search algorithms, ensuring rapid search results regardless of dataset size. Powered by Rust, Meilisearch leverages the language’s performance and safety guarantees, delivering exceptional search performance for your applications. Ready to harness the power of Meilisearch? We have got you covered! Follow the comprehensive tutorial from Digital Ocean to seamlessly integrate Meilisearch into your web projects and unlock its impressive search capabilities. Whether you are building a web application, command-line tool, or any other (Rust) project, Meilisearch can supercharge your search functionality. Tutorial: Link to Meilisearch Tutorial</a> The step-by-step tutorial will guide you through the process of setting up Meilisearch, with the help of Docker, indexing your data, and performing lightning-fast searches. You will discover the Meilisearch frontend client library (Node.js), which offers a straightforward interface for interacting with the search engine. With detailed explanations and code snippets, you will quickly master Meilisearch integration. You can also have a look at the Meilisearch documentation</a> and Rust SDK</a>. Do not let sluggish searches hinder your (Rust) projects any longer. Embrace Meilisearch and provide your users with exceptional search experiences. Get ready to revolutionize the performance and efficiency of your search operations with Meilisearch powered by Rust! The Rise of Rust: A Growing Community and Promising Future</h2> We are excited to present key takeaways from an insightful article on the Rust programming language and its dynamic community. Rust’s popularity continues to surge, with a growing user base and increasing usage across industries. Its seamless integration with other programming languages makes it an excellent choice for mixed-language projects. Although Rust is relatively young, many developers who specialize in other programming languages have embraced it, bringing their professional experience to the Rust ecosystem. While there are still some drawbacks in terms of tooling and ecosystem maturity, significant progress has been made. Rust is widely regarded as a language that delivers on its promises of memory safety and performance. The Rust community is actively involved in various surveys, providing valuable insights into the community and the technology’s potential. Interestingly, most Rust developers have recently started their journey with the language, indicating a growing interest and the need for employers to adapt their expectations when hiring. In terms of technology domains, Rust excels in server-side projects, cloud computing infrastructure, and distributed applications. The Linux platform is a popular choice for Rust developers, while CLI tools dominate the Rust project landscape due to the availability of CLI libraries. Rust’s adoption by tech giants like Microsoft, Google, Amazon, and Meta further solidifies its position. However, most Rust developers currently use the language outside of their official work, suggesting a potential for further industry adoption. Rust’s performance characteristics, security features, and documentation receive high praise from developers. Nevertheless, some developers find Rust more challenging to program in and requires more effort to learn compared to other languages. Areas that require improvement include debugging, profiling, and enhancing the library ecosystem. In conclusion, Rust’s community is young and growing rapidly. Industry adoption is on the rise, supported by enthusiastic developers and evolving tooling. While Rust presents unique challenges, its future looks promising. As a company considering Rust, it’s crucial to have senior engineers with Rust experience to guide the transition and invest in educating and training developers to maximize productivity. Read the full article from InfoQ</a>. The Growing Landscape of Machine Learning in Rust</h2> Machine Learning (ML) in Rust is gaining momentum as an alternative ecosystem to established languages like Python. With its impressive performance, low-level control, and zero-cost abstractions, Rust offers a compelling choice for ML enthusiasts. Although still in its early stages, the Rust ML ecosystem has seen the emergence of ambitious projects and meta-crates, providing developers with practical solutions. A Growing Ecosystem Rust ML offers individual implementations of various ML methods and algorithms, along with meta-crates like linfa</a> and smartcore</a>, which bundle multiple algorithms for convenience. These developments provide a strong foundation for developers looking to explore ML in Rust. Opportunities for Contributors The Rust ML community encourages contributions to existing projects and the creation of new ones. With ample opportunities for developers to make a difference, the ecosystem is open for collaboration. The unofficial Working Group in the ML domain and the Zulip chat provide avenues for seeking help and engaging with like-minded individuals. The Path Ahead The Rust ML ecosystem is still young but holds significant potential. Rust’s unique features, such as memory safety and concurrency, contribute to the development of robust and efficient ML solutions. As the community grows and more developers explore Rust’s capabilities, we can expect further advancements in ML within the Rust ecosystem. Conclusion Machine Learning in Rust is an exciting frontier that offers an alternative to established ecosystems. With ambitious projects, bundled solutions, and room for contributors, the Rust ML ecosystem is steadily evolving. Rust’s performance and high-level abstractions make it an appealing choice for ML practitioners. As the ecosystem continues to mature, we anticipate further growth and innovation in the field of ML in Rust. Learn more at Are we learning yet?</a> </div> </a> </div> </div> Do not hesitate to explore new possibilities in Rust. Pushing yourself out of your comfort zone can be a great way to learn and grow as a programmer. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 17 - Development tool, video explainer, and a historic application Unknown — Wed, 10 May 2023 00:00:00 +0000 Adding more cargo to your dev tools, learn about collections and make use of your history</q></blockquote> Hello and welcome to the newest edition of Rust Trends, your go-to source for staying informed on the latest developments and trends in the Rust programming language. We bring you the most up-to-date news, tutorials, and expert insights to keep you in the loop on all things Rust. Let’s dive into today’s topics and discover the latest and greatest in the world of Rust programming! Streamlining Your Rust Development Process with cargo-edit</h2> </a> Managing dependencies in your Rust projects can be a time-consuming task, but it doesn’t have to be. In our latest blog post, we explore how to use cargo-edit</a>, a powerful tool that can help simplify the process of adding, removing, and updating dependencies in your Cargo.toml file. Learn how to use cargo add and cargo rm commands to streamline your development process and keep your dependencies up-to-date. Check it out now! Add this tool to your belt. Interested in more cargo tools? Check out the previous newsletter editions with cargo fix or cargo watch. Crust of Rust: std::collections, by Jon Gjengset</h2> </a></div> Jon Gjengset is a well-known figure in the Rust community. He is a Ph.D. candidate at MIT and has been an active contributor to the Rust programming language, particularly in the areas of distributed systems and networking. He is also a popular content creator, having produced a number of educational videos on Rust. One of Jon’s most popular video series is called “Crust of Rust”, which is a deep-dive exploration of Rust’s standard library. In the “Crust of Rust: std::collections” video, Jon walks through the implementation of Rust’s built-in collection types, including vectors, hash maps, and more. It’s a great resource for anyone looking to gain a better understanding of how Rust’s collections work under the hood. Here’s the link to the video</a>. </div> </div> Replace your shell history with Atuin</h2> Introducing Atuin</a>, the ultimate shell history manager written in Rust! Atuin replaces your shell history with a powerful SQLite database, allowing you to record additional context for your commands such as exit code, duration, time, and command shown. With Atuin, you can easily search your command history using a full-screen UI or filter your search by specific criteria, search for all successful `cargo build` commands, recorded after 2pm yesterday. What’s more, Atuin offers optional and fully encrypted synchronization of your history between machines via an Atuin server, which you can host yourself or use the server provided. And the best part? Your old history file is not replaced, so you won’t lose any of your valuable command history. With Atuin, you can access the same history across terminals, sessions, and machines and quickly jump to previous items with Alt-<num></code> or switch filter modes via Ctrl-R</code>. Try Atuin</a> today and take your command history management to the next level!</div> </a></div></div> Do not hesitate to explore new possibilities in Rust. Pushing yourself out of your comfort zone can be a great way to learn and grow as a programmer. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> Streamlining Your Rust Development Process with cargo-edit Unknown — Wed, 10 May 2023 00:00:00 +0000 As your Rust projects grow in complexity, managing dependencies can become a time-consuming and error-prone task. Fortunately, cargo-edit is a powerful tool that can help simplify the process of adding, removing, and updating dependencies in your Cargo.toml file. In this blog post, we'll take a closer look at how to use cargo-edit in your Rust projects. Installation</h2> Before we dive into how to use cargo-edit, let's first make sure it's installed. cargo-edit is available as a Rust package, which means you can install it using cargo: cargo install cargo-edit Once cargo-edit is installed, you can use it in your Rust projects. Adding a Dependency</h2> To add a dependency to your Rust project using cargo-edit, simply run the cargo add command followed by the name of the dependency: cargo add my-dependency This will automatically add the latest version of the my-dependency package to your Cargo.toml file, along with any necessary changes to your Cargo.lock file. If you want to add a specific version of a dependency, you can specify the version number using the @ sign: cargo add my-dependency@1.2.3 </code></pre> This will add version 1.2.3 of the my-dependency package to your project. If a package has features you can also add them cargo add my-dependency --features my-feature example with serde and it's derive feature</h2> cargo add serde --features serde/derive </code></pre> Removing a Dependency</h2> To remove a dependency from your Rust project using cargo-edit, simply run the cargo remove command followed by the name of the dependency: cargo remove my-dependency </code></pre> This will automatically remove the my-dependency package from your Cargo.toml file, along with any necessary changes to your Cargo.lock file. Updating a Dependency</h2> To update a dependency in your Rust project using cargo-edit, simply run the cargo update command followed by -p</code> and the name of the dependency: cargo update -p my-dependency </code></pre> This will automatically update the my-dependency package to the latest version, along with any necessary changes to your Cargo.lock file. If you want to update all dependencies in your project, you can simply run cargo update without specifying a package name. Conclusion</h2> cargo-edit is a powerful tool that can help simplify the process of managing dependencies in your Rust projects. With its simple and intuitive commands, adding, removing, and updating dependencies has never been easier. Give it a try in your next Rust project and see how it can help streamline your development process! Looking for the documentation of cargo-edit click here. Stay ahead of the curve with Rust-Trends. Subscribe now for bi-weekly updates on the latest Rust Trends, news, and tips delivered straight to your inbox! 16 - Idiomatic Rust and functional programming Unknown — Mon, 24 Apr 2023 00:00:00 +0000 Exploring the intersection of idiomatic Rust and functional programming</q></blockquote> Welcome to the latest edition of Rust Trends, a newsletter dedicated to keeping you up-to-date on the latest developments and trends in the Rust programming language. Today’s topics are: Idiomatic Rust</li> Functional programming</li> Cargo Fix</li> </li> </ul> Let’s dive into today’s topics and discover the latest and greatest in the world of Rust programming! Idiomatic Rust, what is it and why should I care?</h2> Idiomatic Rust refers to the style of Rust programming that follows the language’s conventions and best practices, utilizing Rust’s unique features to write code that is safe, efficient, and expressive. Some examples of idiomatic Rust code include: Using Rust’s ownership and borrowing</a> system to ensure that memory is managed safely and efficiently</li> Leveraging Rust’s iterators</a> and closures to express complex behavior in a clear and efficient way</li> Using the match expression to handle different cases in a concise and readable way</li> Using conversion traits like From and Into</a></li> </ul> But why should you care about writing idiomatic Rust code? Firstly, idiomatic Rust code tends to be easier to read and maintain, both for yourself and for others who may work with your code in the future. It can also be more efficient, as Rust’s unique features like zero-cost abstractions and memory safety can be utilized to write high-performance code. In addition, following Rust’s conventions and best practices can help you avoid common pitfalls and mistakes that can lead to bugs and security vulnerabilities. By utilizing Rust’s ownership and borrowing system, for example, you can avoid issues like null pointer dereferencing and memory leaks. Furthermore, writing idiomatic Rust code can help you become a better Rust programmer. By understanding Rust’s unique features and conventions, you can become more proficient in the language and better equipped to write high-quality, efficient code. If you are interested in learning more about idiomatic Rust, the Rust programming language website provides extensive documentation on Rust’s design philosophy and best practices, as well as tutorials on e.g. traits, cheatsheets, and examples of idiomatic Rust code</a>. There are also many online communities and forums dedicated to Rust programming, where you can ask questions and share knowledge with other Rust programmers. In conclusion, writing idiomatic Rust code can help you write more maintainable, efficient, and secure programs, and become a better Rust programmer overall. Functional programming in Rust</h2> </div> In Rust functional programming is not a strict requirement, but often used in conjunction with idiomatic Rust to achieve more concise, expressive, and safe code. Functional programming is a programming paradigm that emphasizes the use of functions to perform computations. In functional programming, functions are treated as first-class citizens, meaning that they can be assigned to variables, passed as arguments to other functions, and returned as values from functions. Functional programming also emphasizes immutability, meaning that data structures and variables should not be changed once they are created. Instead, new data structures and variables are created based on existing ones. Rust provides a number of features that make functional programming easier, such as closures, iterators, and pattern matching. These features allow Rust programmers to write code that is both idiomatic and functional, using functions as building blocks to express complex behavior in a clear and efficient way. For those interested in functional programming in Rust, there are several resources available as well. The Rust Programming Language book includes a chapter on functional programming</a>, which provides an introduction to functional programming concepts and how they can be applied in Rust. Moreover, there are blog posts, like this</a> and this</a>. </div></div> Cargo Fix</h2> Cargo’s cargo fix subcommand has been a useful tool for Rust programmers to automatically fix some simple compiler warnings, such as unused imports or variables, since its introduction. Over time, the number of warnings that can be fixed automatically has steadily increased, making it even more valuable to developers. In addition to its existing capabilities, the cargo fix subcommand now also supports automatically fixing some simple Clippy warnings. This means that developers can now rely on Cargo to handle even more of their code maintenance tasks, freeing up time for more important work. To draw more attention to these increased capabilities, Cargo will now suggest running cargo fix</code> or cargo clippy –fix</code> when it detects warnings that are automatically fixable. For example, when a warning is issued for an unused import Cargo will suggest running cargo fix to fix the issue. Overall, these updates to Cargo’s cargo fix subcommand are a welcome addition to the Rust ecosystem, making it even easier for developers to write clean and efficient Rust code. To use these great features make sure to upgrade to the latest version of Rust 1.69.0</a> </div> </a> </div></div> Do not be afraid to try new things in Rust. After all, it is always good to step out of your comfort zone. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 15 - Tesla Model 3 hacked in under two minutes, is it time for Rust to step in? Unknown — Wed, 12 Apr 2023 00:00:00 +0000 Security, Twitter and more …</q></blockquote> We are excited to announce that we will now be publishing our bi-weekly newsletter on Wednesdays instead of Sundays. We hope this change will better accommodate your busy schedules and provide ample time to read and digest our valuable insights. In this edition, we are focusing on the important topic of security and safety, which is becoming increasingly critical in today’s digital and connected world. In addition to this, we will also be bringing you the latest news and updates from the world of Rust programming, so be sure to read on and stay up to date with the latest developments. Let’s dive into today’s topics and discover the latest and greatest in the world of Rust programming! Could Rust be the ideal language for Secure Systems?</h2> As a systems programming language, Rust has been gaining popularity in recent years due to its unique ownership and borrowing system that prevents common classes of programming errors such as buffer overflows and data races. This has led to Rust being identified by the National Institute of Standards and Technology (NIST) as a safer coding tool</a>. In March 2023, NIST added Rust to its list of Safer Languages on the grounds of its ownership model, which “guarantees both memory safety and thread safety, at compile-time, without requiring a garbage collector.” NIST points out that Rust “allows users to write high-performance code while eliminating many bug classes,” and while Rust does have an “unsafe” mode, the institute explains that risk is mitigated through the narrow scope of actions allowed. The recent hacking of the Tesla Model 3 at the Pwn2Own contest, in under 2 minutes</a>, highlights the importance of secure coding practices, particularly in safety-critical applications such as those in the automotive industry. This contest was organized by the Zero Day Initiative</a>. Rust’s safety features make it an ideal language for developing secure systems</a>, but there is one major hurdle to overcome before it can be widely adopted in these applications: ISO 26262 compliance. ISO 26262 is an international standard for functional safety in the automotive industry that sets requirements for the development of safety-critical systems. Rust is not currently ISO 26262 compliant, but Ferrous Systems aims to develop a safety-critical subset of the language</a> that meets the standard’s requirements. If successful, this could make Rust a more attractive option for developing secure systems in the automotive industry and other safety-critical applications. In conclusion, Rust’s unique features make it a safer coding tool than traditional programming languages, and its potential for use in safety-critical applications is significant. With ongoing efforts to bring Rust up to standard, it could become the ideal language for developing secure systems in the future. The recent recognition of Rust’s safety features by NIST, combined with the need for secure coding practices highlighted by the Tesla Model 3 hack, reinforces the importance of prioritizing security in software development. Rust in Space and Beyond</h2> </div>Another area for safety-critical application is space. Tweede Golf, a member of the Rust Foundation</a>, gave a presentation on Rust</a> to the Royal Netherlands Aerospace Centre. Additionally, since the SpaceX launch of 3 January 2023, French company Gama has had a test satellite</a> in orbit that runs largely on Rust software. </div></div> Build System made in Rust</h2> Meta, the social media company behind Facebook, has announced the release of their new open-source build system called Buck2. Buck2</a> is designed to improve the build experience for developers and make it faster and more efficient. In Meta’s internal tests, Buck2 completed builds two times faster than its predecessor, Buck1, written in Java. Buck2 is written in Rust, and its design is based on principles that include a complete separation of core and language-specific rules, increased parallelism, integration with remote execution and virtual file systems, and a redesigned console output. The open-source release of Buck2 is almost identical to the internal version, with the only differences being the toolchains and remote execution, which have open-source alternatives supplied. Buck2 also supports virtual file systems, making it faster and more efficient. In real-world usage, Buck2 is significantly faster than Buck1, making it an excellent choice for developers looking to speed up their builds. Thousands of developers at Meta are already using Buck2, performing millions of builds per day, with hopes that the wider industry will see benefits as well.</div></a></div></div> Snippets</h2> Twitter open-sourced its stack, these</a> are the parts that use Rust. Part of the-algorithm repo is Navi (High-Performance Machine Learning Serving Server)</li> RustNL 2023 conference</a>, 10 May 2023</li> Recently an online conference was held, Ukrainian Rust Conference 2023, for more info look at their Github repo</a>, and do not forget to check out the cheatsheets</a>.</li> </ul> Do not hesitate to explore new possibilities in Rust. Pushing yourself out of your comfort zone can be a great way to learn and grow as a programmer. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 14 - Building your backend in Rust Unknown — Sun, 26 Mar 2023 00:00:00 +0000 Hot reloading, Test coverage and more</q></blockquote> Welcome to the most recent release of the Rust Trends newsletter, where I present to you the most up-to-date news and insights from the dynamic Rust community. No matter if you’re an experienced Rust developer or a newcomer, there’s something in here for you. In this edition, we’ll explore topics like building your backend using Rust, the advantages of hot reloading, and how to achieve comprehensive test coverage. Let’s dive into today’s topics and discover the latest and greatest in the world of Rust programming! Building a Backend in Rust</h2> Are you curious about why you should build your backend in Rust? Not only is it fast, secure, and reliable, resources become more widely available. Rust’s unique combination of performance and safety features has made it a go-to choice for backend development. Rust is an excellent choice for building your backend. But that is not all! If you want to make use of a serverless approach like AWS API Gateway, you can still benefit from writing the functions, called lambdas on AWS, in Rust. Check out this page on lambda performances</a> (cold start, average memory used, and duration). A youtube video on the same topic from the same author can be found here</a>. And if you are still wondering why Rust is worth considering for your backend, we have got an opinion piece</a>, from a credible source, that is sure to persuade you. It discusses the unique features of Rust that make it stand out from other programming languages and explains why Rust is quickly becoming a top choice for backend developers. So, what are you waiting for? Click on those links and start exploring the power of Rust on the backend! Hot reloading with cargo watch</h2> </a></div>If you are looking for a handy tool to automate the build and rebuild process in your Rust project directory, look no further than cargo-watch. This nifty tool automatically builds and rebuilds your Rust project when changes are saved, so you can focus on coding without worrying about manually rebuilding every time you make a change. To install cargo-watch, simply run the following command: $ cargo install cargo-watch </code></pre> Make sure to include the path with the binaries (e.g., /Users/bob/.cargo/bin</code>) in your $PATH</code> variable, and you can execute it from anywhere on your CLI. Here are some useful commands to use in a Rust project directory: ## Rebuilding on changes: $ cargo watch </code></pre> ## Clearing the screen before each run: $ cargo watch -c </code></pre> ## Monitor directory for changes: $ cargo watch –watch src/ -x ‘run’ </code></pre> Check out the cargo-watch Github repository</a> for more information and documentation. Happy coding!</div></div> Test coverage, to make sure we got you covered</h2> Are you looking for a tool to help you test and ensure code coverage in your Rust project? Meet cargo tarpaulin! This handy tool provides coverage statistics and visualizations, allowing you to easily identify untested code and ensure comprehensive test coverage. To install cargo tarpaulin, simply run the following command: $ cargo install cargo-tarpaulin </code></pre> Once installed, you can use the following command to generate a coverage report for your Rust project: $ cargo tarpaulin –workspace </code></pre> This command generates a coverage report for all the tests in your project, including integration tests. You can also use the following command to customize the coverage report: ## Output a coverage report in different formats, such as HTML, JSON, or XML: $ cargo tarpaulin –out Html –output-dir ./target/coverage </code></pre> You can set coverage goals, e.g. –line 75, for your project and fail the build if the coverage is below 75%. Check out the cargo tarpaulin Github repository</a> for more information and documentation. With cargo tarpaulin, you can ensure comprehensive test coverage and identify any untested code in your Rust project.</div> </div></div> Snippets</h2> Announcing Rust 1.68.1</a> – 23 March 2023, don’t forget rustup update</code></li> </ul> Do not hesitate to explore new possibilities in Rust. Pushing yourself out of your comfort zone can be a great way to learn and grow as a programmer. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 13 - Rust Nation UK 2023, Code search and a Rust Magazine Unknown — Sun, 12 Mar 2023 00:00:00 +0000 Search, explore and learn</q></blockquote> Welcome to the latest edition of the Rust Trends newsletter, where I bring you the latest news and updates from the vibrant Rust community. Whether you are a seasoned Rust programmer or just getting started, there is something here for everyone. In this edition, we are excited to highlight a few key events and resources that are sure to be of interest. From a highly anticipated conference to a cutting-edge magazine with a range of topics, we have got you covered. So sit back, relax, and dive into the world of Rust with us! Today’s topics: Rust Nation UK 2023, some interesting talks</li> GitHub’s new code search</li> Rust Magazine</li> </ul> Rust Nation UK 2023, some interesting talks</h2> </a> Although Rust Nation 2023</a> took place on February 16th and 17th, the conference’s talks</a> have just been released on YouTube, offering a wealth of insights and inspiration for Rustaceans everywhere. Here are some of the highlights from the conference’s talented speakers: Fast Flexible Iteration with Rust & Rhai</h3> In his talk at Rust Nation, Jonathan Strong introduced Rhai, a scripting language made in Rust that provides a safe and easy way to add scripting to any application. Rhai is an embedded scripting language and evaluation engine for Rust that allows for fast and flexible iteration. Strong explored how Rust can be used as a script and how Rhai can help to make that process even more efficient. To learn more about Rhai and its applications, check out the video of Jonathan’s talk</a> on YouTube. Spreading Rust to the Rest of the Company: Moving Past the Proof of Concept</h3> In his talk at Rust Nation, Tim McNamara, New Zealand’s “Rust guy” and Senior Software Engineer at AWS, discussed strategies for expanding Rust adoption in the workplace beyond the initial proof of concept. McNamara shared tips and ideas for bringing developers, including those without Rust expertise, up to speed with projects, and explored how to build a sustainable team even after the initial enthusiasm has faded. If you are interested in expanding Rust adoption in your workplace or want to learn more about how to build a sustainable team, check out the video of Tim’s talk on YouTube</a>. Navigating the Ecosystem’s Constant Flux</h3> In his talk at Rust Nation, Jon Gjengset explored the challenges of building applications and services with stability and long-term project sustainability in mind in Rust’s constantly evolving ecosystem. Gjengset discussed the changes that can happen when working with Rust, including crate versioning, backward compatibility, unstable features, minimum supported Rust versions, and 1.0 releases. He offered strategies for living with these changes and making the stable life easier. As a long-time contributor to the Rust toolchain and ecosystem, Gjengset brings deep knowledge and experience to this topic. He’s also been teaching Rust since 2018, including live-streaming intermediate-level Rust programming and creating videos on advanced topics like async and await, pinning, variance, atomics, and dynamic dispatch. To learn more about navigating Rust’s constant flux and building sustainable applications and services, check out the video of Jon’s talk on YouTube</a>. GitHub’s Code search</h2> </a> GitHub’s new code search</a> experience allows developers to ask questions of code and get answers through iteratively searching, browsing, navigating, and reading code. To achieve this, GitHub built its own search engine from scratch, called Blackbird, specifically designed for code search in Rust. Existing solutions for code search didn’t meet the unique needs of code search, such as searching for punctuation, not stemming, not stripping stop words, and searching with regular expressions, and didn’t work at GitHub’s scale of over 200 million repositories with constantly changing code. For more information look also at this talk on Youtube</a>. Rust Magazine</h2> </a> The second and latest edition of Rust Magazine</a>, a publication dedicated to the Rust programming language community. The magazine features contributions from Rustaceans all over the world and is maintained by a diverse editorial team. Among others, this edition explores topics like optimizing Rust binary search and designing an API for a user-friendly retry crate. They have nice articles so I would bookmark them if I were you. Rust Magazine issue 2 Snippets</h2> Announcing Rust 1.68.0</a> – 9 March 2023, don’t forget rustup update</code></li> Popular Github repo RustPython</a> – a Python 3 interpreter written in Rust</li> </ul> Enjoy your Sunday, and have a great week ahead. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 12 - Emulators and memory management visualization Unknown — Sun, 26 Feb 2023 00:00:00 +0000 Understand your program by having a mental picture</q></blockquote> Who said programming should be boring? In this edition, we will bring back the good old times with retro gaming in Rust! Moreover, this newsletter showcases a visualization tool for a better understanding of Rust programs in terms of borrowing, heap, and stack. Grab some coffee and let’s dive in… Nintendo Emulator in Rust</h2> An emulator is a software program that is designed to emulate the behavior of the Nintendo Entertainment System (NES), a popular video game console that was first released in the mid-1980s. The purpose of an emulator is to allow you to play Nintendo games on your computer or e.g. your Raspberry Pico without the need for the original console. When you run an NES emulator, written in Rust, on your computer or other devices, it creates a virtual environment that mimics the hardware of the original NES console. The emulator includes software that emulates the various components of the console, such as the CPU, and the graphics processing unit. The emulator also includes software that can read and interpret the code of NES game cartridges, which you can download here</a> and play in the NES wasm emulator</a> in your browser. Once the emulator is up and running, you can load the virtual game cartridges into the emulator, and it will execute the code of the game as if it were being played on the original console. The emulator will output the video that the game would generate on the original hardware, allowing you to play the game on your computer. Overall, an NES emulator is a powerful tool that allows users to enjoy classic NES games on modern hardware, preserving the experience of playing these games for future generations.</div> </div></div> Memory management: what the hack is a Stack and Heap?</h2> </div> The stack and the heap are two areas of memory that a program can use to store data. The stack is a memory region that is used to keep track of function calls and local variables. It works like a stack of plates: you add a new plate (or item) to the top of the stack, and when you are done with it, you remove it from the top. This order is called Last In First Out (LIFO). The simplicity makes it fast because it can be managed easily and either lives in RAM (fast) or cache (faster) of your CPU. Moreover, the stack is limited in size The heap, on the other hand, is a larger and more flexible area of memory that can be used to store data that is too large to fit on the stack or needs to be dynamically allocated during the program’s execution (e.g. mutable vectors or Boxed variables). Overall, the stack is faster and more efficient, but it has less memory available and is less flexible. The heap is slower and more complex, but it can be used to store larger amounts of data and is more flexible. Knowing when to use each of these memory regions is an important part of writing efficient and effective computer programs. To understand the choices that are made on memory management in Rust (e.g. ownership</a>), knowing what a Stack and Heap are is a must. Some nice reading material: A stack and heap discussion on StackOverflow</a></li> The Stack and the Heap in Rust</a></li> Stack based memory allocation</a> on Wikipedia</li> Heap based memory allocation</a> on Wikipedia</li> </ul> </div></div> Understanding code with help of a visualization tool</h2> The Rust borrow checker is a key component of the Rust programming language that enforces ownership and borrowing rules at compile-time, ensuring that programs are free from certain kinds of memory errors such as data races and null pointer dereferences. The borrow checker analyzes a Rust program’s use of mutable and immutable references to ensure that they are used correctly and that the lifetime of the references is valid throughout the program’s execution. By enforcing these rules, the borrow checker helps Rust programs achieve memory safety and prevents common programming errors that can lead to crashes or security vulnerabilities. To get a better understanding of this topic Aquascope</a> can be a very useful tool. “Aquascope is a tool that generates interactive visualizations of Rust programs. These visualizations show how Rust’s borrow checker “thinks” about a program, and how a Rust program actually executes.” Go ahead and give it a try!</div> </div></div> Enjoy your Sunday, and have a great week ahead. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 11 - Error Handling in Rust Unknown — Sun, 12 Feb 2023 00:00:00 +0000 We all make errors. But how to handle them?</q></blockquote> I am excited to bring you a new edition of our newsletter, focused on a topic that is crucial to every programmer: error handling in Rust. No matter how experienced or talented you are, errors are an inevitable part of the programming process. But do not worry, Rust provides a robust and efficient way to handle them. In this edition, we will dive into the world of error handling in Rust and explore how you can handle errors in your programs with ease. From the Result type and the ? operator, to the match operator and beyond, we will cover all the essential elements of error handling in Rust. So, without further ado, let’s dive in! Introduction to Error Handling</h2> The idea behind error handling in Rust is to make it explicit and unavoidable for the programmer to deal with errors. If you look at other programming languages handling errors is optional. E.g. if you do not use a Try and Except in Python you can still run your script. This can lead to subtle bugs that are difficult to debug and fix. Rust achieves strict handling of errors by using its type system to force it at compile time. In other words, the code will not compile and therefore not run. Which makes writing incorrect code harder from the start. Errors in Rust can be classified into two categories: Recoverable errors</li> Unrecoverable errors</li> </ul> Recoverable errors are errors that can be handled and recovered from within the program. These errors are usually indicated by the Result type, which represents the result of an operation that might fail. Unrecoverable errors, on the other hand, are errors that cannot be handled within the program and cause the program to terminate immediately. These errors are usually indicated by using the panic! macro or assert macro that calls panic!, which stops the program and displays an error message. Unrecoverable errors are typically used for cases where something unexpected has occurred, such as an assertion failure or a bug in the code. In my opinion, there is no justification for intentionally causing a panic. This is because panics can always be replaced with recoverable errors, which provide a more flexible and controlled method of handling errors. So we will focus on the recoverable errors.</div></div></div> Recoverable errors</h2> </div>In Rust, errors are represented as values of the `Result` type, which is an enumeration with two variants: Ok and Err. When an operation returns Ok(T), it means that the operation was successful and the value of type T is returned. When an operation returns Err(E), it means that the operation failed and an error of type E is returned. The programmer can then handle the error by using techniques such as pattern matching</a>, propagating the error up the call stack with the ? operator</a>, or by using error-handling functions such as unwrap() or expect(). Besides the Result</code> type there is another important type called Option</code>. In Rust, the Option</code> type is a way to represent the presence or absence of a value. It is a generic enum with two variants: Some(T) and None. Some(T) holds a value of type T, while None represents the absence of a value. For example, you can use an Option</code> value to represent the result of a function that may or may not find a value, like searching a vector for an item. Instead of returning an error code or throwing an exception, the function would return Some(T) if a value was found and None otherwise. In this way, the Option</code> type can be seen as part of error handling because it provides a way to handle the absence of a value in a type-safe and explicit way, without relying on error codes or exceptions. The following links might be useful to you to dive deeper into the discussed topics: The Rust Book: Recoverable Errors</a></li> Error struct</a> in the standard library</li> The Result</code> type</a> in the standard library</li> Great blog post by Burntsushi (Andrew Gallant)</a></li> Another blog post on unwrap by Burntsushi</a></li> </ol> </div></div> Snippets</h2> Rust as a programming language for automotive software?</a></li> Did you know there is also a Rust Trends LinkedIn Page?</a></li> Rust 1.67.1</a>, February the 9th. Do not forget to run rustup update</code></li> </ul> Enjoy your Sunday, and have a great week ahead. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 10 - Connecting the world with Rust Unknown — Sun, 29 Jan 2023 00:00:00 +0000 Making your own API, a new editor in Rust and more …</q></blockquote> Welcome to the tenth edition of our newsletter! The Rust community is thriving and has an abundance of informative articles, tutorials, applications, and repositories. However, with so much to choose from, it can be overwhelming. We have handpicked the best of the best for you, so let’s dive in! In today’s email: Connecting the world with Rust</li> Introducing Lapce: a new editor built with the power of Rust</li> The Rust Foundation</li> </ul> Connecting the world with Rust</h2> Writing your own API (Application Programming Interface) can be a rewarding and challenging task. An API allows you to expose specific functionality of your software to other developers, enabling them to interact with your application in a predictable and standardized way. In this article, we will take a look at what it takes to write your own API in Rust. Before you start writing your API, it is important to think about what you want to achieve with it. Do you want to expose specific functionality of your application to other developers? Do you want to allow other applications to access data stored in your application? Answering these questions will help you determine the scope and functionality of your API. Once you have a clear idea of what you want your API to do, the next step is to choose a framework for building it. There are several popular options for building APIs in Rust, the most popular ones are Rocket</a> and Actix</a>. Each of these frameworks has its own set of features and benefits, so it is worth doing some research to determine which one is the best fit for your needs. Once you have chosen a framework, you can start designing the structure and functionality of your API. This will involve creating endpoints, which are specific points of access for interacting with your API, and defining the input and output of each endpoint. You will also need to consider how you want to handle authentication, error handling, and other important aspects of API development. To learn more see some links below: Best practices in API design</a></li> The current state of Rust web frameworks</a></li> Rocket Guide</a></li> Actix Documenation</a></li> </ul> With these resources and a little bit of practice, you will be well on your way to writing your own API in Rust. Happy coding! </div> </div></div> Introducing Lapce: a new editor built with the power of Rust</h2> </a></div> We are excited to highlight a new editor for programming in Rust: Lapce</a>. This graphical editor, is built in Rust and utilizes the power of Droid and OpenGL. One of the things that sets Lapce apart is its clean and user-friendly interface. Additionally, it offers optional modal-editing</a> with Vim-like modes, making it a great choice for those who prefer this type of editing. Another feature we really liked is called Code Lens</a>, which allows for a more efficient way of folding code and getting a general overview of a file. Keep in mind that Lapce is currently still in its pre-alpha stage. With ~23k Github stars and 129 contributors, Lapce is definitely worth checking, for a quick youtube movie on Lapce</a> follow the link. Other editors we have highlighted in previous newsletters are Helix</a> (also written in Rust) and Visual Studio Code</a>. </div></div> Snippets</h2> Rust 1.67.0 released</a>. Want to see the release details?</li> mdBook</a> create online books from Markdown files. Made in Rust.</li> Strengthen your Rust skills with Exercism</a> and choose the Rust Track.</li> </ul> The Rust Foundation</h2> The Rust programming language is widely known for its focus on safety and reliability, making it a popular choice for systems programming and other performance-critical applications. The Rust foundation</a> aims to support the continued development and growth of the Rust programming language by providing resources and infrastructure to the community of volunteer developers who maintain the language. Some specific ways the Rust foundation supports the Rust project include: Providing funding for development and infrastructure costs, such as hosting and testing services. Supporting community events, such as Rust conferences and meetups, to foster collaboration and learning among Rust developers. Managing the trademark and branding of the Rust programming language to ensure consistency and protect against misuse. The Rust foundation also seeks to advance the state of the art in systems programming by supporting research and development in areas such as memory safety, performance, and language design. Overall, the goal of the Rust foundation is to ensure that the Rust programming language can continue to evolve and improve, while also providing a stable and sustainable platform for developers to build on. Moreover, the foundation gives out grants</a> to the public to fund initiatives related to Rust. They recently released their annual report for 2022</a> that highlights the financials and important milestones. Enjoy your Sunday, and have a great week ahead. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 9 - Algorithms, Networking and Operating Systems Unknown — Sun, 15 Jan 2023 00:00:00 +0000 Looking at algorithms, network programming, and other related topics, with a focus on the Rust programming language.</q> </blockquote> We are back with another exciting edition of the Rust-Trends newsletter! Whether you are looking to learn more about the language, stay up-to-date with the latest developments, or just get some inspiration for your next project, we’ve got you covered. So please grab a cup of coffee and join us as we explore the world of Rust! In today’s email: Algorithms written in Rust</li> Will this be your next Operating System in Rust?</li> Networking with Rust crates</li> </ul> Algorithms written in Rust</h2> Algorithms are a crucial part of computer science, and they play a vital role in many areas of software development. From sorting data to searching for information, algorithms help us solve problems and perform tasks efficiently. If you are a Rust programmer looking to learn more about algorithms, a great resource to check out is this website</a>. The website is accompanied by this repository</a> that showcases the collection of algorithms written in Rust. The “TheAlgorithms/Rust” repository contains a wide range of algorithms, including those for sorting, searching, and ciphers. It also includes implementations of various data structures, such as lists, trees, and graphs. The repository is maintained by contributors who are committed to keeping it up-to-date and relevant for Rust programmers. If you are interested in learning more about algorithms and how they can be implemented in Rust, be sure to check it out. The nice thing about the website is that it uses the online playground</a> platform, so you do not need to have Rust installed to try it out. Will this be your next Operating System in Rust?</h2> </div>Rust is a language that is gaining popularity in Operating System (OS) development and the Raspberry Pi is a low-cost and powerful platform that can be used to learn and experiment with building an OS. There are several tutorials</a> and resources available for learning how to develop an OS in Rust on the Raspberry Pi, including creating a custom kernel, developing drivers, and creating a minimal operating system. There are also projects like TockOS</a>, which uses Rust to create a secure and efficient embedded operating system. The Rust programming language provides a powerful and safe alternative for building an OS on the Raspberry Pi. The growing community and resources available make it an attractive choice for those interested in this field.</div></div> Networking with Rust crates</h2> Rust is a system programming language, that provides a safe and efficient way to build networked systems. One of the key features of Rust for network programming is its low-level control over memory, which allows for building high-performance and efficient networked systems. Additionally, Rust provides built-in support for low-level network programming, such as socket programming, which enables developers to handle network protocols such as TCP, UDP, and other transport protocols. To get started with network programming in Rust, you can use the standard library‘s support for low-level network programming, such as the std::net module</code>, or use specialized libraries such as mio and tokio which provide more high-level abstractions and are built on top of the standard library. Here are a few resources that you may find helpful when getting started with network programming in Rust: The Rust documentation on Network Programming</a> The Tokio project</a> and the starter tutorial</a> Mio</a>: minimalistic, efficient async I/O library for Rust. Enjoy your Sunday, and have a great week ahead. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 8 - WebAssembly and Rust, learning Rust, and be ready to take notes Unknown — Sun, 01 Jan 2023 00:00:00 +0000 Showcasing WebAssembly, a course on Rust and a note-taking app written in Rust</q> </blockquote> Happy New Year Rustaceans! 2023 is the year of more Rust Trends. No boring summary of the year, but instead content specifically selected for you. Let me know what you think of the newsletters and subjects you want to hear more about. Let’s dive in … In today’s email: Rust + WebAssembly = Web + Speed</li> Comprehensive Rust, want to learn Rust?</li> Note-taking app the Rust alternative for Notion</li> </ul> Rust + WebAssembly = Web + Speed</h2> WebAssembly (Wasm) is a binary format for running code in web browsers that has gained a lot of traction in the last few years. It allows developers to run code written in languages other than JavaScript, such as C++ or Rust, in the browser, enabling the creation of more complex and performant web applications. Rust has a number of features that make it especially suited for compiling to Wasm, including a focus on performance and safety, a strong type system, and low-level control over memory. 2 minutes Youtube intro</a> by Let’s Get Rusty. Using Rust and WebAssembly together allows developers to take advantage of Rust’s strengths while still being able to run their code in the browser. This can be useful for applications that need to perform computationally intensive tasks, such as image or video processing, scientific simulations, or data visualization. A real-world example is the all-in-one design program Figma</a>. Note that Figma uses C++</a> but could also have been Rust. Overall, Rust and WebAssembly offer a lot of potential for building high-performance and reliable web applications. As more developers start using this combination, we can expect to see even more exciting and innovative applications built with Rust and Wasm</a>. Looking for more examples check this out: Made with WebAssembly</a>.</div> </div></div> Comprehensive Rust, want to learn Rust?</h2> </a></div>Comprehensive Rust</a> is a 4-day course developed by the Google Android team. Only the fourth day is Android specific, for the rest a nice generic course to follow for starters. This course comes with a GitHub repository</a> In a previous newsletter, we also highlighted that Android was using Rust and that they saw a steep decline in vulnerabilities</a>.</div></div> Note-taking app the Rust alternative for Notion</h2> AppFlowy.io</a> calls itself the open-source alternative to Notion. They started in November 2021 and have got a lot of traction from the beginning. It is written in Rust and Flutter</a> and has been one of the trending GitHub repositories</a>. If you are looking for a free and good note-taking app, for sure give it a try.</div> </a> </div></div> Enjoy your Sunday, and have a great week ahead. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 7 - Your Dev Environment on Steroids Unknown — Sun, 18 Dec 2022 00:00:00 +0000 Improving your tools will help to improve your code</q> </blockquote> The last newsletter of 2022 the next one will be published on the 1st of January 2023. Time flies when you are having fun with Rust. Let’s dive in… In today’s email: Enhanced Visual Studio Code</li> ChatGPT a glimpse into the future</li> The editor written in Rust</li> </ul> Enhanced Visual Studio Code</h2> As a developer, you need a development environment or editor to write and debug your code. A popular editor is VSCode</a>, which can be enhanced with extensions. The most downloaded Rust extension is rust-analyzer</a>. If you want a more thorough static code analysis</a>, consider using `clippy` instead of the default `check` tool. While check only verifies that your code compiles, clippy analyzes your code and provides useful information and tips. For debugging, you can use the CodeLLdb</a> extension. With this debugger, you can step through your code, put in watches, inspect variables, and see your call stack, among other features.</div> </a></div></div> ChatGPT a glimpse into the future</h2> </a></div>ChatGPT, developed by OpenAI, is an artificial intelligence chatbot that is capable of performing many tasks, including writing code or refactoring existing code. You can find a VSCode plugin</a> that uses ChatGPT here (note: the plugin is still a bit hacky because there is no official API for ChatGPT yet). If you would like to see a demo video on YouTube, click here</a>. If you want to chat with GPT follow this</a> link. You will need to sign-up but it is definitively worth it. Another AI tool that is used in production and helps you write code is Copilot</a>. They call it the AI pair programmer. AI will be the future of in-editor resources, such as StackOverflow, as well as a pair programmer and reviewer all in one…</div></div> The editor written in Rust</h2> Are you interested in trying something new? Consider giving Helix</a> a try – it is an editor written in Rust. To get started, watch this YouTube video</a>. If you’d like to see the manual, click here</a>. Helix is designed to be used without a mouse, keeping your hands on the keyboard. If you’re already familiar with editors like Vim, the transition to Helix should be easy. Consider giving Helix a try in your next hobby project and let me know your experience with it. Helix the editor written in Rust </div></a></div></div> Enjoy your Sunday, and have a great week ahead. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 6 - The Rust Enthusiasm is spreading Unknown — Sun, 04 Dec 2022 00:00:00 +0000 You can get addicted to Rust. Do not take this addiction lightly.</q> </blockquote> The Rust enthusiasm is spreading. You can get addicted to Rust. Do not take this addiction lightly. Let’s dive into the topics… In today’s email: The drop in vulnerabilities in Android 13</li> A port scanner in Rust</li> The Rust Book, now available in a crate format</li> </ul> The drop in vulnerabilities in Android 13</h2> Google says that the number of memory safety vulnerabilities has dropped considerably over the past few years/releases. They believe Android’s ongoing shift from memory-unsafe to memory-safe languages is a major factor. There is a strong correlation between the use of Rust and the decrease in vulnerabilities found. Note that correlation is not causation, but there is strong evidence like: To date, there have been zero memory safety vulnerabilities discovered in Android’s Rust code. Want to read more head over to their security blog</a>.</div> </a> </div></div> A port scanner in Rust</h2> </a> </div>A well-known port scanner is Nmap (Network mapper). Did you know there is a (faster) Rust alternative called RustScan</a>? To be fair it uses Nmap under the hood but utilizes multiple threads to speed up scanning. The well-maintained repository of RustScan can be found here</a>. You can run Rustscan also in a Docker image. This was done to make performance consistent across different Operating Systems, because of the high open file limit. Using a Docker in your Rust development is not new. There is an official Rust image</a>.</div></div> The Rust Book, now available in a crate format</h2> A funny crate and a nice way to close the Newsletter. The Rust Book also called The Book has now I crate of its own. This book is the starting point to learn Rust. Hiro created a command line utility</a> to easily access the book from your command line. </div> </a> </div></div> The Rust in crate form Enjoy your Sunday, and have a great week ahead. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 5 - Writing Your own Apps in Rust Unknown — Sun, 20 Nov 2022 00:00:00 +0000 From Command Line Interface to Graphical User Interface</q> </blockquote> The Rust community is active and has tons of nice articles, tutorials, applications, and repositories but we have to choose. This fifth email is all about setting up your project for a GUI app or CLI utility. Let’s dive in … In today’s email: Setting up your own Rust project</li> Want to make your own app with a GUI?</li> Command Line Interface: unleash the power of Rust</li> </ul> Setting up your own Rust project</h2> When starting a new Rust project, the package manager cargo</a> for Rust has you covered. With a simple command in your terminal cargo new project_name</code> you are ready to write your Rust application. But what if you want to add additional files or directories to your project? Rust uses a module system, with modules and submodules. Then questions arise on how to include those modules. Do I know where to put my unit tests and integration tests? That’s why I created a dummy project to show the possibilities, please check it out on GitHub</a>. Other nice reads are a blog article on Hackernoon, and for testing, you can also have a look at the documentation of Rust by Example here</a>. The great thing about Rust is that testing, benchmarking, examples, and package management are not an afterthought but rather integrated from the start. </div> </div></div> Want to make your own app with a GUI?</h2> </a></div>The ecosystem of Rust is ever-growing. One popular toolkit is Tauri</a>. With this toolkit, you can build Awesome</a> graphical applications for macOS, Linux, and Windows. The GUI/frontend is based on web technology like javascript/typescript and HTML. Tauri is really worth looking at if you want to develop a (simple) desktop application.</div></div> Command Line Interface: unleash the power of Rust</h2> Command line programs are popular among Rust developers. It is an easy starting point if you want to make something in Rust. There is a free getting-started book called Command Line Applications in Rust</a>. The Clap</a> crate is an easy-to-use command line parser and a great fit for your next CLI project. For more inspiration have a look at existing CLI utilities on lib.rs</a>.</div> </a> </div></div> Enjoy your Sunday, and have a great week ahead. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 4 - Web Frameworks, why is Rust Safe, and Blockchains that use Rust Unknown — Sun, 06 Nov 2022 00:00:00 +0000 Making your own API or run your smart contract but do it safe with Rust</q> </blockquote> The newsletter is growing steadily, and this is already the fourth edition of your dose of Rust Trends. Let’s dive into the content. In today’s email: Web Frameworks: make the life of a developer easier</li> Why is Rust safe: improve your coding habits with Rust</li> Blockchains and Rust: a definite match</li> </ul> Web Frameworks</h2> A web framework enables developers to build and run applications for the web without having to write all the code from scratch. Since Rust is a system language, it has several WFs for an overview look at this GitHub</a> repository, and a blog post by Sylvain Kerkour</a>. My favorite is Actix</a>, an active community with many code examples and excellent documentation. </div> </a></div></div> Why is Rust safe?</h2> </div>Multiple features make the Rust language Safe. A quote from the Rust Language Book “Ownership is Rust’s most unique feature and has deep implications for the rest of the language. It enables Rust to make memory safety guarantees without needing a garbage collector, so it’s important to understand how ownership works.” Most design decisions in Rust do not leave room for interpretation, which forces good programming habits. Characteristics like Strongly typed</a>, immutable variables by default, ownership</a>, safe concurrency, etc, make Rust one of the safest languages</a> and removes possible security vulnerabilities and bugs in your code. Most of it happens at compile time, which is way better than in production at runtime.</div></div> Blockchains and Rust</h2> Blockchain, the technology behind Bitcoin and many other decentralized digital currencies, benefits from a secure language like Rust. There are at least five well-known blockchains using Rust as their primary language. The most popular ones are Solana</a> and Polkadot</a>. To see all five blockchains click here</a>. This article refers to another great article Rust vs. Go for Blockchain</a>, and highlights some nice criteria for both languages.</div> </a> </div></div> Enjoy your Sunday, and have a great week ahead. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 3 - Energy efficiency combined with style Unknown — Sun, 23 Oct 2022 00:00:00 +0000 Running Rust on AWS Lambda, improve your coding style and a blazing fast CLI search tool written in Rust</q> </blockquote> The third newsletter with your dose of Rust Trends. Feel free to reply to this email if you have ideas to share… Let’s dive into the content. In today’s email: Lambdas and Rust: running your Rust code in Amazon’s AWS</li> Rust Style Team: improve your coding style</li> Alternative to grep: a command line search tool on steroids</li> </ul> Lambdas and Rust</h2> Want to run your code faster and more energy efficient? Lambdas are one of the workhorses of Amazon’s AWS. Lambdas are programmatic functions that you pay by running time they are rounded to the nearest millisecond. So time is money?! To optimize for cost there are two important takeaways ARM & Rust. Arm CPUs are energy efficient and Rust is fast, both are factors that influence the cost. AWS post</a> on Rust, another blog post on x86 vs Arm</a> Graviton, and a more practical Hackernoon</a> article. </div></div></div> Improve your coding style</h2> </div>The Rust language gains in popularity and regularly gets new language constructs. Reasons for the Rust Style Team</a> to actively maintain a standard style guide. This style is integrated into the widely used rustfmt</a> tool, often used by the IDEs, that automatically formats your code. The standardized style guide helps to keep code readable and uniform across projects and the Rust ecosystem. See also this ZDNet article</a>.</div></div> Speedup search results</h2> Many people know the command line CLI command grep. But did you know a faster grep tool is available and written in Rust? It is called ripgrep and is abbreviated as rg</code>. The link to the official ripgrep repo</a>. The command is available for Linux, macOS, and Windows. A benchmark between ripgrep, grep and other tools can be found here</a>. Want to learn about the internals then this Code review</a> is something for you. </div></a></div></div> Enjoy your Sunday, and have a great week ahead. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 2 - Cloudflare, Linux kernel, and size optimization Unknown — Sun, 09 Oct 2022 00:00:00 +0000 Speed is a must, security is nonnegotiable, and size matters</q> </blockquote> After a successful first newsletter, hereby your second dose of Rust Trends. Feel free to reply to this email if you have ideas to share… Let’s dive into the content. In today’s email: Cloudflare: building a better internet with Rust (Speed)</li> Linux Kernel: Rust will be part of the Linux Kernel (Security)</li> Compiling Rust: speed is number one, but size also matters (Size)</li> </ul> Building a better internet with Rust</h2> Cloudflare is more than only a Content Delivery Network (CDN), that speeds up and secures your website. For their internal infrastructure, they outgrew NGINX and the programming language C. NGINX is known as one of the fastest HTTP proxies and Cloudflare decided to build their own in Rust. To optimize for speed and security on one side and development velocity on the other. Read more</a> on their challenges, trade-offs, and how 5 milliseconds can make a difference. ps. Rust-Trends.com is a happy free user of Cloudflare.</div> </a> </div> </div> Linux Kernel 6.1 will welcome Rust</h2> </a> </div> According to the original creator of Linux, Linus Torvalds: “unless something odd happens,” Rust will be part of the final Linux 6.1 release. Memory safety and removing many vulnerabilities at compile is a big plus for Rust. Read more on ZDNET</a></div></div> Speed and size both matter for Rust</h2> Often Rust is mentioned for its execution speed. However, size does matter as well in Rust. The build environment cargo lets you influence the size of the final binary. Look at our example project on GitHub</a> and read more in this blog post</a>. Want to learn more on this topic the Cargo Book</a> is a valuable source of information when it comes to the building environment.</div> </a> </div> </div> Enjoy your Sunday, and have a great week ahead. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a> 1 - Why Rust Trends? Unknown — Sun, 25 Sep 2022 00:00:00 +0000 Rust is a popular system programming language, and according to the yearly Stack Overflow developer survey</a> most loved programming language since 2015. So 7 years in a row! The language stands for speed, safety, and concurrency. Why should you care? For me, with a background in Embedded Systems, so low-level coding, it became especially interesting when reading over and over again that companies/teams that started using Rust, by rewriting part of their C/C++ stack, experienced the following When the Rust code compiles successfully, it usually just works. This is what you wished for if you ever compiled something in C with pointers, strings, memory (de)allocation, and callbacks …</li> Rust code in production required less maintenance and bug fixing, and therefore left more time for actual coding, which is great!</li> </ul> So now, to stay in tune with everything happening in the Rust world, I challenge myself to biweekly write a newsletter with links to nice articles, blog posts, libraries, (white)papers, and code. I will be searching the web for hours so you do not have to. In today’s email: Tor and Rust: a Tor client on steroids</li> Rust for Microcontrollers: a simulator for ESP32 running Rust</li> Game Engine: Unreal-Rust</li> </ul> Tor a rewrite from C to Rust is now production ready</h2> </a> Tor (The Onion Router), is free and open-source software for enabling anonymous communication on top of the Internet. Started thoughts of rewriting their C stack back in 2017, because of the low development speed. Combined with Rust being less error-prone and providing better secure programming methods it is a clear match. Read more about the official release on the Tor Blog</a>. Rust for Microcontrollers</h2> </a> Rust’s popularity is also spreading towards Embedded Systems. I came across this nice project called Wokwi</a> that provides several simulators, one of which is a simulation that runs your Rust code on an ESP32. You can attach several devices like LEDs, sensors, and displays without the need of heating up your soldering Iron Unreal game engine a Rust add-on</h2> There are already some game engines completely written in Rust but are not yet mainstream. Maik Klein</a> started to go at it via another route. An add-on to the Unreal Game engine that allows you to write in Rust. Note it is currently still a proof of concept. One important take away the editor for the Unreal Engine supports Hot Reloading while editing, however, with C++, the original language for the Engine, you can easily trigger a crash of the editor by e.g. accessing a null pointer. “In Rust crashes or panic are well defined and can be caught. That means if you ever unwrap an Option::None or do out-of-bounds access, unreal-rust will simply catch the panic, exit play mode, and log the error to the console. It will never crash the editor. </div> </a> </div> </div> Enjoy your Sunday, and have a great week ahead. Thanks for reading! Bob Peters Feel free to connect with me on LinkedIn</a>

Rust Trends

76 - Rust Crosses the Chasm

75 - Rust Is Becoming the AI Runtime

74 - When Meta and Anthropic Choose Rust

Why Claude Code Chose ripgrep Over Vector Search

73 - From Lab to Factory: Rust in Production

72 - From Experimental to Enterprise: Rust's Production Moment

71 - Production Rust at Internet Scale

70 - Foundation Moves and Performance Breakthroughs

69 - Rust's Enterprise Breakthrough Year

68 - Special: Rust Your Way Through Summer - Join the Coding Contest & Win Prizes!

How It Works</h2> Complete coding stages to earn points: Very Easy: 5 pts</li> Easy: 15 pts</li> Medium: 30 pts</li> Hard: 50 pts</li> </ul> </li> Points count only once per unique stage (per person, not per language).</li> Score resets after the contest ends on August 1.</li>

Prizes for the Top Rustacean</h2> The highest scorer on August 1 gets to choose one of:</p>

Make This Summer Count</h2> Build real, portfolio-worthy Rust projects</li> Learn at your own pace, whether you're at the beach or your desk</li> Subscription might be reimbursable by your employer</li>

67 - Untangling Rust Errors & the bzip2 Rewrite

66 - Rust, Rewinded: Debug Smarter, Build Faster

Cross-Compiling for Raspberry Pi with Docker

Share</h2> Hacker News</a> Reddit</a> LinkedIn</a></p> </center>

Ferrocene Language Specification Donated to the Rust Project

Implications for Rust’s Future</h2> With the integration of the Ferrocene specification, Rust moves closer to having an authoritative standard document. This helps:</p>

60 - From DNS Servers to JSON Speed: What’s New in Rust

Building a DNS Server in Rust: Part 1 of 2

Understanding DNS: A Quick Crash Course</h2> A DNS request involves:</p>

Constructing a (hardcoded) reply</h2> A valid DNS response consists of three main parts:</p>

59 - Rust for Scientists? Plus, Async Closures & If/Let Chains Explained

The 2024 State of Rust Survey: Key Takeaways for Rustaceans</h2> The Rust Survey Team has released the 2024 State of Rust Survey Results, offering a comprehensive look into the language’s growth and the community’s evolving dynamics.</p> Key Insights</strong></p>

Rust Useful for Scientists? Key Insights from the Community</h2> A recent Reddit discussion—“Is RUST useful for a scientist?”—delves into the applicability of Rust in scientific fields. Here are some key takeaways:</p>

Rust’s Async Closures: A New Way to Handle Asynchronous Logic

Why Do We Need Async Closures?</h2> Previously, if you wanted to write an async function inside another function, you had to define it separately:</p>

Rust’s if/let While Chains: Cleaner Control Flow is Coming!

What’s Changing?</h2> With if/let while chains, Rust will let you write conditions in a more natural way. Instead of nesting if let inside an if, you can chain them together like this:</p>

57 - Start 2025 with Rust: Honeypots, Free Cloud Deployments, and Software Reliability

Building a Honeypot in Rust and Deploy it to Oracle for Free

Share</h2>
Hacker News</a> Reddit</a> LinkedIn</a></p> </center>