An object-oriented modeling system that generates C++ code directly, ObjecTime bypasses the dangerous translation step from model to implementation
Mike Bienvenu
If you use a CASE tool to design and develop large-scale software projects, you should consider a move to ObjecTime. With it, you can create and edit an object-oriented system from the top down and then run the design in an interactive environment with full monitoring and debugging capabilities. Good programmers who understand ObjecTime are able to work three or four times faster than they could in any similar environment, such as Rumbaugh/OMT (Object Modeling Technique).
ObjecTime generates complete, compilable C++ code directly from the design diagrams. You can compile this code with ObjecTime run-time libraries to create ap
plications that will run independently of the ObjecTime tool. As a result, you can build commercial applications within the ObjecTime environment that your customers can execute without their having to buy the complete ObjecTime tool. The ObjecTime microRTS (run-time system) does become part of your application in this case, however. It costs about $200 per copy.
ObjecTime is not cheap. Licenses are granted on either a fixed-node (runs on only one workstation) or a floating-node (runs on any workstation on the network but on only one seat at a time) basis. They cost on the order of $20,000 to $25,000 per seat.
Objects in an ObjecTime system under construction can access existing libraries of other code (which does not have to be C++). Consequently, you can create an object-oriented framework for existing code that isn't object-oriented, and your migration to an object-oriented development environment can occur gradually, as time and resources allow.
ObjecTime is based on the real-time object
-oriented modeling (ROOM) methodology (see the sidebar "All the World's an Actor"), which was developed by engineers on a network-switching project at Bell-Northern Research in 1986. The tool became commercially available in 1992 with the formation of the company called ObjecTime. ObjecTime runs on Unix platforms, including the IBM RS/6000 and workstations from Sun Microsystems and Hewlett-Packard.
The Whole Ball of Wax
One of the great failures of design methodologies in general (not just object-oriented) is that there has rarely been any direct translation from the design methodology to the code. Many, if not most, of the design errors in projects occur because the design was ambiguous or not properly translated into the software architecture and eventual code.
ObjecTime eliminates these translation steps by creating a methodology and a tool that let a team seamlessly move from high-level design all the way down to code, with no translation steps. High-level systems arch
itects and designers use the tool at the abstract level, defining sequences of operations between the major parts of the system or software under construction. The more-detailed portions can then be added in the same tool, in the same methodology. Everyone sees the same diagrams, and problems can easily be traced to either coding errors or design errors.
In addition, ObjecTime is one of the cleanest, best-designed tools we've seen in the CASE market. The company provides excellent 24-hour technical support. Also, the tool is designed so that, if you manage to crash it (not an easy feat), it generates an exception file as it's crashing and automatically sends that file back to ObjecTime technical support.
ObjecTime at Work
Working in the ObjecTime environment consists primarily of creating and editing actor, protocol, and data classes (explained in the sidebar), the sum total of which forms the design of your system or application. Actors are tied together with bindings tha
t represent a connection over which a certain set of messages can be exchanged (i.e., a protocol). Once you've defined your system's structure and behavior, you execute and debug your design in ObjecTime's RTS.
The RTS incorporates numerous debugging features, including actor state monitoring, variable inspection, and message tracing and injection. Message tracing lets you follow the flow of messages into and out of an actor's ports; injection lets you "insert" a message on the fly and observe
the system's behavior
. Additionally, as the RTS executes, you can watch transitions "fire" (as an actor's internal condition moves from one state to another) -- they turn bold momentarily, thus providing a valuable quick check on the execution process.
Extensive drag-and-drop programming, along with built-in automated error checking, makes for fast and error-free design. ObjecTime will not let you drop things in the wrong places. Furthermore, the system's drag-and-drop features minimize t
ypographical errors.
Because ObjecTime can communicate with other Unix processes via messages over a standard TCP/IP socket, a separate GUI process can talk to your ObjecTime application. We used both UIM/X and XVT GUIs successfully in this fashion.
Finally, ObjecTime models can incorporate legacy code. We used this capability extensively in a project that depended on a large amount of legacy FORTRAN code. It enabled us to create an initial working system that used ObjecTime as the overarching event handler and simulation executive. This gave us time to address the replacement of individual legacy portions with updated code at our leisure.
For Example
We used ObjecTime as the design tool and final development environment for a traffic management test-bed design project. The traffic management modeled the overall traffic loads on a network of surface streets and freeways as demand (i.e., rush hours) and/or road conditions (i.e., accidents) changed.
This project
had an interesting collection of requirements that ObjecTime easily addressed: the reuse of legacy FORTRAN code, software and hardware in the loop capabilities (meaning that other hardware or software systems could be incorporated into the system for testing under real-world conditions), and a distributed-processing hardware suite. In addition, we had to have a GUI process running on a PC, while the major test-bed processes ran on Unix platforms. This project used both the design and code-generation features of ObjecTime.
Pitfalls
Based on our work with ObjecTime, we've noticed several potential pitfalls. First is the "runaway programmer" effect. Programmers find themselves making progress at a much faster rate than they're used to, with the immediate feedback of seeing their designs execute. The upshot: Programmers become so entranced with getting ObjecTime to do neat things that they lose sight of what the project needs. If good programmers work three or four times faster in O
bjecTime, they can also diverge that much faster if they are not properly managed.
Second, some projects can stress the message-passing capability of ObjecTime's interactive environment. For the most part, this occurs when an actor has a large replication factor (i.e., many instances of the same class) and those instances all send messages at the same time. We have noticed a slowdown in the message exchanges between other actors in different parts of the model when this occurs.
Finally, ObjecTime's screens, while perfectly suitable for those who really understand the system under design, are not what you want to exhibit at big demonstrations. Most managers and customers will need to see something less technical than the raw ObjecTime screens. You'll need something that helps them visualize the operations of the system.
The Object
ObjecTime is not the only design environment that can directly derive executable files from the diagrams, but it is the only tool we've see
n that offers such a complete environment for the entire development project. ObjecTime has significantly better applicability than other methodologies to design-only projects, too, because the design can be verified through execution without having it prototyped into code.
If you're looking at the development of new systems, or significant redesigns of your existing systems, ObjecTime translates into increased programmer productivity.
PRODUCT INFORMATION
ObjecTime......................$20,000-$25,000 per seat
ObjecTime, Ltd.
Kanata, Ontario, Canada
(800) 567-8463
(613) 591-3535
fax: (613) 591-3784
sales@objectime.on.ca
screen_link (44 Kbytes)
ObjecTime represents a program's execution behavior as independent, communicating objects called actors. This view inside an actor (called ModelExec) shows its internal states (rounded rectangles) and the possible transitions from one state to another.
Mike Bienvenu has been working in object-oriented systems design since 1992. He is with the Washington, D.C., office of Sparta, Inc., and has a Ph.D. from Rice University in electrical engineering. He can be reached at
mpb@mclean.sparta.com
or on BIX c/o "editors."
Systems Design in ObjecTime
