Object oriented programming (and .NET programming in particular) is not a “make it up as you go along” affair. The discipline requires planning and structure. As a result, an indispensable addition to an OO developer's programming toolbox is comprehensive object oriented analysis and design tools that use Unified Modeling Language (UML), the lingua franca of software diagramming languages.

Programmers who use these software engineering methodologies consider it important to have modeling products that work in their development environments, a perception that was not lost on vendors. To maintain a competitive advantage within the software development tools space, Microsoft acquired Visio in early 2000, IBM acquired Rational in late 2002, and Borland acquired TogetherSoft in November of 2002.

Recently, Borland released Together 2.0, its new version of its flagship diagram-to-code development product for .NET programming. Together 2.0 for Visual Studio .NET is a full-scale UML based development environment which is fully integrated with the Visual Studio .NET IDE—and it is impressive. Very, very impressive.

Supports Two-Way, Code-Diagram Generation

Together is a “two-way, no compile needed” modeling tool. When you add a new UML diagram or modify an existing one in Together's Model View, the corresponding C# or Visual Basic code is automatically generated behind the scenes. You don't need to invoke any auto-generate or export feature.

For the purpose of this review, I opened a new VB project, added a UML class diagram with some properties and a method using Together Model View. Voila! There was the code. I did not have to use a reverse engineer feature, as I would do using Visio with Visual Studio Enterprise Architect Edition.

Figure 1: Together generates code from diagrams on the fly.

I did the same procedure with a C# project. Then, when I made changes in my VB and C# code, these changes were immediately reflected in the Together Model View UML diagrams. Again, no compile needed.

When I added inheritance relationships to my UML diagram, these relationships were reflected in the code, again on the fly. The same was true when I created aggregations and compositions. I was impressed.

True IDE Integration

As I mentioned earlier, Together 2.0 is completely integrated into the Visual Studio IDE, with an easy-to-navigate modeling palette. A Model View enhances the Solution Explorer and the Class Explorer, letting you navigate through your project's object model. You also use the Model View to create Use Case, Sequence, Component, Deployment, Activity, Collaboration, and State Chart UML diagrams as well as the Class diagrams which are the main focus of this review. Together supports a variety of code generation mechanisms among the various UML diagrams. Again, it's all no-compile, two-way viewing, so switching between code and diagrams is simple and quick.

Figure 2: Together's Model View allows you to create and edit items as well as organize your project and toggle between code and UML diagrams views.

Together makes extensive use of drag and drop functionality to create inheritance and association relationships between objects. The Together toolbox includes the standard UML inheritance and association line symbols, which you select and drag between objects to create relationships. Associations line symbols can further be configured as aggregations or compositions.

Figure 3: When you use the Together drag and drop features to create inheritance or association relationships, your Visual Studio code updates automatically to reflect the association.

Configuring Classes

Together 2.0 allows you to bypass text-based coding to configure your classes by providing a property page configuration feature. For example, you can use the Property Page class configuration feature to have your class inherit from another class or to select an interface to implement. What's that good for? Property page configuration allows you to code faster and more accurately. It's simply a matter of filling in the blanks instead of keyboarding lines of code. Faster, more accurate coding means faster time to market and this translates into more profits and happier customers.

Figure 4: Together's Property Page Configuration feature allows you to inherit classes, implement interfaces, and set configuration constraints at the class level as well fine tune your methods and properties at the function level.

In addition to class level configuration, Together lets you use the Property Page windows to configure settings at the method and property level, at a high level of granularity.

Together's refactoring support, available for C# projects only, allows you to change the internal behavior of objects easily. That means you can make a change in code in one area, and have the change cascade throughout the entire project. Also, you can extract methods, superclasses, and interfaces. You can also do safe deletes: Together does a global search of the code that you want to delete, and checks to make sure it can be removed cleanly without creating hidden problems.

Figure 5: Together's refactoring allows you to make large scale code changes and enhancements to C# projects automatically.

You also get built-in support for UML design patterns, a standard discipline in the object oriented programming paradigm. The Together Design Registry contains well over a hundred common design patterns. Also Together has a Design Pattern Wizard that helps you create and store your own patterns.

Figure 6: Together allows you to access common design patterns and ship your own.

Gotchas

Together does have a few problems. I had some trouble installing it on my standard development system. After exchanging a few E-mail messages with Borland support, we determined that Together cannot be installed on systems that use the VS Studio Add-In, VBCommenter. This is a definite drawback for developers whose primary activity is VB development under .NET.

Together shines brightest with C# projects. Refactoring is not supported under VB, and a few times I got a diagramming bug when running under VB. However, these episodes were more of an annoyance than showstoppers. The overall power of the product made it easy to tolerate these minor shortcomings. Hopefully, these irritating bugs will be cleaned up in service releases.

Together is a complex, feature-rich tool that brings the power of direct, two way UML diagramming and engineering to the .NET programming environment in a way that few companies can match. Together, although useful for the beginning developer, is best suited for developers experienced in the ins-and-outs of UML and users of design patterns. This is a big tool for big, complex projects. Beginning developers might become overwhelmed by breadth of knowledge really required to take full advantage of Together. Yet, in the hands of developers knowledgeable in the art and practice of OOP, Together could shave 20% to 30% of the time it takes to get a large scale, multi-developer project to market. It has that potential!

Before being acquired by Borland earlier versions of Together sold for over $4,000 a seat. Today, the product sells at a very attractive price point of $199! At this price, Together 2.0 is a steal.

Bob Reselman is a software developer and technology writer who has been making code and writing about code since before Java and as far back as VB version 1.0. Bob is author of four books on computer programming, the latest being Active Server Pages 3.0 By Example (Que, 2000, ISBN 0789722402). He just published his first novel, Coding Slave (newTech Press, 2004).