0%

For new software engineers, knowing how to program is only half the battle. You'll quickly find that many of the skills and processes key to your success are not taught in any school or bootcamp. The Missing README fills in that gap -- a distillation of workplace lessons, best practices, and engineering fundamentals that the authors have taught rookie developers at top companies for more than a decade.

Early chapters explain what to expect when you begin your career at a company. The book's middle section expands your technical education, teaching you how to work with existing codebases, address and prevent technical debt, write production-grade software, manage dependencies, test effectively, do code reviews, safely deploy software, design evolvable architectures, and handle incidents when you're on-call. Additional chapters cover planning and interpersonal skills such as Agile planning, working effectively with your manager, and growing to senior levels and beyond.

You'll learn:

•How to use the legacy code change algorithm, and leave code cleaner than you found it

•How to write operable code with logging, metrics, configuration, and defensive programming

•How to write deterministic tests, submit code reviews, and give feedback on other people's code

•The technical design process, including experiments, problem definition, documentation, and collaboration

•What to do when you are on-call, and how to navigate production incidents

•Architectural techniques that make code change easier

•Agile development practices like sprint planning, stand-ups, and retrospectives

This is the book your tech lead wishes every new engineer would read before they start. By the end, you'll know what it takes to transition into the workplace -- from CS classes or bootcamps to professional software engineering.

Table of Contents

  1. Title Page
  2. Copyright
  3. Dedication
  4. About the Authors
  5. Acknowledgments
  6. Preface
  7. Chapter 1: The Journey Ahead
    1. Your Destination
    2. A Map for Your Journey
    3. Peak Newb
    4. Ramp-Up River
    5. Cape Contributor
    6. Operations Ocean
    7. Competence Cove
    8. Onward!
  8. Chapter 2: Getting to Conscious Competence
    1. Learning to Learn
    2. Front-Load Your Learning
    3. Learn by Doing
    4. Experiment with Code
    5. Read
    6. Watch Presentations
    7. Attend Meetups and Conferences (Sparingly)
    8. Shadow and Pair with Experienced Engineers
    9. Experiment with Side Projects
    10. Asking Questions
    11. Do Your Research
    12. Timebox
    13. Show Your Work
    14. Don’t Interrupt
    15. Prefer Multicast, Asynchronous Communication
    16. Batch Your Synchronous Requests
    17. Overcoming Growth Obstacles
    18. Impostor Syndrome
    19. The Dunning–Kruger Effect
    20. Do’s and Don’ts
    21. Level Up
  9. Chapter 3: Working with Code
    1. Software Entropy
    2. Technical Debt
    3. Addressing Technical Debt
    4. Changing Code
    5. Use the Legacy Code Change Algorithm
    6. Leave Code Cleaner Than You Found It
    7. Make Incremental Changes
    8. Be Pragmatic About Refactoring
    9. Use an IDE
    10. Use Version Control System Best Practices
    11. Avoiding Pitfalls
    12. Use Boring Technology
    13. Don’t Go Rogue
    14. Don’t Fork Without Committing Upstream
    15. Resist the Temptation to Rewrite
    16. Do’s and Don’ts
    17. Level Up
  10. Chapter 4: Writing Operable Code
    1. Defensive Programming
    2. Avoid Null Values
    3. Make Variables Immutable
    4. Use Type Hinting and Static Type Checking
    5. Validate Inputs
    6. Use Exceptions
    7. Be Precise with Exceptions
    8. Throw Exceptions Early, Catch Exceptions Late
    9. Retry Intelligently
    10. Write Idempotent Systems
    11. Clean Up Resources
    12. Logging
    13. Use Log Levels
    14. Keep Logs Atomic
    15. Keep Logs Fast
    16. Don’t Log Sensitive Data
    17. Metrics
    18. Use Standard Metrics Libraries
    19. Measure Everything
    20. Traces
    21. Configuration
    22. Don’t Get Creative with Configuration
    23. Log and Validate All Configuration
    24. Provide Defaults
    25. Group Related Configuration
    26. Treat Configuration as Code
    27. Keep Configuration Files Clean
    28. Don’t Edit Deployed Configuration
    29. Tools
    30. Do’s and Don’ts
    31. Level Up
  11. Chapter 5: Managing Dependencies
    1. Dependency Management Basics
    2. Semantic Versioning
    3. Transitive Dependencies
    4. Dependency Hell
    5. Avoiding Dependency Hell
    6. Isolate Dependencies
    7. Deliberately Add Dependencies
    8. Pin Versions
    9. Scope Dependencies Narrowly
    10. Protect Yourself from Circular Dependencies
    11. Do’s and Don’ts
    12. Level Up
  12. Chapter 6: Testing
    1. The Many Uses of Tests
    2. Types of Tests
    3. Test Tools
    4. Mocking Libraries
    5. Test Frameworks
    6. Code Quality Tools
    7. Writing Your Own Tests
    8. Write Clean Tests
    9. Don’t Overdo Testing
    10. Determinism in Tests
    11. Seed Random Number Generators
    12. Don’t Call Remote Systems in Unit Tests
    13. Inject Clocks
    14. Avoid Sleeps and Timeouts
    15. Close Network Sockets and File Handles
    16. Bind to Port Zero
    17. Generate Unique File and Database Paths
    18. Isolate and Clean Up Leftover Test State
    19. Don’t Depend on Test Order
    20. Do’s and Don’ts
    21. Level Up
  13. Chapter 7: Code Reviews
    1. Why Review Code?
    2. Getting Your Code Reviewed
    3. Prepare Your Review
    4. De-risk with Draft Reviews
    5. Don’t Submit Reviews to Trigger Tests
    6. Walk Through Large Code Changes
    7. Don’t Get Attached
    8. Practice Empathy, but Don’t Tolerate Rudeness
    9. Be Proactive
    10. Reviewing Code
    11. Triage Review Requests
    12. Block Off Time for Reviews
    13. Understand the Change
    14. Give Comprehensive Feedback
    15. Acknowledge the Good Stuff
    16. Distinguish Between Issues, Suggestions, and Nitpicks
    17. Don’t Rubber-Stamp Reviews
    18. Don’t Limit Yourself to Web-Based Review Tools
    19. Don’t Forget to Review Tests
    20. Drive to a Conclusion
    21. Do’s and Don’ts
    22. Level Up
  14. Chapter 8: Delivering Software
    1. Software Delivery Phases
    2. Branching Strategies
    3. Build Phase
    4. Version Packages
    5. Package Different Resources Separately
    6. Release Phase
    7. Don’t Throw Releases Over the Fence
    8. Publish Packages to a Release Repository
    9. Keep Releases Immutable
    10. Release Frequently
    11. Be Transparent About Release Schedules
    12. Publish Changelogs and Release Notes
    13. Deployment Phase
    14. Automate Deployments
    15. Make Deployments Atomic
    16. Deploy Applications Independently
    17. Rollout Phase
    18. Monitor Rollouts
    19. Ramp Up with Feature Flags
    20. Protect Code with Circuit Breakers
    21. Ramp Service Versions in Parallel
    22. Launch in Dark Mode
    23. Do’s and Don’ts
    24. Level Up
  15. Chapter 9: Going On-Call
    1. How On-Call Works
    2. Important On-Call Skills
    3. Make Yourself Available
    4. Pay Attention
    5. Prioritize Work
    6. Communicate Clearly
    7. Track Your Work
    8. Handling Incidents
    9. Triage
    10. Coordination
    11. Mitigation
    12. Resolution
    13. Follow-Up
    14. Providing Support
    15. Don’t Be a Hero
    16. Do’s and Don’ts
    17. Level Up
  16. Chapter 10: Technical Design Process
    1. The Technical Design Process Cone
    2. Thinking About Design
    3. Define the Problem
    4. Do Your Research
    5. Conduct Experiments
    6. Give It Time
    7. Writing Design Documents
    8. Document Consequential Changes
    9. Know Why You’re Writing
    10. Learn to Write
    11. Keep Design Documents Up-to-Date
    12. Using a Design Document Template
    13. Current State and Context
    14. Motivation for Change
    15. Requirements
    16. Potential Solutions
    17. Proposed Solution
    18. Design and Architecture
    19. Test Plan
    20. Rollout Plan
    21. Unresolved Questions
    22. Appendix
    23. Collaborating on Design
    24. Understand Your Team’s Design Review Process
    25. Don’t Surprise People
    26. Brainstorm with Design Discussions
    27. Contribute to Design
    28. Do’s and Don’ts
    29. Level Up
  17. Chapter 11: Creating Evolvable Architectures
    1. Understanding Complexity
    2. Design for Evolvability
    3. You Ain’t Gonna Need It
    4. Principle of Least Astonishment
    5. Encapsulate Domain Knowledge
    6. Evolvable APIs
    7. Keep APIs Small
    8. Expose Well-Defined Service APIs
    9. Keep API Changes Compatible
    10. Version APIs
    11. Evolvable Data
    12. Isolate Databases
    13. Use Schemas
    14. Automate Schema Migrations
    15. Maintain Schema Compatibility
    16. Do’s and Don’ts
    17. Level Up
  18. Chapter 12: Agile Planning
    1. The Agile Manifesto
    2. Agile Planning Frameworks
    3. Scrum
    4. User Stories
    5. Tasks
    6. Story Points
    7. Backlog Triage
    8. Sprint Planning
    9. Stand-ups
    10. Reviews
    11. Retrospectives
    12. Roadmaps
    13. Do’s and Don’ts
    14. Level Up
  19. Chapter 13: Working with Managers
    1. What Managers Do
    2. Communication, Goals, and Growth Processes
    3. 1:1s
    4. PPPs
    5. OKRs
    6. Performance Reviews
    7. Managing Up
    8. Get Feedback
    9. Give Feedback
    10. Discuss Your Goals
    11. Take Action When Things Aren’t Working
    12. Do’s and Don’ts
    13. Level Up
  20. Chapter 14: Navigating Your Career
    1. To Senior and Beyond
    2. Career Advice
    3. Be T-Shaped
    4. Participate in Engineering Programs
    5. Steer Your Promotion
    6. Change Jobs Carefully
    7. Pace Yourself
    8. Closing Thoughts
  21. Index
3.16.212.99