Path of First Principles
Everyday we have a choice between doing what's easy or what's difficult.
What's easy comforts us; whats difficult improves us.
We know these things, but we usually opt for whats easy and inside our comfort zone.
I challenge you to push against that urge.
In programming, people believe its easier to start with languages like Python or Javascript rather than something like C, because C is confusing, has too much to learn, and it gives you nothing.
The problem is we frame: - "confusing" as difficult, instead of lacking understanding - "too much to learn" as difficult, instead of opportunity - "it gives you nothing" as difficult, instead of seeing it as freedom
Therefore, we opt for "easier" languages, not recognizing that each language has its own pitfalls and the difficulty associated with it only gets worse, not better.
For example, the more complex you get into a Python codebase, the harder it is to solve the problem.
The language choice matters, but isnt what's even difficult.
The real difficulty is solving the problem directly in front of us with code.
Not the problem we think we have, but the actual problem.
As programmers, we make things happen one problem at a time.
We break down large problems into smaller problems, until those problems can no longer be broken down (atomic).
We want to tackle these atomic problems one at a time until we arrive at our solution.
To solve problems, though, we need to build a solid base. A base where we can comfortably look at problems we have solved before and try to match it up with our current problem.
We need to focus on problem solving, not tools. We want our tools to get out of our way.
C is great for this.
The hard part everyone talks about, is the problem solving part, not the language itself.
C is relatively simple. The hard part of it is building because it gives you nothing (freedom), and that's a good thing.
This is where we start on the Path of First Principles.
We have to understand what we build.
Good.
Why choose this path?
- To be marketable.
Its not enough to simply know frameworks and gluing code together. The market is saturated and we need to stand head and shoulders above others to become employed.
- To create great code.
Without fundamental understanding, we cant truly make our code resource efficient, performant, and simple. One, if not all, of those three will give way. Having all three contributes to point 1.
- To tinker/hack however we'd like.
Let's face it, you're here because you enjoy building, or at least getting paid to build. You're going to come up against novel problems, and you want to solve them. The only way to solve novel problems is to start with axioms (fundamental known understanding) and exploring possible solutions. A solid base in fundamentals lets us do just that.
The desired outcome is the same: having freedom.
What are the first principles of programming?
- Computer Architecture/Organization
- Understanding data manipulation
- Problem solving
The First Principles path is not an easy one. In fact, its quite difficult.
We choose the hard path now to have freedom later.
We dont want to just be programmers.
We want to be problem solvers.
If you're reading this, you are on the Path of First Principles.
Welcome to the arena.
- Glitchbyte