Paul Simon sings, "Every generation throws a hero up the pop charts." Each person who attempts to conquer the highly fickle music or fashion market frequently does so by merely rehashing old ideas. Trends are repeated and what was once passe becomes fashionable again, as the definitions of old and new are blurred by memory and packaging.
Software is no different. Each new wave is set in motion by realizing the failings of the current technology and then trying to solve those failings. Rather than progressing in a forward direction, however, what often occurs is the very forces that drove the latest technology are also found to be lacking, and so there is a return to the old ideas. In some ways this is no different from politics where, if an incumbent is thrown out on the weakness of his/her current form, the opposition merely returns and attempts the ideas that failed originally. Likewise with technology (although with each reelection time has moved on), hardware is quicker, networks are faster, and problems that let the previous incarnation of the solution down no longer have the same relevance.
The largest, most obvious example of this pendulum swing is the Internet. In the 1970s, mainframes ruled the world; computing was done on a large box with users working on attached terminals; scalability was achieved through the shared loading of programs, pages were cached for each job's session, scheduling was done by queuing time-sliced work, and prestarted resource pools helped with performance. Two evolutionary predators threatened the beast: (1) Moore's Law allowed faster computing power to be provided at lower costs, and (2) the demand for the graphical user interface. PCs ruled the GUI. However, on their own they couldn't provide high-end computing for multiuser environments, thus the client/server model was born - a topology in which the front-end PC had the computing resources to power the GUI while the back end was the workhorse for the application.
A problem arose as to how big a horse the back end would be, with many companies having different vested interests in each endpoint of the equation. Wherever the logic was, so would go the processing dollars. To bolster the front-heavy version the terminal was called "dumb" and, with the subtle inference that it would one day be replaced entirely, the server was nicknamed "legacy." Initial implementations attempted to front-load all of the logic with the back end merely answering SQL requests. The voices of those who had the experience and knowledge to know this solution would never scale were somehow never heard as the emperor paraded his ideas.
The lure of the GUI wasn't enough to sustain unsafely practiced client/server though. All that glitters isn't necessarily gold, and scalability and distribution became the new issues. To move forward from here the software pendulum swung back toward the server. HTML and HTTP were in the right place at the right time and replaced the dumb terminals' display formats. Green was replaced by color, and white became the new black.
