Learning Computer Science Fundamentals Makes You a Better Software Engineer


I’ve heard that one can become a great software engineer with ten years of experience or with fewer years of experience but a solid grasp of data structures and algorithms. Since I studied pure math as an undergrad, I love this stuff. Recurrence relations, prime numbers in hashing functions for hash tables, P vs NP.

When I first started off programming I didn’t know just how much I didn’t know. I thought that being able to write a simple CRUD application was all there was to it and who cares about knowing how quick sort works. It’s true that I’ll probably never have to implement a hash table on the job, but knowing how to reverse a string or a linked list is like knowing how to play the scales as a musician. They’ll never be played during a concert, but they are classic building blocks in understanding computing.

So if you are learning how to code and not enrolled in an academic CS program, invest time after you master your first language or framework and learn the fundamentals of computer science. This will pay off especially if you’re looking for a job since they are common interview questions.

Learn how modern computer architecture works on a basic level (CPU, memory, disk). Read about data structures and algorithms. Networking knowledge is also very helpful (TCP/IP, DNS, basic architecture of the Internet). Find out how databases work (normalization, best practices for designing data models, indexes, ACID-compliance). Object-oriented programming is necessary to know. Threads and locks are not as common but good to understand.

Being able to implement the below fluently in one or two languages is also necessary. The following is taken from Cracking the Coding Interview.

Data Structures

  • linked list
  • binary tree
  • trie
  • stack
  • queue
  • vector/arraylist
  • hash table


  • breadth-first search
  • depth-first search
  • binary search
  • merge sort
  • quick sort
  • tree insert/find/etc


  • bit manipulation
  • singleton design pattern
  • factory design pattern
  • memory (stack vs heap)
  • recursion
  • big-O time