Rust The Future Proof Systems Language
rei.r.joshua • March 3, 2024
Rust The Future Proof Systems Language

Industry Embrace of Rust

Rust has gained credibility across the tech industry thanks to its performance, safety and scaleability:


Cloud Giants like AWS, Azure, Cloudflare and Fastly use Rust for cloud services and edge computing.

Tools & Databases like npm, MongoDB, Vector and Databend leverage Rust’s speed and memory safety.

Operating Systems from Linux to Windows to Fuchsia incorporate Rust for reliability.

Web Tech sees Rust drive Firefox, Deno, CDNs, APIs and more.

Blockchains like Solana, Polkadot and Ethereum rely on Rust for their core infrastructure.


With Rust being battle-tested across domains from tiny devices to massive cloud platforms, it seems primed for long-term industry adoption driven by its unique capabilities.

Zero Bugs and Zero Cost How is This Possible?

Lifetimes represent the scope for which references in Rust are valid. Each reference has an associated lifetime that ensures it always points to valid, allocated data.


For example, consider a function that returns a reference to data created inside the function:

This code does not compile in Rust because the String s is deallocated once the function exits. So the returned reference would be invalid.


To fix this, we need to associate the lifetime of the reference with the lifetime of s. Rust allows specifying lifetime parameters to represent these scopes:

Now the returned reference is only valid for the lifetime 'a, which matches the scope of s. This makes the code safe.

Lifetime analysis is performed at compile time by Rust to catch any invalid references before they cause issues at runtime. They help guarantee memory safety without any runtime cost.


Lifetimes are usually implicit and inferred automatically in Rust. But understanding how explicit lifetimes work unlocks the full power and flexibility of Rust’s borrow checker for advanced scenarios.

Rust is a Breath of Fresh Air

So by now you see why Rust is such a big deal. It gives you both safety and speed — without the usual tradeoffs. Rust sidesteps entire classes of major headaches that have plagued programmers for ages.


Now it won’t click overnight. That borrow checker enforces unique rules; expect a learning curve as you adapt. But developers who embrace Rust tend to become hooked. The superpowers are just too good. Leaders like Microsoft, Google and AWS are betting big on Rust too. They want what it brings — secure, high-performance code. And Rust’s ecosystem expands daily. Rust may never become as popular as Java. But not every tool needs to do everything. Rust solves nasty problems in computing at the lowest level. It makes programmers happy along the way. So while it may never be used everywhere, Rust punches way above its weight class. And working with it just might rekindle that coding joy and thrill that drew you to programming originally. That alone makes Rust worth mastering.

Over the past decade, an exciting systems programming language called Rust has rapidly gained adoption across the industry. Originally created by Mozilla and now stewarded by the Rust Foundation, it has quickly become one of the fastest growing and most beloved languages after finally breaking through to the mainstream in recent years.


Despite being over 10 years old, Rust was mostly an academic curiosity and niche language for its first decade. But it now appears to be hitting an inflection point and coming into its own. Surveys show it topping charts as the “most loved language” among developers for years running.


Leading technology companies have started leveraging Rust for key infrastructure, products, and services. But what explains this once niche language’s newfound mass adoption and meteoric rise to prominence? Much of Rust’s success stems from how it creatively tackles long-standing pain points in systems programming.


Specifically, Rust guarantees memory safety without requiring a garbage collector for memory management. It does this via new concepts like ownership and borrowing that statically enforce validity of memory references at compile time. This eliminates entire categories of crashes, vulnerabilities, and bugs that have plagued systems programmers for decades — all without runtime overhead.


In this article, we will explore Rust’s unique approach to memory safety and other key features that make it well suited for performance-critical systems software like operating system components, embedded devices, browsers, and more. We’ll cover concepts of ownership, borrowing, and lifetimes that come together to enable Rust’s guarantees.

Memory Safety Without the Garbage Truck

Rust’s novel concept of ownership establishes clear resource management rules that the compiler rigorously enforces. Each value in Rust has a variable that serves as its unique owner. Ownership confers both responsibilities and privileges:


  • There can only be one owner at a time
  • The owner has exclusive access to modify or move the resource
  • When the owner goes out of scope, the resource is automatically cleaned up

By statically tracking resource ownership as variables enter and exit scope, Rust ensures resources are managed safely and efficiently without requiring manual allocation/freeing or garbage collection.

The owner of a resource is responsible for both its usage while in scope as well as clean up when no longer needed. This simple but strict rule eliminates entire classes of bugs.

We’ll build on ownership through language mechanisms like borrowing and lifetimes that enable sharing references to resources in well-defined ways. But ownership establishes the foundation.

  • Code Examples

    A code editor depicting lines of formatted rust code.

  • Code Examples

    A code editor depicting lines of formatted rust code.

  • Code Examples

    A code editor depicting lines of formatted rust code.

  • Code Examples

    A code editor depicting lines of formatted rust code.

  • Code Examples

    A code editor depicting lines of formatted rust code.

Concurrency Fearless by Default

A key innovation in Rust is the concept of borrowing. Borrowing allows access to data that is owned by someone else in a controlled manner. When a variable is borrowed, it creates a temporary reference to the resource that enforces rules about valid access at compile time.


Borrowing in Rust comes in two flavors immutable and mutable borrows. Immutable borrows use the & operator. These allow read access to the data, but prevent modifying it as long as the borrow exists:

Mutable borrows use the &mut operator. These allow both reading and modifying the data, but can only have one active mutable borrow at a time:

The Rust compiler (known affectionately as “the borrow checker”) ensures these borrowing rules are satisfied. This prevents invalid references and ensures memory safety without any runtime costs.

Next we’ll explore Rust’s concept of lifetimes, which represent the scope for which borrows are valid…

By rei.r.joshua May 31, 2025
Mention the word ego, and most people think of arrogance—someone who steamrolls meetings, flexes their knowledge, and needs to be the most intelligent person in the room. That kind of behavior? It's real. I've seen it. But it reflects only one extreme version of ego—not the whole picture. Like most concepts, the impact of ego depends entirely on the individual and how they choose to express it. Ego, when harnessed with empathy and purpose, isn't something to suppress—it's a tool you can wield. Like Uncle Ben says to Peter Parker, "With great power comes great responsibility." The same goes for ego: used thoughtlessly, it burns bridges and undermines others' confidence. Used with intent and purpose, it can enhance your ability to perform your job confidently every day. Many professionals shy away from their ego, often because they don't understand what a healthy dose of good ego can do for them. First, let's take a moment to reframe what ego is. Ego comes from the Latin for "I" or "self." In psychology, it refers to the process of navigating between our identity, emotions, and the world around us. In more general terms, it relates to your sense of self-worth, self-esteem, and self-identity. It's the internal portrayal that shapes how you see yourself—and how you hope others see you. So, what does a healthy, purposeful ego look like in action? Let's break it down because when paired with empathy, ego doesn't just elevate you; it amplifies how you show up for others. Self-Esteem Confidence in your abilities lets you speak up confidently, take initiative, and challenge the status quo. Paired with empathy, that confidence supports and lifts others rather than steamrolling them. Self-Worth Believing your voice matters fuels resilience. When you recognize and respect your contributions, you're more open to feedback because you don't feel threatened by it. Self-Identity Knowing who you are helps you stay grounded when things get chaotic. It brings consistency to your work and integrity to your decisions. With empathy, that identity isn't rigid; it's collaborative. Confidence & Leadership A healthy ego allows you to lead with clarity without overpowering those around you. Outstanding leadership isn't about being the loudest voice in the room; it's about creating an environment where others feel empowered to speak and take action. Confidence gives you the presence to make tough calls and speak with conviction; tempered with empathy, it ensures you listen with intention. When ego is grounded in purpose rather than pride, it fuels calm under pressure, consistency in vision, and the strength to stand firm. An individual's ego becomes dangerous when driven by insecurity or a sense of superiority. But when rooted in clarity and conscious thought, it empowers you—and everyone around you. Let me ground that in practical experience. I've been in the technology sector for a while. As a Technical Architect, I've seen what a healthy ego can do when it's not about being the loudest voice in the room—but the one people trust to speak with clarity and conviction. Take high-stakes client reviews. I don't back down from what I know to be the best practice to save time or money. I speak confidently and clearly about what I believe is right for my clients. But I also realize in real-world scenarios, we must be flexible and adapt to the specific situations each client may be experiencing. It's not about winning; it's about finding the middle ground between what is optimal and what is practical. My ego gives me the presence to guide the room and the perspective to keep everyone aligned on what matters: long-term value. Mentorship is another space where ego can shine or implode, depending on how it's applied. I don't mentor to boost my status. I mentor because I've been where others have. I know the grind. My ego is what tells me I can help them build their confidence and grow. And my empathy makes sure I'm listening as much as I'm leading. Fourteen years ago, I held an associate's degree and worked in a call center with no benefits, no roadmap, just a drive to be better tomorrow than I was today. Today, I'm a Technical Architect working with global brands and building enterprise-grade solutions across multiple technology stacks. Two years ago, I jumped into a new technology and a new, strictly typed language. Something I had never done and had no traditional experience with; I not only made the transition, I thrived. How was I able to do all these things over the last fourteen years? Simple, I outworked everyone. I showed up early, stayed late, asked every question, made mistakes, took feedback, built trust, and never stopped learning. "My ego didn't whisper, 'You're better than this.' It shouted, 'You can be one of the best if you're willing to earn it.'" Ultimately, ego isn't the enemy. It's the part of you that believes you're capable of achieving greatness and refuses to quit until you do.
Abstract digital connected cloud.
By rei.r.joshua October 5, 2024
When you hear Salesforce, you probably think of a massive, all-encompassing SaaS provider tailored for enterprise clients. You envision dashboards, reports, accounts, and sales opportunities—all seamlessly connected within complex business processes. Teams of professionals interact with the system daily, weaving their tasks into Salesforce’s vast landscape. But beneath this complexity lies a simple, elegant structure that powers everything. In this article, we’ll strip away the layers to focus on Salesforce's fundamental building blocks—its DNA: objects, records, and relationships.
An abstract image of bright details cloud and commerce related elements.
By rei.r.joshua September 27, 2024
"What is the best option for current Salesforce Commerce Cloud engineers to future-proof their career?" This article aims to answer the question and introduce a more fundamental career philosophy that can enlighten and empower your decisions in the e-commerce sector.
Show More