Computer science fundamentals are the foundation of any software developer’s job. Starting with how a computer works, over logic, maths, algorithms, and data structures, and ending with networking and I/O. Any developer should at least have basic knowledge about these fundamentals. This is why Your Guide to Computer Science Fundamentals exists.
Many of the concepts presented in this guide are things you will just use on a day-to-day basis as a developer, others are used less frequently. The important part is still having some knowledge about them in the back of your head.
This guide comes with a mix of practical advice and a collection of learning resources you can use to advance your knowledge in the respective fields. While this guide can probably be read within a few minutes, you will need way longer to fully understand all the topics covered.
- What Fundamentals are And why they are Important
- The Most Important Fundamentals
- How to Learn the Fundamentals
- How A Computer Works
- What A Programming Language Actually Is And Does
- Data Structures
- Networking / I/O
- Wrap Up
Fundamentals are concepts, and maybe even techniques, that you can apply in multiple areas and multiple programming languages. They are not tied to anything specific and are sometimes pretty theoretical.
The importance of these fundamentals comes from the fact that they build the structure the rest of your programming and development knowledge is based on. Without knowing how a computer works, it becomes more difficult to understand what a programming language actually is and why the instructions you type in are the way they are.
It can take a long time to learn all the fundamentals there are, and it can cost a lot of energy to stay motivated. In the end, however, every piece of fundamental knowledge you acquire speeds up the learning process for everything else that is based on it.
Too many young or inexperienced software developers jump right into frameworks when they learn how to program. Later, they face problems that are not solved that easily if they don’t know how the underlying technology or concept works. Just take networking as an example: It is very easy to perform remote requests these days, but if the underlying network has problems, you might be clueless as to why your requests are never successful. Knowing at least that a network exists and how it approximately works can help with the debugging process.
Here is a list of the most important ones:
- How a computer works
- What a programming language actually is and does
- Data Structures
- Networking / I/O
This list seems long and contains many very broad topics, but if you get broad knowledge in these topics, your chances are high that your programming and software design skills will profit from it a lot. And in return, you will learn new frameworks faster, your code will become better, safer, and more resilient (because you know what awaits you).
This guide will go through these fundamentals a little more in-depth soon, so don’t worry that you are left with only a list of topics you have to dive into yourself. Just know that these exist for now.
How to Learn the Fundamentals
There are multiple strategies for learning something. One approach might be to just try to learn everything at once and then jump into more advanced topics. Another approach might be to learn as you go. Overall, there is no overall correct approach. There is only the approach that suits you best.
No matter what way you take, there are a few key concepts that can help you along the way.
1. Use curiosity to your advantage
No matter whether you try to learn everything up front or along the way, always give in to your curiosity.
Dive a little deeper whenever you become curious because you don’t know something yet. Make a small list and note down all the topics or questions you discover. This ensures you can take care of learning more about it at a later point.
As long as you are curious, chances are high that you are willing to go even down a rabbit hole, and your brain will most probably be more welcome to consume the information you find. This can also have a positive effect on your motivation.
2. Don’t overwhelm yourself
It might often seem tempting to learn everything at once, but most people do best when they learn one topic at a time. This is where a list of topics and questions comes in handy. You always have something to return to later without fearing that you forget what topics you want to research.
You should also make sure to take frequent breaks. There are studies that show that frequent breaks only help you refresh your energy faster and thus enabling you to learn more in less time. The worst thing to happen is not remembering everything from a 2-hour hardcore study session on a complex topic.
3. Revisit topics regularly
Repetition is one major key to learning efficiently and effectively. Reading something once is not enough to build long-lasting connections in your brain. Revisiting topics regularly, especially if you don’t come in contact with them often, helps you keep the crucial knowledge you worked hard for.
If you work with a list, like already proposed, don’t throw it away as soon as you are done. Try to keep it and think about persisting it (Notion, a Todo app, etc.) while additionally attaching your notes to each point. This gives you a great personal learning resource you can revisit again and again whenever you see the need arise.
4. Connect with peers or a mentor
There are many more developers who still need to cover computer science fundamentals. If you have a chance, try connecting with them and learning together. You can exchange your learning materials, explain concepts, and motivate each other to continue this interesting journey. A short weekly call where you talk about your last week of learning and share important discoveries can already be enough.
Another way is to find a mentor. That is usually a developer with more experience than you, who already knows their way around these fundamentals. Admittedly, finding a mentor is difficult these days, but if you can find one who is willing to help you, take the chance. A mentor can help you in many ways. They can guide you, provide you with explanations, share learning material with you, and much more.
Now that you are prepared with crucial knowledge of what fundamentals are, why they are important, and how you should approach learning them, it is time to get into them.
The most basic knowledge of a software developer is understanding how a computer works. The level you work at is already so far away from the current running through wires and circuits inside your computer that it is often hard to even imagine how this can work at all.
This knowledge doesn’t benefit you directly as modern operating systems and programming languages hide these details from you perfectly, though, but it is also foundational knowledge to understand how information travels through networks (and especially the internet as a network on a global scale).
Next to knowing that bits and bytes exist, knowing how they are stored in your computer’s memory (and even in your CPU’s cache) or on your hard drive is crucial information for any developer. It helps you understand that certain ways of storing information are slower than others and can indeed affect the performance of your software.
Finally, it’s always incredible to be able to explain in detail how someone’s smartwatch works at parties, isn’t it? Because conceptually, a smartwatch and a smartphone are also just smaller computers, and most people will probably be quite happy (actually not) if you tell them everything they always (hint: they probably didn’t) wanted to know about their devices.
What you should know
There is a whole lot to know, and knowing everything probably won’t benefit you (except if you are really into hardware engineering and design), but a few key concepts are a necessity for developers:
- How current and transistors actually bring your PC to life
- What a CPU is and how it works
- What memory is and how it works
- How an operating system makes a computer usable for ordinary people and what it provides to developers
Where you can learn about computers
Many resources on the internet can teach you a lot about computers and how they work. It would probably take ages to list them all here. The following list is thus only an excerpt and a starting point for you to dig deeper and learn more (if you wish to):
This is an excellent guide for beginners by Javatpoint, and it covers the most important points (and even a bit more). It’s a great starting point to learn everything you can about computers.
This is another great entry guide to computers by an actual university. The only drawback to it is that you can only navigate by iterating over the resources (Reading01.html -> Reading02.html -> Reading03.html -> etc.).
This is an online course on how computers work. If you prefer a whole guide, including videos, this might be the right one for you.
What A Programming Language Actually Is And Does
When you have a basic understanding of how a computer works, you need to understand that the high-level languages most of us work with do a lot to abstract away low-level details.
There are many different programming languages nowadays, and every one of them has a special purpose (even the esoteric ones, although they often prove a specific point instead of being created for a specific purpose).
A crucial thing to understand with programming languages is that all of them end up as machine code in one way or another. And that machine code is somehow mapped to a processor’s instructions. Some code results in more machine code than others, and some results in less. At least understanding why this is the case and how it can affect the performance of your software is knowledge that can come in handy depending on where you end up working.
What you should know
You should at least understand the following:
- A programming language is a set consisting of
- A specification
- Sometimes a runtime
- Why different programming languages exist
- What purpose different programming languages have
- What manual memory management is
- How a garbage collector works
Where you can learn more about programming languages
You can search for days and find new articles and guides on this topic. The internet is just a vast place of information. To give you a general direction, though, here are some resources that you can start with:
A small introduction to programming languages, what they are, and what they do.
A good introduction to programming languages at a higher level.
This a good entry into memory management and why it is necessary.
A guide on garbage collection that helps you understand what these garbage collectors actually do and how they manage memory for you.
Logic is an integral part of programming. Although it is actually a subarea of mathematics, it has a crucial place in any developer’s tool belt, which is why it is mentioned separately.
Without logic, there would be no way to write effective software. Everything would run always or never, without any middle way. If this happens, then do that is just a fundamental construct. It is so important that every language has at least one construct (if, else if, else, and often also switch) to enable working with it.
Once you have conditions, you are confronted with Boolean algebra. That is another subarea of math (and of logic, which makes up the algebra of operations. With boolean algebra, you can evaluate and simplify your statements and much more.
What you should know
If you plan to stay in software development for longer, you should try to learn as much as possible about logic and boolean algebra. At least you should learn the following:
- What mathematical logic is
- How mathematical logic works
- Set theory
- Boolean algebra
Where you can learn more about logic
There are a few noteworthy resources that you should definitely take a look at:
Khan Academy is a free learning platform that aims at teaching many subjects, including STEM. It has a well-curated section on math and logic, which is why it must be listed here.
Peter Smith has done a great job at writing a book about mathematical logic for beginners. It is well worth downloading and reading.
A few videos are never bad in a study mix. If you are more the kind of a visual learner, these lessons might be great for you.
Computers are pretty good at math. This is why a lot of software deals with math problems (with difficulties ranging from easy to insane) every day. Every frontend, for example, does regularly need to calculate the position of certain UI elements, and a lot of business software takes care of accounting tasks and needs to calculate costs or else.
Sooner or later, every software developer is confronted with a more or less simple math problem. Thus, having some maths skills doesn’t hurt at all. It simplifies many tasks and can often also help with designing efficient algorithms.
Even if you never stumble upon a math-related problem in all your career (and I highly doubt it), you will probably need to calculate an average or median at some point (especially when evaluating the performance of your software) or sum up a few numbers and find the standard deviation.
What you should know
Math is an ultra broad topic with many subareas that themselves are probably deeper than the mariana trench. It is thus really difficult to state how much you should know. Generally speaking, you should try to learn as much as possible, but if math really is not for you, you should at least focus on a few key areas:
- Basic algebra
- Linear algebra (especially useful in the frontend but also for UI work in general)
Where you can learn more about math
As usual, the internet is full of resources, but if you only have the time and resources to visit just one resource, let it be the following one:
You probably already know Khan Academy from the section on logic. It is really an incredible resource if you want to learn math, and it thus deserves a second spot in this guide.
Algorithms are the bread and butter of any software developer. Each line of code you write contributes to an algorithm, even if it only prints a single statement to the console. Without algorithms, there would be no software at all.
An algorithm is a way or a set of instructions the computer follows to get an expected result. If you think about this for a moment, you probably understand that everything you do is an algorithm. The computer always follows your instructions precisely to get the output you intended (or not – nasty bugs) to get.
Additionally, practicing your algorithmic skills also trains your own brain to think more like a developer and how to approach certain problems with a computer, which often differs fundamentally from how you would approach them in the real world. The more you practice, the better you become at solving problems. The better you become at solving problems, the easier it becomes for you to create solutions.
What you should know
You should touch a few basics at least once in your career because other software craftsmen spent years discovering these basic techniques. Next to that, you should, of course, also train your skills outside of these well-known fields.
To give you a general idea, here is a (non-exhaustive) list:
- Greedy Algorithms
- Divide & Conquer
- Branch and Bound
- Dynamic Programming
- Randomized Algorithms
- Brute-force or exhaustive search
- Simple algorithms without any special technique
- e.g., just a sequence of statements to solve a specific problem
Where you can learn more about algorithms
Algorithms usually come together with data structures, which is why you will probably cover a good chunk of the next section with this one. Nevertheless, algorithms themselves are not mutually tied to data structures, as you have already learned, and thus learning algorithms on their own definitely is a good idea. A few good resources to get started are the following:
edX is a learning platform dedicated to bringing university-level education to anyone. They have a large section on algorithms, and a few of those courses are well worth taking.
Geeks for geeks is a big platform these days, with many resources on nearly everything related to software development. Their section on algorithms is a good entry point to get started.
Data structures are often dreaded because many companies still or used to ask questions about them in technical interviews. Many of those interviews involve reimplementing common data structures on a whiteboard or paper. Although this practice is questionable, it has done a lot to make many developers fear this special area of software development.
Generally, data structures are just a common way to collect and interlink data. Like a drawer where you probably store a few important documents, data structures store data that a developer wants to access sooner or later. Every data structure has advantages and drawbacks. Some take longer to insert data, some take longer to retrieve it again.
Knowing the characteristics of data structures is important for a software developer because it influences the runtime of algorithms and software as a whole. A wrong data structure chosen for a specific task can make the difference between an instant response or having to wait a second.
What you should know
A good software developer should know which classes of data structures exist and what types there are. You should also know the most important characteristics of those data structures and their runtime behavior. Being able to implement them by yourself is also a great goal because if you can do that, you probably know everything about them, but it is not an absolute must.
Generally speaking, you should look at the following data structures that all of their own sub types:
Where you can learn more about data structures
You already know that algorithms and data structures are usually interlinked and taught together. This is why you will find the same type of resources here as for algorithms:
You probably already know edX from algorithms. No wonder they also have a section on data structures.
The same as above. Geeks for geeks has a good section on data structures, as well. If you liked their guides on algorithms, you will probably also like their guides on data structures.
Networking / I/O
Depending on how deep you already dug while learning about how computers work, you might probably already have touched this topic. No matter whether you did or not, networking and I/O are crucial aspects of modern software.
Chances are high that you view this article in a browser on one of your devices (a notebook, a desktop PC, a smartphone, a tablet, or whatever else). This means that the content of this guide was transferred to your device over the internet. Its contents were probably read from a database (that stores data on a hard drive and in memory), sent over your local network to your router, through many more routers and switches until it reached your own router, and through your local network until your device’s browser was able to render the page.
Most modern software uses some form of I/O these days. It either reads from or writes to files or accesses servers elsewhere in the world. With all this I/O, a whole new class of issues can arise, and it also leads to interesting design challenges for software. If you know how all this works at least approximately, you can save a lot of time trying to solve issues that you will face while developing software.
What you should know
Networking and I/O are both pretty broad topics. You can basically learn everything from fundamental concepts down to how routers and switches route packets. As a software developer, however, you don’t need to know everything in-depth. A few basics like the following are enough, but the deeper you dig the better:
- How a network works
- How routing works
- How hard drives work
Where you can learn more about networking and I/O
As usual, the number of resources is overwhelming, but here are a few you can start with:
This guide by IBM is not the largest, but it comes with a good level of detail and can be a starting point for you to search further.
Hard drives store your data. Software regularly needs to access this data, and this resource comes with a great video that explains the fundamentals to you.
This is the end of this guide. If you prepared yourself well, you now hopefully have a list of topics you can use as a starting point for your learning journey. If not, quickly prepare one (you will thank me later).
Slowly start to work through these topics and fill the gaps you discover accordingly. And don’t worry if you take longer to understand something. Computer science is far from easy. Sometimes it takes several tries or a longer break to finally grasp a complex concept.
Always keep in mind that you might not get the reason for learning some of these topics immediately. One day, you might be thankful for having something in the back of your head, though.