Framework-Free Software Engineering

Building Robust Systems Without Heavyweight Dependencies

Introduction: The Framework Question

1. What This Book Will Do
2. Who This Book Is For
3. A Note on Language Choices
4. How to Read This Book

Chapter 1: The Case for Framework-Free Development

1. What Framework-Free Actually Means
2. The Cost of Abstraction Layers
3. Control, Transparency, and Cognitive Load
4. When Frameworks Earn Their Keep

Chapter 2: A Brief History of Software Abstraction

1. From Assembly to Libraries to Frameworks
2. The Spring Revolution and Its Aftermath
3. The Rise of Microframeworks and Minimalist Languages
4. Current Trends: Back to Basics

Chapter 3: Core Architectural Principles

1. SOLID Principles Without the Buzzword Theater
2. Clean Architecture in Practice
3. Hexagonal Architecture and Port/Adapter Patterns
4. The Dependency Rule and Inversion

Chapter 4: Modular Design and Separation of Concerns

1. Defining Module Boundaries That Hold
2. Information Hiding and Encapsulation
3. Package Design Across Languages
4. Feature Modules vs Layered Modules

Chapter 5: Dependency Management Without Frameworks

1. Constructor Injection by Hand
2. Service Locators and When to Avoid Them
3. Factory Patterns for Flexible Composition
4. Wiring Up a Real Application

Chapter 6: Configuration, Environment, and Bootstrapping

1. The Twelve-Factor Approach to Configuration
2. Environment Variables, Files, and Hierarchies
3. Secrets Management Without Ceremony
4. Bootstrapping: From Zero to Ready

Chapter 7: API Design and Communication Patterns

1. RESTful APIs Built From Scratch
2. HTTP Semantics Done Right
3. Protocol Buffers and gRPC Without Magic
4. Event-Driven Communication Patterns

Chapter 8: Error Handling, Logging, and Observability

1. Error Types, Propagation, and Recovery
2. Structured Logging as a First-Class Concern
3. Metrics, Tracing, and Distributed Observability
4. Health Checks and Readiness Probes

Chapter 9: Persistence and Data Access Without ORMs

1. Why ORMs Often Fail You
2. Writing SQL That Scales
3. The Repository Pattern Implemented
4. Migrations, Connection Pooling, and Transactions

Chapter 10: Concurrency, Async Programming, and Performance

1. Concurrency Models Across Languages
2. Async/Await Without Framework Magic
3. Locks, Channels, and Lock-Free Patterns
4. Profiling and Performance Tuning

Chapter 11: Security in Minimalist Architectures

1. Authentication Without Framework Helpers
2. Authorization Models From Scratch
3. Encryption, Hashing, and Key Management
4. Input Validation and Attack Surface Reduction

Chapter 12: Testing Strategies for Framework-Free Systems

1. Why Framework-Free Code Tests Better
2. Unit Testing With Hand-Wired Dependencies
3. Integration Tests That Are Fast and Reliable
4. Property-Based Testing and Fuzzing

Chapter 13: Build, Deploy, and Operate

1. Build Tools and Dependency Resolution
2. Container Images That Are Small and Safe
3. Deployment Strategies and Rollbacks
4. Scaling Patterns and Operational Runbooks

Chapter 14: Case Studies: Real-World Framework-Free Systems

1. A High-Throughput Go API Service
2. A Rust CLI Tool at Scale
3. A Minimalist Node.js Microservice
4. Lessons From Systems That Refused the Framework

Chapter 15: Conclusion: Choosing Your Path

1. The Decision Matrix: Framework vs Framework-Free
2. Hybrid Approaches That Actually Work
3. Signs Your Framework Has Become a Prison
4. Final Thoughts on Engineering Judgment

References