Semantic Versioning Pitfalls in Real Projects
Why Semantic Versioning feels simple until it breaks your production builds.
Back to Blog
Archive
Software Engineering
A curated collection of thoughts, tutorials, and insights related to Software Engineering.
Observability vs Monitoring: What Matters
Understanding the difference between monitoring and observability in production.
Evaluating Search Relevance the Right Way
Stop guessing if your search works. Use real metrics for better results.
Why Software Rewrites Usually Fail
Stop chasing the perfect codebase and start fixing the real problems.
Open Addressing vs Chaining: Hash Collisions
A practical guide to choosing between open addressing and chaining for hash maps.
Factorio is Software Engineering
Discover the surprising parallels between Factorio's automation and software development.
Documentation is an Engineering Problem
Treating documentation like code leads to better, more maintainable docs.
Navigating Uncertainty in Software Projects
Strategies for planning and executing software projects amidst unpredictable changes.
Tail Call Optimization Myths Busted
Separating fact from fiction on tail call optimization.
Flow Control at Scale for Developers
Managing complex application flow efficiently. Practical advice for software engineers.
Why Your Code Reviews Are Failing
Discover common pitfalls that make code reviews ineffective and how to fix them.
CS Degree vs. Software Engineering Degree
Should you get a CS or Software Engineering degree? Let's break it down.
Designing APIs Developers Actually Like
Learn how to design APIs that developers love to use.
How Kafka Stores Data Internally
A deep dive into Kafka's file storage mechanisms.
Tuning Garbage Collection for Better Performance
Learn practical strategies to tune garbage collection for your applications.
Run Effective Retrospectives That Work
Make your team's retrospectives valuable. Learn how to run productive meetings.
JavaScript Closures: A Deep Dive Explained
Understand JavaScript closures like a pro. Learn how they work under the hood.
Why I Love TypeScript for Development
A software engineer's honest take on why TypeScript enhances JavaScript development.
GDPR Compliance: What Developers Actually Need to Know
Demystifying GDPR for developers. Focus on practical steps and common pitfalls for compliance.
React Native on PS5 and Windows 11?
Exploring the surprising truth about React Native's presence on next-gen consoles and desktops.
Scrum Ceremonies: Your Team's Weekly Rhythm
Understand the core Scrum ceremonies and how they benefit your development team.
CPU Cache Hierarchies: A Developer's Guide
Understand CPU cache hierarchies and how they impact your code's performance.
Developer Experience: The Hidden Cost
Discover the real cost of poor developer experience and its impact on productivity and retention.
Critically Evaluating Open Source Projects
Learn how to pick the right open source project for your needs.
Better Code Reviews with Checklists
Stop wasting time in code reviews. Learn to build effective checklists.
Designing SDKs for Multiple Languages
Strategies for building robust SDKs that work across different programming languages.
Open Source Maintenance Realities
The unglamorous but vital work of keeping open source alive.
Load Tests Can Lie: What You're Missing
Stop trusting load tests blindly. Learn why they often mislead and how to get real insights.
Redis as a Primary Database: Is It Worth It?
Exploring the pros and cons of using Redis as your main database. A developer's perspective.
Engineering Ethics: Practical Application
Navigating ethical dilemmas in software engineering with practical advice.
Why Software Forks Happen
Understand the common reasons behind software forks in open source.
Build vs Buy: A Developer's Framework
Decide smarter: build in-house or buy off-the-shelf software. A practical guide.
Strategy Pattern in TypeScript Made Simple
Learn the Strategy Pattern in TypeScript. Flexible code, easy to implement.
Banishing Magic Numbers and Strings
Stop using magic numbers and strings. Learn why and how to fix them.
Snapshot Testing: A Trap for Developers
Why snapshot testing can be a dangerous pitfall for your codebase.
Running Chaos Experiments Safely
Learn how to run chaos experiments without causing production disasters.
Stack vs Heap: Memory Management Explained
Understand stack and heap memory allocation in programming. Essential for developers.
Why End-to-End Tests Are Brittle
Exploring the inherent fragility of end-to-end tests and why they often fail.
Kanban for Software Teams: Simple Flow
Boost your software team's productivity with Kanban. Learn its core principles and practical application.
Managing Breaking Changes Effectively
Strategies for handling breaking changes in software development.
Testable Code Through Dependency Injection
Learn how Dependency Injection makes your code easier to test and maintain.
Feature Toggles Fail in Production: Why and How
Learn why feature toggles fail in production and how to avoid common pitfalls.
Why Estimates Are Always Wrong
A straight-talking look at why software estimates fail and what to do instead.
Platform Teams vs Product Teams
Understanding the differences and synergies between platform and product teams.
User Space vs Kernel Space Explained
Understand the fundamental difference between user space and kernel space in operating systems.
API Versioning Without Breaking Users
Learn how to version your APIs effectively and keep your users happy.
Uncle Bob's Clean Code Tips
Practical tips on writing clean code inspired by Uncle Bob Martin.
Stop Fighting Timezones in Your Apps
Mastering timezone logic in software development for reliable applications.
Distributed Systems Consistency Models Explained
Demystifying consistency models in distributed systems for developers. Learn CAP theorem, eventual consistency, and more.
Logs vs Metrics vs Traces Explained
Understand the core differences between logs, metrics, and traces for better observability.
Idempotent APIs: Designing for Reliability
Learn how to design idempotent APIs. Ensure your API requests can be repeated safely without unintended side effects, improving reliability.
Embrace the Mess: When Imperfect Code is the Right Choice
As a software engineer, I've learned that 'perfect' code isn't always achievable or even desirable. Discover when accepting messy code saves time and sanity.
Pinpoint Bugs Fast: About Git Bisect
Stop guessing where bugs were introduced. Learn to use `git bisect` to efficiently find the exact commit responsible for a regression.
Explore other topics
Need to Message Me?
Let's Talk!