TLDR:
While it is a good exercise, you don’t have to do/understand everything from first principles to accomplish useful things. Instead, you either use the abstraction out of the box or learn just enough about it to use it effectively instead of drilling down to its fundamental definitions.
==========================
Before I delve into this text, it’s helpful to know one particular definition of the word “abstraction.”
In software engineering and computer science, abstraction is:
The process of removing or generalizing details or attributes in the study of objects or systems to focus attention on details of greater importance; it is similar to the process of generalization. (original version on Wikipedia)
One straightforward example of abstraction in either math or computer science is multiplication. You don’t need to know that 3 * 3 is 3 added three times or 3 + 3 + 3. You just know, because of the multiplication table, that 3 * 3 is equal to 9. Therefore “3 * 3” abstracts “3 + 3 + 3” away. We can now use “3 * 3” in subsequent, more useful problems without knowing the details of “3 + 3 + 3.”
Now that we better grasp “abstraction,” we can move on to the next topic.
Math and computer science almost always boil down to “things,” the relationship between these “things,” and operations on those “things.” Let’s look at a hypothetical number theory scenario. You first define “1” and “2”. Then you add — aka apply an operation — on two “1s,” and you show that this is equivalent — aka equal (=) — to 2. So 1 + 1 = 2.
In general, “one” is defined as the successor of zero. Adding one to a number means transforming the number into its successor.
Note how the definition of “one” is abstracted by using its symbol: “1.”
So 1 + 0 is the successor of 0, which we defined as 1. This is represented as:
1 + 0 = 1
How can we visualize what a successor is? Successor means the next number to the right of a number on a horizontal number axis:
|—|—|—|————>
0 1 x y
We don’t know what x and y is yet. But so far we have the leftmost number on a horizontal axis, which is our base case: 0. Then, the successor of 0 is the next discrete number to the right. Which we have defined as 1.
1 + 1 = 2 tells us that turning the successor of 0 into its successor is equivalent to 2, meaning that the successor of 1 is 2.
Same thing could be done again:
2 + 1 = 3
Side note: the cool part about math is the fact that you can take long-winded natural language and condense it into a more laconic version made up of symbols.
Now our axis looks like this:
|—|—|—|————>
0 1 2 3
And as we perform “+” on and on, we get the definitions of all the natural numbers abstracted away by a symbol like 2, 3, 4, 5, etc. So essentially “=” is a method of abstracting a thing. You don’t have to know where 2 came from. You just have to know that it’s a natural number and that you can perform operations with it; that is, it can be an input to a certain function — in our case addition — as well as the output of a function — again, addition.
I like to categorize definitions in math and CS as static, operational and relational.
Static
n (which is a number)
successor of n (which is a number)
Operational
+ (addition)
n + m (turn n into its successor m times)
Relational
= (equivalence relationship)
So when you’re learning a new STEM subject, it’s useful to understand the definitions you are working with, be they static, operational, or relational. As you build upon your knowledge, you will notice that you will start working with higher and higher levels of abstraction. And when you work on a real-life engineering problem, you will have to use abstractions created by others. While it doesn’t hurt to understand the nuts and bolts of programs, sometimes knowing everything is not feasible. And so, you have to trust that the abstraction works and use the guide that comes with it to understand general use cases and implementation. A few years back, I wanted to know how everything works conceptually down to their first principles. While it is a good exercise, I now realize that you don’t have to do everything from first principles to do useful things. Instead, you either use the abstraction out of the box or learn just enough about it to use it effectively instead of drilling down to its fundamental definitions.