Abstractions is a part of evolution and it is how we humans have evolved for the last centuries. Seen from the very beginning, we have abstracted (and are still abstracting) everything from our language, math, and programming to way of writing, cooking and staying in touch with friends and families. From the very beginning before we had any formal way of representing numbers we had to actually show the amount we meant, with physical objects. Later we learned to draw lines to represent numbers which later became roman numerals. Now humans had a way of representing an amount of something in writing. Later this evolved into our 10-based number system we use today.

In short, our way of representing an amount of something has gone from the cumbersome use of actually showing the physical representation of a number with sticks, to the easier way of drawing the sticks, to our current and much shorter way of just writing out a number. This is abstraction. Five sticks is now abstracted by a simple number (5). This number abstraction has kept moving forward. Take factorials for example. Instead of writing out $5 \times 4 \times 3 \times 2 \times 1 = 120$ to find out how many possible ways we can arrange five different colored marbles in row we can simply write the answer, 120. Then we have taken it another step forward to write $5!$ which in fact tells us both that we are dealing with factorials (the exclamation mark) and that it’s the factorial of 5 that we are talking about, which in turn is 120. Now we have shortended it down from a row of multiplication to just the answer, and then to just the $5!$. And not only that, the $5!$ has actually more information than just tne answer $120$. So not only is it shorter, it carries more information. This is often what we mean by a beatiful peace of text or explanation. A very short message that contains a lot of information. To be able to say a lot with little actual talking or writing.

In other words, abstraction is all about saying more with less. To be more expressive in fewer words, numbers and symbols. This has both it’s advantage and disadvantages. The advantages is that we can express ourselves more easily, and since it’s so formal there are less risk of misinterpretation. An other advantage is that it drives humans forward. To keep up with the abstraction we must learn to think more abstractivly about the world, which in turn makes the general populations IQ go up. And since humans get smarter, we tend to continue to do even more abstractions. And so it continues. The disadvantages then, what are those? Well, the obvious disadvantage is that it requires more education to understand all of these abstractions. This isn’t necessarily a bad thing, but it becomes a bad thing when people can’t keep up and get left behind. We can’t ignore or forget that we aren’t all alike. We all learn at different speeds, and it’s not good that people get left behind.

## Programming and the like

So, in other words, abstraction in math and languages can make things a bit harder to learn. On the other hand, the upside is that we can express ourself a bit more easily. When it comes to programming things are a little different, even tough some of the things from math and language apply here also. In programming we usually add abstraction layers to order to make the language easier and quicker to learn. I think most people will agree that it is easier to learn Python than C. Same thing goes for C and assembly, it’s easier to learn C than assembly. So the advantages and disadvantages are a bit different when it comes to programming and computer science. Here the advantages of abstraction is simplicity and quicker development and less need for education. And since this moves the development further in a faster tempo, this must be considered a good thing.

There are some disadvantages to abstractions in programming though. First of all, the more abstraction layers you add, the less efficient the end program will run. This is due to the higher languages has to be interpreted and eventually compiled. So there are more steps that has to be taken from the code to the actual running program. And all of these conversions and interpretation adds garbage and unnecessary code. And for interpreted languages it’s also adds the time to compile the program on the fly every time it’s run. All this is inevitable. On the other hand, our computers keep getting faster and faster and so this might not be a problem. And many people argue this isn’t a problem at all since we have Moore’s law. But to be 100% honest, despite our computers today is about a hundred times faster than the computers I ran Windows 3.1 on back in my childhood, my old 486 with Windows 3.1 seemed snappier than my 8 core machine does with most modern operating systems. And this is due to all the abstraction layers. Back in the days developers took great pride in optimizing their code so it would use as little memory as possible and run as fast as possible. Today we’re in such a hurry to develop that this is (mostly) all gone.

Another disadvantage of all the abstraction layers is our own knowledge of the lower bits and pieces of our own computers and machines. If the development towards higher and higher abstractions continue we might end up not being able to fix the lower layers anymore. Like a TV repairman that can only fix TV’s by operating the remote and having no knowledge of the internal circuits or how to use a soldering iron. Then imagine what will happen if something in the lower layers will break and no one being able to fix it. I don’t belive this will ever happen tough, since there are always old school hackers around. But, I do belive that it will be harder and harder to find those who can fix the lower bits and pieces. Imagine 20 years from now, what will the IT-world look like then?

We actually don’t have to go as far as to programming to realize that we keep adding abstraction layers. Take for example LaTeX which I love. Nowdays I write most of my papers in Markdown, which I run through Pandoc, which converts my Markdown to LaTeX, which then produces a PDF. I have even made my own Python script for Pandoc. So I actually ended up with another layer.

Markdown
|
|
|---> My own script
|
|
|---> Pandoc
|
|
|---> LaTeX
|
|
|---> pdftex
|
|
|---> Final PDF


So the layers keep stacking up, one over the other. We get to write shorter and cleaner code and produce greater and greater result. And we keep doing this all the time. And perhaps we shouldn’t argue with it, since it’s evolution. We have kept on doing it since the dawn of time. The question is, can we keep up the pace? And should we?