Genitor, not just another Case tool

There are many good Case tools available for designing object-oriented analysis models. These tools allow designers to model the functionality of a software project, and many even generate skeletal code. The problem is that while these tools are useful in the design phase, they are not very useful for implementing and maintaining code.

Genitor 3.2
Genitor Corp.
Ann Arbor, Mich.
Developers working on implementation must take the skeletal code and "fill in the blanks." To do this, they use text editors to churn out source files and documentation. There are two big problems with this approach. First, there is no way to generate documentation easily. Second, the documentation is frequently not in-sync with the source code; developers often make changes to the source without bothering to update source code comments, much less the documentation.

To deal with these development issues, and to help C++ programmers become more productive and generate better code, Ann Arbor, Mich.-based Genitor Corp. has introduced Genitor 3.2. The object development tool is used in the implementation phase of a project and has four major components:

* Class Editor, which developers use to create C++ classes or C/C++ structures, unions or function groups;

* Class Workshop, which developers use for object browsing. The Class Workshop acts as the overall coordinator for development of multiple classes, and imports and exports classes from the DX database and working class documentation;

* Auxiliary File Generator, which generates the templates, module definition files and external files necessary for compiling the code; and

* Corporate Capture, which imports code generated from any Case design tool.

The components share a graphical interface, as well as a DX database or repository that Genitor uses to store all object-related information. They also let developers build C++ classes and methods easily, and share code with other project members.

Genitor makes a developer's job easier in several ways. For example, developers can view a design in terms of objects. This is a helpful feature, as the modeling tools used to create a project's high-level design often use Unified Modeling Language (UML) to describe software in terms of class objects. Genitor imports the output of these tools, allowing developers to then "flesh out" the functionality of the objects.

We used this feature to capture skeletal code generated from Select Enterprise, a Case tool that uses UML. Genitor's Corporate Capture feature was then used to import Select's skeletal code into the DX database. As the UML-generated code was imported, Genitor checked the code for syntax errors. A number of errors were found; however, we were able to correct these with the Genitor graphical editor before any compile errors occurred. This saved us several hours of debug time. Finally, we assigned the objects to team members so that they could add functionality to objects.

Genitor's Class Editor graphically depicts a project's objects, member functions, methods and associated properties. As users click on the icons that depict an object, the Class Editor expands the tree.
Developers using Version 3.2 can also add or update an object's class description, member functional description and other descriptions without worrying about text wrapping. The software inserts comment delimiters at the appropriate points. Developers only need to make the updates and generate the code/documentation in order to get the latest updates. Additionally, this feature keeps development teams in-sync, communicates functionality to other groups and upper management, and brings new developers up to speed. I cannot count the times I have seen developers make code changes and then be unable to remember why the change was made or forget to inform other groups about the changes.

The software's Class Editor is the key to managing and maintaining code throughout a product's life cycle. The Class Editor graphically depicts objects, member functions, methods and all associated properties. As users click on the icons that depict an object, the Class Editor expands the tree. Developers can then edit the object's attributes.

By representing classes and function groups visually, users can focus on the big picture rather than get caught up in the cumbersome syntactical details of function declaration or class definition. This is often the most difficult aspect for C programmers moving to C++, or one of the most annoying aspects for senior C++ programmers who want to add functionality to a skeletal design. Also, the IDE environment does not attempt to take control of the source code because the actual body of any method still belongs to the text editor.

Genitor generates some of the most readable code I have ever seen, which makes code management that much easier. It also generates header and source files that are synchronized with the source code.

The documentation that Genitor creates is very useful for validating functionality. The documentation consolidated vital information, such as data descriptions, global declarations and file inclusion dependencies into a standard format. Code generated by Genitor is easy to follow, with clearly labeled and consistently formatted comments that break the code into separate sections for global data, function definitions and the like. Analytic information, such as warnings of entities that are declared but never defined, is embedded in comments within the restructured code, which is then transformed into a consistent indentation style.


Genitor's CodeWright edits text and can be configured to emulate several popular editors, including Brief and VI. If these are not enough, Genitor can also be configured to launch an editor of your choice for editing external files. Users can also edit files using their favorite editor and then import them back into the Genitor DX database.

An interface to version-control systems, such as PVCS or SCCS, is included with the software package. This interface lets users check objects in and out before and after working on them. This feature helps developers that are working together to remain synchronized.

As Tom DeMarco says in his book Controlling Software Projects, "You can't control what you can't measure." Genitor helps users accomplish this task by generating quality code and documentation that provide valuable metrics for producing accurate time/cost estimates. Couple this with Genitor's ability to import a UML skeletal design, as well as its ability to flesh out that design, and you have a development tool that removes much of the drudgery associated with software development and improves the quality of the code.

About the Author

Harold Lapprich is a project manager with Network Express, a Cabletron company. He has more than 15 years of experience in software development.


Upcoming Events


Sign up for our newsletter.

I agree to this site's Privacy Policy.