2024-12-13 08:00:00
A Practical Guide for Decision Makers
I wrote this guide for technical leaders and developers considering a move from TypeScript to Rust. After years of helping teams make this transition, I’ll share what works, what doesn’t, and how to make your migration successful.
TypeScript excels at making JavaScript more maintainable, but teams often hit scaling challenges as their codebases grow. You might be facing performance bottlenecks, reliability issues, or maintenance overhead. Rust offers compelling solutions to these problems, but migration needs careful planning and execution. Let me show you how to evaluate if Rust is right for your team, plan a successful migration, and keep your team productive during the transition.
In this article, you’ll learn:
| Aspect | TypeScript | Rust |
|---|---|---|
| 1.0 Release | 2014 | 2015 |
| Packages | 3 million+ (npm) | 160,000+ (crates.io) |
| Type System | Optional | Mandatory |
| Tooling | Rich ecosystem, frequent updates | Stable, integrated toolchain |
| Memory Management | Garbage collected | Ownership system, compile-time checks |
| Speed | Moderate | Fast |
| Error Handling | Exceptions | Explicit handling with Result
|
| Learning Curve | Moderate | Steep |
TypeScript is a great language, but many teams hit a wall around the 10k to 100k lines of code mark. At this scale, the codebase becomes hard to maintain and teams start to feel the pain.
The problems are clear and specific.
While TypeScript has a type system, it remains a dynamically typed language built on JavaScript.
Types are optional and can be bypassed using any or unknown or by freely casting between types.
Without enough discipline, this leads to runtime errors and bugs.
Memory leaks and security vulnerabilities become more common, especially in large, long-running backend services. Some companies I’ve worked with needed regular service restarts to manage memory leaks.
External packages often have security vulnerabilities and need regular updates. Breaking changes are common, and packages frequently become unmaintained. Frameworks like Next.js introduce frequent breaking changes, forcing teams to spend time on updates instead of business logic.
Performance isn’t guaranteed. TypeScript is fast enough for most cases, but performance-critical applications will hit limitations. Error handling through exceptions and promises can be hard to reason about. Large TypeScript codebases become difficult to refactor and maintain, even with type safety.
TypeScript’s type system creates an excellent foundation for Rust adoption. Your team already understands static typing and values its benefits. This gives you a head start with Rust, which takes these concepts further and adds more powerful guarantees.
Rust enforces stronger guarantees than TypeScript through its ownership system and borrow checker. You’ll need to plan for an adjustment period. Most developers need 2-4 months to become comfortable with Rust’s ownership model. They’ll go through a phase of “fighting the borrow checker” – this is normal and temporary. Your job is to keep the team motivated during this learning curve. I’ve seen time and again that developers who push through this phase become the strongest Rust advocates. These developers then become valuable mentors for their teammates.
Rust pushes your team to understand systems concepts better than TypeScript ever required.
You need to know the difference between stack and heap allocation.
You’ll work with different string types like String and &str.
And you should be willing to learn what a pointer or a mutex is.
These concepts might seem intimidating at first, but they make Rust fast. Rust won’t hide these details from you. The idea is that explicit is better than implicit.
Your team will write more efficient code because Rust makes these low-level details explicit and manageable.
You don’t need to be a systems programmer to use Rust and yet, you will need to learn these concepts to become proficient in Rust.
The strict Rust compiler is your strongest ally.
You can refactor without fear because the compiler catches mistakes early and consistently.
You won’t deal with null or undefined errors.
Error handling becomes explicit and predictable with Result.
NPM gives you more packages, but Rust’s ecosystem prioritizes quality. Libraries maintain strong backward compatibility. Breaking changes are rare. Rust itself releases new editions every three years with opt-in changes.
Many Rust crates stay in 0.x versions longer than you might expect. Don’t let this worry you – Rust’s type system ensures robust functionality even before reaching 1.0. The ecosystem grows fast, and the existing libraries work reliably. For specific use cases, writing your own library is common and well-supported.
TypeScript is a great language for backend services. A lot of companies use it successfully. There are many frameworks to choose from, like Express, NestJS, or Fastify. These frameworks are mature and well-documented.
By comparison, Rust’s backend ecosystem is smaller. You have Axum, Actix, and Rocket, among others. These frameworks are fast and reliable, but they don’t provide a “batteries-included” experience like Express.
That said, Rust’s ecosystem is growing fast and most companies find the available libraries sufficient. I personally recommend axum as it has the largest momentum and is backed by the Tokio team.
Deployment is straightforward. You can build your Rust service into a single binary and deploy it to a container or a server. Rust binaries are small and have no runtime dependencies. This makes deployment easy and reliable.
Teams are often shocks that Rust is so fast. They go in expecting Rust to be fast, but the reality still surprises them. You can expect an order of magnitude better CPU and memory usage if you’re coming from JS/TS. The effects of that are very real: reduced cloud costs, less hardware, and faster response times.
Most importantly, your runtime behavior becomes predictable. Production incidents decrease. Your operations team will thank you for the reduced overhead.
Write down why you want to migrate before you start:
This clarity helps when things get tough.
I know this evaluation isn’t easy. We often struggle to see our codebase’s problems clearly. Politics and inertia hold us back. Sometimes you need an outside perspective. I can help you evaluate your situation objectively and create a solid migration plan. This might sound expensive, but think about your team’s salaries and the cost of making the wrong decision. Good consulting pays for itself quickly. Reach out for a free consultation.
You have two main ways to integrate Rust with TypeScript.
You can use WebAssembly (WASM) to compile your Rust code to a library and call it directly from TypeScript. This works great for speeding up performance-critical components. Teams often start here and expand their Rust usage as they see the benefits.
Alternatively, you can deploy Rust as separate services. This fits well with microservice architectures. Your TypeScript and Rust components communicate over the network. This gives you a clean separation and lets you migrate gradually.
You need a Rust champion in your team. This person should have some prior Rust experience and be excited about the language.
Outside help can get you started, but keep the knowledge in-house. You know your codebase and business domain best. A consultant helps with the tricky Rust parts, team augmentation, and training, but your team maintains and extends the codebase in the long run.
They need to believe in the mission.
In order to succeed, your Rust champion needs to be able to motivate the team, answer questions, and guide the team through the learning curve. They work hand-in-hand with the consultant to ensure the team’s success.
Don’t rewrite everything at once! Start small. Maybe pick a monitoring service or CLI tool – something important but not critical. Perhaps you’ll give it a shot during a hackathon or a sprint. Build confidence through early wins.
Ready to make the switch to Rust?
I help teams make successful transitions from TypeScript to Rust. Whether you need training, architecture guidance, or migration planning, let’s talk about your needs.
2024-12-13 08:00:00
A Practical Guide for Decision Makers
This guide is written for technical leaders and developers considering moving their teams from Python to Rust. I used to be a Python developer myself, and I know how daunting it can be to switch to a new language. Base on years of experience helping teams make this transition, I’ll share practical insights on what works, what doesn’t, and how to ensure a successful migration.
Python is an incredibly versatile language that powers everything from web applications to data science pipelines. However, as organizations scale, they often encounter limitations around performance, type safety, and robustness. While Rust isn’t a direct replacement for Python, it has some answers to these challenges.
But is Rust the right choice for your team?
In this article, you’ll learn:
| Aspect | Python | Rust |
|---|---|---|
| Type System | Dynamic, optional type hints | Static, strong type system |
| Memory Management | Garbage collected | No GC, ownership and borrowing |
| Performance | Moderate | High performance, low-level control |
| Deployment | Runtime required | Single binary, minimal runtime |
| Package Manager | Multiple (pip, conda, uv) | cargo (built-in, consistent) |
| Error Handling | Exceptions | Result type |
| Concurrency | Limited by GIL | zero-cost abstractions, no GIL |
| Learning Curve | Gentle | Steep |
| Ecosystem Size | Vast (500,000+ packages) | Growing (160,000+ crates) |
Python excels at readability and rapid development, but teams often hit scaling challenges as their applications grow. Common pain points include:
Python’s Global Interpreter Lock (GIL) limits true parallelism, making it challenging to fully utilize modern multi-core processors. There is a version of Python without the GIL, but it doesn’t solve the performance issues.
While tools like asyncio help with I/O-bound tasks, CPU-intensive operations remain constrained. Teams often resort to complex workarounds involving multiple processes or C extensions.
Despite Python’s type hints, runtime type errors still occur. Types are optional in Python. Developers need the discipline to add and maintain type hints consistently, which can be challenging in large codebases. Furthermore, adoption is inconsistent across the Python ecosyste (e.g., third-party libraries). Large Python applications can become difficult to maintain and refactor confidently.
From experience, there is a breaking point around the 10-100k lines of code mark where the lack of type safety becomes a significant liability.[1]
Python applications require managing runtime environments, dependencies, and potential version conflicts. A lot of the issues can be mitigated with containerization. However, bundling Python applications for deployment is not an easy task, especially when targeting platforms with different architectures.
Python has a relatively manageable memory profile, but it can be inefficient for certain workloads. For example, Python’s memory overhead can be significant for large-scale data processing or long-running services. CPU-bound tasks often get offloaded to C extensions or to worker processes, adding complexity and overhead.
Python developers often want to transition to Rust for several reasons:
Developers interested in Rust are likely willing to understand systems programming concepts. They grew out of Python’s limitations and are looking for more control over performance and memory management.
Python developers often long for stronger type guarantees. They appreciate Rust’s static type system and the safety it provides.
Developers with a Python background often work on data processing or web applications. These are areas where Rust’s performance benefits are most pronounced.
The transition from Python to Rust presents unique challenges:
Python is very syntax-light, which makes it easy to read and write. By comparison, Rust is full of symbols and keywords that can be intimidating at first. Developers need to see through the syntax and understand the underlying semantics. This is a critical step in the transition process.
# A list of bands
=
# A list comprehension to filter for bands that start with "M"
=
# A list comprehension to uppercase the bands
=
# We get ["METALLICA", "MEGADETH"]
let bands = vec!;
let uppercased: = bands.iter
.filter
.map
.collect;
// uppercased = vec!["METALLICA", "MEGADETH"]
Python developers need to adjust to Rust’s ownership model. This is often the biggest hurdle, as memory management in Python is handled automatically. Plan for a 3-4 month learning period where developers will need to understand concepts like:
Moving from Python’s dynamic typing to Rust’s static typing requires a mindset shift. Developers need to:
Option<T> and Result<T, E> for error handlingThe pattern matching syntax in Rust can be a game-changer for developers coming from Python and is often cited as one of the most enjoyable features of Rust.
There are several ways to integrate Rust into your Python codebase:
PyO3 lets you write Python extensions in Rust or call Rust functions from Python. This is ideal for:
For distributed systems, you can:
Command-line tools are excellent candidates for initial Rust projects:
For CPU-bound tasks, consider:
A successful migration requires careful planning:
Start Small
Invest in Training
Measure Success
Rust’s ecosystem is smaller than Python’s.
On top of that, Rust has a much smaller standard library compared to Python. This means you’ll commonly rely on third-party crates for functionality that’s built into Python.
Depending on your use case, here are some key differences to consider:
Python dominates data science with libraries like NumPy and Pandas. However, Rust is making inroads with libraries like Polars and Apache’s Arrow.
You don’t have to migrate your entire data science stack to Rust. Chances are, you have experts on your team who are comfortable with doing data analysis in Python. You can start by using the Rust libraries for data preprocessing and ETL tasks. They have Python bindings, so you get a lot of the benefits of Rust without having to do a full migration.
Rust wasn’t initially planned to be a strong contender in the web development space. This has changed in recent years with the rise of frameworks like Axum and Actix-web. Now, Rust is a viable option for building high-performance APIs and web applications. It is one key are the Rust team is investing in, and the ecosystem is maturing rapidly.
In combination with sqlx for database access and serde for serialization, Rust is a very effective choice for web backends. What surprises many Python developers is how similar it is to working with other web frameworks like Flask or FastAPI. Another surprise is how robust the final product is, as it catches many bugs at compile time and scales extremely well. Production Rust web applications are extremely robust. This lifts a lot of the burden from the operations team.
Not everything needs to be migrated! Python excels at:
Consider a hybrid approach where each language handles what it does best.
One winning strategy is to explore a space in Python and moving production-workloads to Rust once the requirements are clear and the project can benefit from performance and scale. Speaking of which…
Actual performance numbers vary significantly based on workload and implementation, so take these numbers with a grain of salt.
Based on my experience helping teams migrate, here are typical improvements:
Especially the P90 latency improvements are often surprising to teams. There are very few outliers and things tend to run smoothly, no matter the load. In Python, this is a common source of frustration, where a single request can take significantly longer than the rest.
Migrating from Python to Rust is a significant undertaking that requires careful planning and execution. While the learning curve is steep, the benefits in terms of performance, reliability, and maintainability can be substantial.
Success depends on:
Remember that this isn’t an all-or-nothing decision. Many organizations successfully use Python and Rust together, leveraging each language’s strengths. Write down your reasoning for the migration. Many issues can be solved in Python, and the migration might not be necessary. However, if you’re hitting the limits of Python, Rust is a strong contender.
Ready to Make the Move to Rust?
I help teams make successful transitions from Python to Rust. My clients moved critical workloads to Rust and saw significant improvements in performance and reliability. Whether you need training, architecture guidance, or migration planning, let’s talk about your needs.
2024-12-12 08:00:00
Think about this: software engineers have modern code editors, parallel processing, continuous integration, and countless tools that make their work efficient. But hardware engineers? They’re often working with single-threaded tools, limited automation, and workflows that haven’t fundamentally changed in decades. Zoo is building the infrastructure to change that, creating a modern set of tools and APIs that will allow companies and engineers to build better hardware design tools and accelerate the development of physical products.
2024-12-09 08:00:00
There’s been increasing discussion about companies moving from Scala to Rust). The Scala ecosystem faces, and while solutions are proposed, many organizations are evaluating Rust as an alternative path forward.
Even former Scala advocates like Twitter or LinkedIn have expressed concerns about their choice of Scala:
“We’ve recently made the decision to minimize our dependence on Scala in our next generation front end infrastructure which is rolling out this year.” — LinkedIn’s SVP of Eng Kevin Scott
People are looking for guidance on how to navigate this transition, which is why I’ve written this guide for organizations considering migrating from Scala or Clojure to Rust. We will take a cold hard look at the benefits and challenges of moving to Rust, and provide practical advice for making the switch.
The most striking difference between Rust and JVM functional languages is the pace of adoption. Rust has seen extraordinary growth, with over 2.8 million developers using it professionally. Major tech companies including Microsoft, Google, and Meta have embraced Rust, particularly for performance-critical systems. This widespread adoption has created a virtuous cycle: the larger talent pool makes hiring easier, which encourages more companies to adopt Rust, which in turn drives more developers to learn the language. The ecosystem grows more robust by the day, with new tools and libraries constantly emerging to solve real-world problems.
In comparison, Scala and Clojure have seen slower growth and more limited industry adoption. While both languages have passionate communities and are well-suited to certain domains like data processing and Spark applications, they lack the broad appeal and momentum that Rust has achieved. This difference in adoption rates can affect your organization’s ability to hire and retain talent, which is a risk factor for any company.
In fairness, the RedMonk rankings show that Scala has maintained a consistent position in the top 20 languages, while Rust has just recently broken into the top 20.
One of Rust’s strongest selling points is its commitment to stability. Since its 1.0 release in 2015, Rust has maintained backward compatibility across more than 105 releases.
Releases are cut every six weeks and roughly every 3 years a new edition is released, which allows the language to evolve while preserving compatibility with existing code. This stability is a significant advantage for organizations that need to maintain long-lived codebases or have strict requirements around backward compatibility.
Rust’s stability is a fundamental business advantage.
Code written in Rust 1.0 continues to compile and run today, protecting your investment in both code and developer training. Documentation and learning resources remain relevant for years, significantly reducing the ongoing cost of maintaining expertise in your organization. This stands in stark contrast to the breaking changes that have characterized many language ecosystems, including Scala’s transition from 2.x to 3.x.
Rust’s tooling ecosystem, centered around Cargo, provides a remarkably smooth developer experience. Cargo unifies building, testing, and dependency management into a single, coherent tool that just works. The compiler’s error messages are legendary for their clarity and helpfulness, often telling developers exactly how to fix issues. IDE support through rust-analyzer and RustRover is rock-solid, providing a reliable development experience that boosts productivity. This tooling excellence isn’t an accident — it’s the result of deliberate design decisions and years of community investment.
In Scala, build tools like sbt and dependency management tools like Maven can be complex and error-prone. IDE support, while improving, can be inconsistent across different editors and might not support all language features. The overall developer experience in Rust is more polished and consistent.
While Scala and Clojure offer good performance for JVM languages, Rust provides performance comparable to C/C++ while guaranteeing memory safety at compile time. This combination is particularly valuable in an era of cloud computing, where every millisecond of latency and every megabyte of memory directly affects operating costs. However, Scala developers should note that writing truly immutable code can actually be more challenging in Rust than in Scala.
Rust’s predictable resource usage and lack of garbage collection pauses make it ideal for systems that require consistent performance. Organizations often find that moving performance-critical components to Rust can significantly reduce their infrastructure costs.
The business case for Rust extends beyond technical merits.
Scala and Clojure developers typically transition well to Rust because the languages share many fundamental concepts. The emphasis on strong type systems, functional programming patterns, and correctness creates a natural bridge. While Rust’s ownership system presents a learning curve, developers coming from functional programming backgrounds often find they already think in ways that align well with Rust’s model.
A successful migration to Rust typically starts small and grows organically. New microservices or standalone components are excellent candidates for initial Rust projects. Performance-critical systems that would benefit from lower latency or reduced resource usage are another natural starting point. Command-line tools and utilities offer low-risk opportunities to build team expertise.
The key to successful migration is maintaining optionality. Rust’s excellent interop capabilities mean you can gradually introduce it alongside existing JVM services. This allows teams to learn and validate Rust’s benefits in your specific context without committing to a wholesale rewrite.
The transition to Rust does present challenges. The ownership and borrowing concepts take time to master, though the compiler’s excellent error messages help guide developers through the learning process. The ecosystem, while growing rapidly, may not yet have direct equivalents for all specialized JVM libraries. Some internal tooling may need to be rebuilt or adapted.
However, these challenges should be viewed in context. The learning curve, while steep, is finite — developers with a strong functional programming background typically become productive in Rust within a few months. The ecosystem limitations often push teams toward simpler, more maintainable solutions. And the need to rebuild tools can be an opportunity to improve and modernize development workflows.
The decision to migrate from Scala/Clojure to Rust should be driven by specific business needs rather than following trends.
Consider Rust when performance and resource efficiency are crucial, when you need predictable latency and memory usage, when your team is ready for a new technical challenge, or when long-term stability and maintenance are priorities.
The transition requires investment, but Rust’s growing ecosystem, excellent tooling, and strong industry adoption make it an increasingly attractive option for organizations looking to move beyond the JVM while maintaining the benefits of strong typing and functional programming paradigms.
Is Your Team Considering a Migration to Rust?
I can help you evaluate your current systems, design a migration strategy, and help you make an informed decision about moving to Rust. I offer consulting services to help you assess the technical and business implications of a migration, and I can train your developers to succeed with Rust. Get in touch for a free consultation.
2024-12-09 08:00:00
A Practical Guide for Decision Makers
This article is aimed at technical product managers and CTOs who are considering migrating a production Java application — or part of it — to Rust. I will give an honest overview of the challenges and benefits of such a migration, as well as practical tips to make it successful based on years of experience and successful transitions.
Java is an amazing language. It’s a true workhorse, powering some of the world’s most critical systems. Even so, large organizations are increasingly looking to Rust as a way to improve reliability, resource usage, and reduce costs. Decision makers need to weigh the benefits and risks of migrating to Rust, and it’s not always an easy choice.
In this article, you’ll learn:
By the end, you’ll have a clear idea if Rust is the right choice for your organization and if so, how to make the transition as smooth as possible.
Before diving into migration tips, let’s look at key differences between Java and Rust:
| Aspect | Java | Rust |
|---|---|---|
| Memory Management | Garbage collector; possible memory leaks and GC pauses | Borrow checker at compile time; no GC pauses |
| Performance | JVM bytecode, requires runtime | Native machine code via LLVM |
| Default Mutability | Mutable by default | Immutable by default, requires mut
|
| Null Safety | Allows null pointers | No null pointers, uses Option<T>
|
| Code Organization | Classes with inheritance | Structs with traits (composition) |
| Package Management | Gradle/Maven | Cargo (integrated build + deps) |
| Concurrency | Thread-based with synchronized blocks | Built-in safety via ownership system; async/await |
| Error Handling | Checked exceptions | Result and Option types |
| Compilation Speed | Fast to medium | Slow |
| Learning Curve | Moderate | Steep |
| Deployment | Requires JVM runtime | Small, self-contained binaries |
These differences highlight why organizations might consider migrating to Rust, particularly for performance-critical or resource-constrained applications. However, migration isn’t just about technical differences - it requires careful planning and execution. Let’s look at how to make this transition successful.
Migrating to a new language is always tough at first, and Rust is no exception. It has a famously steep learning curve and requires a different mindset from Java. Plan 4-6 months for your engineers to get comfortable with Rust, and expect a few bumps along the way.
That said, there’s plenty of material to help your team get up to speed. Resources like Rustlings, Rust By Example, 100 Exercises To Learn Rust, and Rustfinity are all great for self-learning.
If you’re looking for a more structured approach, consider hiring a Rust consultant or trainer. Bringing in experts can make the transition even faster and smoother. Your team will not only learn Rust but also feel more confident working with it in production.
Migrating to Rust comes with some risks, but careful planning will minimize them. Here’s how to ensure success:
Start Small
Pick a small, non-critical part of your application for the first Rust implementation. This lets your team experiment and build confidence without affecting core systems. Expand gradually as you see results.
Prepare Your Team
Don’t just decide this for your developers—decide together. Get the team ready with training or external expertise, and focus on integration with your existing Java system. Rust will likely need new dependencies, so research the ecosystem and be ready to roll up your sleeves to contribute if necessary.
Take a look at blessed.rs, lib.rs, and awesome-rust for a curated list of libraries.
Evaluate Dependencies Upfront
Consider potential constraints like proprietary tools or databases that may complicate integration with Rust. Make sure the libraries you need are available, or be prepared to write your own.
Have a Plan B
Rust migration doesn’t need to be all-or-nothing. Keep Java components running while testing and migrating. If issues arise, you can scale back or swap components as needed.
Set Clear KPIs
Establish your own definition of success—don’t just follow industry benchmarks. Whether it’s performance, resource savings, or developer experience, make sure you know what you want from Rust and measure it.
Training Pays Off
Even if you eventually decide against Rust, the training will improve your team’s programming skills. It’s an investment that pays dividends in the long run.
Monitor and Test
Use monitoring and automated tests throughout the migration. Rust’s safety guarantees help, but you still need to test thoroughly and catch any issues early.
Initially, you will likely be dealing with a mix of Java and Rust. Where should you start? Look at the boundaries in your application—network layers, APIs, or microservices. These natural seams are perfect places to migrate first.
For Java-to-Rust migration, you have a few options:
Each approach has its pros and cons, so choose the one that fits your use case best. How do you decide? This is something you should discuss with your team and possibly a Rust consultant. They can help you weigh the trade-offs and make the right choice.
If you’d like to get a primer on Java-to-Rust interop, check out this talk from Rust Nation UK 2024 by Konstantin Grechishchev.
Big organizations often have large, complex Java codebases. A full rewrite is not feasible and can be risky.
Consider rewriting the most CPU- or memory-hungry parts of your application in Rust while leaving the rest untouched.
Perhaps you find that you only need to migrate a tiny portion, say 10-20%, to Rust for a significant performance boost. In that case, you can keep the rest of the application in Java and gradually migrate more parts over time if you see benefits. This incremental approach ensures that your team can slowly adapt to Rust and share some quick wins along the way, which is great for morale.
A good way to test the waters is with isolated components — CLI tools or monitoring sidecars. These smaller parts let your team gain experience with Rust without affecting critical system functions.
When migrating to a different language, the new tooling is just as important as the language itself. However, it’s often overlooked in the decision-making process.
Rust’s tooling is excellent, and among the most loved advantages of the language. The tooling is best in class, mature and easy to adopt. Here’s how it stacks up:
However, also consider the constraints and risks your project might face—proprietary tools, unusual databases, or special dependencies. Do the research upfront to avoid surprises. And if you need new libraries, be prepared to get your hands dirty and write your own.
For example, if you’re building a web application, Rust has several frameworks to choose from, with the most popular being axum, but none as mature as Spring Boot. Projects like Pavex or Loco could fill this gap, but they’re still in early stages.
Rust shines when it comes to cross-platform builds. Unlike Java, where you often need to install a runtime (like the JVM) on every machine, Rust’s binaries are small, self-contained, and ready to run anywhere.
Rust compiles directly to machine code, which means you don’t need to worry about dependencies that are typically required by dynamic runtimes. The only consideration might be system libraries (like OpenSSL), but this is manageable with established solutions. [1]
In containerized environments, Docker works just as well with Rust as with any other language, and it’s easier to scale because of Rust’s low overhead. Whether you’re running on AWS, Cloud Run, or any other platform, the experience is reliable and consistent.
Rust supports a wide variety of platforms, including ARM and x64, and can be used seamlessly across development machines, servers, and the cloud.
Yes, Rust has awesome runtime performance. But you shouldn’t focus on raw numbers alone. Thanks to technologies like GraalVM, Java can be very fast as well, especially for long-running applications.
The image above shows a comparison between Rust, Quarkus-Native, and Spring-Native. In terms of raw performance, Rust is the clear winner. Rust uses 12 MB RAM and less than a third of the CPU power of both Quarkus-Native and Spring-Native.
When you migrate to Rust, also consider the secondary effects of improved performance:
Based on my experience helping teams migrate to Rust, here are some ballpark improvements you might see:
Memory Usage: For data-heavy applications, expect to see 30-50% reduction in heap size for most services. This is a very conservative estimate. Depending on your workload, you might see even more significant improvements.
Startup Time: While Java services often need 20-30 seconds to warm up in production, equivalent Rust services typically start in under a second. This makes a big difference for scaling containerized deployments.
Latency: The exact numbers vary widely, but you’ll often see P95 latency improve by 40-60%. The biggest win is usually in tail latencies (P99.9) due to the lack of GC pauses.
Throughput: Again, this depends heavily on your workload, but teams I’ve worked with typically see:
Resource Costs: Several teams have managed to cut their cloud costs by 40-60% after migration, mainly due to lower CPU and memory requirements.
These are rough numbers from my consulting experience, and your results may vary significantly depending on your specific use case. The key takeaway isn’t the exact numbers, but rather that teams consistently see meaningful improvements across different metrics.
Rust helps you get more done with less, making it easier to scale and manage your infrastructure.
Rust’s concurrency model is a major advantage. Traditional Java applications tend to be thread-heavy, and while this works on modern Linux systems, Rust offers more flexibility. On top of that, concurrency in Java can be tricky to get right and is therefore often avoided.
Rust gives you both thread-based concurrency and async execution. With libraries like Tokio, you can use async/await without worrying about the underlying mechanics. It scales incredibly well, often in ways that Java simply can’t match due to its reliance on threads.
What’s powerful about Rust’s concurrency is how it’s baked into the language itself. It’s not something your team has to think about too much. The libraries handle most of the heavy lifting, and once you structure your code properly, Rust’s runtime handles the rest—efficiently and safely.
Rust’s memory management ensures that concurrency is safe, so you won’t need to worry about thread synchronization issues like you would in Java.
One of Rust’s underrated strengths is developer ergonomics.
With Rust’s strict compiler checks, a lot of potential bugs are caught during development, meaning fewer bugs in production. This leads to fewer code reviews and a smoother development process overall. You can move faster with more confidence.
Over time, this leads to more reliable code in production. Rust’s emphasis on memory safety and strict typing means that, once your system is built, you’re less likely to face random crashes or bugs. This saves on-call costs and reduces the risk of downtime.
There are no garbage collector pauses to worry about, and the code has a predictable performance profile. You’ll have a “boring” production environment in the best way possible — things will work consistently and predictably.
Rust is committed to stability. While some core libraries haven’t reached a stable 1.0 version yet, the 0.x versions are highly reliable, with breaking changes becoming less frequent over time. When Rust releases new versions, they follow semantic versioning, so updates are usually predictable and don’t introduce surprises.
If you’re worried about future-proofing your application, Rust’s ecosystem is built with long-term support in mind. If you do encounter missing functionality, you’ll often need to contribute back to the community—this is part of the Rust philosophy.
Training your team in Rust isn’t just about the immediate migration. Even if you eventually decide to stick with Java, Rust’s focus on good practices will make your developers better overall.
Adopting Rust is a big commitment. Don’t make the decision in a vacuum — involve your team in the process. They’re the ones who will be working with Rust day in and day out, so their input is crucial.
If you’re considering a migration, start by discussing the benefits and challenges of Rust. What are your hopes for Rust? What are the alternatives considered? What are your key KPIs for success? What is the skill level of your team, and how can you support them in learning Rust? It helps to put your thoughts into writing and share them with the team.
On that note, hiring Rust developers can be challenging. It’s a relatively new language, and most Rust developers don’t have any production experience yet. Instead, consider upskilling your existing Java developers. They already know your systems and can learn Rust with the right training and support.
At the end of the day, Rust’s investment pays off. Even if you don’t go full Rust, the knowledge gained will make your developers better programmers.
If you’d like to discuss this further, feel free to book a call with me. I offer consulting services to help you make the right decisions for your project – even if that means sticking with Java.
Make the most of Rust
Is your company considering to migrate from Java to Rust? I offer consulting services to get you up to speed with your Rust projects, from training your team to code reviews and architecture consulting. Get in touch for a free consultation.
For example, you can vendor OpenSSL to build it statically. ↩
2024-12-03 08:00:00
Looking to attend a Rust conference in 2025?
Here’s a list of all major Rust events happening around the world. Find dates, locations, ticket prices, CFP deadlines, and more.
Rustaceans like to mingle, learn, and share their knowledge at conferences. With 10-12 conferences happening in 2025, it will be a busy year for the Rust community. To make it easier to keep track of all the events, we’ve compiled a list of all Rust conferences in 2025. Come say hi if you see us at any of these events! (We’ll bring Rust in Production stickers.)
Oh, and in case the call for proposals (CFP) is still open, why not submit a talk or workshop proposal?
Stay up to date with all Rust conferences in 2025 by subscribing to this Google calendar.
Or download the static calendar file and import it into your favorite calendar application. Check back periodically for updated versions as new conferences are announced.
Rust Nation has evolved into a staple event in the Rust community. The organization, speaker lineup, and recordings are always top-notch. It’s a great conference for Rust developers of all levels. As per tradition, they kick off the year of Rust conferences.
“When Safety Meets Elegance” is the tagline for Rust in Paris. It features 12 speakers, 1 day of talks, and 250 attendees.
An event in Poland, actively co-created by Rust enthusiasts.
Aims to bring together Rust developers from the region and beyond. Expect a developer-friendly atmosphere with ~15 expert talks in a single-track format, perfect for staying connected and engaged. After a day of learning, unwind with us in a local pub and network with fellow devs.
Another first-time event, RustAsia is a conference for Rust developers in Asia.
After many years without a Rust conference in Asia (the last one being RustCon Asia in 2019), the community is excited to have a new event in Hong Kong.
The first-ever Rust conference in Turkey, bringing together Rust developers and enthusiasts for a day of technical talks, workshops, and networking. The event will feature in-depth technical sessions on low-level programming, performance optimization, system-level development, and eBPF.
RustWeek is a week-long event that combines talks, workshops, and social events. It’s located in cozy Utrecht, the fourth-largest city in the Netherlands. This is organized by the team behind RustNL. RustWeek takes place during the 10 year anniversary of Rust 1.0. All Rustaceans are welcome to attend and submit talks.
The first conference for Rust blockchain professionals.
The Rust Summit is first-of-its-kind chain-agnostic conference, featuring expert talks, workshops, and networking opportunities for Rust blockchain professionals. It is open to all Rust developers active in the web3 and blockchain sectors and those who are interested in it.
RustForge is the first conference in the Asia/Pacific region that focuses on Rust.
RustConf is the official Rust conference organized by the Rust Foundation. It’s a great place to meet the Rust core team and other community members. The last edition was held in Montreal, Canada and the 2025 edition will be announced soon.
Two days of applied Rust insights from industry innovators. Topics range from cross-platform GUI development to Rust in safety-critical systems.
One of the largest Rust conferences in Europe and a well-established event in the Rust community. It’s a 2 day conference that covers all things Rust: from Rust patterns and idioms to system programming and CLI tooling, servers WASM and embedded systems.
The conference travels to a different European city each year. This time, it’s in Paris, France. 🥖
The Italian Rust conference traditionally takes place in Florence. It’s lovingly organized featuring delicious italian food and a great community.
So there you have it, our complete guide to all Rust developer conferences, workshops, and community meetups happening around the world in 2025. Whether you’re interested in blockchain, embedded systems, or web development with Rust, there’s an event for every Rustacean out there. Let us know if we missed any events or if you have any updates to share. You can directly propose changes by editing the list here. We’ll see you at the next Rust conference!
Note: This list will be updated as more information becomes available. Some conferences are yet to announce their exact dates, venues, or ticket prices.
