I love reading and learning, so I’ve compiled a list of books that I really enjoyed and helped me grow.

Disclaimer: I recommend studying these books, and learning from them, not just reading. This means reading more than once, taking notes, trying out the concepts in real life, trying to link the new knowledge to the one you already have (to make learning effective).

Software Development and iOS Development

Dependency Injection in .NET by Mark Seeman

Mark Seemann’s Dependency Injection offers a thorough explanation of how to decouple software components by injecting their dependencies at runtime, enabling more flexible, testable, and maintainable code in applications.

Takeaways:

• Manual DI: Constructor, Property or Method Injection. Constructor Injection is the safest option in compiler-based languages, as the compiler won’t allow constructing an object unless its dependencies are provided.
• Service Locator anti-pattern - this is a widely used pattern which leads to high-coupling and runtime errors
• Choosing between Manual DI vs DI containers (the later should not be used in all app layers, but rather in the Composition Root only)
• Modularity and how to compose an app using modules and a Composition Root.
• Composition Root pattern = the lowest level and most concrete component, the app entry point
• How to implement cross-cutting concerns with the Decorator pattern.

Working Effectively with Legacy Code by Michael Feathers

If you’re a developer, you work with legacy code. This book highlights the value of existing, functioning code and shows how to make small adjustments to make it testable and unlock refactoring.

Takeaways:

• Legacy code = code without tests or with an unclear structure, regardeless of age
• Use the recipes in the book to make small safe changes that enable testability
• Seams = places where you can alter behavior without modifying existing code directly - essential for introducing tests and making controlled changes
• Write Characterization Tests for legacy code which enable safe refactorings
• Breaking Dependencies - see techniques for dealing with problematic dependencies (like singletons, static methods, or global variables) so that you can isolate and test the units in question. Often involves introducing interfaces or employing DI.
• Sprout Method / Class - instead of modifying an existing method or class heavily, you “sprout” a new one that safely holds new functionality

Refactoring: Improving the Design of Existing Code by Martin Fowler

Refactoring is not rewriting; it’s a methodical process of cleaning up code with recipe-like steps. Think of this as the classic “recipe book” for refactoring.

Takeaways:

• Incremental Improvements: effective refactoring happens in small, safe steps:
  • make one change at a time
  • run tests
  • and proceed only if the system remains stable.
• Code Smells indicate where to refactor - e.g. Long Method, Large Class, Primitive Obsession, Switch Statements, Divergent Change, Shotgun Surgery.
• Automated Testing Is Essential: Having robust unit and integration tests enables you to refactor with confidence—verifying that changes preserve existing functionality.
• Refactoring Preserves Behavior: The goal is to change the structure, not the functionality; if system behavior changes, that’s not a pure refactoring.
• Refactoring Improves Maintainability: Well-structured code is easier to understand, modify, and extend, ultimately saving time and effort in the long run.
• Composition Over Inheritance: Wherever appropriate, prefer using composition to extend functionality rather than complex class hierarchies; this often reduces coupling.
• Encapsulate What Varies: Identify aspects of the code that might change or expand over time and encapsulate them (e.g., through design patterns like Strategy or Decorator).
• Replace Conditionals with Polymorphism: Frequent if/else or switch statements can often be replaced with polymorphic classes or methods to simplify control flow and make code more extensible.
• Naming Matters: Consistent and meaningful names for variables, methods, and classes help communicate intent and maintain clarity.
• Continuous Refactoring Culture: Treat refactoring as an ongoing, integral part of development rather than a one-time event—this keeps code healthy over its entire lifespan.

Clean Code: A Handbook of Agile Software Craftsmanship by Robert Martin

Clean Code by Uncle Bob Martin emphasizes writing readable, maintainable, and elegant code by following core principles, best practices, and disciplined craftsmanship that leads to higher-quality software.

Takeaways:

• Readability Is Key: Code should be optimized for human comprehension first, ensuring that anyone can easily understand and modify it in the future.
• Small, Focused Functions and Classes: Methods and classes should do exactly one thing and do it well, which keeps the codebase modular, testable, and easier to maintain.
• Meaningful Names: Clear, descriptive naming for variables, functions, and classes significantly reduces confusion and improves overall readability.
• Continuous Refactoring: Regularly improving existing code keeps it clean and up to date, preventing “code rot” and complexity from creeping in over time.
• Emphasis on Testing: Testing (often through Test-Driven Development) helps catch issues early and ensures the code’s design stays simple, robust, and reliable.
• SOLID principles
• Error Handling: Handle errors gracefully and clearly. Use exceptions for exceptional conditions and provide context in error messages.
• Code comments: Favor self-explanatory code over excessive comments. Use comments sparingly to clarify complex logic rather than to explain poorly written code.
• Formatting and Consistency: Follow consistent formatting rules to help others (and your future self) navigate the code easily.
• Boy Scout Rule: Leave the camp cleaner than you found it.

iOS Unit Testing by Example: XCTest Tips and Techniques Using Swift by Jon Reid

This is a practical guide to writing maintainable and robust iOS applications through effective unit testing and test-driven development (TDD) principles, focusing on both Swift and Objective-C codebases.

Takeaways:

• TDD encourages Clean Code
• Clear test structure improves readability: use patterns like Arrange-Act-Assert (AAA) and give tests descriptive names
• Using test doubles are essential skills: mocks, stubs, fakes
• Continuous testing boosts confidence: run these locally, while you develop, after every change. Also run them as part of the CI pipelines
• Well-written, high-coverage tests serve as a safety net for refactoring, encouraging developers to improve design without fear of breaking existing functionality.

The Pragmatic Programmer: Your Journey To Mastery by Andrew Hunt and David Thomas

The Pragmatic Programmer provides practical guidance and a mindset for software developers to continually refine their craft, create robust solutions, and take ownership of all aspects of their code.

Takeaways:

• Embrace continuous learning
• Adopt a pragmatic mindset over dogmatic rules
• Focus on clean design and DRY: minimize duplication, promote reusable components, and favor simplicity to reduce complexity
• Take ownership and responsibility: Take pride in your work, own the quality of your code, and be proactive in identifying and fixing potential problems or misunderstandings.
• Refactor early and often
• Orthogonality and decoupling: Strive for independent components whose functionality does not overlap, making your system more adaptable, maintainable, and testable
• Tracer Bullets: Implement thin, end-to-end solutions to test architecture and feasibility early, guiding further development through continuous feedback
• Prototyping: Build quick, disposable implementations to explore ideas, verify assumptions, or confirm feasibility without committing to production-quality code right away
• Design by Contract: Define clear, enforceable contracts for functions, modules, or services (preconditions, postconditions, and invariants) to ensure correct behavior.
• Automation: Invest in tools that automate repetitive or error-prone tasks (testing, builds, deployment) so you can focus on high-value work.
• Coding Conventions and Standards: Maintain consistent naming, formatting, and architectural decisions to improve team collaboration and readability.
• Collaboration and Communication: Write clear documentation, engage in effective code reviews, and communicate openly with team members to address issues early and improve collective knowledge.

Leadership

Extreme Ownership by Jocko Willink

Demonstrates why taking total responsibility is the cornerstone of effective leadership (and personal growth). A fun read if you enjoy military stories.

The Dichotomy of Leadership by Jocko Willink

A follow-up to Extreme Ownership, in the same engaging style. The key message: find balance in all things.

Hal Moore on Leadership by Harold Moore

Translates battlefield lessons into practical insights on inspiring and guiding others. My main takeaway: Colonel Hal Moore used to go on a long run before making a tough decision to gain clarity.

Leaders Eat Last by Simon Sinek

Explores how creating a culture of trust and support leads to stronger, more cohesive teams.

Personal Growth

Atomic Habits by James Clear

Offers practical steps for developing small, consistent habits that grow into significant results. A cornerstone read for high performance.

Indistractable by Nir Eyal

In a world filled with distractions, this is a practical guide for regaining focus and clarity.

Tags: books

---

💬 Comments

Post comment using GitHub

Loading...