Rethinking of Levels of Abstraction
It has been a while since my last blog. But I was busy thinking of a lot of crazy ideas and trying to push myself to the limit. Here some of what I’m thinking of right now!
The current modern systems are built in layers and layers of abstraction. The idea behind abstraction is to divide complex systems into layers and each layer has relatively simpler complexity. But we are accumulating on the same layers built one the beginning of the computer age. For example the microprocessor is the same as the first microprocessors built. Some people might argue that and I agree with them we have very advanced microprocessors today comparing to the Intel 8086. But here I’m not talking about the technology, I’m talking about abstraction. Computer designers are using the same interface for the CPU level of abstraction since the creation of the first microprocessors.
This huge accumulation of old levels of abstraction will start failing in keeping serving the current needs for today’s and future’s technology. One example of that is the multicore processors. With the introduction of multicore we start hearing from researchers that we need to rethink of processors, operating systems, and programming paradigms. However, most of the current efforts directed to keep the same contract between the different layers of abstraction and just change the internal of each layer without breaking the contract between the layers.
I think these levels of abstraction are not written in stone and we don’t just need to think about improving each layer, but we need as well thinking of the abstraction levels from time to time. However, I don’t recommend changing the abstraction levels very frequently. But I do think that there are some times where we need to rethink of the whole stack, and today is one of these times.
In rethinking of the abstraction levels there are two approaches. First approach is rebuilding the whole stack again from ground up. This approach gives the designer total freedom of building new stack. One particular project that I like and follows somehow similar approach is the Par Lab at Berkeley [1]. Researchers there are aiming to setting new agenda for multicore research starting from anticipating the future applications and then design new stack the will support these applications.
The other approach of the rethinking of the stack is to use ideas from higher levels of the stack in the bottom of the stack, or vice versa. This approach allows the designer to reuse already well defined and tested solutions. One project I liked that follows the same approach is Factored Operating System (fos) at MIT [2]. They are using the same concepts Internet to design operating system that is service based. I liked this idea very much since I was thinking of it for more than two years. At the beginning I thought that is very crazy idea but not it’s real.
[...] thing that I already talked about in my previous post. We need to rethink about the contract between the different layers of the stack that we built so [...]