Abridged History of Tech & Related Reads
Way back in the day devseed did Drupal. We saw two main problems with it:
- It tried to hit lots of different usecases and handled this by growing ever-larger instead of becoming modular
- It was slow
We couldn't respond to #2 because it was the 'essential quality' of Drupal being built on PHP/MySQL and having 'make everything dynamic' as an essential property.
We responded to #1 with the 'smallcore idea': http://developmentseed.org/blog/2009/oct/28/smallcore-manifesto-help-us-build-better-teddy-bear/ This was semi-successful but was a hard sell because Drupal's module infrastructure was brittle and had the impossible goal of making programming-like tasks available as configuration.
Smallcore today is basically npm: it makes everything great.
Underlying principle read is the 'unix philosophy': https://en.wikipedia.org/wiki/Unix_philosophy
The extreme examples of unix philosphy in node-land are basically substack and yields, two people who write sometimes idiotically tiny bits of code - https://github.com/yields/fmt/blob/master/index.js - and distribute it as modules. These modules fit together into logical bits, but seeing what people call 'work' sometimes impossibly small bits of code - is weird.
Next principle: Worse is Better http://www.jwz.org/doc/worse-is-better.html I jokingly paraphrase this as "good enough is perfect" all the time. Basically: in many cases it's important to use a heuristic and get things halfway there first rather than thinking through a perfect solution.
Learning how to think about heuristics https://en.wikipedia.org/wiki/Heuristic_(computer_science) is a big element of working. For instance, this massive heuristic hack http://www.macwright.org/2011/08/10/fast-hacky-queries-with-utfgrid.html is how our reverse geocoder works. It turns a problem that's super hard to solve into a different one that's similar enough on the surface but is really easy to solve.
As far as how tech moved:
- First, mainly static pages.
- We started with PHP & CMSes, of course. In this phase everyone wanted to make it easy to do blog-like software on the web, and make it extremely user-friendly and modular. It's still kind of an uncompleted goal.
- Then, ruby on rails. This brought the rise of convention over configuration and don't repeat yourself as basic principles.
- Then _why introduced camping. He was awesome, and it turned Ruby on Rails on its head - instead of lots of assumptions and lots of magic, it was brutally simple and ground-up.
- Camping inspired sinatra which inspired express which is what we use in node.
As far as web/client stuff:
- First, there was prototypejs. It, like its name, extended the prototype of javascript objects, so like you could do things with just
"string".foothat you couldn't before - People drifted away from prototype to jQuery because the principle of extending objects got weird since the language itself was tricky so some of the features prototype added javascript itself would add and that made for weird conflicts. The creator wrote a great post about it.
- jQuery is/was the world-winner because it fixed how javascript worked across good and bad browsers and let people do fancy things more easily
- Once bad browsers started to fade in importance, a bunch of jQuery alternatives came into the picture that either didn't care about bad browsers or cared a little and focused on something else. d3 could be considered this, or zepto or ender.
Beyond basic 'how you interact with the page', there was a movement towards tools that organize the flow of stuff on webpages, like views and events and whatever. The first was Backbone, and then there were variants that tried to define more of the process or do other neat wheelies, like Ember, Angular, and so on. These could be considered 'second gen' but really they're a different approach and maybe one that sucks. Facebook's React framework might be considered a third wave, since it is kind of like Backbone meets d3. But all of these are a little kludgy and huge.
The cool kids ignore all of that and build with browserify because it lets things start super simple and embraces the unix philosophy hard.