Working in a Team Development Environment
When you develop an application, you often work as a team. G2 supports three basic techniques for team development:
This section describes how to use each technique and the advantages and disadvantage of each.
To support team development, G2 provides these features:
For more information about Telewindows, see the Telewindows User's Guide.
For more information about designing and creating G2 module and workspace hierarchies, see Modularizing Your Application.
Using a Single G2 for Sequential Development
Sequential development means multiple developers work consecutively on the same G2 application, using the same G2 license. Periodically, the developer hands the application off to the next developer for further development.
This table summarizes the advantages and disadvantages of sequential development:
Because sequential development is a relatively slow development technique, it is not recommended in a team development environment.
To implement a sequential development environment:
- A single developer builds part of the application, which is fully-documented for the next developer.
- At some point in the development cycle, the first developer hands the KB off to the next developer, who continues building the application.
Using Telewindows for Concurrent Development
Concurrent development means that multiple developers work concurrently by remotely logging in to a single G2 application, using Telewindows. Telewindows is a G2 client application that enables communication to a G2 server application.
Using Telewindows, multiple developers have access to the same source code concurrently. In this mode of team development, the source code is loaded onto a server machine, and each developer connects via Telewindows to the source.
This table summarizes the advantages and disadvantages of concurrent development:
To implement a concurrent development environment:
If you do choose to use concurrent team development, consider using these techniques.
- Structure the module hierarchy such that different developers can work on different parts of the application without conflicting with other developers.
- Each developers uses Telewindows to log in to the single G2 application.
Generally, we do not recommend concurrent team development because it tends to result in KBs that are large, difficult to maintain, and difficult to debug. However, this technique is very effective for rapid prototyping.
Using a Master KB for Parallel Development
Parallel development means multiple developers work on separate parts of the application in parallel, using separate G2 licenses. G2 supports this development technique by using modules, which are sets of related information contained in an application. Periodically, you merge the separate modules together into a single application, called a master KB. Each of the individual developers then uses the master KB to continue development.
When you use this technique, you decompose the problem into manageable modules and assign each module to an individual developer or to a small development team. Each team develops its module separately by following a well-documented set of standards, and you merge the resulting modules only at specified milestones. In addition to facilitating team development, decomposing the problem has numerous advantages, described in Chapter 3, Modularizing Your Application.
Using parallel development, a developer may work on only one module at a time, even if he or she is the author or primary developer of more than one module under development. When a developer is working on a particular module, the source code for that module is loaded as the top-level module, along with copies of the supporting modules, which are write protected to prevent editing. The developer then saves only his or her module.
If you take time early on in the implementation process to design a well-modularized application, you often enhance the maintainability, quality, and reusability of your application.
This table summarizes the advantages and disadvantages of parallel development:
To implement a parallel development environment:
- Each developer begins by building a separate module of the application.
- At some point early on in the development process, you merge the modules together to create a master KB.
You must resolve any conflicting class definitions at this point.
- Distribute the master KB to each developer, who works on a local G2 to continue development of his or her own module.
The developer should load his or her module as the top-level module and load copies of the supporting modules. The developer should have a write lock on all but the top-level module and save only the top-level module.
When you load your module as the top-level module, you should ensure that your items do not have any notes indicating illegal references to items in higher-level modules.
- Periodically, you merge the remote modules together to create a new master KB, which you redistribute to all the developers.
Tip: Load the entire source when making global changes, such as name changes, because Inspect can make these changes rapidly over the entire KB.
For more information, see these references:
Copyright © 1997 Gensym Corporation, Inc.