- Title Page
- Copyright
- Dedication
- About the Authors
- Acknowledgments
- Preface
- Chapter 1: The Journey Ahead
- Chapter 2: Getting to Conscious Competence
- Learning to Learn
- Front-Load Your Learning
- Learn by Doing
- Experiment with Code
- Read
- Watch Presentations
- Attend Meetups and Conferences (Sparingly)
- Shadow and Pair with Experienced Engineers
- Experiment with Side Projects
- Asking Questions
- Do Your Research
- Timebox
- Show Your Work
- Don’t Interrupt
- Prefer Multicast, Asynchronous Communication
- Batch Your Synchronous Requests
- Overcoming Growth Obstacles
- Impostor Syndrome
- The Dunning–Kruger Effect
- Do’s and Don’ts
- Level Up
- Chapter 3: Working with Code
- Software Entropy
- Technical Debt
- Addressing Technical Debt
- Changing Code
- Use the Legacy Code Change Algorithm
- Leave Code Cleaner Than You Found It
- Make Incremental Changes
- Be Pragmatic About Refactoring
- Use an IDE
- Use Version Control System Best Practices
- Avoiding Pitfalls
- Use Boring Technology
- Don’t Go Rogue
- Don’t Fork Without Committing Upstream
- Resist the Temptation to Rewrite
- Do’s and Don’ts
- Level Up
- Chapter 4: Writing Operable Code
- Defensive Programming
- Avoid Null Values
- Make Variables Immutable
- Use Type Hinting and Static Type Checking
- Validate Inputs
- Use Exceptions
- Be Precise with Exceptions
- Throw Exceptions Early, Catch Exceptions Late
- Retry Intelligently
- Write Idempotent Systems
- Clean Up Resources
- Logging
- Use Log Levels
- Keep Logs Atomic
- Keep Logs Fast
- Don’t Log Sensitive Data
- Metrics
- Use Standard Metrics Libraries
- Measure Everything
- Traces
- Configuration
- Don’t Get Creative with Configuration
- Log and Validate All Configuration
- Provide Defaults
- Group Related Configuration
- Treat Configuration as Code
- Keep Configuration Files Clean
- Don’t Edit Deployed Configuration
- Tools
- Do’s and Don’ts
- Level Up
- Chapter 5: Managing Dependencies
- Chapter 6: Testing
- The Many Uses of Tests
- Types of Tests
- Test Tools
- Mocking Libraries
- Test Frameworks
- Code Quality Tools
- Writing Your Own Tests
- Write Clean Tests
- Don’t Overdo Testing
- Determinism in Tests
- Seed Random Number Generators
- Don’t Call Remote Systems in Unit Tests
- Inject Clocks
- Avoid Sleeps and Timeouts
- Close Network Sockets and File Handles
- Bind to Port Zero
- Generate Unique File and Database Paths
- Isolate and Clean Up Leftover Test State
- Don’t Depend on Test Order
- Do’s and Don’ts
- Level Up
- Chapter 7: Code Reviews
- Why Review Code?
- Getting Your Code Reviewed
- Prepare Your Review
- De-risk with Draft Reviews
- Don’t Submit Reviews to Trigger Tests
- Walk Through Large Code Changes
- Don’t Get Attached
- Practice Empathy, but Don’t Tolerate Rudeness
- Be Proactive
- Reviewing Code
- Triage Review Requests
- Block Off Time for Reviews
- Understand the Change
- Give Comprehensive Feedback
- Acknowledge the Good Stuff
- Distinguish Between Issues, Suggestions, and Nitpicks
- Don’t Rubber-Stamp Reviews
- Don’t Limit Yourself to Web-Based Review Tools
- Don’t Forget to Review Tests
- Drive to a Conclusion
- Do’s and Don’ts
- Level Up
- Chapter 8: Delivering Software
- Software Delivery Phases
- Branching Strategies
- Build Phase
- Version Packages
- Package Different Resources Separately
- Release Phase
- Don’t Throw Releases Over the Fence
- Publish Packages to a Release Repository
- Keep Releases Immutable
- Release Frequently
- Be Transparent About Release Schedules
- Publish Changelogs and Release Notes
- Deployment Phase
- Automate Deployments
- Make Deployments Atomic
- Deploy Applications Independently
- Rollout Phase
- Monitor Rollouts
- Ramp Up with Feature Flags
- Protect Code with Circuit Breakers
- Ramp Service Versions in Parallel
- Launch in Dark Mode
- Do’s and Don’ts
- Level Up
- Chapter 9: Going On-Call
- Chapter 10: Technical Design Process
- The Technical Design Process Cone
- Thinking About Design
- Define the Problem
- Do Your Research
- Conduct Experiments
- Give It Time
- Writing Design Documents
- Document Consequential Changes
- Know Why You’re Writing
- Learn to Write
- Keep Design Documents Up-to-Date
- Using a Design Document Template
- Current State and Context
- Motivation for Change
- Requirements
- Potential Solutions
- Proposed Solution
- Design and Architecture
- Test Plan
- Rollout Plan
- Unresolved Questions
- Appendix
- Collaborating on Design
- Understand Your Team’s Design Review Process
- Don’t Surprise People
- Brainstorm with Design Discussions
- Contribute to Design
- Do’s and Don’ts
- Level Up
- Chapter 11: Creating Evolvable Architectures
- Understanding Complexity
- Design for Evolvability
- You Ain’t Gonna Need It
- Principle of Least Astonishment
- Encapsulate Domain Knowledge
- Evolvable APIs
- Keep APIs Small
- Expose Well-Defined Service APIs
- Keep API Changes Compatible
- Version APIs
- Evolvable Data
- Isolate Databases
- Use Schemas
- Automate Schema Migrations
- Maintain Schema Compatibility
- Do’s and Don’ts
- Level Up
- Chapter 12: Agile Planning
- Chapter 13: Working with Managers
- Chapter 14: Navigating Your Career
- Index
To my family. Thanks for your love and support.
Chris Riccomini
To Gita.
Dmitriy Ryaboy
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.