What Do Computer Science Majors Actually Learn?

AI translation notice: This English version was translated from the original Chinese article with AI assistance. Some nuances may differ from the original.

Whenever I chat with the elders in my family, or introduce my major to younger students who are getting ready to choose one for the gaokao, I get asked the same question: What do you computer science people actually study?

The question looks simple, but answering it clearly is not easy.

Because the word “computer” is far too broad in everyday life, and for anyone with even a passing knowledge of technology, there are also far too many directions within it. If you have never studied the major yourself, plenty of misconceptions remain.

Some people think studying computers means writing code, some think it means repairing PCs and installing operating systems, and others think it means making games, building websites, or doing artificial intelligence. All of these are related to computers, but each is only one direction within the field, and they have little to do with what “computer science” means in undergraduate education.

Undergraduate “Computer Science and Technology” is mainly a complete system built around “how to make machines process information reliably, efficiently, and automatically.” It begins with mathematics to lay the logical foundation, then expresses everything clearly in code; but what matters most is the abstraction, systems thinking, engineering, and problem decomposition behind it all.

So I want to write a simple user manual. Next time someone asks me “What do you study in computer science?”, I can just send them this article, which beats explaining it from scratch every time and still not being clear or complete.

Of course, the curriculum differs from school to school, and I have never personally taken computer science courses at a top university. Fortunately, Berkeley and MIT publish many open courses, and through them I have caught a glimpse of how top schools think about education. What follows is mainly based on my own school—an ordinary first-tier university—and the content common to most domestic “Computer Science and Technology” undergraduate programs, plus what I learned from those open courses.

---

First, a Misconception: Computer Science Is Not “Learning a Piece of Software”

Many people's first impression of a computer science major is whether you can fix a computer, install an operating system, make a PowerPoint deck, or edit a video.

These are certainly useful skills, but they are not the core of the major. Otherwise you would study mechanical engineering just to turn screws, architecture just to move bricks, and food science just to put chocolate chips on Chips Ahoy cookies.

In undergraduate education, computer science mainly cares about:

• Why can a program run at all?
• How is the data inside a program organized and processed?
• How does the network move information from one place to another?
• Why can an operating system run many programs at the same time?
• How is a large system designed, developed, tested, and maintained?
• How do algorithms solve problems while using as little time and as few resources as possible?

Next, I will also discuss mainstream directions such as artificial intelligence, databases, graphics, cybersecurity, and embedded systems, sharing what I have come to understand about them over the past few years and what problems each one is trying to solve.

Now let us go bottom-up, layer by layer, through where the ideas of computing come from, what our learning goals are, and the problems and detours I ran into along the way.

Layer One: Mathematical Foundations

When we first entered university, many classmates were surprised: “Why am I majoring in computers, and the first thing I have to study is this much math?”

During freshman year we would get together and complain about exactly this, but later on we realized that mathematics is not just the algebra from elementary, middle, and high school—that is called elementary mathematics. What undergraduates study is broader and deeper, and the foundations really do matter.

Calculus, linear algebra, probability and statistics, and discrete mathematics are basically unavoidable. Some schools even cover numerical analysis, combinatorics, or operations research.

Calculus focuses on continuous change and the ideas of differentiation and integration; linear algebra shows up constantly in graphics, machine learning, and data processing; probability and statistics underpin artificial intelligence, data analysis, and stochastic processes; and discrete mathematics is especially close to computing—sets, logic, graphs, trees, relations, recursion. These sound like mathematical concepts, but they keep reappearing later in data structures, algorithms, databases, compilers, and artificial intelligence. I happened to study discrete mathematics fairly seriously back then, and later it gave me a feeling of understanding one thing and grasping many others.

Of course, there is no need to be intimidated. For an ordinary student who does not plan to keep struggling at the frontier of technology, there is really no need to push mathematics especially hard. Even if you forget most of it later, it will not affect your job search or your ability to handle ordinary front-end and back-end programming problems. Most undergraduate math courses are just cultivating a way of thinking, so that when you meet complex concepts later you are not completely without a handhold.

The problems I ran into:

Over my four years of university, if I had simply followed the school's courses step by step, I most likely would not have gained any deep understanding of mathematics.

To make assessment easy to quantify, school courses do not test your mathematical understanding or your way of thinking; they mainly test your ability to solve problems.

I think this is a problem with how schools assess students. Take the most telling example: almost every classmate around me understands linear algebra as computing determinants, multiplying matrices, finding eigenvectors... and not one of them thinks about its geometric meaning. My impression is that we focus too much on the “algebra” part of linear algebra and neglect the idea of “linear,” so that most students, even after studying artificial intelligence or graphics, do not understand why matrices have to be there (I will put together a separate article about this sometime).

Only by teaching myself Professor Gilbert Strang's 18.06 course and 3Blue1Brown's animated explanations did I begin to grasp the concepts and meaning of mathematics from the ground up.

Layer Two: Programming Foundations

Anyone who studies computer science has to be able to program 👋😭👋!

The usual introductory languages are C, C++, or Python, depending on the school. Most schools emphasize C at the start because it is closer to the metal (you could almost call it the origin of everything), and it helps you understand foundational concepts like memory, pointers, arrays, and function calls. Once you have those down, learning other languages is much faster (I highly recommend CS 50 here). Some schools use Python or Java for beginners, because it is easier to produce something that runs, which lowers the barrier to entry.

At the beginning, the content usually covers variables, conditionals, loops, functions, arrays, structs, classes and objects, and file reading and writing. It looks like you are learning language syntax, but in essence you are training how to break a real-world problem into steps a machine can execute.

Many people think the hard part of coding is memorizing syntax, when in fact syntax is only the surface. The genuinely hard part is understanding the problem, breaking it down, designing the flow, and handling edge cases.

A simple example: write a program that computes the average of a set of grades.

It looks simple, but what if the data is empty? What if the input is malformed? What if there are so many grades that they do not fit in memory? What if you need to display the result live on a web page? Dig into one problem layer by layer, pin down the requirements, and apply basic variables and logic, and it gradually turns from “a small feature that takes a few lines of code” into “designing a complete system.”

The point of an introductory programming course is not to teach you a particular language, but to get you into the habit—for the first time—of organizing your thoughts the way a program does.

The problems I ran into:

1. Problems caused by assessment:

Most computer science instructors now read off slides, hand out assignments, and grade mainly on written reports. Now that AI has taken off, most of the thinking practice can be handled by simply sending the AI a set of requirements, with almost no brainpower required. Classmates around me who chase GPA, wanting high marks from the instructor, choose the more conservative approach, avoid making mistakes, and use AI to do the main work directly, spending more energy polishing the report. As a result, I know plenty of classmates who can barely program but are quite good at documentation.

2. Problems with how courses are designed:

The quality and difficulty of the assignments I got in these foundational courses were clearly different from Berkeley's assignments. What we eventually completed was roughly at the level of Berkeley's homework before the midterm, and it is hard to go deep enough through a single project for students to learn to break a problem down clearly and properly.

And I have a very clear and strong feeling: most of the instructors who taught our courses were constrained by the required class hours, and they did not really understand the language themselves. The C++ instructor's use of pointers, for instance, stopped at the basic usage, and the Python instructor's knowledge of Python's standard libraries was limited to what was in the course slides—not to mention the farce of writing code in class that would not run and then explaining that it was pseudocode.

These problems mean that my classmates' programming foundations were never deep or systematic to begin with, so afterward they even had to take an extra language course to shore them up.

Layer Three: Data Structures and Algorithms

If I could pick only one course that best represents the fundamentals of a computer science major, I would probably pick data structures and algorithms.

Data structures study how to store data; algorithms study how to solve problems.

• Arrays, linked lists, stacks, queues, trees, graphs, hash tables, and heaps are all common data structures.
• Sorting, searching, recursion, dynamic programming, greedy algorithms, and graph algorithms are common algorithmic ideas.

This course was the most painful for me at first, because unlike building a web page, you do not see results right away, and unlike making a small piece of software, there is no clear interface giving you immediate positive feedback. It is like practicing internal martial arts: a lot of it looks easy to understand and easy to grasp, but most of the time you are failing over and over, looking for a way out.

Data structures and algorithms together form the foundation of every program. It is also common for two excellent products to occupy the same niche with the same purpose but different data structures.

Take Notion and Obsidian, both used for “taking notes.” Their interfaces both support pages, nesting, and links, but the data management underneath is completely different. Notion breaks documents into Blocks and uses a tree structure to manage hierarchy and nesting; every operation is essentially moving and collapsing subtrees. Obsidian treats each note as a node in a graph, creating edges through bidirectional links and maintaining associations and backlinks with an adjacency list.

Put simply, Notion is like organizing a multi-level set of folders, while Obsidian is more like weaving a spider web. The former cares about hierarchy; the latter cares about connection points. Precisely because of this, even though both are “organizing notes,” Notion is asking “who belongs to whom” while Obsidian is asking “who is related to whom”—data structures do not change what you can do, but they determine how you think about it.

So data structures and algorithms do not exist for the sake of grinding LeetCode. Grinding problems is only one form of training; what it really trains is: when facing a problem, how to choose the right abstraction and solution strategy.

Layer Four: The Computer as a Whole System

The biggest difference between a computer science major and pure software training is that it asks you to understand “what happens underneath the code.”

This part usually includes courses such as computer organization, operating systems, computer networks, database systems, and compilers.

Computer organization tells you how the CPU, memory, instructions, registers, and caches work together—that is, how everything on your screen is transformed by binary zeros and ones across electronic components and finally becomes software or a game.

Operating systems covers processes, threads, memory management, file systems, scheduling, and deadlocks. You will understand why a computer can run many programs at once, why programs freeze, why running out of memory slows things down, and why poorly written multithreaded code produces strange bugs.

Computer networks covers TCP/IP, HTTP, DNS, routing, and congestion control. Every day when you open a web page, send a message, or watch a video, you are using these protocols. After the course, at least you will know that “the network is bad” is not a universal explanation—behind it may be latency, packet loss, bandwidth, DNS, the server, the client, and a pile of other links all contributing.

Databases covers the relational model, SQL, indexes, transactions, concurrency control, and data consistency. It solves the problem of how to store data long-term, reliably, and in an organized way, while keeping things from falling apart when many people access it at once.

Compilers covers how a language goes from source code to a form the machine can execute. Lexical analysis, syntax analysis, semantic analysis, optimization, code generation—it sounds hardcore, but it will help you understand that programming languages did not appear out of nowhere; they are systems that can be designed and implemented. (This course really tests your logic, and it is not easy.)

Together these courses form the systemic foundation of the major. You may not go on to work directly on operating systems or compilers, but understanding this material gives you a stronger sense of “what is underneath” when you face complex problems. If you study deeply enough, you can even work out the underlying direction when you hit a strange bug—for example, when I was reading this post, by the later part of the problem description I guessed that it might be related to floating-point arithmetic caused by historical reasons.

The Final Layer: Specialized Direction Courses

By junior and senior year, many schools offer direction courses or electives. They vary noticeably between schools, but the common directions are roughly the following. You can also use csdiy.wiki to find the courses you want (if you are very capable, you can consult the author's reviews; for an ordinary student like me, everything took considerably longer than the author reported, felt somewhat harder, and I definitely did not remember it all after finishing).

Artificial intelligence and machine learning. This includes machine learning, deep learning, natural language processing, computer vision, data mining, and more. It is very popular right now, but actually studying it is not just “prompting a large model.” You need to understand basic concepts like data, models, training, evaluation, overfitting, loss functions, and optimization methods, and you also need to learn frameworks such as PyTorch. Getting started really is exciting—watching the loss go down during training genuinely gives you a kind of simple, slightly silly happiness.

Networks and information security. This includes cryptography, network security, system security, Web security, reverse engineering, and more. I know almost nothing about this area; I only once had the chance to interview cybersecurity staff in the police and at a company, and picked up a little knowledge. I know market demand in this area is still growing, but to really go deeper, that becomes the content of the cybersecurity major itself.

Embedded systems and the Internet of Things. This leans toward the combination of hardware and systems, and may involve microcontrollers, sensors, real-time systems, embedded Linux, and so on. It cares more about how a program runs stably on a device with limited resources.

Software development and engineering practice. This includes Web development, mobile development, cloud computing, microservices, software testing, DevOps, and more. This direction is closely tied to actual employment and emphasizes engineering ability and system development experience.

In freshman year, our dean (now a vice president) taught us Introduction to Computers, and in class he recommended the book The Mythical Man-Month. When I saw that it was from the 1970s, I thought the dean really was an “old-timer” (no disrespect intended). It was not until I organized a student innovation project and actually built something that I remembered the teacher's recommendation, and realized that the pitfalls I was hitting had already been given better solutions by others fifty years earlier. If you want to understand the development process, The Mythical Man-Month is a storybook with no barrier to entry that runs through the whole process.

Graphics, games, and virtual reality. This involves geometry, rendering, physical simulation, engines, interaction, and more. It looks cool, but behind it is a great deal of mathematics, algorithms, and engineering detail. I once studied GAMES101, but eventually I really had no time and the course was a bit hard, so I gave up. Even so, that brief exposure made me pay close attention to a game engine's rendering logic when I play games, and I often watch Unreal Engine presentations to understand this dazzling technology. In fact, graphics is not only knowledge for game engines; there are many directions behind it, which I will introduce later.

Big data and databases. This includes distributed systems, data warehousing, data analysis, recommendation systems, and more. The problems it handles usually involve large data scale, high concurrency, and complex systems. I have not gone deep into big data, so I am not in a position to offer an expert assessment.

These directions are not isolated from one another. Artificial intelligence, for instance, needs algorithms and mathematics, but also systems and engineering; cybersecurity needs operating systems and networking fundamentals; back-end development cannot do without databases, networks, and software engineering.

That is the nature of a computer science major: the further you go, the more you find that many courses connect to one another. As I see it, no one can learn all of the directions above thoroughly, or even take them all once. Even specializing in a single direction takes years. My exploration over four years of university was not small, but deeper study afterward is more or less the direction and purpose of graduate school.

For specifics, see this Zhihu answer:

Should computer science undergraduates spend a lot of time writing compilers and operating systems, or is that a distraction from their proper work? - Freezy's answer - Zhihu https://www.zhihu.com/question/321433640/answer/2066636784763720375

What Does Studying Computer Science Require?

I think the most important thing is not being a “math genius,” nor “having written code since childhood.”

What matters more is a few rather plain but rare abilities.

First, a willingness to look things up yourself. The field changes fast, and many problems will no longer have a teacher walking you through them step by step—many classmates will not have the time to teach you hand in hand either. Error messages, official documentation, search engines, open-source projects, papers, and community discussions all become part of your learning. Even in today's AI era, this ability matters especially.

Second, being able to tolerate frustration. Program errors are routine, and failing to get an environment set up is perfectly normal. I once spent three days getting an environment configured before it finally ran, and spent a week on one bug, staying up late every day. Maybe that is just me being bad, but judging by experiences shared on forums, it does not seem rare.

Third, enjoying breaking problems apart. Computer science rarely solves one huge problem directly; instead it keeps making the problem smaller, turning vague requirements into concrete steps and complex systems into modules. Once this habit of thinking takes hold, even when you are browsing a web page you will unconsciously try to abstract the data structures inside it. (It is actually quite similar to force analysis in high school physics.)

Fourth, a bit of patience for continuous learning. You may have just learned a framework when a new tool appears; you may have just understood one direction when the industry's hot topic shifts again. A computer science major is not well suited to living off what you learned in four years of university for the rest of your life. Especially now that the AI era has arrived, that old knowledge may be reset to zero outright, and keeping up learning may be the only way for ordinary people like us to keep pace with it.

Final Thoughts

A computer science and technology major covers a lot, and it is scattered.

It has mathematics and engineering; theory and practice; it requires understanding the underlying systems and being able to build applications on top. When you first start, it is easy to feel that these courses have nothing to do with one another: math is math, C is C, operating systems are operating systems, databases are databases. But as you go further, you slowly discover that they are all answering the same question:

How can information be better represented, stored, transmitted, processed, and used?

This article is a very rough introduction, mainly as a record of what I have taken away from four years of continuous study, along with the problems I noticed and my most sincere advice. The learning experience of an ordinary student at a university outside the 985 and 211 tiers, who is full of uncertainty about the future, cannot cover everything, but at least I hope it helps parents and students interested in computers form a basic impression: computer science is not a pile of math, nor simply typing code. It is understanding every layer underneath the computer.

If you do choose to study it, you will most likely run into plenty of bugs that give you headaches, courses you cannot follow, environments that will not configure, and projects you cannot finish.

But there will also be some very happy moments: the first time a program runs, the first time a web page goes live, the first time a model produces a result, the first time a small tool you wrote actually helps someone. Those moments make you feel that you really are turning the ideas in your head into reality, little by little.

These tiny bits of happiness and positive feedback are probably what attracts me most to computer science.