Application Lifecycle Management Enables Effective Application Development

It's no secret that many software projects are either late or fail to deliver the required features. Software teams determined to improve their performance must ask the question, "If the same problems occur in project after project, how can we change our development process to eliminate them? Are tools available to support needed process changes?"

Teams willing to ask these questions, change their process and adopt new tools can learn to deliver high-quality applications and do so consistently. These teams will quickly become valued and rewarded contributors to business success.

Application Lifecycle Management (ALM) provides a set of processes and tools designed to enable software teams to succeed. ALM is based on the concept that all elements of an application's lifecycle must be managed as a single, ongoing process. Instead of viewing each phase of an application's lifecycle as a separate activity, view the lifecycle as a whole.

Consider the reasons for application failure. Business groups develop requirements without input from developers. The result: Software designers find that a requested feature will be very difficult, expensive or time-consuming to implement. Another scenario: The delivered application doesn't operate as intended because software development teams misinterpreted requirements documents.

Consider also why software projects are delayed. Some tasks take longer or require more resources than expected. Managers lack visibility into actual progresses so they can't reallocate resources as needed. Another cause for delay; development tools lack the flexibility needed to support the complexity of today's applications.

Tools Enable Effective Application Lifecycle Management Vendors have created ALM tool sets to address these problems. They provide a unified view and visibility across all aspects of an application's lifecycle. A centralized, integrated data repository is the critical component. Individual tools access the repository and place all output into the repository.

Project data including requirements, design documents, work items, source control, builds, and test plans and results are all stored in the repository. Each requirement is linked to the individual work items required to design, implement and test the feature. Reporting tools indicate whether individual work items are being completed on schedule. Project managers are spared the unpleasant surprise of learning about schedule slips when it's too late to take corrective action.

A centralized repository, visible to all, becomes especially critical when teams are spread across different geographies. A development or test team in Asia-Pacific must be able to communicate effectively with groups in the U.S. or Europe.

Attack Development Problems One by One Changing every process and tool at the same time is very difficult. Examine what has gone wrong on past projects. Then modify processes and adopt tools to address each issue in turn.

Requirements development is the first step in an application's lifecycle and often a source of friction between business staff and software developers. The business staff develops requirements without input from developers, testers or operations staffs. Software developers are then surprised by a set of finalized requirements and expectations from management about how long development should take.

The solution: Place preliminary requirements documents in the repository. Give developers visibility into requirements as they develop and provide an opportunity for discussion. The result: Software team members understand what is being requested. They can also suggest alternative approaches where necessary and compress the schedule by beginning work early on software architecture.

In some cases, it's not possible to create final requirements. It isn't completely clear how to address a business need or the competitive environment is changing rapidly. In these cases, techniques such as agile development provide a way to develop the application incrementally. Specify, design, implement and deploy one piece at a time. Continue the process, readjusting each new increment based on what is learned from previous components.

Older development tools do not support incremental development. Project planning and source management tools lack the required flexibility. ALM tool sets were developed with incremental development in mind. They contain process templates specifically created to support agile methods and similar techniques.

Interface design is another common cause of project delays. A design that looks good on paper can prove difficult to use or is confusing. Code must be discarded and replacement code written—activities usually not included in the project schedule. Look for design tools that fit into the development workflow and can emit code usable by the developers; this ensures what was designed is what is used in the application UI.

ALM Tools Support the Software Development Process New tools, included in ALM tool sets, save time throughout the development process. Interface development tools enable software developers to quickly create interface templates. Business staff, documenters and operation staff can review the templates to determine how easy customers and internal users will find the proposed interfaces. Clumsy or confusing interfaces can be quickly updated and replaced. For software managers, the result is no wasted development time and no schedule slips while new interface code is written.

Design methodologies such as Unified Modeling Language (UML) add clarity to a design, speeding implementation and reducing defects. UML design tools included in ALM tool sets link each design element with individual work items required to implement and test the element. Reporting tools provide immediate notification if implementation is slipping or tests fail.

Inflexible source control tools can be another source of delay. ALM tool sets include flexible, integrated source control tools that enforce the component integration plan. Build Verification Tests (BVT) should be supported, insuring that builds don't break and integration proceeds on schedule.

Other tools automate common time-consuming tasks such as tracing through code to identify all of the functions called from within a code sequence. Such tools are useful both during initial software development and for ongoing maintenance.

Software quality scan tools identify potential code defects. Performance measurement tools determine which parts of the code are consuming the most time.

All of these tools, interface design and UML, source control and code analysis have been available for years. Modern ALM toolsets provide the critical value-add: Integration. Developers no longer waste valuable time trying to translate information from one tool to the other.

ALM Tools Span the Entire Application Lifecycle Integrated tools continue to assist after initial deployment. In the past, Help Desk tools were often not integrated with any of the software development tools. Problem reports were not visible to software developers or the business staff. ALM tools make this data visible. Developers may find out that user problems are concentrated in just a few areas. A simple interface change or possibly simply modifying help text can greatly reduce calls to the Help Desk, to say nothing of alleviating user irritation.

Completing one successful application development project is not enough. Successful software development teams must be able to repeat their success over and over. ALM tools assist here also. The detailed reports produced during previous projects provide valuable input to the planning process. Customizable process templates and configurable enforcement policies capture and support repeatability of best practices. Project leaders can use the actual time required in the past to indicate how long similar work items will take. Accurate information about past problems can help avoid similar problems in the future.

Critical ALM Features Vendor ALM offerings will differ, but some features are critical. Be sure to choose an ALM product that includes the following features:

• Central Repository. The repository must be capable of storing a wide variety of information types covering the entire application lifecycle. More than simply a database, the repository must maintain relationships among items such as requirements, software design diagrams, units of source code and test cases. It must be geographically accessible to support distributed teams, and its interfaces must be flexible to support access by team members with differing skill sets.
• Project Management and Reporting. Maintaining project schedules and ensuring that all application requirements are met requires flexible management and reporting tools. The tools should provide visibility to management as they monitor overall progress while providing detailed reporting to component project leaders and individual contributors.
• Project Planning Tools. The toolset should include tools that support a variety of process methodologies. Teams should be free to adapt their process without needing to move to a different ALM toolset.
• Software Design Tools. Formal design methods such as UML provide clarity to designers and implementers that results in shortened development cycles and improved quality. Support for popular methods should be included.
• Code Development. Developers should not be limited to one vendor supplied IDE. Access to widely used open source IDEs such as Eclipse IDE should also be supported. Source code management must be flexible so that software engineers can work on individual components without interfering with others.
• Test Management. Test plan development tools must ensure that every item in the requirements documents is addressed. Test tools must assist in creation of individual test cases and report the success or failure of each test.

A careful choice of ALM toolsets is vital to project success. It must include elements to support every phase of application lifecycle, from requirements creation through deployment. It must be flexible enough to support differing project methodologies and must provide reporting capabilities to address the level of detail required by management while also reporting at a detailed level. Interfaces must be flexible so it provides meets the needs of all team members.

Microsoft has combined its Visual Studio Team Foundation products with SharePoint, Project, Office, Expression Studio and Test Manager with open source tools to create an integrated ALM solution. By offering developers versatile options for the entire software development lifecycle, Microsoft has created an ALM solution that flexibly meets the needs of a variety of organizations. Importantly, this full set of tools facilitates successful application development without forcing developers to abandon their current development practices.