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.0on December 22, thenv0.4.0on December 31 with the first real admin dashboard and S3 API) - Started Data Science program at AMSE: April 2, 2026 (Aix-Marseille School of Economics)
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!
- Start before you feel “ready”—you only get ready by doing.
- Read error messages like you’d read between the lines of a text—all the clues are there.
- Celebrate every small win—your first compiling program matters.
- Don’t be afraid to ask for help (Discord, Reddit, Rust forums, etc.).
- Keep it enjoyable: consistency is easier when you like the process.
Distributed Core:
- Multi-node Raft consensus (leader election, log replication, snapshots, recovery, partition detection)
- Advanced Two-Phase Commit (2PC) for distributed writes: chunked transfers, error handling, retries, timeouts
- Configurable N-way replication (default: 3 replicas)
- High Random Weight (HRW) placement for even distribution
- 256 virtual shards for horizontal scaling
- Automatic cluster rebalancing (load detection, blob migration, metadata updates)
- Range queries (efficient key scans)
- Batch operations API (multi-put/get/delete)
- TLS encryption for HTTP and gRPC
- Flexible configuration: file, env, CLI override
- Admin dashboard endpoint (
/admin/status) for cluster monitoring - S3-compatible API (PUT/GET, in-memory and persistent backends)
- 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
- Instant index snapshots (5ms restarts)
- CRC32 checksums on every record
- Automatic background compaction and space reclamation
- Persistent storage backends: RocksDB, Sled, in-memory (configurable)
Security & Multi-Tenancy:
- API Key authentication (Argon2)
- JWT token support
- Role-Based Access Control (Admin/ReadWrite/ReadOnly)
- Multi-tenant data isolation
- AES-256-GCM encryption at rest
- Per-tenant quotas (storage, objects, rate limits)
- Audit logging for all admin and data modification events
Durability:
- Write-Ahead Log (WAL) for safety
- Configurable fsync policy (always, interval, never)
- Fast crash recovery via WAL replay
APIs:
- gRPC for internal communication (coordinator <-> volume)
- HTTP REST API for clients
- CLI for cluster ops (verify, repair, compact, rebalance, batch, range)
- 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:
- Integration, stress, and recovery tests
- Release preflight checks (fmt, clippy, build, tests)
- All code, scripts, and docs in English
- 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
- Implemented a real-time notification system (watch/subscribe via WebSocket and SSE) for key changes
- Integrated persistent storage backends (RocksDB, Sled)
- Added time-series APIs and vector similarity search
- Reached v1.0.0 with release engineering checks and updated documentation
- Started a Data Science program at AMSE (Aix-Marseille School of Economics) on April 2, 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 beginner, learning by building, including distributed key-value systems.
"Structure determines meaning. You learn by writing and by building."