I'd like to announce the release of Trace Modeler v1.0, an easy-to-use and smart UML sequence diagram editor. It combines the immediate and automatic layout of UML sequence diagrams with a simple drag and drop interface. And it's cross-platform to boot. Here's a 30 sec demo of Trace Modeler in action. It can be used by any development team for brainstorming and prototyping the design of new systems, or for the documentation of existing ones. Sequence diagrams are notorious for their rigid layout constraints. Even a simple design change can require a complex rearrangement of diagram elements. Surprisingly, most developers can expect little help from their UML tool in this matter. They're forced to express their design ideas using low-level shape manipulations and have to (re)layout their diagram manually whenever they change it. Not only is this tedious and a waste of their time, it also distracts from the task at hand. Trace Modeler grew out of a personal itch that needed scratching : I have to draw a lot of sequence diagrams and got a bit frustrated that is was such a drag. So I rolled my own in an attempt to optimize developer productivity when working with UML sequence diagrams. It's main benefit is that it can save you a tremendous amount of time. It instantly updates a diagram's layout whenever it changes, freeing you to focus on the actual content. Furthermore, its layout engine ensures that every diagram is visually pleasing and structurally correct. At the heart of it lies an understanding of the flow of control in sequence diagrams. This domain knowledge is used not only to determine the proper diagram layout, but also to interpret user actions. This enables you to quickly change a diagram with simple drag and drop gestures, whilst Trace Modeler maintains its correctness and pleasing layout. As a result, ideas can be expressed almost instantly with Trace Modeler. The visual appearance of a diagram is controlled by a handful of style settings. These enable you to give it a consistent look with just a few clicks. Here's a gallery of UML sequence diagrams to demonstrate these style settings. Trace Modeler also offers a couple of unique features such a

• splitting activations
• inlining message calls
• smart flow-based comment connectors
• right-to-left diagram layout and full bidi-text support for non-Western scripts
• automatic object lifetimes
• control flow highlighting

Diagrams are stored in a simple and readable text-based file format, ideal for versioning systems and file comparison tools. This format makes it easy to generate sequence diagrams with other tools or from running code, and visualize them with Trace Modeler. Diagrams can be exported to various popular graphics formats and the clipboard. It also offers a batch export feature that can be used from the command-line for easy integration into any automated documentation process. Trace Modeler is extremely portable: it works on all major platforms, requires no installation and has very accommodating license terms. A free, fully functional evaluation version is available for download. Visit www.tracemodeler.com for downloads, online demos and other UML sequence diagram resources. But what about you? How often do you use sequence diagrams in your daily work and what for? Do you feel you're being productive with your current tool? What neat features would you like to see added to tools that support these diagrams? I'm always looking forward to feedback, especially on the unique features described above or any others you can think of! Thanks for your time!

Trace Modeller looks nice, I'll try it out, but here is another tool I really like: http://www.zanthan.com/itymbi/archives/cat_sequence.html Not even drag and drop - you write little scripts, which is ultra-productive.

Funny you should mention it, that's how Trace Modeler started out as well! In fact those roots are still present in the current file format. For example a simple diagram with two objects and two messages looks like this : # targets OBJECT target0 "object1" OBJECT target1 "object2" # trace CALL target0 "message1" CALL target1 "message2" RETURN "return2" RETURN "return1" # comments COMMENT 48.0 -19.0 "this is a comment" So if you like the scripting approach, be sure to check it out because Trace Modeler also gives you all kinds of target varieties, message kinds, combined fragments, operators and style settings through its text format. To me the scripting approach only makes sense if the text is generated. I can't imagine how manual scripting could ever be faster than drag & drop with Trace Modeler. Perhaps we can organize a Pepsi-challenge :) Thanks for bringing up the scripting option Paul! PS : if you really want to, I could add a little easter egg that lets your enter text manually ;)

I wonder how relevant it is without having the code around. I believe such tools should be part of the IDE, related to the code.

I don't think that having the code around is very relevant really. Here's why.. Sequence diagrams facilitate communication between developers and are not at the same level of detail as the code itself. They highlight only the interaction between objects, and not the innards of any single object. Generating sequence diagrams from source code doesn't bring you much because it generally shows all possible paths and doesn't account for dynamic binding. And the other way around, generating code from sequence diagrams doesn't work because the set of diagrams is not exhaustive and the relationship between the diagrams isn't specified. So most people use them to document (an interesting part of) their design. And now with Trace Modeler you can also use them to come up with your design initially and/or quickly try out some design alternatives.

In general, I see two main uses to Sequence Diagrams: design (pre-coding) and execution tracing (post-coding). The later can be done either by static code analysis or runtime tracing. I agree there are limitations to static code analysis. However, you can get nice results from tracing the code at runtime (look at TPTP sequence diagram for instance). I can see why developers may want to communicate designs with sequence diagrams, but I don't see it working in void. There should be an underlying model defined either as code or as class diagram.

Ah, because you mentioned IDE and code, I assumed you meant source code. I agree that generating them from running code is definitely a good approach - if you have a way to somehow filter the output to keep the diagram focused. I haven't come across any yet, but thanks for the TPTP link, I'll check it out! With the current simple text format, it should be easy to capture execution traces and display them with Trace Modeler. I'll give it a go once I find the time to work on a decent filtering approach. What tool are you currently using?

I invite you to read a blog post I wrote about tracing Java execution. Check out the comments, too, some readers left references to more tools. http://zvikico.typepad.com/problog/2007/11/five-ways-for-t.html

Interesting read, thanks for offering an unlimited evaluation-version. For my thesis project, I found the sequence diagram editor in NetBeans6 quite useful, UML-support in NB is getting better and better. For some reason, free design tools are still a minority in Eclipse.

Thanks for the article, I had already read and bookmarked it earlier ;)

i agree Zviki!!it benefited me a lot and its usage is relevant what to buy a graphic designer

THis is great TheServerSide!!i deeply appreciated the information you share here

stork club movie