Object oriented tools pose many additional demands when compared with traditional development tools. The three main technologies that contribute to this are listed below:
· Reuse.
· Inheritance.
· Contract maintenance.
Reuse is one of the main benefits of using Object Oriented technology. One creates an object to perform a particular business function with the aim of re-using this object in many applications. The reuse process minimises the development and maintenance overhead by reducing the number of objects that need to be managed across the IT systems that are in use.
Employing reusable objects complicates the configuration management process because one needs to track the usage of a given object with the aim of identifying the impact of change to the reusable object. Given that an object may be used across several applications or systems, a change to the object in one application will affect the other applications and systems.
Inheritance is a feature by which the operations of one object are inherited from another object. Inheritance is similar to reuse and one must be aware of the usage of an object to make sure that all changes to this object are compatible with the way the object is being used by other objects.
Objects have a defined contract, i.e. they provide defined features that other objects have access to. Configuration management to objects must extend to managing change to the individual contracts. This is essential since a change to a contract may necessitate major updates to other objects that make use of this contract.
Object technology can simplify the configuration management process by providing the developer with a mechanism to encapsulate the object functionality and by providing a controlled interface, or contract. When implemented correctly, developers may be able to modify the internals of an object with relative ease and with minimal impact on other objects as long as they do not affect the object contract.
This is a very common technology in the Windows environment and is used extensively in many of the office automation tools, i.e. word processors and spreadsheets.
The essence of this technology is that one is able to produce a complex compound document that is made up of sections that are produced by different tools. The complex document acts as a container that holds the individual sections that can be modified using their own individual authoring tools.
Whilst it is relatively easy to track changes to the master document using traditional configuration management tools, it is currently not possible to track changes to the individual sections, each being a document in its own right.
Object imbedding introduces a further complication when a single object is imbedded into several different documents. Current tools are still unable to track the usage of such imbedded documents and one is required to track this usage to make sure that all documents are updated when a common object is modified.
Dynamic linking is now common place on the PC and UNIX platforms. Dynamic linking is a process by which functions are stored into libraries that are accessed at run time rather than being bound to the run time image at compile time.
Implementing dynamic linking reduces the footprint of the process by enabling the operating system to load the required functions into memory when required rather than loading all functions when the process is started. This introduces several major challenges that must be managed through formal configuration control.
· One must ensure that all the required dynamic link libraries are distributed with the application. Given that the application tries to access these functions at run time, any missing functions will result in major application failure.
· Only one version of a given dynamic link library can exist on a platform at any one time. It is therefore important that all changes to the dynamic link library are compatible with all applications that make use of it.
· There are no tools that enable one to verify compatibility between an application and the dynamic link libraries that reside on the target environment. Also there are no applications that allow one to check that all the required link libraries are actually present on the target platform.
· The developer specifies where the link libraries should be found at run time. Installing the link libraries at different locations may prevent the application from working altogether.
Dynamic linking is a major issue that must be addressed formally through formal configuration control. It is essential that one is able to;
· Identify each individual link library and its contents.
· Document the location at which the library should be installed and ensure that it is installed correctly at run time.
· Document the libraries that an application requires and make sure that these are installed correctly when the application is distributed.
· Identify and document the applications that make use of a given library.
· Ensure that all changes to a given library or its members are assessed to make sure that such changes maintain compatibility with existing applications that make use of the library.
As mentioned earlier, whilst current development tools are designed to manage the individual components that make up an application or a library, these tools are not designed to track the usage of libraries with the aim of assuring compatibility for all planned changes.
Configuration management problems due to poor management of dynamic link libraries can only be uncovered at run time. This in stark contrast to traditional compilation and linking where the compiler and linker performed searches to ensure that all referenced functions are specified and provided. This can result in major run time application failure as opposed to failure during the compile and link processes.
Most first generation tools are now provided with interfaces to development tools. This trend is now extending to include 3GL, 4GL, CASE tools and office automation products.
Whilst many development tools now provide a direct and seamless interface to source and version control tools interfaces into other configuration management tools have not made as much progress. It is therefore quite difficult to find a development tool that has interfaces with third party change management or software distribution tools.
The market in this area is still young and immature. Many of the interfaces are primitive offering a limited set of features when compared with stand-alone tools. There are also additional problems relating to the quality and robustness of these interfaces.
This level of integration is likely to increase and will probably become commonplace across all new development tools. Some source control tools now provide interfaces to 50 or more development tools. Also some are being sold as part of the development tool at little or no additional cost.
Integration into second-generation tools is not as advanced. This is probably due to the cost associated with such tools. Given that most development tools cost in the region of £100 to £500 per user, it is difficult to envisage a situation where such a tool will be provided with an interface to a configuration management tool that costs anywhere up to £5000 per user.
This is certainly the main trend in all configuration management tools. Whilst this is a positive trend that will enable configuration management tools to automate most of the configuration management tasks this development has several drawbacks. The workflow and process management features will:
· Make the tools more complicated and more difficult to use.
· Increase the memory and processing resources required to operate the configuration management tool.
· Increase the price per user.
· Many do not interface with 4GL tools.
· Some employ proprietary technology making customisation difficult and very expensive.
Workflow management tools do promise many benefits, however these benefits are only realised if the user is prepared to invest time and effort in working with the tool. Potential benefits include the following:
· Provide project management and team leaders with an up to date view on the progress of the project.
· Improve communication and visibility in the project.
· Provide valuable metrics to identify bottlenecks and speed up the development process.