Genix

Backend engineer, open-source developer, and lifelong computer enthusiast from Iran — currently finishing a Bachelor's in Computer Engineering, though the real education started much earlier and never went through a syllabus.

I build systems that trade simplicity for scale, and question abstractions until they fall apart. Most of my work lives somewhere between distributed messaging, event-driven architectures, and the philosophy of arrays.

Still learning. Still breaking my own designs.

How I Got Here

Computers have been around since I was four — first as a source of curiosity and games, later as a window into how technology actually works. Long before I wrote any software, I wrote stories; at thirteen or fourteen I finished my first "book," a dinosaur story with no relation whatsoever to programming. It didn't teach me anything technical, but it left behind a habit that turned out to matter more: pursuing an idea simply because it was interesting, all the way to the end.

At nineteen, that childhood fascination with computers turned into something more deliberate. University gave me a syllabus; curiosity gave me a different, mostly self-directed one. I started a personal roadmap repository — Algorithms & Data Structures — that began as study notes and slowly became a learning journal and a map of computer science as I was discovering it, one rabbit hole at a time.

That roadmap pulled me through a wider range of languages and paradigms than any course would have assigned — Perl, Haskell, Ada, a bit of raw assembly, alongside the obvious C and C++. C and C++ in particular pulled me toward the lower layers of computing: how abstractions actually emerge from hardware, and how software ultimately talks to the machine underneath it. Most of my serious work since — CLI tools, backend frameworks, validation systems, HTTP clients, file-tree explorers, moderation services — has gravitated toward developer tooling and infrastructure, almost all of it open source.

Then a deceptively simple question showed up:

What is an array?

It looked trivial. It wasn't. Following it seriously turned a familiar programming topic into a much longer inquiry — one that runs from high-level language syntax down through memory layout, CPU caches, and transistor physics, then back up through SIMD, GPUs, and tensor cores, brushing against the foundations of quantum computation along the way. ARLIZ is the written record of that detour: an attempt to follow one simple question as far as it would go, and to understand not just how arrays are used, but what they actually are.

What I Build

I write code that solves problems—sometimes elegantly, sometimes through brute force iteration. My focus areas include:

• Event-Driven Architecture: Building systems where components communicate through events rather than direct calls. My GLAND framework embodies this philosophy.
• Data Structures: Not just using them, but understanding why they exist. ARLIZ is my attempt to document that journey from a transistor to a tensor core.
• Distributed Systems: How do we build reliable software when everything can fail? This question drives much of my research.
• Developer Tooling: From Vim configs to CLI tools, I believe good tools amplify good thinking.

Philosophy

I'm fascinated by the intersection of philosophy and computation. How do we know what we know? What makes a proof convincing? Why do abstractions work—until they don't?

Writing is thinking. That's why I write books, papers, articles, and documentation. Not to teach—to learn. Every explanation forces clarity. Every attempt to simplify reveals what I don't understand.

Systems over solutions. How components interact matters more than what they do individually. Emergence is more interesting than implementation. Architecture outlasts code.

Current Focus

• Writing ARLIZ — Three volumes tracing one question, "what is an array?", from semiconductor physics up through CPU architecture to arrays themselves and where they actually do work.
• Writing short papers — Formal, focused write-ups for questions precise enough to need a definition and a proof rather than a blog post. See papers.
• Building GLAND — An event-driven architecture for JavaScript systems. Modular, protocol-agnostic, built for scale.
• Algorithm Analysis — Deepening understanding of complexity theory and formal methods. Currently working through MATHESIS, my book on mathematical foundations.

Tools & Technologies

What I work with daily:

Get in Touch

I'm always interested in discussing systems design, algorithms, or the philosophy of software.

• Email: bitsgenix@gmail.com
• GitHub: github.com/m-mdy-m
• Dev.to: dev.to/m__mdy__m
• Medium: medium.com/@m-mdy-m