New pages

07:4007:40, 16 November 2025 Rust Data Structures: Vec T, & T , Box T. Do You Really Understand Collection Containers? (hist | edit) [17,384 bytes] PC (talk | contribs) (Created page with "Now that we have encountered more and more data structures, I have organized the main data structures in Rust from the dimensions of primitive types, container types, and system-related types. You can count how many you have mastered. As you can see, containers occupy half of the data structure landscape. When mentioning containers, you may first think of arrays and lists — containers that can be iterated. But in fact, as long as some specific data is wrapped inside...")
07:3507:35, 16 November 2025 Finally Understanding Rust Ownership: A Visual Guide (hist | edit) [7,721 bytes] PC (talk | contribs) (Created page with "You’re staring at your screen. The code looks completely normal. You’ve written this exact pattern in three other languages this week. But the Rust compiler is throwing “value borrowed here after move” and you’re just… stuck. It’s not that you don’t understand the words. It’s that the ground rules changed and nobody mentioned it. Variables don’t work the way they used to. Memory feels suddenly fragile, like you’re handling something that might break...")
07:3307:33, 16 November 2025 Rust’s “cannot move out of borrowed content” (a.k.a. “behind a shared reference”) — what it really means and how to fix it without (hist | edit) [7,141 bytes] PC (talk | contribs) (Created page with " Ever hit this? error[E0507]: cannot move out of `*line` which is behind a shared reference …and then you slap a .clone() on it, the code compiles, you ship it—and you’re still not sure why it failed in the first place? Let’s demystify this error, understand exactly what’s going on, and then walk through the most idiomatic, zero-allocation fixes. We’ll use your example and expand it into a general mental model you can reuse anywhere. The setup You ha...")
07:3107:31, 16 November 2025 7 Hard Security Wins Rust Guarantees — And 9 Traps It Won’t Save You From (hist | edit) [9,314 bytes] PC (talk | contribs) (Created page with "Pull Quote #1: Rust deletes memory-unsafe classes of bugs; Rust does not delete misuse. Rust’s pitch is paradoxical and powerful. Safe Rust makes entire categories of memory corruption impossible, yet exploitable systems still ship when logic, concurrency, or supply-chain decisions are wrong.  That tension is the real story. Not language wars. Risk accounting. Below is a precise map: what safe Rust kills outright, what Rust narrows, and what you must still def...")
07:3007:30, 16 November 2025 Is it possible to cause a memory leak in Rust? (hist | edit) [7,193 bytes] PC (talk | contribs) (Created page with "Short answer: yes. Rust guarantees memory safety, not “no leaks ever.” It’s entirely possible — sometimes even desirable — to leak memory on purpose. The important bit is understanding how leaks happen in Rust, why they don’t violate memory safety, and how to avoid them when you don’t want them. This post walks through the most common leak patterns — Rc cycles, std::mem::forget, Box::leak, and Box::into_raw—and shows how to design your type...")
07:2807:28, 16 November 2025 Inside the Borrow Checker: How Rust Validates Lifetimes in MIR (hist | edit) [11,386 bytes] PC (talk | contribs) (Created page with "Introduction: The Unsung Hero of Safety If Rust had a soul, it would be the borrow checker. Every time your code compiles successfully, it means this invisible guardian has run thousands of tiny logical proofs — verifying that your data isn’t being accessed after it’s dead, ensuring no two mutable borrows overlap, and making sure your program won’t corrupt memory like a wild C pointer. But here’s the fun part: The borrow checker doesn’t operate on your sour...")
07:2707:27, 16 November 2025 How to Get a Slice as an Array in Rust (Without Losing Your Mind) (hist | edit) [6,941 bytes] PC (talk | contribs) (Created page with "You have an array or slice in Rust. You know it definitely has (at least) three elements. You want a nice, clean [u8; 3] out of it. So you try this: fn pop(barry: &[u8]) -> [u8; 3] { barry[0..3] // expected array `[u8; 3]`, found slice `[u8]` } …and the compiler gently tells you: expected array [u8; 3], found slice [u8] What’s going on, and how do you fix it in a clean, idiomatic way? Let’s walk through it step by step. Slices vs Arrays: Why the Co...")
07:2507:25, 16 November 2025 How Miri Simulates Rust’s Memory Model for Undefined Behavior Detection (hist | edit) [8,144 bytes] PC (talk | contribs) (Created page with "Introduction — The Debugger That Thinks Like the Compiler Rust doesn’t let you “wing it” with memory. It’s strict, almost annoyingly so — but for good reason. You might have heard of Miri, the mysterious tool that catches undefined behavior before your program ever runs natively. But what is Miri, really? It’s not a debugger. It’s not a linter. It’s something deeper — a virtual interpreter for Rust’s mid-level intermediate representation (MIR)...")
07:2407:24, 16 November 2025 What If Rust Ran in the Browser Natively — Without WebAssembly? (hist | edit) [7,904 bytes] PC (talk | contribs) (Created page with "Introduction — The Thought Experiment No One Asked For, but We’re Doing Anyway We live in a world where Rust is already inside your browser — indirectly. Every time you load a WebAssembly module, Rust is running after being translated into a safe, sandboxed bytecode. It’s powerful, but it’s not native. Rust doesn’t speak directly to the browser. There is no rustc → Chrome, no rustc → Firefox engine, no “native Rust VM” running inside the Java...")
01:0201:02, 16 November 2025 What Is the Equivalent of the join Operator Over a Vec String in Rust? (hist | edit) [7,464 bytes] PC (talk | contribs) (Created page with "If you’re coming to Rust from languages like Python, JavaScript, or Ruby, one of the first “quality of life” things you look for is a join operation: * Python: "-".join(["Foo", "Bar"]) * JavaScript: ["Foo", "Bar"].join("-") * Ruby: ["Foo", "Bar"].join("-") So naturally you ask: “What’s the equivalent of join for a Vec<String> in Rust?” You Google a bit, maybe see something about connect, maybe run into traits, lifetimes, and &str vs String,...")
01:0101:01, 16 November 2025 Futures and Wakers Explained — The Real Async Engine Inside Rust (hist | edit) [10,560 bytes] PC (talk | contribs) (Created page with "When I first learned async programming in Rust, I made a rookie mistake. I thought async and await worked like in JavaScript — just yield, resume, done. Oh, how wrong I was. Rust’s async system is nothing like JS, Python, or Go. It has no built-in runtime, no threads magically waiting around — it’s pure state-machine wizardry. Underneath every .await, there’s an engine of Futures and Wakers quietly scheduling, polling, and waking your code — all...")
00:5900:59, 16 November 2025 Google Launches Magika 1.0: Rust-Powered AI Engine Doubles File Type Detection Capabilities (hist | edit) [5,175 bytes] PC (talk | contribs) (Created page with "Google has officially launched Magika 1.0, a production-ready AI model designed for precise file type identification. This release marks a significant advancement in automated content detection, particularly for cybersecurity applications. Announced this month, the milestone version features a core engine completely rewritten in the Rust programming language, resulting in substantial performance improvements. The system now supports over 200 distinct file formats, doubl...")
00:5800:58, 16 November 2025 Rust-cargo-docs-rag-mcp (hist | edit) [662 bytes] PC (talk | contribs) (Created page with "they say necessity is the mother of invention. github.com/promptexecution/rust-cargo-docs-rag is an mcp server that downloads rust docs, counts the tokens, provides pagination and structures the information in a way that b00t can access it. I forked this because the original MCP server was so bad .. I noticed other people have also made rust doc servers; and google has picked those up but my version is better because it is dynamic (it allows the agent to request a sp...")
00:5700:57, 16 November 2025 What Learning Rust Taught Me About My Java Code (hist | edit) [8,557 bytes] PC (talk | contribs) (Created page with "I didn’t switch teams. I switched mental models. Rust didn’t make me abandon the JVM. It made me delete a lot of Java habits that quietly cost latency, memory, and sleep. The punchline: ownership, explicitness, and resource discipline translate beautifully into modern Java (records, pattern matching, structured concurrency). And when they do, your “enterprise defaults” suddenly look… noisy. Pull Quote #1: “Rust didn’t replace Java for me; it replaced...")
00:5600:56, 16 November 2025 7 Boring Rust Sidecar Wins — Cut Memory 40% Without Rewrites (hist | edit) [8,474 bytes] PC (talk | contribs) (Created page with "A contrarian playbook for teams who prefer graphs over glory. We had the rewrite itch. You know the one. “Throw it all away, do it ‘right’ in Rust, bask in p99 bliss.” We didn’t. We shipped a Rust sidecar instead — one tight, hot-path service next to our app — and cut memory by 40%, trimmed p95, and lowered GC churn. No heroics. No year-long migration. Just a smaller heap and quieter dashboards. The thesis: full rewrites are strategy claims disguised...")
00:5300:53, 16 November 2025 Rust is King, But Java’s Project Loom Just Changed the Game (hist | edit) [15,101 bytes] PC (talk | contribs) (Created page with "So, for what feels like, I don’t know, forever in our super fast-paced software world, Rust has really been the go-to champion. Especially if you’re talking about things like system-level programming, apps where every millisecond counts, or, dare I say it, “fearless concurrency.” Developers, myself included, have totally gravitated towards it. Why? Because it promises stuff like memory safety without a garbage collector — which is, like, a huge deal — plu...")
00:5200:52, 16 November 2025 Rust, ORT, ONNX: Real-Time YOLO on a Live Webcam- Part 3 (hist | edit) [16,674 bytes] PC (talk | contribs) (Created page with "In this third part of the series, we implement the actual YOLO object detector. As a reminder, the system runs across four threads: * the camera thread reads raw frames and hands them to thread 2; * the preprocessing thread resizes frames to 640×640 and bundles them with the original image and metadata into a YoloFrame; * the YOLO detector thread (this part) runs inference and draws results; * the UI thread renders the annotated output. Below is the YOLO...")
00:5100:51, 16 November 2025 Learning Rust Part 2 — Data Layout and Enums in Practice (hist | edit) [25,451 bytes] PC (talk | contribs) (Created page with "The Learning Journey Continues! Let’s keep building our intuition for Rust’s memory model — and level up our tiny CLI app while we’re at it. Recap Last time, we learned ownership: every value in Rust has exactly one owner, and when the owner goes out of scope, the value is dropped. We saw moves, copies, borrows, and how those ideas make memory safety the language’s responsibility rather than yours. Today we’ll go one level deeper — into how data live...")
00:4900:49, 16 November 2025 Building a High-Performance Orderbook Aggregator in Rust (hist | edit) [6,808 bytes] PC (talk | contribs) (Created page with "In the fast-paced world of cryptocurrency trading, having access to accurate and consolidated orderbook data is crucial for making informed trading decisions. In this article, we will explore the architecture and implementation of a high-performance orderbook aggregator built in Rust. This system fetches, processes, and merges orderbook data from multiple cryptocurrency exchanges, providing a unified view of the market. Architecture Overview The orderbook aggregator foll...")
00:4800:48, 16 November 2025 The Pin API Explained: Why Rust’s Async Needs This Complexity (hist | edit) [6,652 bytes] PC (talk | contribs) (Created page with "I was two days into debugging a custom Future implementation when the compiler hit me with cannot be unpinned. I stared at that error for a solid thirty minutes. What did "unpinned" even mean? The future worked fine when I .awaited it directly, but the moment I tried storing it in a struct and polling it myself, everything exploded. Turns out I’d been thinking about async Rust completely wrong. The Problem Nobody Told Me About Here’s what broke: I wanted to wrap...")
00:4500:45, 16 November 2025 The White-Collar Rust Belt (hist | edit) [7,753 bytes] PC (talk | contribs) (Created page with "A good name for the phenomenon is the White-Collar Rust Belt, which, humbly, is a name I made up. I’m referring to the vast quantity of vacant office space in the tall office buildings that you see clustered in big office parks and lining the sides of freeways. When the sun glimmers off their paneled windows, they look like impressive shining monuments to the so-called service economy. You’d think the buildings are chock-full of people sitting at their desks, working...")
00:4400:44, 16 November 2025 Initialize a large, fixed-size array with non-Copy types in RUST (hist | edit) [6,605 bytes] PC (talk | contribs) (Created page with "Summary Need [Option<Box<T>>; N] without Copy or Clone? * Rust ≥ 1.79: let a: [Option<Box<T>>; N] = [const { None }; N]; * Rust ≥ 1.63: let a = std::array::from_fn(|_| None); (works with any initializer logic!) * Rust ≥ 1.38: const INIT: Option<Box<T>> = None; let a = [INIT; N]; (initializer must be a const-eval value) If you’ve ever tried to initialize a fixed-size array of a nullable, non-copyable type in Rust — say, Option<Box<Thing>>...")
00:4200:42, 16 November 2025 From JavaScript to Rust: A Web Developer’s Journey Into Systems Programming (hist | edit) [10,209 bytes] PC (talk | contribs) (Created page with "The browser console blinks at you. undefined is not a function. You fix it in thirty seconds, refresh the page, move on. That's the rhythm of JavaScript—quick feedback, instant gratification, problems that resolve with a page reload. Then you open a Rust file for the first time and everything slows down. Like, dramatically slows down. You’re not alone in feeling that whiplash. A 2024 Stack Overflow survey found that 68% of web developers who tried systems programmi...")
00:4100:41, 16 November 2025 Are Globals in Rust a Bad Idea… or a Necessary Evil? (With SQLite Examples) (hist | edit) [8,568 bytes] PC (talk | contribs) (Created page with "If you’re coming to Rust from C/C++ or scripting languages, “just make it global” can feel like the easiest way to share state — like a database handle — across a bunch of functions. Rust pushes back hard on that instinct, and for good reasons (safety, testability, concurrency). But sometimes a single, shared “thing” really is central to your program. So: Can you use globals in Rust? Yes. Should you? Usually no — but sometimes yes, if you do it the...")
00:4000:40, 16 November 2025 My Rust Server Handles 100k Concurrent Users (And Here’s the Proof): Part 2 (hist | edit) [6,807 bytes] PC (talk | contribs) (Created page with "In the previous tutorial, “Blazingly Fast Rust Server from scratch– 100k connections like it’s nothing (Part 1)”, I claimed that my Rust server can handle 100k connections, yet I provided no proof! In this article, I will discuss the tests I performed to corroborate the outrageous claim. The setup is rather empirical because, along the way of stress testing our server, we learned a lot. However, after some trial and error, we got the proof we needed — we can h...")
00:3700:37, 16 November 2025 Rust vs OCaml in 2025 — Benchmarks, Binary Sizes, and a 10-Minute Decision Tree (hist | edit) [9,730 bytes] PC (talk | contribs) (Created page with "You are choosing a language for real work. You care about speed, but you also care about sleep. You want control without turning your day into a wrestling match. This is a straight walk through Rust and OCaml in 2025 with one goal: help you ship and feel proud of the choice. No drama. No noise. Just what matters for performance, footprint, and day-to-day flow. What You’ll Walk Away With * A decision path you can follow right now * Two allocation-aware code...")
00:3500:35, 16 November 2025 Rust’s Two Kinds of mut: Binding vs. Borrow (and how to pick the right one) (hist | edit) [6,177 bytes] PC (talk | contribs) (Created page with "Rust has two places where you’ll see mut, and they mean different things: * Before a variable name (mut foo): makes the binding mutable — you can reassign it, and you can borrow it mutably. * Inside the type (&mut T): makes the reference mutable — you’re allowed to mutate the thing it points to. If you keep just that sentence in your head, 90% of the confusion goes away. Let’s unpack it with the exact signatures you saw, why the mut moves aroun...")
00:3300:33, 16 November 2025 Fine Tuning Models in PyTorch & Using ONNX for Inference in Python & Rust (hist | edit) [29,391 bytes] PC (talk | contribs) (Created page with "[1] Overview I want to mostly focus on the Inference side of things and how ONNX can be leveraged, but to get there I want to cover fine tuning a model to serve as a starting point and as a working example. Then I will dive into the specifics of how to use ONNX for inference in both rust and python, also covering how some of the pre-processing transforms can be replicated without having to rely on the transforms used in PyTorch. Here is why ONNX can be advantageous — w...")
00:3100:31, 16 November 2025 The M:N Scheduler Problem: How Rust Futures and Go Goroutines Handle Thread-Bound I/O (hist | edit) [5,684 bytes] PC (talk | contribs) (Created page with "Your p95 dies when one syscall grabs the only thread — here is how to fence it in. I watch a clean async service stall after a single DNS call blocks the wrong thread and drags p95 up by 37 percent. Futures look busy. Goroutines look plenty. The reactor has work. The scheduler does not. I need to separate real nonblocking work from code that clings to an OS thread. The fix is not magic. It is placement. When thread-bound I/O stalls everything A neat M:N runtime colla...")
00:3000:30, 16 November 2025 Best Blockchain Dev Pathway for 2026: EVM, Rust, or TON? (hist | edit) [6,070 bytes] PC (talk | contribs) (Created page with "As we move toward 2026, the blockchain development landscape is evolving rapidly. Protocols are pushing for higher throughput, richer smart-contract capabilities, deeper cross-chain integration, and tighter ties between Web3 and traditional stacks. Meanwhile, the dev tooling in 2025 has matured — offering frameworks, SDKs, infrastructure, and patterns that set the stage. For teams planning new dApps, protocols, or infrastructure through 2026, understanding where the ec...")
00:2800:28, 16 November 2025 Web3 Languages: Episode 4 — Rust, The Borrow Checker With Biceps (hist | edit) [8,366 bytes] PC (talk | contribs) (Created page with "If the first three episodes gave you the lay of the land, this one is the trail run with ankle weights and a snack break. Rust is what happens when a systems language hits the gym, reads a few chapters on type theory, and decides memory safety can be fast, actually. If you need a refresher on the bigger Web3 picture, the Web3 overview is a good place to start. Then come back, lace up, and let’s ship something fearless. What is it? Rust is a general-purpose, compiled...")
00:2400:24, 16 November 2025 Why Go Developers Are Cheering About Rust’s Secret Memory Trick (hist | edit) [11,685 bytes] PC (talk | contribs) (Created page with "Alright, so let’s just get this out of the way, right? We’ve all heard the buzz about Go and Rust. For ages now, Rust has been sitting pretty, like the cool kid in school, with its legendary speed and memory safety. No garbage collector (GC) to fuss with, mostly! Its big secret? A super smart system that tracks who “owns” what in memory, stopping bugs dead in their tracks even before your code runs. Pretty neat, huh? But, I mean, let’s be real — diving into R...")
00:2300:23, 16 November 2025 Let It Crash: 7 Erlang Lessons Every Java, Go, and Rust Engineer Should Steal in 2025 (hist | edit) [7,770 bytes] PC (talk | contribs) (Created page with "People don’t remember the sprint where you shipped five features. They remember the day nothing broke when it should have. This is a blueprint for building that kind of calm. Borrowed from Erlang. Spoken in Java, Go, and Rust. 1) Let it crash — and bounce back Stop padding every edge with ifs and try/catches. Accept that some calls will fail. Recover by restart, not by adding more glue. Why this works: a fast restart is cheaper than a slow spiral. A clean resta...")
00:2200:22, 16 November 2025 Design Patterns in Rust: Factory method, automating the factory — Code nomad (hist | edit) [3,384 bytes] PC (talk | contribs) (Created page with "Creating objects can quickly become messy and repetitive — but it doesn’t have to be. The Factory Method pattern streamlines object creation by letting specific implementations decide what to build, keeping your code clean and flexible. In this article, we’ll explore how to implement the Factory Method pattern in Rust and see how it elegantly extends the Abstract Factory approach. Introduction In this article I discussed the implementation of the Abstract Factor...")
00:2000:20, 16 November 2025 Rust’s “Borrow Checker” Explained: The One Feature That Makes You a Better Programmer (Even in Other Languages) (hist | edit) [6,312 bytes] PC (talk | contribs) (Created page with "It’s the mythical gatekeeper of the language. It’s the source of a thousand blog posts titled “Why I Quit Rust.” It’s the reason your “simple” 10-line program won’t compile, screaming at you about “lifetimes,” “moves,” and “borrows.” My first week with Rust was a masterclass in humility. I’m a senior developer. I know how to code. But the borrow checker? It felt like a hyper-pedantic, passive-aggressive pair programmer who wouldn’t approve...")
00:1800:18, 16 November 2025 Inside Cranelift IR — How Rust Code Turns Into Machine Instructions at Runtime (hist | edit) [8,423 bytes] PC (talk | contribs) (Created page with "When you write a simple Rust program like println!("Hello, world!"), you probably imagine it being compiled directly into machine code and executed natively. And you’re right — most of the time. Rust uses ahead-of-time (AOT) compilation via LLVM to generate blazing-fast binaries. But there’s a hidden world — one that sits between Rust’s source and your CPU — where things could get much more dynamic. That world is Cranelift IR: a low-level, JIT-friendly in...")
00:1700:17, 16 November 2025 Why GPU Drivers Became the New Frontline in the Rust Versus C Debate (hist | edit) [6,285 bytes] PC (talk | contribs) (Created page with "A graphics driver crash took a production laptop down for an hour and forced a rewrite in a language no one expected to see inside the kernel. That one event changed how many kernel developers now argue about safety and performance. This is not an academic fight. It is a practical argument about which mistakes will be visible at scale and which will be invisible until they ruin someone else day. The GPU driver debate exposes a wider choice. The choices will shape sta...")
00:1500:15, 16 November 2025 The Rust Patterns That Break the Moment Real Traffic Arrives (hist | edit) [7,212 bytes] PC (talk | contribs) (Created page with "A production spike proved that clever Rust abstractions can hide catastrophic costs until traffic becomes real. This is a practical article. It is for engineers who ship code and then fix what breaks. The examples are short and concrete. The diagrams are drawn with text. The code is compact and actionable. Read this like a postmortem that could save hours of firefighting. Why this matters • Abstractions solve developer pain while they work on features. • At low tr...")
00:1300:13, 16 November 2025 Rust“Wait… why is 2 ^ 10 equal to 8?” — Exponentiation in Rust (the right way) (hist | edit) [5,769 bytes] PC (talk | contribs) (Created page with "If you’ve ever typed this in Rust: assert_eq!(2 ^ 10, 8); …and felt your brain do a somersault, you’re not alone. In Rust, the caret ^ is not exponentiation — it’s bitwise XOR. That’s why 2 ^ 10 (binary 0b0010 ^ 0b1010) becomes 0b1000, a.k.a. 8. Clear? Great. Now let’s do actual exponentiation, idiomatically and safely. Rust’s ^ is the XOR operator, not power. See the language reference / operator table. The simplest way: .pow(...) on n...")
00:1200:12, 16 November 2025 3 Rust Debugging Tricks Every Developer Should Know (hist | edit) [9,089 bytes] PC (talk | contribs) (Created page with "Stop guessing. Fix the cause. Ship confident code. This article gives three surgical, practical debugging tricks for Rust projects. Each trick is short, hands on, and built so that you can use it in the next hour. Code is clear. Benchmarks are realistic examples. Diagrams are hand-drawn style using lines so the architecture remains readable in plain text. Read this as a mentor speaking over coffee. Use these techniques to find the root cause faster, to stop chasing sympt...")
00:1000:10, 16 November 2025 Beyond Threads: Unveiling the Async I/O Performance Kings — Rust Futures vs. Go Goroutines (hist | edit) [22,103 bytes] PC (talk | contribs) (Created page with "Okay, so let’s be real for a sec. In today’s crazy-fast software world, making your applications handle tons of requests without, like, totally seizing up is super important. I mean, think about it- from those lightning-quick web services we all use to processing data in real time, our apps just gotta juggle a bunch of tasks all at once. And often, they’re waiting on something external, right? Like maybe a network response or a database doing its thing. That’s...")
00:0800:08, 16 November 2025 R“Rust-analyzer failed to load workspace” in VS Code — The Fixes That Actually Work (hist | edit) [9,446 bytes] PC (talk | contribs) (Created page with "You’ve finally carved out an evening to learn Rust, you scaffold a project with cargo new, pop open VS Code, and… boom: rust-analyzer failed to load workspace: Failed to read Cargo metadata … cargo metadata exited with an error: error: could not execute process rustc -vV (never executed) Caused by: No such file or directory (os error 2) I’ve been there. This post is the piece I wish I’d had the first time rust-analyzer melted down on me. We’ll decod...")
00:0700:07, 16 November 2025 Streaming Analytics in Rust: Polars, Arrow, and Real-World Benchmarks (hist | edit) [15,207 bytes] PC (talk | contribs) (Created page with "The analytics landscape is experiencing a seismic shift. While data engineers have relied on Python’s pandas and Spark for years, a new generation of Rust-powered tools is redefining what’s possible in streaming analytics. Polars achieves more than 30x performance gains compared to pandas, while the new streaming engine shows that Polars streaming can be up to 3–7x faster than its own in-memory engine. This isn’t just about raw speed — it’s about building ana...")
00:0500:05, 16 November 2025 NASA’s Rust Adoption Journey (hist | edit) [10,359 bytes] PC (talk | contribs) (Created page with "I spent six hours fighting the borrow checker on a telemetry parser. Then I realized my entire approach was wrong. The code looked fine. Parse incoming sensor data, store it in a shared buffer, spawn threads to process different data streams. Simple concurrent design — the kind I’d written dozens of times in C++. Rust’s compiler rejected it with a wall of red text about borrowed references and mutable aliasing. I thought the compiler was being pedantic. It was actu...")
00:0400:04, 16 November 2025 Creating a Neural Network from Scratch in Rust — Part 2 (hist | edit) [6,169 bytes] PC (talk | contribs) (Created page with "In the previous article of this series, Creating a Neural Network from Scratch in Rust — Part 1, we learned more about the neurons and the perceptron model. Now we're ready to dig deeper into how neural networks learn, process, and "store" information. My goal in this post is to build up the foundation and understanding needed so that in the next articles, we can continue implementing our neural network in Rust. My goal here is not to explain all the math and details,...")
00:0200:02, 16 November 2025 I Rewrote Our Slowest Service In Rust: The Brutally Honest Before-And-After (hist | edit) [12,895 bytes] PC (talk | contribs) (Created page with "There was one box on our architecture diagrams that everyone secretly feared. Whenever a dashboard looked red, someone would say the name of that service and the whole room would go quiet. Nobody wanted to own it. Nobody wanted their sprint hijacked by it. Tickets that touched it moved through the board like a hot potato. Developers would quietly shift them away during planning, hoping nobody noticed. For a long time, I did the same. Until I realised I was spending mor...")
00:0000:00, 16 November 2025 6 Times Unsafe Rust Was Actually the Right Choice (hist | edit) [3,767 bytes] PC (talk | contribs) (Created page with "A single unsafe block once saved our payment service from collapse. It was the only way to stop latency from spiking and throughput from falling off a cliff. Unsafe is not evil. It is power wrapped in responsibility. Used with intent, it can make the impossible both safe and fast. This is a look at six real scenarios where unsafe Rust was the right call — and why. 1. Calling a Battle-Tested C Library Without Copies Problem: Rewriting a C encoder in Rust was...")

23:5823:58, 15 November 2025 Google’s 1000x Security Win: What Android’s Rust Migration Means for the Language’s Future (hist | edit) [7,943 bytes] PC (talk | contribs) (Created page with "Memory safety vulnerabilities now account for less than 20% of Android’s total vulnerabilities. Four years ago, that number was over 75%. The culprit behind this dramatic shift? Rust. Google just released their 2025 data on Rust adoption in Android, and the numbers are staggering. But here’s what makes this genuinely exciting for Rust developers: the story isn’t just about security anymore — it’s about velocity. The Numbers That Matter Let’s cut straight t...")
23:5723:57, 15 November 2025 The Rust Trick That Shrinks Bloated Code Into Clean, Elegant Logic (hist | edit) [5,878 bytes] PC (talk | contribs) (Created page with "One feature combination turned two hundred lines of fragile glue code into twenty lines of clear intent. That reduction saved time, reduced bugs, and made the code base easier to review. Clarity feels like luxury when deadlines are tight. Clarity becomes necessity when bugs hide inside layers of helpers. The Rust feature combo described here makes clarity practical and measurable. Why this matters to the reader • Less code means fewer places for errors to hide. ...")
23:5623:56, 15 November 2025 Rust’s Borrow Checker vs. Early Returns: Why Your Fallback Fails (and the One-Line Fix) (hist | edit) [4,193 bytes] PC (talk | contribs) (Created page with "If you’ve ever tried to “try this, else fall back” with a mutable reference in Rust, you may have met this villain: error[E0499]: cannot borrow `self.val` as mutable more than once at a time It often shows up with code shaped like this: struct Foo { val: i32 } impl Foo { pub fn maybe_get(&mut self) -> Option<&mut i32> { Some(&mut self.val) } pub fn definitely_get(&mut self) -> &mut i32 { if let Some(val) = self.maybe_get() {...")

16 November 2025

15 November 2025