Blog
Guides on Android development, data recovery, digital forensics, and how the hardware underneath it all actually works.
Building World Travel Tracker: An Android App Case Study
How World Travel Tracker — an Android app for tracking visited countries with a map and JSON export — was designed and built, and the decisions behind it.
Wi-Fi 7: What's Actually New, and Is It Worth Upgrading For
A practical look at what Wi-Fi 7 actually improves over previous generations, and whether it's worth upgrading your router and devices for right now.
OBS vs a Custom Solution: Why I Built Reflux
Why an existing, mature tool like OBS wasn't the right fit for a specific streaming need, and the reasoning behind building Reflux instead.
DIY Recovery vs Hiring a Specialist: When to Make the Call
A practical framework for deciding when to attempt data recovery yourself and when it's genuinely time to call a specialist instead.
What TDP Actually Means (and Why It's Not What You Think)
A clear explanation of what TDP (Thermal Design Power) actually measures, and why it's routinely misunderstood as a power consumption number.
What Is ARM Architecture, and Why Is Everyone Moving to It?
A clear explanation of ARM architecture, how it differs from traditional x86, and why Apple Silicon and other manufacturers have shifted toward it.
What Is an NPU, and Why Is It in Every New CPU?
A clear explanation of what an NPU (Neural Processing Unit) actually does, why it's become standard in new processors, and when it actually matters to you.
What Actually Happens When You Boot a Computer
A plain-language walkthrough of everything that happens between pressing the power button and reaching a usable desktop.
What Clients Actually Look At in a Developer Portfolio in 2026
What actually influences a client's decision when looking at a developer's portfolio in 2026, beyond just having polished project screenshots.
USB4 vs Thunderbolt: What's Actually Different, and Do You Need to Care
A clear explanation of the real differences between USB4 and Thunderbolt, and whether the distinction actually matters for your typical use case.
Unity vs Godot for a 2D Fighting Game: Why I Chose Unity for SAMT: All Stars
A practical comparison of Unity and Godot for building a 2D fighting game, and the reasoning behind choosing Unity for SAMT: All Stars.
Syncing Music and Gameplay with Frame-Level Precision
The technical approach to keeping music and gameplay events perfectly synchronized in a game, and why naive timer-based approaches drift over time.
Deleted Files on an SSD: Why TRIM Changes Everything
Why deleted files on an SSD are much harder to recover than on a hard drive, what TRIM actually does, and when recovery is realistically still possible.
Signs of a Dying HDD or SSD (and What to Do Before It Fails)
The warning signs that a hard drive or SSD is about to fail, and the practical steps to take while there's still time to get your data off it.
Recovering Data from a Corrupted USB Drive or SD Card
Why USB drives and SD cards corrupt more easily than internal drives, and the practical steps to recover data from one.
Ryzen 7 vs Ryzen 9: Is the Upgrade Worth the Price?
A practical look at what actually changes between Ryzen 7 and Ryzen 9 chips, and when the price jump is genuinely worth it versus wasted budget.
Room vs SharedPreferences vs DataStore: Which Storage for What
A practical comparison of Android's three main local storage options — Room, SharedPreferences, and DataStore — and when each one is actually the right choice.
Designing Rhythm Game Mechanics: Lessons from Beat the Piano
How the core mechanics of a rhythm game get designed, using Beat the Piano as a working example — timing windows, feedback, and difficulty curves.
Reverse Engineering for Vulnerability Research: What's Legal and What Isn't
The legal boundaries around using reverse engineering to find security vulnerabilities — what's clearly fine, what's clearly not, and the gray areas in between.
Recuva vs TestDisk vs PhotoRec: Free Recovery Tools Compared
A practical comparison of three free data recovery tools — what each one is actually good at, and when to reach for which one.
Reading Disassembled Code When You Haven't Written Assembly in Years
A practical refresher for reading disassembled or decompiled code without needing to relearn assembly programming from scratch.
Data Recovery After a Ransomware Attack: What's Realistic
What actually happens to files during a ransomware attack, what recovery options genuinely exist, and why paying the ransom isn't the only or first option.
Your RAID Array Failed: Can the Data Be Recovered?
What actually happens when a RAID array fails, when recovery is realistic, and the mistakes that turn a recoverable RAID failure into data loss.
RAID 0 vs RAID 1 vs RAID 5: The Simple Explanation
What RAID 0, RAID 1, and RAID 5 actually do differently — speed, redundancy, and what happens when a drive fails in each.
Quantum Computers, Explained Simply: What They Actually Do Today
A plain-language explanation of what quantum computers actually do differently from regular computers, and a realistic look at what they can genuinely do in 2026.
From Idea to a Playable Build in a Weekend
A practical approach to turning a game idea into something actually playable within a weekend, without cutting the corners that make the result meaningless.
Choosing a PC for Compiling Large Codebases
Which hardware specs actually matter for a developer machine focused on compiling large projects quickly, ranked by real-world impact.
Parserize: Finding Local Businesses Without a Website (or a Bad One)
How Parserize identifies local businesses with no website or a poor one, and the case for why that's a genuine business opportunity, not just a curiosity.
Optimizing a Video Stream for a Weak Internet Connection
Practical techniques for keeping a video stream usable over a slow or unstable internet connection, without just accepting poor quality as the only trade-off.
Optimizing a Unity Game for Weak Hardware
Practical, high-impact Unity optimization techniques for getting a game running well on lower-end hardware, in the order that actually matters.
Building an Offline-First Android App
What 'offline-first' actually means architecturally, why it's not just a checkbox feature, and the core patterns that make it work.
NVMe vs SATA SSD: When the Speed Difference Is Actually Noticeable
A practical look at when NVMe's speed advantage over SATA SSDs actually matters in day-to-day use, and when it's a spec-sheet difference you'd never notice.
Nvidia vs AMD GPUs: Comparing by Price Segment, Not Brand
Why comparing Nvidia and AMD GPUs by brand loyalty misses the point, and how to actually compare them within your real price segment.
What You Can Realistically Build as an MVP in 2 Weeks
A realistic look at what fits into a genuine 2-week MVP timeline, and the scope decisions that make that timeline achievable without cutting corners that matter.
A Developer's PC in 2026: Minimal vs Optimal Configuration
What a genuinely minimal developer setup needs versus what an optimal one adds, and where the real value-per-dollar actually falls between them.
Migrating an Existing Java Codebase to Kotlin Without Breaking Everything
A practical, incremental approach to migrating a real Java Android codebase to Kotlin without a risky full rewrite.
Malware Analysis in a Sandbox: The Basic Workflow
A safe, practical introduction to analyzing suspected malware in an isolated sandbox environment — the core workflow and the precautions that actually matter.
Mac vs Windows for Development: An Honest, Non-Tribal Take
A practical, non-tribal comparison of Mac and Windows for software development, focused on real workflow differences rather than brand loyalty.
Streaming to a Friend with Minimal Latency, Without OBS/Twitch
Why the standard OBS-to-Twitch streaming path adds latency that doesn't matter for broadcasting but matters a lot for real-time interaction, and what a lower-latency alternative looks like.
The Technical Fundamentals of Low-Latency Streaming
How low-latency video streaming actually works technically — codecs, buffering, and protocol choices, and how they trade off against each other.
Linux vs Windows for Data Recovery and Digital Forensics
A practical comparison of Linux and Windows for data recovery and digital forensics work, focused on tooling and specific workflow considerations.
Laptop vs Desktop for Developers: What Actually Matters More
A practical comparison of laptops and desktops for software development work, focused on what actually affects your day-to-day productivity.
Kotlin vs Java in 2026: What to Choose for Android
A practical comparison of Kotlin and Java for Android development in 2026 — syntax, performance, tooling, hiring, and migration.
Intel vs AMD Ryzen in 2026: What to Actually Choose
A practical Intel vs AMD Ryzen comparison for 2026 — gaming, development/compiling, power efficiency, and platform longevity.
Indie Game Development in a Team of 2-3 People: What Actually Works
Practical lessons on keeping a small indie game development team functional and avoiding the friction that sinks small projects.
From Idea to First Playtest: A Small Game's Actual Path
What actually happens between having a game idea and getting real, useful feedback from a first playtest — the steps that matter and the ones that don't.
How a VPN Actually Affects Your Speed and Security
A clear, non-marketing explanation of how a VPN actually affects internet speed and security, and what it does and doesn't protect against.
How RAM Actually Works, Explained Simply
A plain-language explanation of what RAM actually does, why it's different from storage, and why more RAM doesn't always mean a faster computer.
How Data Actually Moves from Your Disk to RAM
A clear walkthrough of what actually happens when data moves from storage into RAM, and why this step is often the real bottleneck in perceived computer speed.
What Happens Inside Your CPU When You Run a Program
A plain-language walkthrough of what actually happens inside a processor between double-clicking a program and seeing it run.
What CPU Cache (L1/L2/L3) Actually Does
A clear explanation of what L1, L2, and L3 CPU cache actually do, why they exist as separate tiers, and why cache size affects real-world performance.
Building a Hitbox/Hurtbox System for a 2D Fighting Game
How hitbox and hurtbox systems actually work in 2D fighting games, and the practical implementation details that determine whether combat feels fair.
5 Mistakes to Avoid on Your First Google Play Release
The most common, avoidable mistakes first-time Android developers make when releasing to Google Play, and how to sidestep each one.
Ghidra vs IDA Pro: Which Should You Learn First?
A practical comparison of Ghidra and IDA Pro for reverse engineering — cost, decompiler quality, and which one makes sense for a beginner.
Getting Started with Reverse Engineering in 2026
A practical starting point for reverse engineering in 2026 — the tools, the mindset, and the first exercises worth doing before touching a real target.
From Freelancing to Running Your Own Studio: A Realistic Path
What actually changes when moving from solo freelance development to running a small studio, and the decisions that matter most along the way.
Formatted a Disk by Mistake: What to Do in the First 10 Minutes
A checklist for what to do immediately after accidentally formatting a drive, and why the first few minutes matter more than the recovery tool you pick.
Digital Forensics + Software Development: An Unusual Combination That Works
Why combining digital forensics/data recovery experience with general software development is a more useful pairing than it first appears, and how the two disciplines actually reinforce each other.
What a First Technical Consulting Meeting Actually Looks Like
What actually happens in a first technical consulting conversation, and how to prepare for one whether you're the client or considering becoming a consultant.
How to Estimate the Cost of a Custom Business Tool Before Committing
A practical framework for getting a realistic cost estimate for a custom business tool before committing budget, and the questions that actually determine the number.
What a Digital Forensics Examination Actually Looks Like
A walkthrough of how a digital forensics examination of evidence actually proceeds, from intake to report, and why the process matters as much as the findings.
How Digital Forensics Finds Deleted Messages and Browser History
A plain-language explanation of how digital forensics investigators recover deleted chats, messages, and browsing history — and why 'deleted' rarely means gone.
DDR4 vs DDR5: What the Real-World Performance Difference Actually Is
A realistic look at how much DDR4 vs DDR5 RAM actually matters for real-world performance, beyond the raw bandwidth numbers on the spec sheet.
Custom Tool vs Off-the-Shelf SaaS: When a Business Actually Needs Custom
A practical framework for deciding when a business genuinely benefits from a custom-built tool instead of an existing SaaS product.
Cloud vs Local Storage: Which Is Actually Safer for Your Data
A practical comparison of cloud and local storage safety, and why the honest answer is that they protect against different risks rather than one being universally safer.
How to Choose a Tech Stack for a New Project (Without Regretting It)
A practical framework for choosing a tech stack for a new project that accounts for more than just what's currently trendy or familiar.
A Checklist Before Hiring a Developer for Your Project
The practical questions to answer and the preparation to do before hiring a developer, so the engagement starts on solid footing for both sides.
Recovering Data from a BitLocker-Encrypted Drive
What's actually possible when you need to recover data from a BitLocker-encrypted drive — and what genuinely isn't, no matter what tool you use.
Automating Repetitive Tasks with Python: A Practical Starting Point
How to identify what's worth automating and a real, working Python script example for renaming and organizing files automatically.
Designing Android Architecture So You Don't Rewrite Everything Later
The architectural decisions that actually matter early in an Android project — the ones that are expensive to change later if you get them wrong.
How Much Does It Actually Cost to Build an Android App?
A realistic breakdown of what actually drives Android app development cost, beyond the vague 'it depends' answer most estimates give.
How to Analyze an Android APK File Step by Step
A practical walkthrough of the tools and steps used to decompile and analyze an Android APK file, from unpacking to reading the decompiled source.
How AI Accelerators Are Changing CPU Architecture
How the rise of AI workloads is changing how CPUs are designed, beyond just adding an NPU as a bolt-on feature.