How Programmers Can Take Charge of Their Career: Lessons from 20 Years in Tech

World Development Trends

The information‑technology revolution is divided into three chronological stages:

1990‑2000 (MB era) – Portal sites such as Yahoo, Sina, Sohu, NetEase; ISPs/ICPs digitizing information.

2000‑2010 (GB/UGC era) – Widespread Internet access, proliferation of digital devices, user‑generated content and social networking.

2010‑2020 (TB era) – Mobile Internet dominates; smartphones keep users constantly online, generating massive data that is digitized and modeled.

Hardware and software evolve to handle larger data volumes, leading to distributed architectures and eventually edge computing. From a business perspective, digitization enables copying, computation, mathematical modeling, automation and scaling, which together reshape entire industries. The author concludes that technology evolution follows the pattern of automation plus scaling, reducing cost and increasing efficiency.

Talent Demand

Technicians – Operate machines and write code; vulnerable to automation and may become obsolete as technical thresholds lower.

Specialists – Understand underlying principles and solve difficult, domain‑specific problems; less likely to be replaced because they master the fundamentals.

Engineers – Not only use technology but also improve code readability, extensibility, maintainability and reuse; produce reusable tools and methods.

Designers & Architects – Build frameworks, patterns and tools that lower technical barriers, improve performance, stability and user experience, thereby reducing cost and increasing efficiency.

Managers – Organize teams, deliver projects and create profit; act as the “glue” in larger organizations.

Google SRE Scorecard

0 – Unfamiliar with the technology domain
1 – Can read basic material in the domain
2 – Can make small changes, understand basic principles, and find details with simple guidance
3 – Basic mastery; no help needed
4 – Very comfortable; can handle all routine work
5 – Deep, low‑level understanding and skills
6 – Can develop large‑scale programs and systems from scratch, design and deploy large distributed architectures
7 – Can leverage advanced techniques to automate extensive system management and operations
8 – Deep expertise in obscure protocols or system internals; can design, deploy and own critical large‑scale infrastructure and automation
9 – Can author a classic book in the field and work with standards bodies
10 – Recognized industry expert, author of a seminal book, possibly the inventor of the technology

Self‑evaluation items listed in the scorecard include:

– TCP/IP Networking (OSI stack, DNS, etc.)
– Unix/Linux internals
– Unix/Linux systems administration
– Algorithms and data structures
– C/C++
– Python
– Java
– Perl
– Go
– Shell scripting (sh, Bash, ksh, csh)
– SQL and/or database administration
– Additional scripting language of choice
– People management
– Project management

Self‑Assessment Method

Strengths – Identify personal abilities that outperform peers; these guide where unique value can be added.

Interests – If strengths are unclear, focus on activities that persist despite difficulty; sustained passion indicates a viable direction.

Methods – When neither strength nor interest is evident, adopt disciplined learning habits: plan, summarize mistakes, seek answers independently, and develop personal problem‑solving routines.

Diligence – As a last resort, rely on hard work; however, diligence alone loses value over time as younger, more diligent workers emerge.

Foundational Knowledge

Mastering stable underlying principles enables rapid adaptation to new languages or frameworks. The author groups core foundations into four categories:

Programming Languages – Language semantics, standard libraries, concurrency, asynchronous patterns, design patterns.

System Principles – Operating‑system concepts, networking protocols, database theory.

Middleware – Message queues, caching systems, gateways, schedulers.

Theoretical Knowledge – Algorithms, data structures, database normalization, OSI model, distributed‑system concepts.

University curricula often omit many of these topics, requiring engineers to self‑study for four to five years to acquire the full set.

Learning Efficiency

The author emphasizes active learning (discussion, practice, teaching) over passive consumption (listening, reading). Six concrete practices are recommended:

Select primary knowledge sources – Prefer first‑hand, English‑language material; avoid second‑hand summaries that lose detail.

Focus on principles – Understanding fundamentals enables skill transfer across languages (e.g., C/C++ to Java or Go).

Build knowledge graphs – Structure concepts hierarchically (e.g., TCP state diagram → reliability mechanisms → congestion control) to navigate related topics efficiently.

Practice analogical reasoning – Learn the same topic via multiple methods (reading, coding, debugging) to reinforce understanding.

Summarize and abstract – Create personal frameworks and patterns that survive language changes.

Practice consistently – Repetition turns knowledge into skill; disciplined practice is essential for long‑term growth.