Balancing Theory and Practice: My Journey of Technical Skill Development and Book Recommendations

Computer Technology Theory and Implementation Are Both Important

Often I receive the same questions from backend readers, and after reading my "Development Inner‑Skill Cultivation" article they thought it was well written. They asked, "How do you usually hone your technical abilities and write these articles? Could you also recommend some systematic books?" So I decided to write a unified reply.

Before we start, I want to share a shallow understanding of computer technology. Unlike other disciplines, computer technology demands both theory and practice. The most useful growth method is to combine them, as Deng Xiaoping said: grasp both hands, make both strong.

If you are still a student, theory likely dominates; you need to strengthen practice by doing projects, applying what you learn, which deepens your grasp of theory.

If you are already working, you may be busy with tasks. You should pause the mechanical work, reflect on areas where your theoretical depth limits your work, dive back into theory, and then elevate your work to a higher level.

My Technical Growth Story

I belong to the working‑professional group. Besides daily coding, I rhythmically and purposefully advance my theoretical thinking. I don’t just "study"; I "think". I question seemingly obvious problems at work, spend time researching, deeply contemplate, test the theory, and finally apply it in projects.

For example, once we maintained an online Redis instance (the engineering team had no Redis platform yet). To improve performance I switched from short connections to long connections. Although performance improved, I kept thinking: all backend machines connect to this Redis, potentially creating over 6,000 concurrent connections. I wondered how many TCP connections a Linux server can handle and whether 6,000 long connections would break the server.

I dug into kernel‑related materials, searched articles online, and performed multiple practical tests until I fully understood the theory. This led to my article "Comic | How Many TCP Connections Can a Linux Server Support?" , which greatly helped my later work.

Similar deep‑thinking episodes include performance testing of backend services, exploring memory latency and bandwidth, and comparing SSD vs. HDD performance, which resulted in several articles.

All these reflections culminated in the current "Development Inner‑Skill Cultivation" series.

When you start thinking deeply about a specific problem, you often find that no single book provides a complete answer. I had to combine several books, scattered online resources, and hands‑on testing to fully understand memory latency, bandwidth, and related concepts.

This deep, theory‑plus‑practice knowledge becomes ingrained and rarely forgotten, especially in the era of abundant information where only deep thinking can organically integrate knowledge into your skill stack.

Classic Book Recommendations

Now, regarding book recommendations: although classic books may not answer every question, they are immensely valuable and worth owning, preferably in paper form for quick reference. Below is the recommended list.

"Computer Systems: A Programmer's Perspective"

This book is my favorite; I often revisit it. It is perfect for anyone who wants to understand how programs run. It covers memory hierarchy, virtual memory, page tables, and TLBs, providing deep insight into CPU caches and address translation.

"Modern Operating Systems"

A classic in operating‑system theory, covering processes, threads, memory management, file systems, I/O, deadlocks, etc. It is comprehensive but leans toward theory, making it suitable for beginners.

"TCP/IP Illustrated, Volume 1: The Protocols"

A thorough guide to TCP/IP, covering ARP, IP, TCP, UDP, and Linux network tools like ping and traceroute. Essential for developers.

"TCP/IP Illustrated, Volume 2: The Implementation"

If you want to see how the protocols are actually implemented, this volume is the follow‑up to Volume 1.

"Understanding the Linux Kernel"

Linux is open source; this book helps you navigate its source code, covering process scheduling, system calls, page cache, VFS, and Ext file systems—useful when you encounter puzzling issues at work.

"Inside Linux Network Internals"

This book complements Volume 2 of TCP/IP by covering Linux network components such as NIC registration, NAPI, interrupt handling, and soft interrupts.

"Tracing Linux TCP/IP Code Execution"

A Chinese book based on Linux 2.6 that explains socket implementation, kernel listening, and connection handling—useful when other books fall short.

Wireshark Packet Capture Tool

When you need to perform network measurements, Wireshark is indispensable. If you prefer a book, I recommend the following title.

"The Art of Performance"

This book explains how programs consume CPU, memory, disk, and network resources on servers and which tools to use for analysis—essential for backend developers and operations engineers.

Linux Kernel Source Code

Beyond books, the source code itself is the most important resource. Open the code in an IDE like VSCode to trace execution, because books target specific kernel versions while real deployments may differ.

Linux source can be downloaded from:

https://mirrors.edge.kernel.org/pub/linux/kernel/

This mirror hosts versions from 1.0 to 6.x.

Electronic Versions Download

Finally, I have collected electronic versions of the recommended books. You can download them from the following link:

Download address: https://pan.baidu.com/s/1yzSbhD96wdfYW6ncA9cN7A

Extraction code: 4uqa

Efficient Learning Method Summary

My kernel‑cultivation method does not rely on traditional exhaustive reading of classic books because work leaves little time and shallow learning rarely internalizes. My three‑step approach is:

1. Keep curiosity and discover problems

In work, even trivial details can spark deep thinking—disk usage of empty files, where file names are stored, or how many connections a server can sustain.

2. Deeply research and think about the problem

I first consult classic books, then Google and, if needed, read Linux source code to fill gaps left by the books.

3. Never skip hands‑on testing

After forming a theoretical explanation, I verify it with performance tests or custom code, iterating until the doubt is fully resolved.

In short, never ignore any seemingly insignificant question at work; investigate it deeply, think hard, and validate with practice to achieve massive personal growth.