Programming Beginner's Guide - Cryptocurrency Exchange Platform

Programming Introduction Guide

Preface

Today, programming has become an increasingly essential “skill”: as a designer, knowing some programming can help you better understand your work; as an entrepreneur, being a technical founder makes many tasks easier. For beginners just starting out, faced with a vast amount of information, you may not even know where to begin; after easily passing through basic materials, you find learning becomes more difficult, and the steep learning curve discourages you. You know how to print some text on the page, but you don’t know when to undertake a truly useful project; you are unaware of what else you don’t know, and you can’t even figure out what to learn next.

This article will not only provide some directional advice but also include a fundamental core programming introduction. Of course, a step-by-step route is unrealistic, and everyone has their own characteristics, so this beginner’s guide is more about sparking your thinking and ultimately helping you develop a learning path suited to yourself.

But note: this article is written for those who genuinely want to learn programming—those who are determined to create something real, who won’t give up until they master it; not for those who just “heard that programming is fun.” In my view, such people will never truly get into programming, let alone produce something decent.

Although the tone of the entire article is based on the so-called “Strong Opinions, Weakly Held,” readers should remain skeptical of everything we write, just as they would doubt everything around them. If you have any questions, feel free to discuss openly.

Mindset Adjustment

Set Your Goals

Before you start learning programming, think about your goals. Having a clear ultimate goal will make your path much clearer. So, what do you want to build? A website? A game? An iOS or Android app? Or do you want to automate boring tasks to have more time to enjoy the scenery outside the window? Maybe you just want to improve your employability and find a good job. All these are valuable goals, and they are part of what drives your learning of programming. Without motivation, it’s impossible to go far on the often monotonous long journey of learning.

This video might inspire you: “Most Schools Don’t Teach This”

Don’t Be Impatient

Bad programming is easy. Even Dummies can learn it in 21 days. Good programming requires thought, but everyone can do it and experience the extreme satisfaction that comes with it. Bad programming is easy. Even Dummies can learn it in 21 days. Good programming requires thought, but everyone can do it and experience the extreme satisfaction that comes with it.

Whether in physical bookstores or online, many books are titled “Learn X in 21 Days,” promising to teach you relevant skills in a short time. Matthias Felleisen explicitly pointed out this “quick fix” trend and satirized it in his book How to Design Programs.

There are no shortcuts or “silver bullets.” Wise words say that mastering something takes 10 years or 10,000 hours—like the Chinese saying “磨刀不误砍柴工” (“Sharpening the axe won’t delay chopping wood”). So, don’t rush; effort will pay off.

Cultivate Interest

Most good programmers do programming not because they expect to get paid or gain public admiration, but because it is fun to program.

– Linus Torvalds

Immerse yourself in programming, driven by interest. Interest is an inexhaustible source of motivation. Keep this sense of curiosity alive so you can dedicate yourself to your 10-year/10,000-hour journey of coding. Programming is fun—it’s the joy of exploration. It’s the joy of creation. Seeing your own work displayed on the screen is interesting. People marvel at your code. People praise your products in public, neighbors use your products, and media discuss your work—these are all fun. Programming should be very fun; if not, find out what makes it boring and fix it.

Start Learning

A Wake-up Story

When I was in middle school, I started learning programming. Unfortunately, I read many of the popular “21 Days to Master C++” type of junk books. At that time, it was okay; I could even write small programs. But when software malfunctioned, I didn’t know why. When faced with larger problems, I was helpless. I could only shrug when existing libraries couldn’t do the job. Although I coded every day, I found my programming ability was improving very slowly. My understanding of “iteration” and “recursion” was very limited; I was basically just using the computer as a calculator.

In college, I majored in physics. Initially, I memorized and recited physics formulas without understanding how they were derived, their connections, or their meanings. I kept learning how to calculate solutions to common physics problems but had no idea about the “Why” behind the “How.”

When I tried to make physics-based computer games, I encountered the same difficulties: helpless when facing new problems, fear accumulating, and I began to avoid understanding deeply, instead hoping to copy and paste solutions via Google. Fortunately, a class in my sophomore year changed my approach entirely. It was the first time I felt like I had “opened my eyes.” I painfully realized I had only a poor understanding of some subjects, including physics and computer science.

About that class: We had just finished learning electricity and special relativity. The professor wrote these topics on the blackboard and drew a line connecting them. “Suppose we have an electron moving along a wire at relativistic speeds…” Initially, the professor just wrote familiar formulas from electricity and relativity, but after algebraic derivations over several blackboards, the magnetic field formula appeared magically. Although I had known this formula years ago, I didn’t realize the deep connection between these phenomena. The difference between magnetism and electricity is just a matter of “observation perspective.” I suddenly realized that I should not just focus on “How” to do (How), but also ask “Why” (why). I started to revisit the basics, learn the fundamental knowledge I should have studied well before. This process of reflection was painful, and I hope you can be warned by it: never be complacent.

Reflections After Awakening

This diagram is from Douglas Hofstadter’s book Gödel, Escher, Bach. Each letter in the diagram is composed of smaller letters. At the highest level, we see “MU,” where M is made up of three HOLISM (holistic view) components, and U is made up of a REDUCTIONISM component. Each letter contains the other, and vice versa. At the lowest level, you’ll find the smallest letter composed of a recursive “MU.”

Each level of abstraction contains information. If you only naively apply holism at the top level or reductionism at the bottom, you’ll only get “MU” (which in some dialects means nothing). The question is: how to acquire as much information as possible from each level? Or, in other words, how to learn the many knowledge points in complex fields like programming?

A common key issue in education and learning: beginners often focus too much on holism and neglect fundamentals. For example, students very much want to build a robot but lack understanding of the underlying physical models → understanding electronics → understanding servo systems and sensors → making the robot move. This process often fails to excite interest.

There are two major pitfalls for beginners:

1. If beginners only interact with pre-built “engines and components” (without understanding their construction principles), it will severely limit their future ability to build these things and make troubleshooting difficult.
2. The second pitfall is less obvious: naive “holistic” methods can sometimes seem effective, which is deceptive. But after a year or two (or maybe less), when you have advanced further, trying to “fill in the gaps” by going back will be psychologically difficult. You will need to abandon previous narrow views and patiently progress step by step—much harder than learning basics at the start.

But don’t go to the extreme either: falling into the “reductionist” trap by trying to do grand theories from the beginning can be dangerous. It can lead to theoretical stagnation, boredom, and loss of motivation. This often happens to computer science students.

To better understand, think of learning programming as learning cooking: you buy some cookbooks to learn how to make good dishes. If you just want to cook for your family, that’s fine—you can follow recipes and make decent dishes. But if you want to impress friends, become a top chef, you need to understand the ideas behind these recipes, the theory, not just blindly practice. However, if your only daily activity is reading thick theoretical books without practice, you will only become a poor cook, or never a chef, because after a few days of reading, boredom will make you give up.

In summary, programming is the bridge between theory and practice, an intersection of computer science and application technology. The correct way to learn programming should be: explore from top to bottom through self-guided discovery and project practice to develop intuition and motivation; and from bottom to top, build a solid foundation and reinforce understanding of programming concepts.

As a beginner, focus on the latter, with the former as support.

Fundamentals of Program Design

“Which programming language should I learn?” This is often the first question beginners ask, but it’s the wrong question. The first thing you should consider is: “What are the fundamental components of learning programming?”

At the bottom of the programming knowledge pyramid, there are three key parts:

1. Algorithmic thinking: for example, how to find the largest number in a set? First, you need a variable like maxSoFar, then for each number…
2. Syntax: how to express these algorithms in a programming language so that the computer can understand.
3. System fundamentals: why does a thread never end when executing while(1)? Why is the code int *foo() { int x = 0; return &x; } invalid?

For beginners in the enlightenment stage, choosing C as the first language can be very difficult and boring because they are forced to learn all three parts simultaneously. Before they can do anything, they need to spend a lot of time.

Therefore, to minimize the focus on “syntax” and “system fundamentals,” it is recommended to start with Python as the first language. Although Python is very friendly to beginners, it does not mean it is just a “toy.” In large projects, you can see its powerful and flexible role. After familiarizing yourself with Python, learning C is a good choice: it helps you think from a low-level perspective and later understand some principles of operating systems.

Below is a suggested guide for the enlightenment phase. After completing it, you will have a general framework in your mind, helping you explore from top to bottom. The materials listed below are not in strict order; you can choose any, and if you get stuck, consider switching to another.

MIT 6.00.1x (Introduction to Computer Science and Programming in Python). Although the course uses Python, it emphasizes core concepts and paradigms in computer science, not just teaching a language. If you are not a CS major, it broadens your perspective during self-study. Course content: computational concepts, Python programming, basic data structures and algorithms, testing and debugging.

Harvard CS50x (Harvard University: Introduction to Computer Science). Also an introductory course, complementary to MIT’s. Languages include C, PHP, JavaScript + SQL, HTML + CSS. The breadth and depth are well balanced, and it introduces some of the latest technological achievements, which can greatly stimulate interest. Supplementary reading: Coding.

After completing the enlightenment phase, you will have accumulated some coding experience and understanding of programming. You might want to learn a specific technology, such as web development, Android, or iOS development. You can try building simple projects, like a website or a small game, and gradually expand. If your ideas are unclear, consider following the Lianwa Research Institute or choosing projects from the Mega Project List that you like.

If you find SICP too difficult, don’t force yourself—skip it and continue with the regular route: start reading The Elements of Computing Systems. It teaches you how to build a computer from the very basics of NAND gates until it runs your programs smoothly. This book will run through your entire programming introduction phase. Your goal is to complete all projects in this book (including a simple compiler and operating system).

To master this book thoroughly, lay a solid foundation, and prepare for future deep learning, you should do some homework in the following areas (note: the order is not absolute):

Computer System Fundamentals

After the previous programming foundation, if you want to deepen your understanding of computer science, consider this book: Computer Systems: A Programmer’s Perspective, 3/E. The Chinese translation’s name is criticized as not truly “deep,” but it is just the textbook for CMU’s “Introduction to Computer Systems.” CMU’s CS program leans more towards software; this book observes computer systems from a programmer’s perspective, focusing on “how programs execute in a computer,” covering many internal implementation details.

If reading feels dull, you can follow a MOOC on Coursera: The Hardware/Software Interface, which is a subset of CSAPP but with the most classic experiments ported over. Also, review The C Programming Language to revisit C language knowledge.

After finishing this book, you will have a solid system foundation and prerequisites for learning operating systems, compilers, and computer networks. When studying advanced system topics, review relevant chapters and implement the examples in code. This will deepen your understanding of the theories, and you will be able to write practical code, understand design from top to bottom, and trace data flow in network-memory-cache-CPU.

Data Structures and Algorithms Fundamentals

Nowadays, many believe that programming (especially web development) mainly involves using others’ code and expressing ideas clearly and simply—more than mastering hardcore math and algorithms. They think built-in data structures, sorting functions, binary search are enough, rarely used in work, and question the usefulness of algorithms. Such “pragmatist” thinking is undesirable. Without a solid theoretical background, bottlenecks are inevitable.

Data structures and algorithms are paired. In the beginner stage, you should focus on: what algorithms and data structures can solve this problem faster? This requires familiarity with common data structures and algorithms. You don’t necessarily need to code; writing on paper is faster. For unfamiliar data structures and algorithms, look up their main purposes and usage scenarios.

Recommended learning resources:

1. Introduction to Algorithms: Some say don’t treat this as an introductory book, but it’s not really an intro book anyway. The title “Introduction to Algorithms” is just because the author didn’t want to mix it with others. You can skip exercises and proofs on the first read if you feel unsure; if still hesitant, read Data Structures and Algorithm Analysis first.
2. Algorithms: Design and Analysis [Part 1] & [Part 2]: Stanford’s algorithm courses, language-agnostic, covering basic algorithms. If English is a problem, consider MIT’s Introduction to Algorithms.
3. In the beginner phase, also focus on developing the ability to solve small-scale problems with standard algorithms. Combining with the previous SICP section, read books like Programming Pearls and The Practice of Programming.

Other Fundamentals

Some points often overlooked in the beginner phase:

1. Learn to ask questions: encountering problems is normal; learn to use search engines properly. When search doesn’t help, ask on Stack Overflow or Zhihu. Before asking, read this article: Effective Questioning Methods.
2. Don’t try to be a lone wolf: communicate ideas with others on CoCode or similar platforms. Try building a simple personal website. Record your thoughts on a blog. Subscribe to programming blogs you like, such as Joel on Software, Peter Norvig, Coding Horror.
3. Improve your English: English is the main tool for accessing high-quality learning resources. In the beginner phase, translated books are less damaging, so weigh your own situation.

Summary

Don’t be afraid of the above content. The entry into programming is not a small project that can be completed in a few weeks. You will encounter many difficulties. When you hit a wall, try the “Feynman Technique”: break down the difficulty into smaller knowledge chunks and tackle them one by one. Then, explain clearly to others to verify your understanding. Of course, some problems may still be unsolvable immediately. Don’t force yourself—often, when you revisit later, everything will become clear.

Besides, don’t limit yourself to the materials mentioned above. There are other books worth repeatedly reading during the initial and advanced stages. Among the top programmer must-reads voted on Stack Overflow, the top two are:

Code Complete: Suitable for both experienced programmers and newcomers without formal training. It helps fill knowledge gaps, especially in variable naming, testing, and personality chapters.

The Pragmatic Programmer: Known as the “little black book” of coding—covering DRY, KISS, professionalism, and more.

The author, Dave, begins with this paragraph:

You’re a Pragmatic Programmer. You aren’t wedded to any particular technology, but you have a broad enough background in the science, and your experience with practical projects allows you to choose good solutions in particular situations. Theory and practice combine to make you strong. You adjust your approach to suit the current circumstances and environment. And you do this continuously as the work progresses. Pragmatic Programmers get the job done, and do it well.

This philosophy and the Pragmatic Bookshelf have always influenced me. Therefore, I also try to incorporate this mindset into this guide, aiming to guide you to become a true Pragmatic Programmer.

Postscript

If you manage to complete all the above tasks, congratulations—you have truly entered the world of programming. This means that in your deeper future studies, you will not fear learning new languages, complex APIs, or specific technologies. It will even feel quite easy. Of course, mastering these still requires extensive practice: your back may ache, walking may be tiring, and you might not reach the 5th floor with a single breath. But I guarantee you will experience a huge shift in your mindset, gain great confidence, and others’ perceptions of you will subtly change. Although you have only completed the entry stage, you have already become a high-level programmer in spirit. No, I was wrong— even a high-level programmer doesn’t have super-strong mental power; they will doubt themselves, think that without money, nothing matters. But overall, if you follow this guide and read diligently, you will feel the “peak” of achievement.