Learn Principles, then Programming

Experience != experience. Especially when you’re getting started

Prior to last year, I had spent most of my time at and outside of work focusing on writing code and creating applications. After all, that’s generally what the company that hires you pays you for. However, for someone who never studied computer science systematically in college, there was an underlying and lingering knowledge void that made me uncomfortable. Sure, I was becoming more experienced as a programmer (on paper) but even with all that experience I didn’t really feel ‘all that experienced’. There were more things I did NOT understand than I did. And somehow the list of things I didn’t understand kept growing every day instead of shrinking. I was able to use the latest Javascript libraries or C# tricks but with a very shallow understanding.

I have since learned that all experience is not created equal. we gain experience virtually by doing anything and shouldn’t be satisfied with just that. What we should seek is an experience of high quality. Especially when we are still new to a subject, we should try and seek an experience focused on fundamentals and principles that have a long shelf-life and upon which we can build. Only by doing that can we maximize the compounding interest of our efforts.

This lesson changed my entire approach to learning.

Learning by First-Principles

You’ve likely heard of the term of doing things by “first-principles”. It’s a rather famous approach to problem-solving where you continuously break a complex question or issue down to its very core, it’s basic principles. Then, using those fundamental truths, you logically build your way up to a solution. It’s an extremely simple way of tackling complex obstacles and makes a good deal of sense. The funny thing is that most of us rarely build our lives around such techniques that could help us save ourselves lots of effort, make infinitely better decisions, and become smarter faster.

In large part, I believe this is because few of us have actually been able to quantify the benefit from doing things in such a structured way. Further, because we make lots and lots of decisions every single day like that, of which some need to be made under certain time pressure, the effect of each decision is diluted and things blur together. That makes evaluating the efficacy of our progress even harder. We lose the signal in the noise.

Slow things down and think long-term

However, if we want to get better at anything, practising slowing things down and trying to get to the core of what it is that we’re dealing with or trying to learn has profound effects. It takes time and it’s not the most convenient thing in the world, but the payoffs over time dwarf any of your other efforts if you sit down and compare notes over time.

In general, it seems that humans are extremely short-sighted and short-term focused. It’s not really in our DNA to consider long-term effects and how it affects compounding, nor does it come naturally to most. That kind of makes sense. Our ancestors didn’t live very long and spent most days roaming around looking for food and trying not to get killed. Ironically enough, in today’s significantly more fast-paced technological world, slowing things down and developing patience has become one of the most important indicators of your success in life. It’s actually easy to see this truth play out in everyday life. Just look at the people around you that are successful. They usually display a pattern of consistent, diligent action which yield long-term outsized returns. They’ve usually been playing the piano every day for 2 hours since they were 5 years old. They’ve usually been eating out less and investing more since they were in college. They’ve usually been reading and doing the stuff that’s hard and doesn’t pay off immediately rather than the stuff that’s fun, easy, and makes you feel great in the now but is fleeting.

Ask yourself “Why?”

As it relates to computer science I have found that the same fundamental truth applies. Learning by first-principles requires you to take a step back and likely reduce the amount of code you write for some time. You start to spend most of your screen time researching, reading, taking notes and researching some more. You find yourself asking questions like “where does this come from?”, and “why is this being done that way?”, and following that question up with another “but why?”.

Over time you start to realize that most programming languages and technical marvels are made up of lots of simple ideas, of which many are inter-related. More often than you’d think, the birth of those ideas coincided in time and place and/or the same people were involved in fostering or popularizing them. The field of computer science, like most great things, wasn’t built in a day. Smart people worked together on problems they cared about and came across a solution that worked. Most importantly, they decided how to implement that solution which ended up affecting how the next generation did things and then the next.

50 years later, those initial ideas are easily forgotten and we stand in the midst of massive, fast-moving complexity that largely derived out of those somewhat arbitrary decisions made all those years ago. By repeatedly asking myself “why?”, I embarked on a learning path that has had its focus in part on the history and in part on computer science. This path has led me to start understanding the foundational and great ideas upon which much of modern computer science is built.

Obviously, I am incredibly far way from mastering any of them, and probably never will. However, I can already tell that despite writing less code in the last year, I have become a significantly better programmer. Despite not reading up on the latest and greatest tech every day, I am able to jump into new stuff more quickly and pick things up. The void I mentioned in the beginning, has started closing. When I code today, I have a much more intuitive sense for what’s going on under the hood. I feel much more in-sync with my computer and every time I hit a key on a keyboard my mind has a rough understanding of what’s happening in the background, both in software and on the hardware. In a cool way, that has heightened my joy coding and my appreciation for all the hard work those amazing people in the past have done to get us where we are today.

So what exactly does learning by first-principles look like for me at this stage?

• Focusing on studying the fundamental building blocks of computer science
• Avoid spending too much time on the latest and greatest tech, unless absolutely necessary to solve a problem or directly mandated at work
• Reading more books, blogs, etc. rather than just writing code for the sake of writing code
• Developing an appreciation for computer science history, because new tech builds heavily on old ideas.

— — — — —

Hope you enjoyed the article. I would love to hear any feedback or stories of your own that might relate to this topic.

Scott