I've been thinking about this for awhile (and in fact wrote a couple of blog posts about it) but I wanted to get some feedback from you guys. There seem to be two opposing camps in the programming world. The simplicity at all costs approach and the abstraction is best approach. C is a good example of simplicity. The language is extremely terse and if you can already program it is relatively straightforward to learn. Once you have mastered the language there really is not all that much more to learn. The disadvantage with this approach is that it requires the programmer to spend inordinate amounts of time implementing all the small little details in their program. There is no standard read line function for instance. This makes it extremely inefficient for writing small applications as you end up spending several orders of magnitudes longer implementing simple functionality yourself. Of course you end up building a library yourself over time and just reusing that in all your applications which eventually saves you time. Then there is the abstraction camp. Java is a great example of this. It has extremely comprehensive libraries and frameworks and attempts to get rid of the problem that C programmers face by abstracting away some of that complexity to the standard library and by providing an object orientated programming idiom which hides some of the implementation detail. This means that for small applications Java is much better than C as you can just use the wealth of pre-written standard library functions to get the job done for you. The problem with the abstraction method is that it removes the one thing that all programmers have in common. An interest in computers and by inference computer architecture. My contention is that by hiding the implementation behind an object orientated idiom you are turning something that programmers naturally find easier to understand into something which is outside of their realm of experience. With C and other bare bones languages the time spent to implement a program is probably going to be equal to the amount of time a Java programmer takes getting used to using the absolutely huge Java frameworks. Have you ever tried to use Java EE? It is a mind boggling task which is just made harder by the attempts to hide the implementation behind abstractions. Programmers no longer have the option to really understand what they are doing, instead they have to rely on understanding abstractions which are not necessarily any easier to understand and are often poorly explained in documentation. They also must grapple with 1,000 page documents which attempt to explain things in a friendly fashion. By the time you have read most of the documentation of these frameworks one can not help but wonder what you could have achieved in the mean time if you had just put your head down and got on with it in C. Ideas, comments, opinions?