The enterprise software development arena can be a harsh and unrelenting environment – not a place for the faint-of-heart to work. Fortunately, software configuration management (SCM) software can make it not only more tolerable, but more efficient and, yes, even more successful.

SCM software is not a luxury, nor just another layer of technology to be added to an already complex process. SCM software is a necessity for development teams working concurrently and in parallel on development projects, especially those employing agile processes to deliver higher quality software more rapidly.

Two of the biggest benefits of using SCM software are the ability to coordinate distributed teams and parallel development more effectively, no matter where your team members are located or even the language of the replicas being used – they can be in the next cubicle, the next state, or the next country.

We, of course, recommend AccuRev SCM

No surprise there. After all, we designed it to be fast, flexible, scalable, and effective. After all, we’ve taken process management and version control and made the ideal mash-up that provides the most comprehensive set of SCM tools available, including these best practices:

• Change management
• Visualized SCM patterns
• Automated workflows
• Private developer history
• Multi-stage continuous integration
• Issue-based development

With a single set of comprehensive, best-practices SCM tools to work with, life becomes much easier for your development teams – they can focus on software development instead of management and administration tasks. SCM software made nice and simple.

What makes it even easier is how AccuRev SCM easily handles virtually any combination of development processes, including Agile, XP, and waterfall – you name it. You’re free to mix-and-match because AccuRev SCM’s flexible model enables your teams to rip through development with continuous integration, code refactoring, and automated code sharing, to name a few.

Even parallel development is a cinch with fully-transparent code base relationship management that enables teams to store work safely and test it before sharing it with others. A stream-based architecture makes code branching and merging easier, too – it even allows changes to be automatically inherited from other teams.

If for some reason you’re not already using SCM software or if you’re unhappy with whatever software configuration management tool you’re using now and you want to know more about SCM software and AccuRev SCM in particular, check out our SCM Software Resource Center and AccuRev SCM 5.3.

AccuRev is once again pleased to inform everyone that its flagship product, AccuRev, has been selected as a Jolt Award Finalist for Dr. Dobb’s 19th Annual Jolt Product Excellence Awards in the Change and Configuration Management category. 

For the past 18 years, the Jolt Product Excellence Awards have been presented annually to showcase products that have “jolted” the industry with their significance and made the task of creating software faster, easier, and more efficient. The awards presentation is sponsored by JOLT, the fabled soft drink quaffed by software developers for sustenance during project development marathons.

“The Jolt judges have selected these finalists from the nearly 300 qualified nominations that were submitted online. The submissions represent the many innovative tools available for every phase of the software development lifecycle,” said Amber Ankerholz, Jolt Award Project Manager. “This year’s finalist round was extremely competitive and we appreciate the effort all of the participants put into showcasing their products’ features for the judges.”

In the next round of the Jolt Award process, the judges will examine the finalists according to the standard criteria of audience suitability, productivity, innovation, quality, ROI, risk, and flexibility. They focus on products that are ahead of the curve, universally useful, rich in functionality or that were solutions to problems in their product space.

Winners are announced during the Jolt Awards ceremony that takes place on March 11 at SD West 2009 Conference & Expo at the Santa Clara Convention Center.

by Dave Thomas

Your team has been coding a feature for a few days, across dozens of files, and everyone is excited with progress.  Deep into development, you find an interesting 3rd party library that may simplify your work and possibly take the team’s feature to the next level.  But it will require adding new files, moving some directories, and refactoring some critical code.  However, you’re not ready to commit your current changes because they are unfinished and will surely break everyone else.  Your changes need to be saved before prototyping in case of a rollback but also be integrated with prototype development.  And what if the new library is a bust?  If you start co-mingling the library integration with unfinished code, the potential revert process will be a complete nightmare and waste of time.

Private Versioning. With AccuRev’s private workspace, you can always commit your changes early, often, and safely without sharing amongst your peers.  But in this case you have two logical development efforts, the 2nd effort depends on the first and both need commits to preserve evolving changes.   How do you keep them cleanly separated and continue to work on both in parallel?

Stream Inheritance.  AccuRev streams have an intriguing and very powerful feature called inheritance.   Similar to how an OO subclass implicitly inherits methods from parent and grandparent classes, a child stream implicitly inherits versions of files & directories from parent and grandparent streams.   Taking advantage of inheritance, we can use streams to independently manage logical changes and cleanly maintain change dependencies without physically co-mingling files.

The Pattern.  Prototyping changes without co-mingling files can be done by simply creating a series of ‘personal’ or ‘private’ development streams (though, they are just regular dynamic streams). This pattern will create a “Feature”, “MyDevelopment”, and “MyPrototype” stream sub-hierarchy.  See Picture.

click to enlarge

From your Integration stream (or equivalent), start by creating a “Feature” stream that will collect all changes from your entire team.  [See related blog, Stream-per-Task Pattern].  The majority of team members may have their workspaces directly from here.  Next, create a child stream called “MyDevelopment” that will track your personal ongoing development activity.  Finally, create a grandchild stream called “MyPrototype” to track changes that will be discarded or retained depending on the level of success.

The prototype development activity is committed, shareable, integrated, and yet cleanly segregated from both active feature and private development.

The “Feature” stream is the collection point of all in-progress development activities for the given feature from the entire team.  Developers will promote here frequently possibly kicking off an automated build with success/fail notification.   The “MyDevelopment” stream provides a collection point for all of your personal development changes.  This stream may be considered a “private” development stream simply because no other developers will likely use it – set a stream lock to be sure.  A lightweight Continuous Integration build (i.e. compilation only) may be performed on “MyDevelopment” for sanity sake or just compile and promote as a practice.  The “MyPrototype” stream is a collection point for all prototype changes. Even as new changes are promoted to “Feature” and “MyDevelopment”, the “MyPrototype” stream will automatically incorporate those changes (via inheritance) and the prototype developers will merge changes as necessary. The prototype development activity is committed, shareable, integrated, and yet cleanly segregated from both active feature and personal development. Also, by using a stream for prototype work, multiple developers can contribute and collaborate. If the prototyping work is deemed successful, the files can be promoted to “MyDevelopment”. If the prototyping efforts don’t work out – no problem – just remove the “MyPrototype” stream and re-purpose the workspaces.

The beauty of this pattern is that it isolates development activity by purpose without co-mingling physical file changes.   It lets the prototype developers go nuts and shoot from the hip while the regular feature developers (with the deadline!) work unimpeded and without fear of rampant changes — and everyone stays up-to-date.   And with no limit to stream depth, teams can perform prototyping efforts in parallel and/or perform prototyping based on existing prototypes by adding another child stream!  Furthermore, the pattern works for any size development activity or team, even for us Team-of-One developers with tons of ideas, fast fingers, and a few green screen x-terms (2 space, 80-char wrapping of course – <chuckle>).

This is a perfect example of how AccuRev empowers the developer to take control of their own development.  Creating streams is extremely easy and the stream browser provides unprecedented visibility into the entire development process.  With the right amount of security in place (Locks, ACLs, Triggers), the critical release streams (left side of the stream structure) can be locked down by the CM Admins, but the development related streams (right side) can be fair game for developers to create an environment that suits their purpose, such as prototyping.

Does anyone have a good story to tell about how this pattern (or equivalent) helped with a major refactoring effort or library upgrade?

/happy prototyping/ – dave

by Tahir Hussein, Alterian

This diagram shows one key aspect of our development process i.e. 3^rd Line Support. It is critical to our operations because we support anywhere from the last 3 to 5 release steams. This includes monthly patch releases which address key customer defects and enhancements.

3rd Line Support

Prior to 2006 our development operation was UK based (in a single location). Everything was straight forward! However, when we opened up a development centre in Bangalore, that situation changed. Once we had recruited and trained the developers it was time to get them using our SCM tool, Serena Dimensions. This has served us well since 2000 but the performance of the connection to Bangalore meant that the PC and Web clients were totally unusable for shared development work e.g.

* It was taking over 5 minutes for them to browse change documents

* Editing the attributes e.g. to specify the fix times etc was taking around 10 minutes

* Making any kind of source code changes on a change document, especially one with a lot of additional related items or change documents was even longer.

* To fetch all 9000 items from the repository for a sandbox development and build was an overnight job (if it worked at all!)

Hence we had to put our thinking caps on and come up with another solution.

We tried making use of Subversion and associated tools and initially this looked very promising. However, when we started putting our Development processes on top of Subversion, in particular “Branching and Merging”, it became apparent that the underlying SVN functionality was not going to be mature enough for the tools to be available to cater for this. The solution we were looking at was Subversion running in UK and Bangalore, with the replication of data taken care of by a product called WANdisco and the Application Lifecycle management by Polarion. We had a number of meetings and discussions with all of the above parties, including the Subversion developers, who gave us an insight into the future plans. In the end the overall solution was not going to be elegant and satisfy all our needs. We carried on looking and eventually came across AccuRev.

At first we were reticent to go down this route as it was a proprietary system. However, when we were demoed the system by the AccuRev guys it seemed to fit in exactly with what we were looking for. Even with the addition of merge tracking in SVN, AccuRev is still head and shoulders above with its merge, change and namespace tracking.

We then obtained a demo license and spent a month evaluating the product against our list of requirements. The sort of checks we carried out were:

* How long does it take to create something e.g. stream, workspace in the UK and see it reflected in Bangalore and vice versa

* Can you create/delete hundreds or steams without affecting the system performance

* The critical one of can a number of developers on the UK and Bangalore work together on a set of changes in parallel and easily have those merged back together.

The whole thing ran so smoothly that we could no longer delay the decision to purchase. Last year around this time we purchased the required licences and then started the process of moving the development over to AccuRev.

So, where are we currently?

The intention has been to move over to using AccuRev and Jira combination (as Serena Dimensions covers both Issue Tracking and Source Control). However, as we have a limited number of resources available, and the fact that we require quite a lot of work to implement the appropriate workflow and associated build process, we have not had the time to do this. We are currently using AccuRev for ALL development and 3^rd Line support work but still use Dimensions for the Issue tracking and build process. Given that none of the developers in Bangalore or UK are impacted by this and can get on with their day-day work then I am cool with this. The only person affected is me as I have an additional step to perform by moving changes between AccuRev and Dimensions and vice-versa. I am confident that in the near future we will fully move onto the AccuRev/JIRA system and gain even more benefits.

I hope this will be of help to others and I would be more than happy to answer specific queries.

One of the most common and problematic challenges that exists in today’s software development environments is how best to support a Globally Distributed Development organization. In ye olden days, you had the entire team co-located in the proverbial cube farm under a single monolithic roof. If Brad wanted you to review the code he just wrote, he would literally turn around in his chair, ask you to come in and look over his shoulder.

Times have definitely changed. Now, your team might be headquartered in Boston, separate R&D sites in California and London, with some specialized groups in Bangalore and Shanghai. But that’s not necessarily the hard part. Where it gets complicated is when all these developers are trying to work on the same source code at the same time. Mastership issues questions, latency, mismatched process across sites; communication problems, lack of project visibility; these things all lead to significant decrease in productivity, not to mention the chaos for those trying to manage the effort.

Enter AccuRev. Uniquely architected to support remote and geographically distributed development (GDD), there are several key built-in capabilities that make the challenges of the past disappear. Consider the following graphic:

• AccuRev’s Stream Browser presents a dynamic visual representation of the software development process that is both fundamentally tied to the source code itself as well as being flexible and enforceable. At a single glance, *anyone* working on the project anywhere knows exactly what the process in place is. (See example AccuRev annotated screen shot here from the Alaska Airlines success story).
• Geography has zero impact on your position in the process; a developer in the UK can happily use a Workspace on the same parent stream as a developer in the United States. For low bandwidth locations, AccuReplica can provide LAN-quality access without introducing the traditional mastership and latency problems of other replication solutions.
• The private nature of the Workspace means that these remote developers can “share” code while still determining when to deliver their changes publicly.

Here’s the scenario: Developer ibergman works out of London, while jtalbott works in Boston. However, they are both part of a virtual team working on ComponentC. With AccuRev, the normal boundaries and limitations of time and space – not to mention being constrained by an inadequate SCM tool – no longer apply. Okay, I took some verbal liberties with the “time and space” bit, but it’s actually not too far from the truth.

In London at noon, ibergman wraps up a section of code she’s been working on and performs a Keep, which in AccuRev is a private check-in. The change is versioned yet stays within the confines of the Workspace, not yet ready for public consumption. But ibergman wants some validation, and asks jtalbott to review her code. Using instant messaging (IM), she pings him and catches him as he’s having his first sip of coffee, probably a colombian supremo. In other tools, how would someone review a private change that was just committed on the other side of the ocean? Would they even have private commits in the first place? In AccuRev, the moment ibergman performed that Keep in London, a visual identifier is available to anyone viewing the StreamBrowser, such as to jtalbott in Boston. So jtalbott clicks on the icon, and now has immediate access to operations like View, to see the file, and Diff, to compare against any previous revision of this file:

Did I mention that jtalbott’s access to these operations is instantaneous, as soon as ibergman performs the Keep? He can even take her version and send it into his own workspace if he finds it interesting enough to want to do additional development on.

So the previously mentioned problems of mastership, latency, visibility, communication, and most importantly Process, have all gone away. No more waiting on a 24-hour turnaround to get that Shanghai code copied into the branch. No more working in the dark not knowing exactly where your piece of code fits into the puzzle. Each team can regain the responsibility of merging in their efforts into common integration points, using a well-defined process implemented with streams.

It’s a remarkably simple and elegant solution to a complex and challenging problem. Of course, it’s still not going to solve the amusing problem of both the London and Boston developers feeling like they are superior to each other, but at least now they can actually review each other’s code real-time to help figure that one out