The Archaeology of a dead .OVA
"It should be easy to download." Famous last words. The Premise There exists (or existed) a certain .ova file. .ova is a packaged VM - all in one file It contains .ovf metadata (xml like describing the specs, ram, cpu...), .vdmk file(s) (created by VMWare -> contains OS, other files..) Widely used Popular in a very specific niche Distributed officially at some point Then… quietly erased from existence No announcement. No archive. Just... gone. Like it never happened. Phase 1 - Denial Naturally, I assumed: "I'll just Google it." So I searched: Copy "specific ova file name" download Results: tutorials from 2017 broken official links forum threads ending in silence Classic. Phase 2 - Automation (aka coping) At this point, I did what any reasonable person would do: wrote a…
defaultDesigning a Column-Major Matrix Class with Row-Major Multiplication Optimizations (CPU & GPU)
When I designed my C++ Matrix<T> class for Fulgurance, I deliberately chose a column-major memory layout (Fortran/Eigen style). It fits linear algebra conventions elegantly: columns are contiguous, column vectors are natural, and transposition and determinant routines fall into place. But for heavy multiplications, CPU caches love row-major traversal. This article explains the architecture, shows why/how I compute multiplications using a row-major access pattern (while keeping column-major storage), and finishes with a GPU benchmark using cuBLAS to show how performance scales on modern hardware. 1) Column-Major Storage in a 1D Vector The matrix is stored as a flat 1D vector in column-major order. Element (i, j) (row i, column j) lives at index: Copy index = j * nrow + i Example, for the matrix Copy 1 4 7 2 5…
defaultRebuilding the LU Decomposition and Benchmarking It Against My Own Determinant Algorithms
When I first started playing with determinant algorithms in C++, I wanted to really understand what happens behind Eigen’s .determinant() call. So I decided to reimplement the LU decomposition from scratch — the same method used inside Eigen and LAPACK — and compare it with two determinant algorithms I built myself: A recursive Laplace expansion A non-recursive Laplace expansion (my own invention 💡) But to make benchmarking clean and efficient, I represented matrices as 1D flat vectors in row-major order, so that values in the same row are contiguous in memory — perfect for cache-friendly computations. Here’s the full story, the math, and the code. 1. From Laplace to LU Laplace’s expansion expresses the determinant as a recursive cofactor expansion: $$ \det(A) = \sum_{j=0}^{n-1} (-1)^j a_{0j} \det(M_{0j}) $$ It’s beautiful,…
defaultBuilding a New Determinant Engine - An Iterative Combinatorial Approach
One morning, I decided to compute a determinant from scratch — no recursion, no Gaussian elimination, no library shortcuts. I wanted to understand what really happens behind the determinant and see if it could be expressed as a purely iterative combinatorial process. That exploration became part of my C++ library Fulgurance — a framework for statistics, linear algebra, and data manipulation. Idea: an iterative cofactor traversal (flattening the tree) In the classic Laplace expansion, computing a determinant means recursively removing one row and one column until you reach 2×2 minors. Each recursive branch corresponds to a combination of column indices — but recursion itself isn’t fundamental. The determinant can be computed iteratively by: Enumerating the valid column subsets directly, Computing the sign via permutation parity (number of inversions), Multiplying the…
defaultExploring the Power of Metaprogramming in Rust
Metaprogramming in Rust: Exploring macro_rules! Power Rust offers one of the most expressive and hygienic metaprogramming systems in modern languages. Through declarative macros ( macro_rules!), we can generate functions, handle code repetition, and even emulate control-flow constructs — all at compile time. In this article, we’ll explore Rust metaprogramming from basic macro pattern matching to complex variadic patterns and custom control structures — step by step, with working examples. 1. Macro Pattern Matching and Expression Types Copy macro_rules! macr { () => { println!("Check out my macro!"); }; ($name:ident) => { println!("Hello, {}!", stringify!($name)); }; ($val:expr, $val2:expr) => { println!("2: {}, {}", $val, $val2); }; ($val:expr) => { println!("3: {}", $val); }; } fn main() { macr!(); macr!(7777); macr!(7777, 8888); macr!(Alice); } Output Copy Check out my macro! 3: 7777…
default📊 Building a Flexible Access Log Analyzer in R
In this tutorial, we’ll walk through the design and implementation of a small but powerful R script that analyzes web server access logs — for instance, NGINX or Apache logs — and produces clean, insightful PDF plots of your website’s traffic patterns. This project demonstrates how to combine dplyr, lubridate, ggplot2, readr, and optparse to build a command-line data analysis tool in R. repo 🧰 Overview The script accepts an access log file, parses and filters it according to date range, regex patterns, and time interval, and then generates a PDF plot summarizing the number of requests per page over time. Example usage: Copy Rscript convert.R \ -l 60 \ -p '^/$--^/all_posts/.*$--^/post_search/0$' \ -i h \ -f access.log This example analyzes the last 60 hours of requests for three URL…
defaultThe Goldbach Conjecture and Its Recursive Implementation in Haskell
The Goldbach Conjecture is one of the oldest unsolved problems in mathematics. It states that every even integer greater than 2 can be expressed as the sum of two prime numbers. While no formal proof has been found, the conjecture has been verified by computers for very large numbers. In this post, we’ll explore how to express this idea recursively in Haskell — using an elegant search through the space of prime pairs. 1. Restating the problem For any even number x > 2, find two primes p1 and p2 such that: Copy p1 + p2 = x For example: 4 = 2 + 2 6 = 3 + 3 10 = 5 + 5 or 7 + 3 The challenge is to find such a pair efficiently — and…
defaultReimplementing diff in C++: A Minimalist Approach
Why Rebuild Something That Already Exists? The diff command is one of the cornerstones of the GNU/Linux ecosystem. It’s simple in appearance, yet behind the scenes it powers version control, code reviews, and collaborative software development. I wanted to reimplement diff myself — not because the world needs another diff tool, but because it’s a great exercise in understanding how file comparison works at a low level. Writing it from scratch in C++ forced me to think about edge cases, data handling, and performance, even for what seems like a “trivial” utility. Defining the Scope The real diff command is sophisticated. It can produce unified diffs, context diffs, side-by-side comparisons, and even patch-friendly outputs. My goal wasn’t to replicate all of that. Instead, I set out to create a minimalist…
defaultAutomatic Documentation for Any Codebase
When working with R, I loved how Roxygen lets you generate clean documentation directly from comments in your source code. But I often wished there was something similar for every language, not just R. That’s why I built simple_doc: a lightweight documentation tool that works on any codebase. The Idea Instead of maintaining separate README files, wiki pages, or doc websites, you can write structured comments directly in your code. simple_doc then parses those comments and generates clean, human-readable documentation automatically. How It Works In your code, you add special annotations (inspired by Roxygen style): Copy // @T dcauchy // @U std::vector<double> dcauchy(std::vector<double> // @U &x, double location = 0, double scale = 1) // @D Returns the probability distribution of the Cauchy distribution. // @A x : vector of…
defaultImplementing DataFrames in C++: A Custom Approach for High-Performance Data Manipulation
Introduction When working with data, Python and Pandas dominate the landscape. They provide an intuitive way to load, transform, and analyze datasets. But what if you need the same capabilities inside a C++ pipeline, without switching languages, and with full control over memory and type safety? That’s the motivation behind Tablo, my implementation of DataFrames in modern C++. This project provides a flexible and performant way to manipulate tabular data directly in C++ — including CSV parsing, type inference, missing value handling, and column/row operations. In this article, I’ll walk you through the architecture, features, and next steps of this implementation. Architecture Overview The core idea of this project is simple: Each column of the DataFrame is stored as a std::vector<T>, where T is the inferred type of the column.…
defaultEditing My YouTube Videos the Weird Way: With Nothing but ffmpeg
Most people edit their YouTube videos with slick GUIs: Premiere, DaVinci Resolve, Final Cut Pro, even OBS + Shotcut for the open-source crowd. Me? I’m allergic to timelines and mouse-dragging. I prefer to edit in the most brutalist way possible: directly from the terminal, using nothing but ffmpeg. Yes, I’m basically editing like a robot with a text editor and command lines. It’s unusual, it’s nerdy, but it works. Let me walk you through my strange ritual. Step 1 — Recording the Chaos I start by summoning ffmpeg to record my microphone and my screen at the same time. One incantation later: Copy $ ffmpeg \ -f pulse -i alsa_input.usb-JMDZ_MICROPHONE_WOODBRASS_UM1_20211207-00.mono-fallback \ -f x11grab -s 1920x1080 -i :0.0 -f pulse tells ffmpeg to grab audio through PulseAudio, my sound system on…
defaultImplement Core Operations
I have just finished developing a library for manipulating numbers so large and/or precise that no conventional datatype can encode them. You can find this library there: repo Or download on this website as zip: zip -Ok so if even a long unsigned int, double... can't represent my number, how do I? I'm not going to use vecteur, see a deque? In fact, if one is obliged, but it requires the complete reimplementation from zero of the fundamental operators ( +, -, *, /, %%, !, exp(x), log(x)...) taking into account the data structure with which we work. Addition For example, we do the addition and then we can do the multiplication and division. Example "12" * "0.4" = "12" + "12" + "12" + "12" then we moove the…
