Rinat Abdullin

The management of software development is all about using scarce development resources to satisfy unlimited wants of the customers.

In the situations with limited resources (time, budget and skilled labor) the only way to get more out of nothing is to use these resources more efficiently. One way of achieving such a goal is about better automation of some development processes and leveraging the opportunities provided by the integration of different development subsystems.

Here some examples of such automation and integration:

• Integration server tags SVN on every production build, runs the normal routine, then packages all redistributables in a separate folder (matching build label) that is accessible via FTP (side effect is that all production packages are saved somewhere and could be easily retrieved if such need arises).
• Integration server uses svnRevisionLabeller (or any other similar plugin) to retrieve revision number from the SVN, incorporate it into the proper 4-digit version and build .NET assemblies with that.
• Integration server updates version flag on every production release. Production systems have module that checks this flag regularly and informs user of the new version.
• Integration server updates Click-Once publication on every production release and the client application updates automatically after the next launch.
• Keywords (feature from the Subversion) are used to populate attributes of some business classes with the "last changed" and "latest revision id" values on per-file basis. These values are retrieved via the reflection upon the generation of some inter-development reports/statistics
• Integration server hosts continuous monitoring project that regularly checks the production systems, runs some sanity checks and reports any failures or deviations if they are detected
• Integration server checks commit messages before build and passes all encountered tags to the build script (i.e.: #RunAllTests, #DeployToTest, #CreateRelease, #SetVersion(1.2), #TestPerformance etc). Friend of mine used to do that on his projects.
• Integration server locates all issues/tickets that were closed since the last release build, marks them with the build version and either creates a link to the filter in issue management system (JetBrains does that) or auto-populates change log report (being delivered with the release artifacts).
• Integration server runs the unit-tests and captures screen-shots of all the presenters available. These shots are then labeled and framed nicely and are used to update the pictures in the product documentation (which is also gets packaged and processed on the release cycle)
• Production release creates Virtual Machine package with the pre-installed and pre-configured solution (could be used by testers and sales-people)

I've leveraged some of these scenarios (items 1 through 6) in different development projects I've been a part of (esp. in projects that were based on the xLim principles). On the overall such things do really reduce the development friction and have solid Return On Investment rate in increased stability and saved time. And they also reduce the risk that a mere mortal would make a stupid mistake while performing some mundane action.

Reduced development and release friction obviously promote faster development iterations. That shrinks the lag between the moment customers have requested some functionality and the moment they can inspect it (and provide feedback for the next changes).

Are there any time-saving recipes that have proved themselves worthy in your project and are not on this list?

NB: Obviously one must be cautious about taking any single item from the list and applying it to the specific development project. Specifics always matter and not all combinations will be worth it.