Code Repositories, Skills, Databases Can All Be Extended, Redeployed To Maximize Investments
The Monolithic Application is Dead - Long Live the Component!
As investments in client/server architectures begin to bear fruit and Internet/Intranet applications development becomes feasible, it has become clear that forward-thinking companies have rejected the 18-24-month massive-application development cycle. Requirements shift too quickly to support such a lengthy development phase.
The failure of these strategies holds lessons for today s developers. The dynamics and economics of the business systems environment have substantially shifted, rendering the traditional systems development model ineffective.
A Gartner Group study concluded that approximately 85 percent of the cost of a business application is allocated to the labor involved in developing and maintaining that application. These findings serve to reinforce the objective of adopting a more responsive process for the development of flexible applications that can evolve as the business evolves.
Instead, new client/server and Internet/Intranet architectures lend themselves to rapid, iterative development cycles. With the pressure of global 24-hour markets, increased competition, and shifting technical landscape, the cycle now lasts only a few months - from prototype to production.
Factors Driving Modular Applications
Today, applications run in a different context than five years ago. Developers and users have access to more powerful processors on clients and servers. Faster networks and more sophisticated operating systems give more power, but also more complexity. MIS staffs are leaner, necessitating greater productivity. Applications are distributed on multiple servers in multiple countries and must be modular in structure. Object-oriented development will be the dominant paradigm for the foreseeable future. Finally, there is no application maintenance just continuous improvement.
The Key to Rapid, Modular Development: Component Reuse
These rapid, iterative cycles of modular development have one overriding requirement: reusability. Reuse can bring benefits in several ways:
Reusing Code Through "Componentization"
*Code components - All software developed should be modular and completely reusable. Development teams must have access to previously created and proven code modules, objects and other components. Documentation should be consistently updated. Notes Components, Java applets, ActiveX, Agents, and Rich Text are examples of reusable code modules that speed future application development/enhancement.
Focus on Incremental Improvement - Development efforts focus on improving existing modules, rather than re-creating the wheel. Adapting an existing application requires a much smaller percentage of the time it would take to build from scratch.
Increased Reliability - Since new developments are based on proven, production components, the risks of new developments are reduced.
Reusing Skills In New Ways
Expertise - With reusability, newer technologies and developments do not require re-learning new languages or methodologies. For example, newer, modern Notes development tools should take full advantage of LotusScript and Visual Basic expertise, not require the acquisition of a new language.
Collaboration - Since several developers will work simultaneously on the same set of application components, team members must communicate and coordinate their efforts. This collaboration fosters a re-use of skills as team members share their expertise with one another.
Development Specialization - Teams can assign members to areas that make use of their strongest talents. Each developer assigned to the project works primarily in his or her area of expertise, such as interface design or communications. In this manner, the developer continually reuses and refines his specialty and develops greater expertise in that area.
Reusing Databases
Exploiting Current DBMSs - New applications do not mean new DBMSs. Instead, new systems must exploit the databases that currently run the business - including relational or workflow/groupware sources.
Increasing Connectivity to Data From Multiple Sources - Developers can create applications that broadly leverage the numerous, heterogeneous databases by connecting to multiple sources.
Multi-Level Data Access - In addition, developers can create selective levels of access - viewing, reporting, and updating, for example - so that broader classes of users can derive value from information without data integrity concerns.
The Repository: The Hub for Component Reusability
One of the most effective means of managing and deploying a culture of reusability is through an active, integrated repository. Revelation Software has long been a champion of component reuse through a repository-based development model. An active repository provides:
Component Engineering – This is the primary function of the active application development repository. At its most basic level, an active repository is a database application that stores, tracks and manages the definitions, relationships and use of application components. These components may include forms, table definitions, images and code which are joined to produce applications.
Component Reuse - The active repository assists developers through the automated tracking and management of application components. Without the ability to readily locate components, reuse remains only a theory, since "you can t reuse, what you can t find." While this seems obvious, it should be noted that software library systems and passive "repositories" do not support this function.
Check-in/Check-out - Check-in/Check-out is a requirement for managing workflow during cooperative development. When a developer works on an application component, that component must be "checked-out" from the repository. During "check-out", other developers are denied access to that component for purposes of modification. When work is completed, the component is "checked-into" the repository and again becomes available to other developers.
Net Change and Impact Analysis - When modification to an application component is proposed, the active repository provides an impact analysis of the changes for all occurrences of the component prior to implementation. Once the component is modified, the repository executes a global change, updating each code module in which the component appears. The repository maintains a complete change log of all modifications made to each component.
Application/Component Inheritance - The active repository can assign the functionality of an existing application to a new application, when the existing application is specified as the "ancestor." Applications that are derived from a generic ancestor can be evolved in new directions, while the integrity of the ancestor is preserved.
Support for Multiple Tools - An active repository does not impose barriers on tools. For example, one developer can use LotusScript to create a component for a Notes application, while another uses Revelation ViP.
Conclusion
**
Monolithic development cycles are no longer merely pass , they pose serious risks to the organization. Development teams must exploit existing resources, skills, and experience through a variety of re-use strategies in order to achieve simultaneous goals of increasing application deliver volumes as budgets and timeframes continue to shrink.