From Ops Soldier to DevOps General: How to Start Reading Open‑Source Code

Preface

In the era of massive data‑center scale, how can operations staff evolve from a "soldier" to a "general" and manage a whole cluster like a single host? This article introduces the essential knowledge for ops engineers to become DevOps experts by starting to read source code.

Changing Mindset

1. Embrace Change

Ops personnel should not fear reading source code. A good developer needs testing, maintainability, and rigor—qualities that ops engineers already possess. Many top internet companies have ops staff with strong development skills.

2. Plan Carefully

Reading source code is a step‑by‑step process; reading too slowly or too quickly is ineffective. Approach it with a clear plan, just like reading a book.

3. Face English

Understanding English documentation is unavoidable. The initial pain will eventually become habit.

4. Share Knowledge

Most ops engineers rarely ask questions in the community. With basic English, you can interact with global developers. Contribute not only by obtaining information but also by sharing answers and avoiding dismissive replies.

Related Knowledge Links

1. Open‑Source Communities

Every open‑source project relies on a community that provides a homepage, documentation, source acquisition, contribution guidelines, deployment architecture, and more.

Definition and description of the software

How to obtain source code or packages

How to contribute to the community

Usage and configuration documentation

Deployment architecture documentation

Development workflow for contributors

Frameworks and testing tools used by developers

Major community events

For example, the OpenStack community homepage contains all of the above.

2. Open‑Source Licenses

Understanding the licenses that govern open‑source code helps protect intellectual property and avoid legal issues.

3. Getting Source Code

Most open‑source code can be fetched from github. Learning to use git is therefore essential. A simple, step‑by‑step Git tutorial can be found at:

http://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000

4. Contributing to Communities

4.1 Contribute Documentation – Writing or translating documentation is the fastest way to give back and deepen your own understanding.

4.2 Code Review – Review source changes to help maintain quality; many projects, such as OpenStack, encourage anyone to participate in reviews.

4.3 Bug Reporting – Reporting bugs and assessing their impact is a rewarding way to contribute.

4.4 Share Cases – Sharing best‑practice cases helps you and others understand integration details.

4.5 Contribute Code – Direct code contributions require familiarity with the project's submission workflow.

4.6 Attend Conferences – Participating in community meetups or annual conferences provides insight into project direction and networking opportunities.

5. Design Patterns

Design patterns are reusable solutions to common software design problems, improving code reusability, readability, and reliability.

OpenStack, for example, heavily uses the Proxy and Factory patterns, which helps understand many functions.

6. Concurrency vs. Serial Execution

Open‑source projects may choose processes, threads, coroutines, or goroutines based on performance needs. Understanding why a particular model is chosen, its efficiency gains, and its overhead is essential.

Many high‑performance projects use asynchronous event loops (e.g., HAProxy, jQuery) to achieve speed.

7. Modularity

Modules can be functions, files, directories, or packages. Reusing mature modules and customizing where needed leads to more maintainable systems.

8. Data Structures

Complex projects like Ceph, Hadoop, and HAProxy rely on advanced data structures; mastering them is necessary to become an expert.

9. Algorithms

Algorithms such as quicksort, heap sort, binary search, and Paxos are fundamental for any programmer, including ops engineers.

Implement basic algorithms in a language you are comfortable with.

In big‑data (Hadoop) and cloud (OpenStack) contexts, simple scaling often outweighs sophisticated algorithmic research.

10. System Calls

Understanding the system calls used by open‑source software is crucial. For example, Perl's file‑open code translates to the following C prototypes:

int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);

Studying system calls like open, epoll, or namespace isolation is required to grasp Docker or HAProxy internals.