A minimizing framework

I love the .NET framework for it’s simplicity, abstraction and immense documentation, but it is these levels of abstraction that often make me doubt the .NET framework.

E.g. the ADO.NET library which converts data into objects, and later objects into data is an abstraction layer to make sure that no extra calls to the database are made at runtime. What happens is that data is read from a database, serialized into XML objects, that you can later send over the network(SOAP), or simply change the data with some code. Once you command it to save the changes, only actual changes are compiled into a single, most efficient transaction and sent to the database.

This may seem as a layer too much for many small application developers, since on the small scale you can as a rule of thumb keep an eye on your transactions, and this conversion just slows the things down. That is true on the small scale, but on the large scale this is more efficient since human stupidity is limitless, so this is a means of making sure that no mistakes are made.

However the result is slowing of the application, and this is something that we with years accept, and something I hate about the software business. We abstract, abstract and abstract, every year making our applications slower, slower, slower and slower, however smarter and easier to develop. I, unlike most, value speed just as much as complexity and ease of development, so I believe there is one underlying goal missing in the .NET framework.

This goal is the following. When you are developing the application, abstraction layers make it a lot easier to develop a complex application, but once you are done it would be brilliant if these abstractions could be minimized. Meaning that i.e. function calls could replaced with the actual code of the function, so that a whole class or library doesn’t have to be loaded into memory. However function calls are sometimes more effective than simple code(i.e. dynamic programming), but it is just as often that you would use the same function a single time or just a few times within your application, and if the code could be isolated into your application that would have been much more efficient.

So what I want is a sort of compiler, or rather optimizer that I could invoke once my application is fully developed, which minimizes unneeded function calls and thereby abstraction layers.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s