Programming

Command to test in qemu.

An easiest way — from registry.

A simple exercise — how to develop the smallest possible Hello World application.

Just notes about Epipolar Consistency of X-Ray Images

When you first see an expression like

it looks impossible to compute. The number \(9^{2018}\) is unimaginably large — far beyond what any calculator can display.

Fortunately, modular arithmetic has a wonderful property: even enormous powers often fall into small repeating cycles. Once you notice the pattern, the problem becomes surprisingly simple.

This post walks you through the reasoning step by step.

A simple exercise — how to obtain the CPU base frequency.

A simple exercise — how to obtain the CPU base frequency.

A simple exercise — how to obtain the CPU brand string using CPUID in Rust and pass it to LabVIEW.

A curated list of RustRover hotkeys that help me code faster and stay focused. This is a living collection — I’ll continue updating it as I discover new and useful shortcuts.

When iterating diagonals of a 3D array, the performance differences between LabVIEW and Rust become very noticeable. Even with a straightforward implementation, the generated machine code tells a story about what’s happening under the hood.

Rust’s borrow checker guarantees memory safety at compile time, but some rules—especially around raw pointers—are too subtle for the compiler alone. That’s where Miri comes in. In this post, we’ll walk through two tiny Rust programs: one that Miri accepts, and one that Miri flags as Undefined Behavior. The difference comes down to how Stacked Borrows tracks pointer permissions.

Modern CPUs are fast—but some instructions still hide surprising costs. One of the most misunderstood is DIV. Is 32‑bit division faster than 64‑bit? Does instruction width matter anymore on x86‑64?

To answer this properly, we need more than wall‑clock timers. We need cycle counters, instruction retirement statistics, serialization barriers, and tight control over CPU affinity.

Time to time, and especially for learning purposes, it’s useful to inspect the internal representations that the Rust compiler generates. Below are some notes on how to do that.

One of the most common early borrow‑checker surprises in Rust happens when working with String and references. Developers often expect a borrow to end at the line where it is created — but Rust extends the borrow until the last use of the reference.

Rust’s borrow checker is famously strict, but also famously precise. When something fails to compile due to borrowing rules, the compiler is not guessing — it is analyzing your code through several internal representations, especially HIR (High‑level Intermediate Representation) and MIR (Mid‑level Intermediate Representation).