[Part I Premise]

CHAPTER 1 What is Software Engineering?
1.1 Time and Changes
1.2 Scalability and Efficiency
1.3 Tradeoffs and Costs
1.4 Software Engineering vs. Programming
1.5 In conclusion
1.6 Key Summary

[Part II Culture]

CHAPTER 2: Fostering Teamwork
2.1 I want to hide my code
2.2 The Myth of Genius
2.3 Hiding is harmful
2.4 It all depends on the team
2.5 In conclusion
2.6 Key Summary

CHAPTER 3 Knowledge Sharing
3.1 Obstacles to Learning
3.2 Philosophy
3.3 Laying the Board: Psychological Safety
3.4 Expanding my knowledge
3.5 Expanding Your Question: Ask the Community
3.6 Expanding Knowledge: Everyone Has Something to Teach
3.7 Expanding the organization's knowledge
3.8 Readability System: Standard Mentoring System through Code Review
3.9 In conclusion
3.10 Key Summary

CHAPTER 4: ENGINEERING FOR A FAIR SOCIETY
4.1 Prejudice is inevitable
4.2 Understanding Why Diversity Is Needed
4.3 Developing multicultural competencies
4.4 Practicing Diversity
4.5 Rejecting a One-size-fits-all Approach
4.6 Challenging Established Processes
4.7 Value vs. Outcome
4.8 Let's move forward without losing interest.
4.9 In conclusion
4.10 Key Summary

CHAPTER 5 LEADING A TEAM
5.1 Manager and Tech Lead (or both)
5.2 From Individual Contributor to Leader
5.3 Engineering Manager
5.4 Antipatterns
5.5 Correct Pattern
5.6 Unexpected Questions
5.7 Other Tips and Tricks
5.8 People are like plants
5.9 In conclusion
5.10 Key Summary

CHAPTER 6 LEADING A GROWING ORGANIZATION
6.1 Always Be Deciding
6.2 Always Be Leaving
6.3 Always Be Scaling
6.4 In conclusion
6.5 Key Summary

CHAPTER 7: MEASURING ENGINEERING PRODUCTIVITY
7.1 Why Measure Engineering Productivity?
7.2 Selection: Is it worth measuring?
7.3 GSM Framework: Selecting Meaningful Indicators to Support Goals and Signals
7.4 Goal
7.5 Signal
7.6 Metric
7.7 Validating Indicators with Data
7.8 Take Action and Track Results
7.9 In conclusion
7.10 Key Summary

[Part III Process]

CHAPTER 8 STYLE GUIDE AND RULES
8.1 Why Rules Are Needed
8.2 Creating Rules
8.3 Modifying Rules
8.4 Guidelines
8.5 Applying the Rules
8.6 In conclusion
8.7 Key Summary

CHAPTER 9 Code Review
9.1 Code Review Flow
9.2 Code Review @ Google
9.3 Benefits of Code Reviews
9.4 Code Review Best Practices
9.5 Code Review Types
9.6 In conclusion
9.7 Key Summary

CHAPTER 10 Documentation
10.1 What is documentation?
10.2 Why Documentation is Needed
10.3 Documentation is the same as the code.
10.4 Know Your Readers
10.5 Document Types
10.6 Documentation Review
10.7 Documentation Philosophy
10.8 When You Need a Technical Writer
10.9 In conclusion
10.10 Key Summary

CHAPTER 11 TEST OVERVIEW
11.1 Why Write Tests?
11.2 Designing a Test Suite
11.3 Google-scale testing
11.4 Google's Testing History
11.5 Limitations of Automated Testing
11.6 In conclusion
11.7 Key Summary

CHAPTER 12 UNIT TESTING
12.1 It must be easy to maintain.
12.2 Preventing Fragile Tests
12.3 Writing Clear Tests
12.4 Testing and Code Sharing: DAMP, Not DRY!
12.5 In conclusion
12.6 Key Summary

CHAPTER 13 TEST BAND
13.1 The Impact of Test Bands on Software Development
13.2 Test Band @ Google
13.3 Basic Concepts
13.4 Test Band Utilization Techniques
13.5 Actual Implementation
13.6 Cheating (Fake Objects)
13.7 Crushing (Stub)
13.8 Testing Interactions
13.9 In conclusion
13.10 Key Summary

CHAPTER 14 A BIG TEST
14.1 What is a larger test?
14.2 Larger Tests @ Google
14.3 Structure of a large test
14.4 Larger test types
14.5 Large Tests and Developer Workflow
14.6 In conclusion
14.7 Key Summary

CHAPTER 15 Disposal
15.1 Reasons for Discarding
15.2 Why is disposal so difficult?
15.3 Disposal Types
15.4 Disposal Process Management
15.5 In conclusion
15.6 Key Summary

[Part IV Tools]

CHAPTER 16 Version Control and Branch Management
16.1 What is version control?
16.2 Branch Management
16.3 Version Management @ Google
16.4 Monorepo (Single Repository)
16.5 The Future of Version Control
16.6 In conclusion
16.7 Key Summary

CHAPTER 17 Code Search
17.1 Code Search UI
17.2 How Google Developers Use Code Search
17.3 Why it was created as a standalone web tool
17.4 The Impact of Scale on Design
17.5 How did Google implement it?
17.6 Tradeoffs Google Chooses
17.7 In conclusion
17.8 Key Summary

CHAPTER 18 Build Systems and Build Philosophy
18.1 Purpose of the Build System
18.2 What if I don't have a build system?
18.3 Modern Build System
18.4 Handling Modules and Dependencies
18.5 In conclusion
18.6 Key Summary

CHAPTER 19 Critique: Google's Code Review Tool
19.1 Code Review Tool Principles
19.2 Code Review Flow
19.3 Step 1: Create a Change
19.4 Step 2: Request a Review
19.5 Steps 3-4: Understanding and Commenting on Changes
19.6 Step 5: Approve the Change (Score the Change)
19.7 Step 6: Commit the Changes
19.8 In conclusion
19.9 Key Summary

CHAPTER 20 Static Analysis
20.1 Characteristics of Effective Static Analysis
20.2 Key Lessons Learned from Applying Static Analysis
20.3 Tricorder: Google's Static Analysis Platform
20.4 In conclusion
20.5 Key Summary

CHAPTER 21 Dependency Management
21.1 Why Dependency Management is Difficult
21.2 Importing Dependencies
21.3 Dependency Management (in theory)
21.4 Limitations of the Significant Version
21.5 Dependency Management When Resources Are Infinite
21.6 In conclusion
21.7 Key Summary

CHAPTER 22: MAJOR CHANGES
22.1 What is a major change?
22.2 Who handles large-scale changes?
22.3 Factors that block atomic changes
22.4 Large-scale change infrastructure
22.5 Large-Scale Change Process
22.6 In conclusion
22.7 Key Summary

CHAPTER 23 Continuous Integration
23.1 What is continuous integration?
23.2 Continuous Integration @ Google
23.3 In conclusion
23.4 Key Summary

CHAPTER 24 Continuous Delivery
24.1 Continuous Delivery Idiom @ Google
24.2 Speed ​​is a Team Sport: Breaking Distribution into Manageable Pieces
24.3 Isolate and Evaluate Changes: Protecting with Feature Flags
24.4 Struggle for Agility: Equipping the Release Train
24.5 Focus on quality and users: Deploy only the features you'll use.
24.6 Return to Origin: Make Data-Based Decisions Earlier
24.7 Changing Team Culture: Establishing Distribution Disciplines
24.8 In conclusion
24.9 Key Summary

CHAPTER 25 Compute as a Service
25.1 Taming Your Compute Environment
25.2 Writing Software for Managed Compute
25.3 CaaS by Time and Scale
25.4 Choosing a Compute Service
25.5 In conclusion
25.6 Key Summary

Googler reveals engineering strategies that bring innovation to businesses.

You don't need to create another giant software engineering company called 'Google'.
However, if you don't know the vast amount of know-how Google has accumulated over the years, you'll be missing out on the software engineering knowledge that tens of thousands of engineers have honed over the past 20 years.
This is too valuable knowledge to ignore.
In this book, Google's software engineers and technical writers come together to showcase Google's unique engineering culture, processes, and tools.
Beyond simply explaining the tool's features and how to use it, it also goes into great detail about the philosophy and processes that Google's teams follow.
We'll also look at three fundamental principles software organizations should never forget when designing, writing, and maintaining code.
This book contains a variety of case studies and examples of practical techniques proven through trial and error by tens of thousands of Googlers. We hope that this book will help you gain a deeper understanding of the core of software engineering and help you grow into a great engineer.