We have exciting news this month, though most of you reading this probably knew it was coming. On Sept. 10, we officially released Polarion ^® ALM for Subversion ^™ 3.0. A lot of people have been waiting for this because it is - as the press release puts it - the first fully integrated ALM platform on the market.

And we do mean fully integrated. It covers every phase of application lifecycle management, from the initial set requirements, though design, coding and testing, debugging, deployment subsequent upgrades and on to eventual retirement, replacement or integration with other projects.

And it does it all using Subversion, the market-leading repository for collaboration. It's the market leader now for a reason - it is easy to use, complete, able to handle any aspect of a project and, of course, completely open source with all that implies.

If you don't already use Polarion, you can download and work with Polarion ALM Team - the comprehensive ALM platform for development teams - for free through December 31, 2007. Download here: http://www.polarion.com/downloads.php. Request your free Polarion ALM Team license here: www.polarion.com/products/alm/team_order.php

Polarion^® ALM for Subversion^™ 3.0 has a lot of terrific features. Here are some of the the highlights. Let's start with the qualities that set Polarion ALM apart from any other ALM solution out there.

Live and Painless ALM

Although these qualities are no longer exactly new, since we've been designing to that standard from the start, we did put a lot of thought into how we could tell people, in short, sweet, easy terms, what sets Polarion apart. The terms "live" and "painless" seemed to boil it down to the essentials.

It's painless, because you never have to struggle with someone's afterthought of an integration, or use point-solution tools designed by different teams for different purposes, with completely different interfaces, pasted together when the concept of ALM arose and marketed as a suite.

We've never been shy about our intent to create a unified, integrated system covering the entire range of the application lifecycle. We wanted an integrated approach from the very start. Nothing would ever be awkwardly cobbled together and called a "suite" for marketing purposes. I guess you can tell we're proud of the results we achieved.

Our "Live ALM" technology is just as important as the painless aspect. It's "live" because you never have to guess how close the reports you see actually come to the current status of any aspect of your project. What you see is not based on guesswork or on what some harried developer thinks you want to hear. What Subversion makes possible for Polarion ALM is actual, live, transparent status reports for everything from setting the initial requirements onward. No guesswork. Everything is entered and recorded in real time, as tasks are done, and everyone on the team who has access at a given level can see it happen in real time.

That's revolutionary all by itself. Bugs and bottlenecks get exposed early when it's still easy to deal with them. Managers and team members are kept in the loop about key metrics, so they always know how a project is actually going. Criteria like reuse of software assets, levels of compliance with maturity models like CMMI or processes such as XP (eXtreme Programming), satisfaction of requirements, or whatever else you use to gauge progress are transparent and visible in real time as the project moves forward.

Polarion^® ALM for Subversion^™ 3.0 does all this better than ever - and certainly better than any other ALM products out there. Try it - you'll see.

End-to-end Coverage

We mentioned project requirements, and here's a bit more on that. A huge source of frustration in projects is the disconnect between how requirements engineers have to think and work, and the continuous process used by actual developers. Think about it a moment - requirements guys generally work to set down solid, clear and unambiguous goals for the developers to work to. They may be performance oriented, process oriented, data oriented, or whatever, but the project requirements will eventually be signed off by a manager and will then constitute the ultimate guide posts used by the development and implementation team.

The metaphors I use with that type of engineering - guide posts, unambiguous goals - all imply solidity. "Unchangingness", Performance. No slippery, hard-to-grasp sliding around. For obvious reasons, that tends to throw requirements engineers into document mode - write a draft, review, revise, finalize, sign off and post for everyone to see. The final product - a set of requirements - may change from time to time but for the most part they are static and set. Word and Excel documents are natural working tools for that kind of engineering.

Compare that to what the development guys do. They're concerned not so much with the static requirements of a project as with the process used to bring them to reality. Anyone who has worked on a project of any complexity knows what a slippery process that is - subject to constant revision, testing, integration with other people's work and more changes made to keep the modules working as expected. It's a dynamic process, not static.

And that's the disconnect - the constantly morphing, changing, adapting development process launched from static, rarely changed requirements documents. When requirements do change in midstream, it can cause all sorts of headaches to the other teams because the effects of change, whether intended or not, tend to ripple down into the most unexpected corners of the constantly changing code or data streams.

The reverse can also happen. The development process may reveal incompatibilities between requirements, leading to changes that ripple into the process and cause still more changes. In a closely managed project that can throw some serious gray into a manager's hair.

Polarion ALM for Subversion 3.0 solves that by integrating the requirements documents into the project completely, making them part of the development process itself. Changes to requirements documents are visible throughout the project, at the same level of transparency as changes to the code. The entire project goes through Subversion, so evolving requirements never get lost, versioning problems disappear, and the impact of changes is always completely visible.

It has never been easier to see an entire project, from inception to eventual retirement, in one place, or to drill down to any level of detail required. This full integration, all by itself, is changing how application lifecycle management is done.

Different Versions for Different Folks

Polarion ALM for Subversion now comes in three licensing flavours, designed to scale from small labs and teams to the largest enterprise-wide project. It is easy to shift from one level to the next as an organization's needs grow. Here are the three license levels:

• Polarion ALM Team for Subversion: For teams and organizations focused on the engineering aspects of ALM. That includes Change and Version Management, Issue Tracking, Time Tracking and Full Traceability. The ALM Team license has it all covered.
• Polarion ALM Enterprise for Subversion: This is the "whole deal," the complete ALM package. It covers the same things as the Team version, but adds Requirements Management, Project Management, maturity model (CMMI) and agile process (XP) compliance, Flexible Workflow Engine... There's more but those are the top-level additions.
• Polarion ALM Multisite for Subversion: Everything in the Team and Enterprise versions, plus repository replication & syncing over WAN. As many local teams and workgroups as needed can combine their efforts into one large team, independent of where the individual members are located.

What this means to organizations is that they can roll out Subversion-based ALM processes at any immediate level for a given project. Then, as their needs grow or when they decide to apply the management and development advantages of ALM on a wider scale, they can simply "turn on" whatever extra capabilities they need.

And when they do, they will know Polarion ALM will scale to any size project, for any size of organization, and never lose its end-to-end ALM capability.

Details on the new Polarion for Subversion 3.0 are available at http://www.polarion.com/ .