100+ Computer Science Fundamentals Every Software Engineer Should Learn (Slowly)
Hi, I’m Abdirahman Jama. I’ve been a Software Engineer for over 7 years, and today I build distributed systems at AWS. I studied Computer Science at King’s College London (and even had an MSc offer from the University of Oxford), but most of what I rely on today I learned on the job
University taught me the fundamentals and the building blocks.
The job taught me how things actually work, and how to put large scale distributed systems together in a production grade environment.
If I had to start my journey again, in 2026, with or without a degree, here are over 100 fundamentals I would learn slowly.
Why Computer Science still matters in 2026
I don’t think every engineer must go to university to study Computer Science (CS). But I do think every engineer, should at least consider learning CS fundamentals. These fundamentals will help with understanding underlying nuances of building software. Also, real world engineering always pushes us back to the basics:
Why is this API slow?
Why is this query expensive?
Why is this process using so much memory?
Why does this part of the system keep failing?
These aren’t framework questions.
They’re actually CS questions. Questions that we face every single day in production environments.
► Programming & Languages
Begin here. If you can write programs confidently and understand how execution works, everything else becomes easier.
0. Coding (variables, data types, conditionals, loops, functions, control flow)
1. Procedural programming
2. Object-oriented programming
3. Functional programming
4. Type systems
5. Static vs dynamic typing
6. Memory safety
7. Compilation vs interpretation
8. VMs & runtimes
9. Garbage collection
10. Imperative vs declarative languages.
► Data Structures & Algorithms
These are the tools every engineer uses daily… even if you don’t realise it. They’re the building blocks behind performance, memory, and scalability.
11. Arrays, linked lists, stacks queues
12. Hashmaps, sets, heaps
13. Trees & graphs
14. Sorting and searching
15. BFS & DFS
16. Complexity analysis (time and space: Big O notation)
17. Recursion
18. Greedy algorithms
19. Divide and conquer
► Databases & Storage
Data is the heart of almost every system. Learn how it’s structured, accessed, indexed, and stored at scale.
20. Relational models
21. ACID
22. Isolation levels
23. Indexing
24. Query planning
25. Normalisation vs denormalisation
26. Replication
27. Sharding
28. Consistency models
29. Transactions at scale
► Operating Systems
Your code doesn’t run in a vacuum. It runs inside an operating system. Understanding how the OS works gives you real superpowers.
30. Processes & threads
31. Scheduling
32. Interrupts & syscalls
33. Locks & race conditions
34. Memory management
35. Virtual memory
36. IO systems
37. Concurrency
► Computer Architecture
Everything ultimately runs on hardware. Understand what the machine is doing underneath.
38. CPUs
39. Caches
40. Pipelining
41. Instruction sets
42. Hardware vs software optimisation
43. Memory hierarchy
► Networking
Modern software is networked software. Understanding networking is understanding how the internet, and most systems, actually work. You know those iMessage / WhatsApp messages you send to your friends and family? That’s all possible thanks to networking!
44. OSI model
45. TCP/IP
46. DNS
47. NAT
48. TLS / HTTPS
49. Routing
50. Load balancing
51. Firewalls
52. Congestion control
► Cryptography & Security
If your system touches real users or real data, security isn’t optional: it’s foundatiaonal.
53. Hashing functions (SHA-2, bcrypt, argon2)
54. Asymmetric encryption (aka public key cryptography: RSA, ECC)
55. Symmetric encryption (aka private key cryptography: AES)
56. Encryption modes (CBC, GCM)
57. Key exchange (Diffie-hellman, ECDH)
58. Certificates & PKI
59. Authentication vs authorisation
59. Signing vs encryption
► Mathematics for Computing
This is the theory behind almost everythign in CS. You don’t need to be great at maths — just fundamentaly aware.
61. Logic
62. Discrete maths
63. Probability
64. Statistics
65. Graph theory
66. Linear algebra
67. Boolean algebra
68. Combinatorics
69. Proofs
70. Number theory
► Distributed & Cloud Systems
Real-world systems today are distributed systems. Understand these and you’ll understand 90% of backend engineering.
71. Replication
72. Partitioning
73. CAP theorem
74. Event-driven architecture
75. Idempotency
76. Eventual consistency
77. Queues & streams
Serverless fundamentals
Observability
Multi-region design
Gossip protocols
Distributed transactions
Leader election
Service discovery
Circuit breakers
Retry & backoff patterns
Distributed tracing
Fault injection
Chaos engineering
Consensus algorithms
► Software Design and Architecture
These are the principles that separate “I know how to code” from “I know how to design software.”
SOLID principles
Design patterns
Dependency injection
API design
REST fundamentals
GraphQL fundamentals
Message-based systems
Domain-driven design
CQRS
Event sourcing
12-factor applications
Clean architecture
Microservices
Monoliths
Hexagonal architecture
► Testing
Testing is engineering. If you can’t test it, you don’t really know how it works.
Unit testing
Integration testing
End-to-end testing
Test pyramids
Mocking & stubbing
Property-based testing
Load testing
Fuzz testing
Test automation frameworks
► DevOps & CI/CD
Ship software properly. Deployment and automation skills compound massively over your career.
Continuous integration
Continuous delivery
Continuous deployment
GitOps
Infrastructure as Code
Configuration management
Monitoring vs observability
Canary releases
Blue/green deployment
► Performance and Scalability
Every large system eventually becomes a performance problem. These concepts matter more than you think.
Latency vs throughput
Vertical vs horizontal scaling
Caching strategies
Hot path optimization
Performance profiling
Backpressure
Rate limiting
Timeouts
► Computer Science (Advanced)
You won’t need all of these immediately. But knowing they exist helps you understand what’s possible.
Compilers
Operating system kernels
Distributed file systems
Data compression
Real-time systems
Embedded programming
Networking protocols internals
Language runtimes (JVM, CLR)
Transactional memory
Formal verification
Before you go…one more thing
You don’t need to rush through these, or even learn them in this order. What matters is that you slowly build deeper intuition over time. Pick one topic you’re curious about, explore it for a few weeks, and then come back to the others later. These are life-long skills—you’ll revisit them throughout your entire career.
Every single topic above can take months to truly understand, and honestly, I’m still learning a lot of this every year. Building real distributed systems constantly pushes me back to the fundamentals.
So instead of trying to “know everything”, focus on understanding why things work the way they do. That mindset will take you farther than memorising APIs ever will.
Where to learn these fundamentals
Here are some of the best places to go deeper:
Books
Computer Networking: A Top-Down Approach
Operating Systems: Three Easy Pieces
Designing Data-Intensive Applications
Clean Architecture
Design Patterns (Gang of Four)
Free online
MIT OCW (free university courses):
Harvard CS50 (free)
“System Design Primer” on GitHub: https://github.com/donnemartin/system-design-primer
Final thoughts
You don’t need a Computer Science degree to become a Software Engineer. Some of the best engineers I’ve worked with studied completely different subjects.
What matters most is curiosity and the willingness to learn things you don’t know yet.
Take this slowly. Pick one topic and go deep. Keep learning, and keep being curious.
If you find this content helpful, share with someone who wants to start their software engineering journey next year.
really insightful - loads of practical lessons to take onboard.
Good list for every software engineer there.