Backend Engineer building systems from first principles in Go | Exploring compilers, parsers, and distributed systems

"Understanding comes from building it yourself. Frameworks are tools, but knowing what's underneath makes you dangerous."

type Engineer struct {
    Name              string
    Expertise         []string
    CurrentFocus      string
    LearningApproach  string
}

me := Engineer{
    Name:              "Uthman",
    Expertise:         []string{"Systems Programming", "Network Protocols", "Language Design"},
    CurrentFocus:      "Building Git from scratch",
    LearningApproach:  "First principles - no shortcuts",
}

I don't just use frameworks - I understand what they're abstracting. Whether it's building an HTTP server from raw TCP sockets or implementing Git's internals, I learn by reconstructing systems from the ground up. This approach has taught me more about performance optimization, protocol design, and distributed systems than any course could.

My approach is stoic: focus on what I can control. I can't control market trends or what's popular. I can control the quality of my code, the depth of my understanding, and the consistency of my effort. Everything else is noise.

Real-time messaging system with TLS encryption, AI integration, and rate limiting. Handles 100+ concurrent connections with goroutines.

Key challenges solved:

• Concurrent connection management with proper cleanup
• Real-time message broadcasting across lobbies
• AI assistant with conversation context
• Rate limiting and abuse prevention

Performance: Tested with 100+ simultaneous users, ~50MB baseline memory, minimal CPU under load.

View Project →

No frameworks. Just sockets, the HTTP spec, and Go. Built to understand networking at the protocol level.

Performance journey:

• Started at 250 RPS (buggy)
• Fixed connection handling: 1,389 RPS
• Added keep-alive optimization: 1,710 RPS
• Peak performance: 4,000 RPS
• 16x improvement from initial version

What this taught me: Connection pooling, HTTP/1.1 keep-alive, goroutine management, and how low-level implementation details impact throughput.

View Project →

Production-ready calculator with AST parser, trigonometric functions, unit conversions, and persistent history.

Technical highlights:

• Recursive descent parser with proper operator precedence
• AST construction and traversal
• Edge case handling (division by zero, factorial limits, domain errors)
• 95% test coverage

Why it matters: Understanding how parsers work is fundamental to building compilers and interpreters. This project was my entry point into language design.

View Project →

Tokenizer for building compilers, interpreters, and DSLs. Supports Unicode identifiers, multiple number formats, and JSON-based configuration.

Features:

• 50+ token types
• Single-pass tokenization with low memory allocation
• Error recovery (detects errors while continuing)
• Validated against 1700+ tokens

Use cases: Compiler frontends, configuration parsers, code analysis tools.

View Project →

PHP library supporting authenticator apps, email, and SMS verification with built-in encryption.

Integration is dead simple:

use Swift2FA\Swift2FA;
$swift2fa = new Swift2FA();

Security measures:

• Secret key encryption before storage
• TOTP-based code generation
• QR code generation for easy setup

View Project →

AI summarization tool with multiple output styles (short, detailed, objective questions, simplified explanations). Used extensively by students during exam preparation.

Technical challenges:

• UTF-8 encoding normalization
• Character corruption fixes with replacement hashmaps
• PDF text extraction and processing

Impact: Helped coursemates study for Computer-Based Tests (CBT) by generating objective questions from study materials.

Student feedback: "Brevity helped me through my exams, and I use it in my everyday life." - Olamide (Course Mate)

View Project →

I focus on what I can control:

• The quality of my code
• The depth of my understanding
• The consistency of my effort
• The problems I choose to solve

Market trends, popularity, what's "hot" right now - that's all external noise. I build systems that work, understand principles that last, and let the rest take care of itself. This mindset keeps me focused on craft over hype, fundamentals over frameworks.

Building mini-git to understand version control internals
Exploring distributed consensus algorithms
Extending Axion into a full programming language
Studying systems design patterns at scale

Languages

Databases