About Me
I’m Brian Yildirim, a software engineer focused on building practical systems: clean APIs, efficient backends, and thoughtful tooling that make teams faster without adding complexity. I like small, well-crafted components that can be explained line-by-line and scaled when it counts.
Education
I study Computer Science (Information specialization) at the University of California, Irvine. My coursework blends systems, data, and software engineering so I can design end-to-end solutions— from low-level data structures and concurrency to deployable services with clean interfaces.
Expected Graduation: June 2027
Selected Coursework
- Advanced Python Programming; C/C++ as Second Languages
- Software Engineering; Requirements & Analysis Engineering
- Discrete Math; Calculus II; Linear Algebra;
- Data Structures & Algorithms; Probability & Statistics; Statistical Methods for Data Analysis
Beyond classes, I learn the most by shipping portfolio projects that force trade-offs: performance vs. simplicity, correctness vs. speed, and the “right now” vs. “right long-term.”
Skills
I’m comfortable moving between product requirements and the engineering decisions needed to ship. I value small, composable modules, explicit interfaces, and good observability.
Languages & Frameworks
- Python (FastAPI, Flask, NumPy, Pandas)
- TypeScript/JavaScript (Node.js/React/Next.js/Vite)
- C++20 (CMake, GoogleTest/Benchmark)
Data & Infra
- PostgreSQL/SQL; basic schema design & migrations
- AWS (S3, RDS/PostgreSQL, EC2); Docker; basic CI/CD
- Observability: health/metrics endpoints, structured logs
Practices
- API design with clear contracts and tests
- Performance-minded development (profiling, p95 latency awareness)
- Versioned environments; reproducible builds; documentation as code
Soft Skills
- Leadership through clarity: I break work into measurable milestones
- Communication: concise updates, decision records, and readable PRs
- Curiosity and follow-through: I like to own problems to completion, and I am eager to learn
Experience
Software Engineer Intern — Toros Tile (Fairview, NJ)
At Toros Tile, I contributed to internal tooling that simplified operations and reduced manual effort. I focused on pragmatic improvements: small services that automated repetitive tasks, scripts that turned spreadsheet processes into APIs, and dashboards that made status visible at a glance.
My approach prioritized maintainability: I wrote clear docs, added smoke tests, and instrumented services with health and metrics endpoints so issues were easy to detect. I also emphasized developer ergonomics— fast local runs, simple configuration, and reproducible builds—so changes could ship with confidence.
Projects
I build projects that teach real constraints: concurrency, persistence, observability, and clean packaging. Each project has a long-form write-up in the blog with code snippets and design notes.
Minecraft Enchantment Calculator
A web app for Minecraft users to quickly calculate optimal enchantment orders, saving experience levels. The core search is a recursive, memoized bipartition over the set (base + books). For each split, sub-solutions are merged, enforcing anvil rules in a single place (the model). Results are memoized by the multiset of inputs (as an immutable tuple), dramatically pruning identical subproblems.
C++ Rate Limiter
A tiny, fast token-bucket library with sharded maps for concurrency, Q32.32 fixed-point math for precise refills, and first-class CMake packaging. It ships with unit tests, optional Google Benchmark, and a C API for broader language access. The goal: in-process throttling without extra infra.
Image Quality Gate (FastAPI + OpenCV)
A production-ready microservice that rejects blurry or unusably dark/bright photos before they pollute datasets. Deterministic metrics (variance of Laplacian for blur, mean grayscale for brightness), environment-driven thresholds, Prometheus metrics, and Docker packaging.
Python Multithreaded TCP Server
A from-scratch TCP key-value store with a simple text protocol, reentrant locks for thread safety, and file-backed persistence (append-only log + periodic snapshot). I wrote it to internalize sockets, framing, and crash-safe writes. The blog covers message parsing, shutdown, testing, and performance metrics.
Full write-ups and source links live on the Projects blog.
What I’m Learning Now
I’m deepening my understanding of performance trade-offs and reliability patterns: benchmarking methodology, lock contention and sharding strategies, idempotent APIs, and how to design for safe retries. I’m also practicing “operational empathy”—building services with great defaults, clear logs, and simple runbooks.
On the web side, I’m refining full-stack patterns with Next.js and TypeScript: clean API boundaries, incremental static regeneration where it fits, and small utilities that keep data fetching predictable and testable.
Contact
I’m actively looking for opportunities where I can contribute to well-engineered systems and learn from experienced teammates. If you’d like to chat about internships or projects, feel free to reach out.