Archive for December, 2007

AccuRev is a Jolt Award 2008 Finalist

December 21st, 2007

AccuRev 4.6 for ClearCase, which includes our new ClearCase Coexistence Adapter, has been selected as a Finalist in the 2008 Jolt Product Excellence Awards! James has been sharing with you some of the core new features in AccuRev 4.6 in his previous posts, such as the VersionSlider and viewing work-in-progress at the Issue level, but for a more detailed look, check out the What’s New in 4.6 Web page.

2007 was truly the year of both SCCM conversion, and co-existence (a relatively new concept). While AccuRev added significant new features to its core offering this year, enabling co-existence with leading SCCM solutions is jolting in a number of significant ways.

AccuRev is the glue that allows teams to continue using their existing SCCM infrastructure, while integrating AccuRev into new or existing projects.  This eliminates risk and potential disruption associated with a comprehensive one-time conversion, and provides freedom of choice.

AccuRev 4.6 for ClearCase enables adoption of AccuRev in previously homogenous ClearCase environments, through real-time bi-directional synchronization without rework or porting. Ultimately, these organizations will save time, money, and deliver higher quality software.

Jolt Product Excellence Winners for 2008 will be announced at the SD West conference in March.

Happy Holidays!

Always Act Like This is The Release

December 20th, 2007

by Damon Poole

I think of this practice as a major guiding principle of software development. If every practice is done as though it is part of the final act of releasing the product, then you will automatically have fewer practices. Fewer practices means less chance of problems falling through the cracks until the last minute and a higher level of maturity for things that have been done multiple times.

For instance, instead of having one process for developers to build during development and another build process for release, use exactly the same one. That way, when it comes time to release, the path is well worn and the chances are better that you will be able to completely reproduce the release if and when the time comes.

How Accessible is Your Source Code?

December 19th, 2007

One of the things that frightens anyone who develops code the most, or more accurately the people who are responsible for releasing or deploying that code, is the possibility that you might not have access to it within your software configuration management tool or version control system when you need it. Computers are fickle things; unless you are prepared to spend fantastic amounts of money for a truly redundant hardware/software infrastructure, there is always the chance that your system could be inaccessible when you need it most. And this doesn’t even begin to address potential network outages.

AccuRev, because of the ease of backup and restore for one thing, and the always accessible locally resident Workspaces for another, is a great insurance policy against data loss and brings developer down-time to zero. But let’s say that one of those dreaded network outages or hard disk failures occurs exactly at the time when you need to pull the latest source over to your build system for a critical release. Or imagine any kind of similar roadblock you’ve run up against in your own environment. This is yet another area where AccuRev, with just a tiny bit of prep and foresight, can save you hours, if not days, of aggravation by ensuring that you always have access to your latest “buildable” code.

How does this happen? Well, consider first the AccuRev stream paradigm where – unlike branches – there is a well defined progression of code, from the high instability of a developer’s Workspace to the “always buildable” top-level release stream. You simply have to choose the stream that you would consider as your ideal location to retrieve “offline” code from. In the following StreamBrowser, I’ve chosen the top-level “Claims_Client” stream.

offline_code

Create an AccuRev reference tree based on your chosen stream. Define the location on disk where that reference tree should populate the code to. Then, use a trigger (we provide examples with exactly this functionality) to Update that reference tree anytime a Promotion happens into this stream. The end result is that you have a specific file-system location that is *guaranteed* to have the latest and greatest code from any given stream that you want. Also, this approach is optimized because it only has to transfer changes, not the entire source tree, and there is zero manual intervention required! So in the case where the network or SCM server goes down, no problem for you; your code is happily hanging out right where you need it to be.

Some organizations are much more tolerant of this kind of scenario than others. If so, can you think of other times or examples where this kind of functionality would be helpful to you?

Selecting and Adopting a New SCM Tool

December 12th, 2007

by Damon Poole

Comparing SCM Tools

People often ask me “what is the best SCM tool” or “is there a comparison of SCM tools available.” I would say that generic comparisons of SCM tools are sort of like generic comparisons of cars. Somebody looking for something that is fast and doesn’t care about gas mileage probably wouldn’t think much of a Prius.

Currently, IMHO, the SCM market is not a commodity market where the products are generally about the same. There is a wide range in both pricing and functionality. So, you really have to know your requirements and the priority of those requirements. A good initial priority to figure out is: which is more important to the organization; price or return on investment? There’s no sense in looking at all of the tools on the market if there’s not enough budget.

Determining Requirements and Building Consensus Among All Stakeholders

Generally, a good way to acquire a new SCM tool is to start from a well defined set of requirements, create a shortlist of 3-5 candidates that seem close, take a closer look and narrow that down to 2, and then do a proof of concept on those 2 and pick the 1 that most closely meets your requirements.

Depending on the size of the development group and the size of the company, acquiring a new SCM tool can be an eye-opening experience. Finding a tool that meets your requirements is perhaps the easiest part of the process. Some of the harder parts are: figuring out who all of the stakeholders are, getting all stakeholders to consensus on the requirements, getting upper-management buy-in, and securing the budget for the purchase. Getting budget and requirements to match is generally the hardest part and typically involves writing some sort of business case to justify the purchase.

Here are some typical stakeholders: CEO, CFO, Purchasing Agent, Legal, VP of Engineering, Director of QA, key developers, and Release Engineering. Some of these may seem to have nothing to do with SCM, but they do get involved in large purchases that affect the whole company. It is better to make contact with all of these folks early to get the full scope of what is required to change SCM tools so as not to get surprised later and potentially impact release schedules.

If you make a recommendation that fits the budget and best meets the other requirements, but there is still a big gap in the requirements, don’t despair! If you’ve involved all of the stakeholders and built consensus, you have a good chance of leveraging that gap to increase the budget.

Start From High Level Use Cases

When moving from one software configuration management SCM system to another, it is often the case that people concentrate on “Which of the pains that I have in my current SCM system will this new system alleviate?” This is certainly a valid question. However, it is also important to ask “What benefits will the new system bring that perhaps I haven’t considered?”

Another common question is: “Our old system is missing a certain feature to compensate for a certain problem that the system has. We’ve developed a work-around for the missing feature. Does your system have the feature that is missing in our current system?” If the new system doesn’t have the problem that the old system had, then the need for the feature is often eliminated.

A better way to compare SCM systems is to start from high level business use cases. There are many ways to implement business level use cases for software development. Some of the implementation choices include: components, streams, tasks, and branches. An example of a business level use case is: “There are different versions of software installed at different customer sites. A defect is reported by one of the customers. The defect needs to be fixed in the version that the customer has as well as all other versions which have that problem.” The implementation of this use case will be different in a component-based and a stream-based system for instance.

When changing from one SCM implementation to another, be sure to start from your business level requirements instead of mapping from your current implementation to a different implementation. The reason for this is that the high level use cases do not require a particular implementation; they can be implemented using a variety of methods. If you have currently implemented the use cases with components, it is unlikely that directly mapping this implementation into streams will be the same as starting from the uses cases and implementing with streams. For most use cases, it does not make sense to map the way they would be implemented in your current system into a your new SCM system. While it is possible to do it, the result can be difficult to set up, understand, maintain, and use. This sort of implementation will also generally make it more difficult to realize the potential of your new SCM system. In other words, you may end up with the drawbacks of both worlds and the benefits of neither. The most successful approach will be to implement the high level business requirements into your new SCM system.

Eclipse BIRT and AccuWork

December 6th, 2007

As a developer I’ve found it necessary from time to time to generate reports, especially for internal consumption. Internal reports tend to be more adhoc than those presented to clients or non-technology managers, and therefore have less time devoted to their care and feeding (and cost). While I’ve used Crystal Reports and similar tools for external reporting, most development reporting has consisted of spreadsheets and any charts that they generate in the ten minutes I have before a review meeting.

Always wanting to explore various technologies, I took the opportunity to try my hand at using the BIRT (Business Intelligence and Reporting Tools) implementation in Eclipse. If you’re interested in finding out specifics about this plugin, you can find it on the Eclipse web site. While I find the tool to have a higher learning curve than I would have expected, it shows promise for the future.

There are a number of data points that we generate as part of our development, and capturing all of them in a report format proves to be a surprisingly complex task. It is a task that gets little time and investment, as development goals are not report oriented, they are product delivery oriented. I’ve attempted to capture some of the more mundane details, and set aside future report details that require a larger effort. I’ll be describing what I’ve done to create the reports, but not really discuss about why or how to interpret the data. A discussion of some other data and what you can do with it can also be found here.

Here at AccuRev our projects are issue oriented. We use AccuWork, which is our own tightly integrated issue management environment.

Given that, and the goals for the reporting that I defined, I had to find a way for AccuWork to communicate information that BIRT could interpret. In the past using Excel, I’d simply query issues in AccuWork and export the data into an HTML table that Excel could then read in and, with the help of pivot tables, generate the desired reports. The basic information reported included:

  1. Number of issues per developer
  2. Count of issues by priority per developer
  3. Distribution of issue resolution (Whether issues are duplicates, regressions, cancelled, deferred, etc)
  4. Distribution of issue severity (Whether issues are crashes, major implementations, cosmetic, etc)
  5. Weekday issue completed per developer
  6. Weekly Find rate vs. Fix rate
  7. Weekly average number of days to complete issues

Using this information, it is easy to see projects taper off to closure, as well gather some ideas as to how the developer workload was being distributed. Some developers cringe at this information, but I believe as long as it is used positively and to evenly distribute work, then everyone gains from reviewing this information.

With these same charts in mind, I loaded up my version of Eclipse, installed BIRT and its associated plugins, and started to figure out how to get the data into the tool. » Read more: Eclipse BIRT and AccuWork