Standards and Abstractions Speed Development
Code quality and development speed are usually in opposition. One of the things that drew me to Ruby on Rails development was the focus on development speed without compromising quality. The primary means of achieving this veritable panacea is by making decisions once, abstracting the principles, and then layering with convention. Rails has done this well. However, in our own application development it oftentimes feels like we're reinventing the wheel every time we start a new project.
Sounds to me like it's time to do some abstractions of our own, but there are a few reasons why we haven't started this process sooner:
There are a number of people/companies doing the same thing and have contributed their abstractions to the community. It takes time to find and evaluate the tools already available because we don't blindly use any plugin that we can find. We like to take the time to fully understand the tools that we are using.
You need experience doing things the hard way first in order to fully grasp the nature of the problem and be able to offer truly elegant solutions. The opinions that we have on software development and the tools needed are drastically different now than they were one year ago. We have completed a number of major projects in the last year where we employed many different techniques, watched patterns emerge, and formed new opinions about how to build solid and usable web applications.
Abstractions are more difficult and take longer to create. We have been consistently over-capacity for the last year and its hard to make the decision to take the longer path to completion on your own dime. So far, we've taken the rather straight-forward approach of building custom software and charging for every hour of development time. It's not often you'll find a client willing to bankroll such abstractions.
Typically, when up against a budget or deadline it's time to cut features (and rightly so). My problem, however, is that what usually gets cut isn't necessarily entire features, but the depth of features actually implemented. Beyond the applications unique features, we end up creating the same things over and over again, but all at surface level.
It's going to take a lot of extra work, but we're starting the process of abstracting our common decisions and implementations into libraries, plugins, gems, and services. You can always keep up with our open source contributions at http://github.com/sevenwire.