10 Fundamentals Self-Taught Developers Often Miss

Throughout my career, I have met good programmers, great programmers, and terrible programmers. Some of the best programmers that I have met were self-taught programmers. This means that they did not attend University or have a formal computer science education.

They learned a technology because they wanted to get their hands dirty and start developing and creating. They may have wanted to make a website, a game, or a mobile application. These developers are very good at finding out what they need to understand to "make it work". Many times their solution is not optimal, but they usually can get the job done (an important quality none the less).

With this article, I am aiming to help the self-taught developer educate himself/herself with what formally educated programmers have known for years. What I am referring to are topics that are covered in Computer Science 101. Armed with this knowledge, the self-taught developer can take their skills to the next level and have a deep understanding of the interworkings of their code.

Well, let's get started...

1. Arrays

• Know how to use arrays. You will use them a lot.
• Learn how to make them grow dynamically (for programming languages like C).
• Know how to use a standard library array (example: vector)
• Learn to use strings (they are arrays).
• Know how to sort them with two good sorting algorithms (QuickSort and MergeSort)
• Learn to search in an array. First linear search and then binary search.
• Learn QuickSelect, it will be useful.

2. Linked Lists

• Learn how to create a linked list from scratch in C.
• Know the basic operations: insert, print, delete.
• You won't implement linked lists a lot in the real word, but having a solid understanding of how they work will be of great use.
• Know different versions of linked lists: circular and double, for example.
• Know the advantages of a linked list vs an array

3-4. Stacks and Queues

• Learn to implement stacks and queues with arrays and lists. Know the advantages.
• For stacks, learn postfix conversion and evaluation. Practice implementing parenthesis matching. This will help you master stacks and get an idea of some of their use cases.
• For queues, you should try to do some multithreading programming.

5. Trees

• If you did proper work with linked lists, trees should feel a little natural.
• Learn to implement a binary tree (insert, delete, search).
• Know the basic properties of a tree.
• Learn at least one self-balancing tree (AVL, Splay, Red-Black).
• Understand the Trie data structure. Learn its applications.
• Another data structure used a lot is the heap. Understand heaps and realize they are just a priority queue. 
• Learn Breadth First Search and Depth First Search.

6. Hashmap

• Understand the advantage of a Hashmap and realize that it is one of the most useful data structures for retrieval of an item in constant time - O(1)
• Learn how to use them and how to implement one (learn how to implement an efficient and effective hashing function).
• Understand what collisions are and how they are handled in a Hashmap.

7. Graphs

• Learn what a graph is and how to implement them with a matrices and lists.
• Learn how to find shortest path in a graph.
• Implement DFS and BFS.

8-10. Algorithms

• As I mentioned before, learn sorting and searching algorithms.
• Learn Big O notation.
• Search: MergeSort, QuickSort, HeapSort.
• Dijkstra - understand the significance and its applications.
• If you are really interested in diving deeper, read the text Introduction to Algorithms. This is the defacto book on the subject.

If you liked this post, please share it with others! That is the biggest compliment I could receive. 

This article originally appeared on my blog at jasonroell.com. Please subscribe if you are a technology enthusiast!