Serious developers know that code can always be improved. With each iteration, you make optimizations—small and …
Serious developers know that code can always be improved. With each iteration, you make optimizations—small and large—that can have a huge impact on your application’s speed, size, resilience, and maintainability.
In Seriously Good Software: Code that Works, Survives, and Wins, author, teacher, and Java expert Marco Faella teaches you techniques for writing better code. You’ll start with a simple application and follow it through seven careful refactorings, each designed to explore another dimension of quality.
Great code blends the skill of a programmer with the time-tested techniques and best practices embraced by the entire development community. Although each application has its own context and character, some dimensions of quality are always important. This book concentrates on seven pillars of seriously good software: speed, memory usage, reliability, readability, thread safety, generality, and elegance. The Java-based examples demonstrate techniques that apply to any OO language.
Seriously Good Software is a handbook for any professional developer serious about improving application quality. It explores fundamental dimensions of code quality by enhancing a simple implementation into a robust, professional-quality application. Questions, exercises, and Java-based examples ensure you’ll get a firm grasp of the concepts as you go. When you finish the last version of the book’s central project, you’ll be able to confidently choose the right optimizations for your code.
Part 1. Preliminaries
Chapter 1. Software qualities and a problem to solve
Chapter 1. Mostly external software qualities
Chapter 1. Mostly internal software qualities
Chapter 1. Interactions between software qualities
Chapter 1. The recurring example: A system of water containers
Chapter 1. Data model and representations
Chapter 1. Storing connections
Chapter 1. Hello containers!
Chapter 1. Method connectTo
Chapter 2. Reference implementation
Chapter 2. Memory layout diagrams
Chapter 2. Memory requirements
Chapter 2. Time complexity
Chapter 2. Applying what you learned
Part 2. Software Qualities
Chapter 3. Need for speed: Time efficiency
Chapter 3. Adding connections in constant time
Chapter 3. Delaying the updates
Chapter 3. The best balance: Union-find algorithms
Chapter 3. Connecting trees of containers
Chapter 3. Amortized time complexity
Chapter 3. Amortized analysis of resizable arrays
Chapter 3. Comparing implementations
Chapter 3. And now for something completely different
Chapter 3. Real-world use cases
Chapter 3. Summary
Chapter 4. Precious memory: Space efficiency
Chapter 4. Space and time complexity
Chapter 4. Plain arrays
Chapter 4. Forgoing objects
Chapter 4. Creating containers with a factory method
Chapter 4. Connecting containers by ID
Chapter 4. The black hole
Chapter 4. Space-time trade-offs
Chapter 4. Real-world use cases
Chapter 4. Applying what you learned
Chapter 4. Exercise
Chapter 5. Self-conscious code: Reliability through monitoring
Chapter 5. Invariants
Chapter 5. Checking contracts
Chapter 5. Designing containers by contract
Chapter 5. Containers that check their contracts
Chapter 5. Checking the contract of connectTo
Chapter 5. Containers that check their invariants
Chapter 5. And now for something completely different
Chapter 5. Real-world use cases
Chapter 5. Exercise 2
Chapter 5. Exercise 3
Chapter 6. Lie to me: Reliability through testing
Chapter 6. JUnit
Chapter 6. Testing containers
Chapter 6. Testing addWater
Chapter 6. Input coverage criteria
Chapter 6. Testing connectTo
Chapter 6. Testability
Chapter 6. And now for something completely different
Chapter 6. A test suite
Chapter 6. Real-world use cases
Chapter 6. Applying what you learned
Chapter 6. Exercise
Chapter 7. Coding aloud: Readability
Chapter 7. Structural readability features
Chapter 7. Exterior readability features
Chapter 7. Readable containers
Chapter 7. Final thoughts on readability
Chapter 7. Real-world use cases
Chapter 8. Many cooks in the kitchen: Thread safety
Chapter 8. Dealing with deadlocks
Chapter 8. Thread-safe containers
Chapter 8. Immutability
Chapter 8. The implementation
Chapter 8. And now for something completely different
Chapter 8. Applying what you learned
Chapter 9. Please recycle: Reusability
Chapter 9. The general framework
Chapter 9. Mutable collectors
Chapter 9. A generic container implementation
Chapter 9. Recovering water containers
Chapter 9. And now for something completely different
Chapter 9. Real-world use cases
Chapter 9. Exercises and further reading
Appendix A. Code golf: Succinctness
Appendix B. The ultimate water container class