There are a lot of guides out there in the wild, most of the time, telling you what languages to learn and the hottest thing to know so that you’ll be an industry unicorn.

While they may be useful, they only guide you on the surface value. They give you a surface trajectory and if you want depth, you’re going to need to go swimming.

So, that’s what I’ve decided to do today — to help you gain the depth of knowledge needed to become a truly effective developer, but on the “meta” knowledge of programming that no one really talks about unless you’ve really put yourself into the deep end.

They are the things that computer science graduates are taught, things that those on the self-taught track often miss out on. They are foundational towards how you view and write your code.

Here is a checklist-styled guide for you to traverse and pick up in those little pockets of random curiosity.

A Comprehensive Guide (Mostly Language Agnostic)

1. Let's Talk About Algorithms

Everyone talks about “the algorithm” as if it is some mysterious entity, conjured up by AI and will be the doom of us all. Or, perhaps that’s just one side of the general public’s perception of it.

Before you jump on the bandwagon, in programming, an algorithm is simply a set of repeatable rules to achieve a particular outcome.

When it comes to algorithms, knowing the mechanics of sorting algorithms can help keep you sane when you’re presented with large sets of data.

At some point, you’re going to encounter data and you’re going to need to do something with it. If you’re privy to methodologies that have been designed and tested for specific kinds of data, it makes you less reliant on methods like list sort().

This is because sort() tends to run on its own algorithm that may differ based on the rendering engine. When you write your own algorithms, you are in better control of the quality and speed of the data processed through your code.

2. The Art of Design Patterns

Everything boils down to a pattern. Implementing a design pattern is the result of taking steps back, looking at the bigger picture, and determining if the problem has been encountered before.

If it has, a design pattern is used to save time, prevent potential issues further down the road, and create a standard for the code creation process.

While design patterns may seem like a large area to learn, it provides a good return on investment because you are essentially cutting down on the potential future spaghetti and meatballs that could materialize from your code due to lack of or weak structures.

In a way, design patterns are like a predesigned blueprint that helps maintain code readability and comprehension as your application grows.

3. Arrays! Because Everything Is Data

In almost every tutorial, ever, you encounter a very simple version of an array. You know the kind — flat, single-leveled, and has a few items in it. But in real life, there are a lot more variety, shapes, and strangeness that can present themselves in the form of an array.

Multi-dimensional and jagged arrays are the kinds that we often work with when production-level data sets are involved. How we optimize the structure of these arrays for creation and consumption can also determine how efficiently and effectively we can implement them.

4. Linked Lists

Unless you’re in the world of C++ or Python, it is unlikely that you’ll encounter the idea of linked lists. While it may look like an array and sometimes smell like an array, linked lists have specific pros and cons that are different from using arrays.

If you start diving into how data is presented with linked lists, you’ll find that it works rather well for large datasets due to its capacity to be limitless.

Arrays will eventually need to be resized if they get too big. Linked lists can just keep “linking” with one another.

5. Hash Tables, What? (Unrelated to Hashbrowns)

Programs work on organizing large bodies of data in a way that is accessible and comprehensible. A hash table is another method of storing and retrieving data.

It’s often used when large datasets (we’re talking millions of data points) are involved and data needs to be retrieved quickly. But it can also be engineered for smaller datasets, in local application storages for efficiency and cataloging specific sets.

6. Let’s Get Serious — Processes, Threads, and Concurrency

When you start getting into processes, threads, and concurrency, it means that you’re starting to hit the deep end of programming.

However, even if you never encounter them because they are predominantly for back-end developers and you’re a front-end dev, it’s still good to have an idea of how they work.

This is because it gives you an overall understanding of how computers work and how code works as a communication bridge between humans, the rendering or interpreting engine and machines.

It also makes you aware of how memory works and how the code you write impacts performance.

7. Binary Search

And we’re back to another data-related topic. Binary search is an important topic to check into as it has to do with the performance.

For the binary search to work, the dataset that’s being searched has to be pre-sorted, giving the algorithm the ability to quickly move through each data point and decide if it is a match or not.

There are different techniques when it comes to binary search, often a mix between algorithms and recursion. The idea of binary search can be applied across different languages and is more a technique based on mathematical reasoning than actual code.

8. Trees

At some point, you’re going to hear about trees. Not the usual thing that grows in dirt and gives you oxygen, but the thing that structures your data based on a relationship base structure — accessible through nodes, leaves, children, parents, and siblings.

If you’ve worked with HTML, you would have heard of the DOM tree. That’s one type of tree. A binary tree is one where each node has two child nodes attached to it, creating a pyramid style graph that can be traced back to the topmost point.

But there’s more to trees than that, namely to do with performance, dealing with data, and how to quickly retrieve it.

9. Testing

Don’t just learn how to test. Look into theories behind testing. When we test things, we tend to focus only on unit testing rather than also figure out how big-picture ideologies work and why they are fundamental for robust code.

There are also functional-based tests and non-functional ones such as performance, security, usability, and compatibility tests. These things are also often on the low priority list, if not on the agenda at all.

Testing also lets you run hypothetical scenarios and pre-determine the shape of your data, which are important and let you anticipate potential issues before you start coding.

10. Dynamic Programming

Dynamic programming is a method of solving complex scenarios by breaking them down into their smallest possible components in a recursive manner. It’s a programmatic technique that is used across multiple disciplines and isn’t just limited to just code.

The thing about dynamic programming is that its usage of recursion means that a problem is only solved once and works to optimize the workload rather than combing through things based on a specific and repeated algorithm.

Initially, the idea of dynamic programming can be confusing, especially when it looks and sounds almost like algorithms. But they are significantly different and work on different ideologies that can help you become a better programmer in the long run.


SOLID is a set of five design principles in programming. They are patterns that can be implemented for object-oriented style programming.

Their usefulness comes in the form of creating code flexibility, long term maintainability, and a generalized understanding of how things are implemented between developers.

SOLID also forms the core philosophy for agile software development, in addition to creating robust code.

Parting Words

There’s more to code than just learning how a language works. There are the unspoken mechanics and techniques that make the language, framework, or library tick.

I hope this meta-knowledge guide has brought more awareness towards the vastness of coding and that it’s not just limited to…well, code.

Going beyond if...else statements in your code is also a sign of growth and knowledge application, something that many juniors and beginning coders get stuck into.

You don’t have to fully understand everything completely. But the knowledge dots can help us in the future as code creators.

Knowing, or at least having knowledge of, how the above topics function and fit into the bigger picture will help accelerate your coding process and increase the potential robustness of your creation against cracks and decay.

Share this post