ng to build Google in 1998 or even 2009. Just because you can build anything you want in theory, doesn't mean you know how to do so in practice.
But not only has hardware gotten cheaper and easier to handle (through software), but during the same time our collective understanding of best practice software engineering has progressed by leaps and bounds as well. In between 2006 and 2009 many more people became acquainted with highly distributed architectures. More tutorials, libraries, and opensource software were written than ever before. Distributed Databases and NoSQL systems garnered a lot of attention. And with distributed version control systems like Git, code reuse and collaborative development became more commonplace. Many people stopped thinking about how to program individual computers altogether, and started thinking only in networked systems. Because of the wealth of information and code available, and a large community concerned with distributed system problems, a lot of things that were difficult a decade earlier, had become fairly easy to do.
Somewhen towards the end of 2009 I realized that writing Google as it was in 1998 didn't seem as daunting a task anymore. Not only was the hardware cheap, and the information on how to do it widely spread, but a lot of the functionality had already been implemented. Distributed Datastores? Check. Batch Data Processing? Check. Web Crawlers? Check. Web Servers? Check. The age of big data had arrived, because self-taught kids who wanted to could now play with it without asking for permission.
So do I think a fourteen year old could have pulled it off? I sure think so, but I realize in 2009 it would have taken a very tenacious fourteen year old. But that was 2009. If you are skeptic about my predictions for the past, how about applying them to today or 2015? How long till the technology that, at the time, precipitated the fastest wealth generation humanity had ever seen, can be replicated by a teenager with next to no budget during summer break? How long till it's something you write as a pet project while learning to program. Our tools are still getting more powerful, and our collective understanding of software problems is still increasing at a rapid pace. Do you think there's an upper ceiling for how good we can get at writing software? Are we close?
A few years ago, it was hard to find a library providing the functionality you'd need to write your application. A few decades ago the concept of reusable shared libraries had to be invented before you could write one. And if you'd wanted to use a hash table, if you even knew what a hash table was, you'd have to write your own. Today programmers have a wealth of collaboratively developed libraries for almost any purpose at their disposal. When you write software today, you're standing on the shoulders of countless giants.
Personally I believe that a large part of the reason we're collectively getting better at building software is that a portion of software written is software for building better tools for building better tools. We're not even close to peak productivity yet. We're so much drowning in solvable problems, that we don't even know what peak productivity in software engineering would look like.