Hi, I’m Emilie (Em'). This document summarizes how I moved from literature and languages to systems programming with Rust, then into formal data science studies, starting almost from scratch.

Before 2025, my world was literature, linguistics, and foreign languages, not computers.
When I first saw code, it looked like a tangle of acronyms and semicolons.

Curiosity pushed me to give programming a serious try.

January/February 2025: I joined the Apple Foundation Program (AFP).
My first real encounter with code: Swift, UI/UX, Xcode, iOS apps.
Everything felt visual and concrete: constructing, testing, deploying.
Variables, loops, and functions started to make sense, like learning a new language to build things rather than only analyze them.

Most importantly, I realized I could learn to code.

After the AFP, I kept building Swift projects on my own.
Bit by bit, the basics became clearer.
One question kept coming back: What really happens behind the scenes?
What do computers do with memory and files? How do real systems work?

Timeline:

• Started Rust: October 27, 2025 (at 00:27 UTC+1 I ran my first "Hello World" in Rust)
• Shipped mini-kvstore-v2: November 21, 2025
• Released minikv (distributed): December 2025 (v0.3.0 on December 22, then v0.4.0 on December 31 with the first real admin dashboard and S3 API)
• Founded Rust Aix-Marseille (RAM): December 2025, with our first online meetup on January 14, 2026
• Started Whispem, my own programming language: January 28, 2026
• Started Data Science program at AMSE: April 2, 2026 (Aix-Marseille School of Economics)
• Released minikv v1.0.0: April 8, 2026
• Earned my DESU in Data Science at AMSE: summer 2026
• Released minikv v2.0.0: September 2026, with a reworked distributed layer

After hearing:

• “Rust is way too hard.”
• “Beware the borrow checker!”
• “It’s not for beginners.”

I had no formal tech background, but I wanted to understand how systems worked and challenge myself with low-level code.

• The compiler is strict but a true teacher: error messages are detailed, sometimes even confessional—pointing to a solution.
• Ownership and borrowing: I thought I got “ownership” from literature, but Rust forces you to internalize it.
• Everything’s explicit: Who owns what, who can change or just borrow, and for how long.
• The Rust community: Genuinely welcoming, even to beginners.

• The Rust Book: Everyone says it, because it’s true (especially Chapter 4—ownership!).
• Clippy: My favorite code reviewer, even when it stings.
• Keeping notes: Writing down every concept, compiler message, and solution helped me not get overwhelmed.
• Building side projects: Practice drives progress, including failed attempts.

• Loops, structure, types… remind me of literary analysis—except here it’s the machine that reads.
• Close reading (“is this reference mutable or immutable?”) and not skipping details—skills that transferred perfectly.
• Patience with ambiguity, digging deep until understanding—the same in both worlds.
• UI/UX taught me to design for people. Rust taught me to design for people and computers.

• You don’t need to be “technical” to start. Curiosity is the real prerequisite.
• Don’t optimize too soon: get it working, then get it right.
• Testing can’t be too early.
• Learning isn’t linear. There are setbacks and victories. Stick with it!

1. Start before you feel “ready”—you only get ready by doing.
2. Read error messages like you’d read between the lines of a text—all the clues are there.
3. Celebrate every small win—your first compiling program matters.
4. Don’t be afraid to ask for help (Discord, Reddit, Rust forums, etc.).
5. Keep it enjoyable: consistency is easier when you like the process.

Distributed Core:

• Multi-node Raft consensus: leader election with log up-to-date checks, persistent log and term, majority commit, leader step-down when the quorum is lost
• Linearizable reads on every coordinator (ReadIndex)
• Two-Phase Commit (2PC) between the leader and the volume servers: size and BLAKE3 checks at prepare, commit or rollback on every replica
• Configurable N-way replication (default: 3 replicas), with one blob per object version
• Highest Random Weight (HRW) placement across volume servers
• Automatic failover: the remaining coordinators elect a new leader within about a second
• Volume servers that register themselves through heartbeats
• Range queries and batch operations
• TLS encryption for HTTP and gRPC
• Flexible configuration: file, env, CLI override
• Admin status endpoint (/admin/status): role, term, leader, commit index, volumes
• S3-compatible API (PUT/GET/DELETE)
• Watch/subscribe system (WebSocket and SSE) for real-time key change notifications

Time Series and Vectors:

• Time-series write and query APIs for event and metric workloads
• Query-time filtering and aggregation for analytical use cases
• Vector upsert and similarity query endpoints (top-k)
• Persistent vector index on coordinator disk for restart durability

Storage Engine:

• Segmented, append-only log structure
• In-memory HashMap indexing for O(1) key lookups
• Bloom filters for fast negative queries
• Index snapshots
• CRC32 checksums on every record
• Compaction with space reclamation
• RocksDB for coordinator metadata

Security & Multi-Tenancy building blocks (implemented and tested as modules; enforcement on the HTTP API is on the roadmap):

• API Key authentication (Argon2)
• JWT token support
• Role-Based Access Control (Admin/ReadWrite/ReadOnly)
• AES-256-GCM encryption
• Per-tenant quotas (storage, objects, rate limits)
• Audit logging for admin operations

Durability:

• Write-Ahead Log (WAL) for safety
• Configurable fsync policy (always, interval, never)
• Fast crash recovery via WAL replay
• Raft log and term persisted with CRC32 checksums and fsync

APIs:

• gRPC for internal communication (Raft between coordinators, 2PC with volumes)
• HTTP REST API for clients
• CLI for put/get/delete
• WebSocket & SSE endpoints for real-time notifications

Infrastructure and Operations:

• Docker Compose setup for dev/test
• Helm chart with dev/staging/prod profiles
• GitHub Actions for CI/CD
• k6 benchmarks for real scenarios
• Distributed tracing via OpenTelemetry & Jaeger
• Prometheus metrics endpoint (/metrics) and alert rules
• Grafana dashboards for cluster visibility
• Backup and restore runbook for operations

Testing and Quality:

• End-to-end cluster test: 3 coordinators and 3 volumes, leader failover and restart
• Unit tests for Raft (votes, log conflicts, persistence), the 2PC staging, and placement
• Integration, stress, and recovery tests
• Release preflight checks (fmt, clippy, build, tests)
• All code, scripts, and docs in English

• Whispem: a programming language whose compiler is written in Whispem and recompiles itself to a fixed point, running on a standalone C VM
• learn-assembly-with-em: x86-64 assembly from a 512-byte boot sector to miniasm, a small assembler that matches NASM's output on its subset
• asm.fm: a synthesizer written in pure x86-64 assembly, from raw waveforms to FM bells and a resonant filter
• sussurro.cpp: offline neural translation (English, Spanish, French, Italian) in C++ on ggml
• dprism: a data explorer that lives in the terminal

• Learned the fundamentals of Rust: ownership, lifetimes, async/await
• Built a distributed storage engine with Raft, WAL, and 2PC
• Added API Key/JWT authentication, RBAC, quotas, and audit logging building blocks
• Implemented a real-time notification system (watch/subscribe via WebSocket and SSE) for key changes
• Added time-series APIs and vector similarity search
• Reached v1.0.0 with release engineering checks and updated documentation
• Reached v2.0.0: persistent Raft, 2PC with volume servers, linearizable reads, and an end-to-end failover test
• minikv passed 400 stars on GitHub
• Founded Rust Aix-Marseille (RAM), a Rust community open to every level
• Gave my first talk at Epitech Marseille, about my journey into tech and Rust
• minikv was featured in Programmez!, followed by a live talk at the Programmez! Meetup and a guest editorial
• Built Whispem, my own programming language
• Started a Data Science program at AMSE (Aix-Marseille School of Economics) on April 2, 2026, and earned my DESU in Data Science in summer 2026

“If you can read and express an idea, you can code. Patience, curiosity, and a love of learning are everything!”

Written by Em' (@whispem), Rust developer, learning by building, including distributed key-value systems.

"Structure determines meaning. You learn by writing and by building."