Series
Software Engineering Principles
Writing code is easy; engineering software that lasts is hard. This series explores the core philosophies and mental models that define professional software development. We go beyond syntax to discuss the timeless principles of modularity, abstraction, testing strategies, and technical debt management. Whether we’re discussing the Zen of Python or the rigors of formal verification, this series provides a high-level perspective on how to think like an engineer, not just a coder.
16
Articles
4h 8m
Estimated reading
Intermediate to Advanced
Knowledge level
1,037
Readers
About this series
Writing code is easy; engineering software that lasts is hard. This series explores the core philosophies and mental models that define professional software development. We go beyond syntax to discuss the timeless principles of modularity, abstraction, testing strategies, and technical debt management. Whether we’re discussing the Zen of Python or the rigors of formal verification, this series provides a high-level perspective on how to think like an engineer, not just a coder.
Series Progress
0% Complete0 of 16 articles viewed
Continue Learning
OWASP Credential Stuffing Key Terms Explained with Practical Examples
Article 1 of 16
Continue ReadingWho is this for?
Software engineers and developers learning this topic.
Knowledge Level
Intermediate to Advanced
Last Updated
Jun 18, 2026
Created by
Abstract Algorithms
All Articles
Lesson 1
FoundationOWASP Credential Stuffing Key Terms Explained with Practical Examples
TLDR: Credential-stuffing defense works only when you treat login as a layered, risk-adaptive system: detect attack shape, add step-up authentication, combine bot and fingerprint signals, prevent user
15 min read
Lesson 2
FoundationSingle Trunk Model Explained: Golden Branches, Feature Toggles, and Continuous Feature Delivery
TLDR: The single trunk model exists to reduce integration pain, shorten feedback loops, and keep one golden branch always releasable. Teams make it work with strong CI, short-lived feature branches, f
15 min read
Lesson 3
IntermediateConcurrency Models: Actor Model vs. Communicating Sequential Processes (CSP)
TLDR: Shared-memory multithreading using manual locks is notoriously difficult to scale and debug. To avoid race conditions and deadlocks, modern platforms use message-passing concurrency models. This
10 min read
Lesson 4
IntermediateUnderstanding KISS, YAGNI, and DRY: Key Software Development Principles
TLDR TLDR: KISS (Keep It Simple), YAGNI (You Aren't Gonna Need It), and DRY (Don't Repeat Yourself) are the three most universally applicable software engineering mantras. They share a common enemy:
15 min read
Lesson 5
IntermediateJava 8 to 11: Lambdas, Streams, Modules, and the End of Boilerplate
TLDR: Java 8 introduced the most impactful set of language features in Java's history — lambdas eliminated anonymous inner classes, streams replaced imperative loops, and Optional made null handling e
16 min read
Lesson 6
IntermediateSimplifying Code with the Single Responsibility Principle
TLDR TLDR: The Single Responsibility Principle says a class should have only one reason to change. If a change in DB schema AND a change in email format both require you to edit the same class, that
11 min read
Lesson 7
IntermediateDomain-Driven Design (DDD): Designing Aggregates, Value Objects, and Context Boundaries
TLDR: Domain-Driven Design (DDD) shifts the focus of software development from database schemas to core business logic. By implementing a rich domain model using Entities, Value Objects, and Aggregate
11 min read
Lesson 8
IntermediateStrategy Design Pattern: Simplifying Software Design
TLDR: The Strategy Pattern replaces giant if-else or switch blocks with a family of interchangeable algorithm classes. Each strategy is a self-contained unit that can be swapped at runtime without tou
12 min read
Lesson 9
IntermediateDependency Inversion Principle: Decoupling Your Code
TLDR TLDR: The Dependency Inversion Principle (DIP) states that high-level business logic should depend on abstractions (interfaces), not on concrete implementations (MySQL, SendGrid, etc.). This let
13 min read
Lesson 10
IntermediateHow the Open/Closed Principle Enhances Software Development
TLDR TLDR: The Open/Closed Principle (OCP) states software entities should be open for extension (add new behavior) but closed for modification (don't touch existing, tested code). This prevents new
13 min read
Lesson 11
IntermediateLiskov Substitution Principle Demystified: The Heart of Polymorphism
TLDR: The Liskov Substitution Principle (LSP) mandates that subclasses must be substitutable for their superclasses without changing the correctness of the program. It shifts our understanding of inhe
13 min read
Lesson 12
IntermediateInterface Segregation Principle: No Fat Interfaces
TLDR TLDR: The Interface Segregation Principle (ISP) states that clients should not be forced to depend on methods they don't use. Split large "fat" interfaces into smaller, role-specific ones. A Rob
14 min read
Lesson 13
IntermediateJava 8 to Java 25: How Java Evolved from Boilerplate to a Modern Language
TLDR: Java went from the most verbose mainstream language to one of the most expressive. Lambdas killed anonymous inner classes. Records killed POJOs. Virtual threads killed thread pools for I/O work.
25 min read
Lesson 14
AdvancedJava 14 to 17: Records, Sealed Classes, Text Blocks, and Pattern Matching
TLDR: Java 14–17 ran a deliberate four-release preview-to-stable conveyor belt. Records replaced 50-line POJOs with one line. Text blocks ended escape-sequence chaos in multi-line strings. Sealed clas
25 min read
Lesson 15
AdvancedAdapting to Virtual Threads for Spring Developers
TLDR: Platform threads (one OS thread per request) max out at a few hundred concurrent I/O-bound requests. Virtual threads (JDK 21+) allow millions — with zero I/O-blocking cost. Spring Boot 3.2 enabl
18 min read
Lesson 16
AdvancedJava 21 to 25: Virtual Threads, Pattern Matching, and Structured Concurrency
TLDR: Java 21 LTS makes virtual threads a production-ready replacement for bounded thread pools — your newFixedThreadPool(200) can become newVirtualThreadPerTaskExecutor() and handle 10× the concurren
22 min read
Software Engineering Principles: Learning Roadmap
You're staring at a codebase where every change breaks something else. Classes are doing five different things. Methods are 200 lines long. You copy-paste code because extracting it feels riskier than duplicating it. Your tests are brittle and your architecture is rigid.
You've heard about SOLID principles and design patterns — buzzwords that promise maintainable code — but every tutorial starts with abstract Shape hierarchies that have nothing to do with your real problems. This roadmap changes that. It starts with the pain points you recognize and gives you a clear learning path to fix them.
TLDR: This is your decision tree for learning software engineering principles — starting from your specific pain points (unmaintainable code, fragile tests, copy-paste programming) and guiding you to the exact SOLID principles and design patterns that solve them.
What You'll Learn
Understand Software Engineering Principles through real published examples
Follow a sequence of 16 articles from fundamentals to deeper topics
Connect related concepts: Security, owasp, authentication
Practice explaining trade-offs and implementation decisions
Prerequisites
FAQs
How should I read this series?
Start from the first article if you are new, or use the article list to jump into the most relevant topic.
Is progress automatic?
Progress is based on articles opened from this browser using the local learning history.