DEC's CohesionWorX delivers a sophisticated software development environment spanning heterogeneous networks
Edmund X. DeJesus
The popular image of the lone programmer writing a software application on a stand-alone computer is rapidly becoming a quaint anachronism. Most modern software development is the product of teams of programmers working on networked computers. Unfortunately, this distributed software development creates new sets of problems.
Heterogeneous networks may include computers from many different vendors, running different operating systems and environments. Software development tools, source code files, and data may reside anywhere on the network. Managing access to source files on a network can be a nightmare. Tools may run on one platform and not on others. Syntax to run tools m
ay differ from one machine to the next. Programmers have better ways to spend their time than keeping track of what tools and files are where and how to access them.
One solution is CohesionWorX 2.0, DEC's new CASE environment for distributed software development on heterogeneous Unix networks. CohesionWorX consists of a suite of integrated tools and a supporting graphical environment for all stages of software development. Supported platforms now include Sun SparcStations or SparcServers running SunOS 4.1.3, Hewlett-Packard HP 9000 Series 700s running HP-UX 9.01, and DEC's own Alpha AXP running OSF/1 1.3.
A Consistent GUI
CohesionWorX provides a consistent graphical environment on all platforms and transparent access to tools, source files, and data, no matter where they physically reside on the network. Such cross-platform connectivity streamlines access to tools and data and can enhance cooperation and communication among programming team members, especially on large collaborative software
development projects. Using libraries, programmers can manage access to files across the network. CohesionWorX offers DEC's FUSE tools for each stage of software development, including design, coding, build, debugging, integration, and management; each tool has an on-line tutorial and context-sensitive help system.
CohesionWorX displays a graphical desktop paradigm as an extension of The Santa Cruz Operation's SCO IXI X.desktop. CohesionWorX shares X.desktop's conventions for window display and behavior (i.e., multiple overlapping windows, scroll bars, and so on). One of the prime appeals of CohesionWorX is that it looks the same no matter which platform on the network you happen to be using.
There are several types of windows. You can create virtual workarea windows suitable for a specific task (e.g., test and integration) or software project. A workarea can contain tools and data appropriate to its purpose. DEC provides predefined task-oriented workarea types (e.g., Configuration Management a
nd Detailed Design), each configured with tools specific to that type. When you open one of your workareas, it's like unpacking a desktop full of all the tools and files you need for that task or project. You don't waste time locating tools and files every time you sit down to work. Your workareas are available wherever you are on the network.
Desktop Tools
Data objects, like files, appear as representative icons in a window. The appearance of a file icon and any special symbols it might wear can suggest the file's contents, as well as other file attributes; for instance, a sheet of line-printer paper wearing eyeglasses is a read-only source file icon.
The icon represents a file on the workarea. The actual file can be anywhere on the network. You are spared the details of precisely which machine, drive, and directory contain the file; CohesionWorX keeps track of all that, so programmers can be programmers and stop being file clerks. You can view or edit a file (as its access allows) simply by
double-clicking on its icon with the mouse.
Tools (e.g., editors) also appear as representative icons in a window. Running a tool is as simple as double-clicking on its icon or dropping a data icon (e.g., a document file) on a tool icon (e.g., a printer). As with data icons, tool icons represent a tool's appearance and behavior, while the actual tool description files can be anywhere on the network. You need not know where on the network the tool (or its data) resides. In fact, you need not know anything about Unix or network operations at all. CohesionWorX keeps track of where everything actually is, as well as how to run everything. Tool icons animate to show when they activate, so you'll know when something is happening; for instance, when you drop a file on the trash can, debris appears in the trash-can icon.
You can control the priority of servers available to run a given tool. For example, if certain servers are often in use for intensive testing, you can specify another server to maintai
n tool performance. You can also employ speedier servers for specific one-time tasks, such as a resource-intensive compiler run.
Distributed Objects
CohesionWorX performs all this seeming magic with the help of its Control Services, based on DEC's ACAS (Application Control Architecture Services) and vendor-specific DCE (Distributed Computing Environment).
ACAS lets you access applications (including tools) independent of the platform you're on. ACAS handles communications between users and tools (e.g., running the tool) and between tools (so one tool can run another or pass data to another). ACAS takes care of the details of fielding user requests, finding servers to satisfy requests and supporting ongoing user-to-tool and tool-to-tool communications, all transparently to the user (see the figure "Distributed Objects with CohesionWorX" on page 158). You gain access to tools on other platforms, effectively multiplying the number of tools available.
This design strategy is especially att
ractive to organizations that have grafted a variety of computers to a network because of collaboration, merger, acquisition, or departmental consolidation. You need not leave behind tools and applications you are comfortable with and in which you've invested time and training. By allowing access to known tools and applications, organizations can save the time and expense of locating and acquiring new tools. In addition, they avoid the cost and effort of retraining disgruntled users.
You can add tools or even servers dynamically to the environment without disturbing existing activities or rebooting the system. ACAS (which is changing its name to ObjectBroker for version 2.5) complies with the CORBA (Common Object Request Broker Architecture) standards.
DCE services support distributed applications and provide interoperability across heterogeneous platforms. The DCE Security Service provides for secure (optionally encrypted) communication across the network and also authenticates users and their
privileges on each machine on the network. Performing one log-in to DCE saves the time and bother of logging onto every server whose tools or data you access.
DCE's Cell Directory Service keeps track of where tools and data physically reside on the network and provides access to the tools and data across the entire network. This simplifies access to distributed tools and data tremendously, since DCE makes the networked resources look like a single virtual system to the user.
Given such complex interplay between the network, ACAS, and DCE, the initial installation of CohesionWorX can be a bit of a challenge. DEC recognizes this and provides detailed step-by-step manuals and release notes specific to every supported platform, in addition to DEC engineering support services. Much of the installation of CohesionWorX itself is automatic, using interactive scripts that request basic information the installer can provide.
Custom Workareas and Version Control
In a typical scenario, you create
a new workarea for a software project or task. You can choose from predefined task-oriented workarea templates. Each workarea template is preconfigured with tools appropriate for its task. For example, the Implementation and Unit Test workarea might contain the CohesionWorX FUSE Editor, Builder, Debugger, and other tools.
Having created and named the workarea, you can then place appropriate tools and source files on the new workarea. For source files, this can be as simple as opening a directory folder, selecting one or more file icons with the mouse, and dragging the whole lot onto the new workarea. You can either move or copy the files to the workarea. In either case, the physical location of the files in the directory structure does not change: The icon on the workarea is a reference to the file, not the file itself. The file can reside anywhere on the heterogeneous network.
Besides populating your new workarea with the tools and files you need, you can also customize its appearance. You can
specify colors for each part of the workarea window and choose the fonts for object labels. Different users often prefer different color schemes and types and sizes of fonts. The workarea will reflect your preferences no matter what machine on the network you happen to be using. You can even customize workarea window behavior, such as automatically saving the layout when closing the window.
If you want to manage access to some existing source files, you simply select the file icons and drop them on the DEC FUSE Code Manager tool icon. Code Manager creates a new library to contain and manage the source files by version and configuration. At present, CohesionWorX supports RCS (Revision Control System) and SCCS (Source Code Control System) style libraries. You can enter comments for each source file added to the new library. Code Manager then assigns initial version numbers to each file. You never have to remember (or waste time finding out) which is the latest revision: CohesionWorX remembers for you. Yo
u can display whole revision histories of files, with information including date and time, creator's name, comments, and status. You can also compare different versions of files.
You can edit source files with the FUSE Editor tool in a variety of intuitive ways: by running the Editor (double-clicking on its icon) and loading the file into the editing buffer, by dropping the file icon on the Editor icon, or by running the Editor from within another tool (e.g., the Code Manager tool). CohesionWorX also includes support for the widely used gnu emacs and vi editors.
If run from Code Manager or the library, the source file checks out of the library and loads into the Editor buffer. You can edit the file using multiple file buffers, search and replace, cut and paste, undo, and other standard editing functions. When you save the file, it checks back into the library with a new version number. You can also create new files with the Editor and even initiate compiles of source code.
Drag-and-Drop Co
mpiler
By dropping the source file icon on the FUSE Builder tool icon, you can initiate a compile and build. CohesionWorX supports C, FORTRAN, Pascal, and (optionally) Ada and C++. Builder is a graphical front end to Unix make or gnumake utilities. You can use any of your existing make files with Builder or create new make files, using a graphical representation of the build to specify build dependencies.
After compiling, any syntax errors appear in a special transcript area of Builder. When you double-click on a syntax error, the Editor automatically loads the corresponding source file, opening it to the appropriate line of code. You can then edit and recompile. This is an example of the interoperability that simplifies and speeds up typical software development activities.
After a successful build, you can initiate the FUSE Debugger, a graphical front end for Unix system debug utilities (e.g., dbx, xdb, or gdb). You can set breakpoints within the source code of any component of the program
, and you can set traces to track program execution. You can run the program from within Debugger, stop the program manually or with breakpoints, and then single-step through trouble areas. You can set up separate windows to monitor inputs and outputs. As with Builder, you can run the Editor from within Debugger, change source code, recompile, and continue debugging. This tight interoperation speeds and simplifies program debugging.
The FUSE Call Graph Browser tool graphically displays call relationships between functions or files. This is a valuable aid in visualizing the operating structure of your program and identifying potential problems. You can interoperate Call Graph Browser with Debugger, allowing you to monitor graphically which source files or functions are executing at any time.
Seeing the dynamic changes on the call graph as the program runs in Debugger is quite astonishing; it looks more like a video game than a CASE tool. Yet by observing which functions seem to run all the time,
you can quickly identify which ones might benefit most from optimization efforts. This impressive interoperation can help you allocate programming efforts more efficiently, saving extra steps in program development.
Software Profiling
To help further optimize program performance, the FUSE Profiler generates dynamic run-time statistics on program execution. Profiler displays graphs based on statistics from Unix tools like prof and pixie. You can view statistics on any level of program organization, including files, functions--even individual instructions. This lets you pinpoint which program elements are slowing down the program and zero in on offending code. A few mouse-clicks load the source file for editing. You can then recompile the edited program and rerun Profiler, with some increase in performance expected.
Distributed software development projects can so camouflage data and function references that you might never unearth their source code. The FUSE Cross-Referencer exists specificall
y to root through program files for just such program items. You can construct very broad or very specific queries to find data and function declarations and references buried in program files. This can save a lot of time locating software objects across platforms.
The nature of C++ produces its own characteristic difficulties. The optional C++ Class Browser deals with one such difficulty by displaying C++ class hierarchies. You can quickly view base classes, derived classes, members of each class, and other inheritance relationships. As usual, a few mouse-clicks can load the source code in the Editor for modification. With team software development (or even single-programmer development), keeping C++ class definitions straight can prevent problems farther along in the development process.
Graphical Unix
Besides the DEC FUSE tools, CohesionWorX offers a wide array of graphical Unix tools for mail, manual help, printing, shell, and other common activities. All these tools also appear as deskto
p icons, and you need no knowledge of Unix syntax to use them. Each user has a personal toolbox in which to keep tools or customized versions of tools.
New users needn't abandon and unlearn all the tools and language-specific programs (e.g., compilers) they currently use. One of the most powerful features of CohesionWorX is its ability, with the optional EnCASE, to assimilate other tools into the desktop object paradigm.
EnCASE includes tools, scripts, and templates to simplify the integration of tools into the CohesionWorX environment. This can make existing tools that you are already comfortable with available across the network. The simplest level of integration can be achieved without any programming at all, while the most in-depth integration may require the source code of the tool. You can specify a server for the tool, plus special activation and drag-and-drop behavior.
In effect, this makes CohesionWorX a universal host to any third-party tools already in use on a software develop
ment project. It helps protect company investment in existing software development tools and training. Also, as your needs change and you acquire new software, EnCASE accommodates the changes dynamically. Several vendors have already prepared EnCASE versions of their report-writing and project management software for CohesionWorX.
An Emerging Standard
CohesionWorX supports standards, including operating-system and environment standards OSF (Open Software Foundation) Motif, Posix, X/Open, OSF DCE, and SPEC1170; ANSI X3H6 messaging specification; OMG (Object Management Group) CORBA messaging standard; and CDIF (Compound Document Interchange Format) and ECMA (European Computer Manufacturers Association) PCTE (Portable Common Tool Environment) standards. Government standards like MIL-STD-973 and DOD-STD-2167A are also supported.
An outgrowth of DEC's ASD/SEE (Aerospace-Defense/System Engineering Environment) work for the F-22 program, CohesionWorX provides an ideal environment for aerospace and d
efense-related software development and maintenance. DEC's future plans for CohesionWorX include support for other popular Unix and non-Unix platforms. Besides being a stand-alone software development solution, CohesionWorX also represents the foundation for DEC's CohesionWorX Team/SEE: a complete process management solution for managing the full lifestyle of medium- or large-scale software projects.
CohesionWorX is a heavyweight competitor of other Unix software development tools, such as HP's SoftBench and Sun Microsystems' SparcWorks. Its built-in support of heterogeneous networks is unique among comparable tools. Because of its consistent graphical interface, broad suite of included tools, ability to integrate third-party tools easily, and cross-platform power, CohesionWorX is a complete solution--and the emerging standard--in Unix software development. It's a solution you can stick with through every stage of software development.
The Facts
DEC CohesionWorX
Ove
rview
Distributed software development environment for networks.
Hardware Platforms
Sun, HP, and DEC workstations.
Workstation Requirements
32 MB of RAM (48 to 64 MB recommended, depending on the specific platform).
Server Requirements
120 MB of disk space for CohesionWorX, 26 MB for ACAS and DCE, 150 MB of base swap space, and 50 MB per user. Disk space usage depends heavily on the load.
Environments
Unix (SunOS, HP-UX, OSF/1).
Languages Supported
C, FORTRAN, Pascal, Ada (optional), C++ (optional).
Tools Included
Editor, Builder (compiles programs, runs make files), Debugger, Code Manager (controls access to files in libraries), Profiler (displays program run-time statistics), Call Graph Browser (displays program call structure), Cross-Referencer (finds program data and function references).
Optional Tools
EnCASE (integrates tools into CohesionWorX), C++ Class Browser (displays C++ class hierarchies).
Pricing
CohesionWorX license fee: $2300
C
ohesionWorX C++ support license fee: $1000
CohesionWorX Ada license fee: $1000
CohesionWorX EnCASE license fee: $2400
Digital Equipment Corp.
146 Main St.
Maynard, MA 01754
(800) 344-4825
Illustration: CohesionWorX provides a consistent graphical environment on all platforms and transparent access to tools, source files, and data, no matter where on the network they physically reside. Besides the DEC FUSE tools, CohesionWorX offers a wide array of graphical Unix tools for mail, manual help, printing, shell, and other common activities. All these tools also appear as desktop icons; you need no knowledge of Unix syntax to use them.
Illustration: Using libraries, you can manage access to files across the network. The foreground window shows a Check Out box where files are checked out of the library. The Code Manager window displays the files contained in the current library. Code Manager manages the source files by version and configuration. You never have to re
member which is the latest revision: CohesionWorX remembers for you. You can display whole revision histories of files, with information including date and time, creator's name, comments, and status. You can also compare different versions of files.
Figure: Distributed Objects with CohesionWorX
With CohesionWorX, you access the entire network by manipulating objects on a local desktop. Control Services--using DEC's CORBA-compliant ObjectBroker software, DCE, and the Multi-cast Message Server--identifies servers to run each tool, transparently to the user. This design strategy is especially attractive to organizations that have grafted a variety of computers to a network because of collaboration, merger, acquisition, or departmental consolidation. You don't have to leave behind tools and applications you are comfortable with and in which you have invested time and training.
Edmund X. DeJesus has a Ph.D. in physics and has been a professional programmer for over 15 y
ears. He has worked for IBM and MIT Lincoln Laboratory and has taught at Boston University and Middle Tennessee State University. As a computer consultant, technical writer, and course developer in the Boston area, he has participated in early testing of DEC's CohesionWorX. You can reach him on the Internet at
70761,2303@compuserve.com
or on BIX c/o "editors."
Linking Development Teams
