This writeup is about where I see web development going, where I want it to go and where I think it should go but it shouldn't.
Don't lock things in. But give an obvious path for beginners. Locking things makes evolution to better tools more difficult. Giving options makes getting this done more difficult and time consuming.
The interface and the platform should be separate frameworks with a compatible interface. Perhaps a schema file that the interface can read and understand for generating queries to the platform.
Can mount the platform and the interface side by side (use them like a single app) but they will talk to each other in the same way.
Perhaps the syntax of the platform could also document it?/Have the schema generated from it.
Take BDD into consideration with the design of the framework. A core piece.
Interesting writeup about fast-specs http://ariejan.net/2011/10/13/fast-specs-run-your-specs-in-less-than-1-second Essentially a fast spec is a spec with few dependencies.
Concurrency problem? Like node.js. It allows you to handle tons of coocurrent users. How? Is that an interface thing? Or both sides? Hmm.
Need better understanding of using compass with SASS.
Failures need to be understood and fixes. Usability failures as well as technical failures (gems failing to install). There should be a systamatic way for everything to report and bitch about it's issues. Like a Airbrake queue from everything. Specific to the gem not the applicaiton.
Standard cheatsheet documentation style. Every document I read has a different style and a different way to navigate it. Competing styles are good. Everyone doing their own thing is bad.
Edit through the browser using on the IDEs and store on github instead of a local storage. For saving but not committing use a form of branching? Or something...hmmm
admit that applications need constants. And this constants often need to be different between environments and setup a file for that. The interface and platform should not need the same constants.
Publish the issue rates of gem/interfaces/libraries. This includes the 500 style exceptions and the "wtf do I do" exceptions. This may be unfair for libraries trying to tackle harder problems.
Listen to the churn. Churn is important. For some stuff.
Non-gem dependencies (like Redis, mysql, postgres) should be managed by homebrew or an equilvent via a bundler Gemfile style interface.
JavaScript is code too. Should the language of the code change it's handling? Or just client side versus server side? Or neither?
JavaScript ajax style requests so hit the platform and not the interface? Hmmmmm.
API changes must include transition depreciation releases. Perhaps APIs could be automatically tested based on their interface? Strong typing style?
Does a platform have data views? Should it?
How hard would it be to write an image processor in RUby? How does ChunkyPNG Work? How hard are C built libraries? hmm
ImageMagick is a big headache for everyone.
Sqlite as a pure rubygem? For beginners they should only have to install git + rvm? hmm
Gem updates should have a changelog. What changed?!
Standard changelog format using YML or something? Rspec's https://github.com/dchelimsky/rspec/blob/master/History.rdoc