The only change is that the source jar file now contains the data for the help files, such as they are. Here are sequence_src.jar and sequence.jar .

A new version of sequence. This one makes the --headless option for producing .png images directly from sequence flow descriptions work again. The default is now to use the new parser. An executable jar file is available as sequence.jar and the source code is in sequence_src.jar. Hope you like it.

Well, sort of. So this week I'm here at JavaOne, in fact I even presented this morning but that was work related and so not the point of this. Yesterday I was in the Concurrency Utilities in Practice TS-2136 talk, which was excellent, and I noticed that the look of one of the sequence diagrams shown on the screen was very familiar. I talked to the presenters afterwards and it turns out they'd use SEQUENCE to generate it. I think I'll have to get round to woking on the program again soon.

plus, of course, some bug fixes. Embarassing though it is to admit, working through putting together the examples, which are available under the Help menu in SEQUENCE, showed up a few problems that I needed to fix. As well as adding lots more examples, and improving the help I also deprecated the old "LISP style" syntax for describing sequence diagrams. You can still get access to it by passing the --offer_parser_choice option on the command line, but by default you now only get the more Java like syntax.

The source code is in sequence_src.jar and an executable version is available in sequence.jar. To run it just type java -jar sequence.jar. You'll need a 1.4 or better Java version.

Just a few small improvements. I've added the beginnings of a help system, currently consisting of a menu option and a couple of java help pages. I've also changed the command line options slightly. To run in headless mode you now need to say

java -jar sequence.jar --headless <input_file_name>

and when you run with a display you can choose the default directory used by the open and save commands if you say

java -jar sequence.jar <default_dir>

As usual the compiled code is sequence.jar and the source is sequence_src.jar

I hope to get round to making other changes that people have asked for soon.

An initial version of a new release that supports an alternative syntax for defining sequence diagrams. The sequence.jar file can be executed by typing java -jar sequence.jar. The sequence_src.jar file contains the source code. The parser for the new syntax is implemented using javacc.

I've got the parser finished and hooked in as the picture below shows. I now need to upgrade the layout algorithm so that it can handle double line object names and work out how to determine which parser to use for a saved file.

I'm making quite good progress with implementing the alternative syntax. Using JavaCC, which I've had some experience with in the past, it was easy to put together a grammar that recognizes valid statements in the new syntax. We've also recently used JavaCC at work to write a grammar for parsing SQL like statements.

I'm thinking of implementing an alternative syntax for specifying a diagram for SEQUENCE. The current syntax is going to make it very difficult to add some of the features, such as stereotypes and method arguments in a sensible way. Here are my initial thoughts.

Simplest. Call method aMethod on object anObject.

anObject . aMethod

You can also use << and >> for methods like create.

instance.<<create>>

The spaces around the . separating the object and method names are optional. If aMethod has a return value it is shown following -> after the method name, as below.

anObject.aMethod -> returnValue

The calls made by a method are shown in it's method body, enclosed in { and }, which follows the method name, or returnValue if present.

anObject . aMethod {
  anotherObject.aDifferentMethod -> someValue
}

anObject.aMethod -> returnValue {
  anotherObject.aDifferentMethod -> someValue
}

The name of the object can be made up of three fragments. The ClassName must start with : and the stereotype must be surrounded by << and >>.

objectName :ClassName <<stereotype>>

Any combination of the fragments may be used so any of the six examples below would be valid.

objectName
objectName :ClassName
objectName:ClassName <<stereotype>>
:ClassName
:ClassName <<stereotype>>
<<stereotype>>

A quick example. This also shows the use of " to surround a names that contains spaces. The same technique is used if the class name contains spaces. As the stereotype must be surrounded by << and >> there is no need to use " in this case.

"A Student" <<actor>> enroll {
  :EnrollInSeminar <<controller>> ."wish to enroll"
}

The method name may also be more elaborate than a simple name. It can include an iteration marker *, a condition enclosed with [ and ], and arguments following the method name surrounded by ( and ).

accountBalance.*[transaction has debits]withdraw(debit amount)

I've made a couple of bug fixes and improvements to SEQUENCE recently. I added arrows to the call and return lines, they'd got dropped in a previous build, and I fixed a layout problem with calls that went from right to left on the diagram. Here's a screen shot of the latest version. The source code for SEQUENCE is here while an executable jar file for SEQUENCE is here.

Look here for the latest developments and releases of SEQUENCE.

Shiv asked for an example command line to execute SEQUENCE from the classes directory that it is build in. Here's one that works for me. It should all be on one line of course, I split it for "better" presentation

/usr/java/j2sdk1.4.1_02/bin/java 
-cp classes:properties:lib/log4j.jar:lib/jlfgr-1_0.jar
com.zanthan.sequence.swing.Sequence

• classes is the directory containing the compiled code for SEQUENCE.
• properties is the directory containing the log4j.xml file that specifies the logging settings. Without this you get a single warning when the program starts, otherwise the program runs fine.
• log4j.jar contains the code for log4j
• jlfgr-1_0.jar contains the java look and feel icons from the Java look and feel Graphics Repository
• com.zanthan.sequence.swing.Sequence the main class

As to the OutOfMemory error on exporting a very large diagram to PNG format, I really don't know what that could be. The ExportAction class uses the javax.imageio.ImageIO static method write to output the image after it has been drawn on a BufferedImage instance. If you put some logging statements in the ExportAction export method you could probably isolate where the problem is. If you send me the file causing the problem I'd be glad to take a look.

Look here for the latest developments and releases of SEQUENCE.

A couple more improvements to SEQUENCE. They're both illustrated in the diagram below.

Matt Ring changed the SwingPainter component so that the return lines are shown dashed, as they should be. I've improved the layout code so that the exported png diagrams actually show all of the diagram, and I changed the Display class so that when the diagram size changes the scroll bars are undated. The new executable jar file is here and the source code here.

Look here for the latest developments and releases of SEQUENCE.

At the suggestion of Chris Winters I've made a couple of changes to SEQUENCE. Firstly, instead of the name of the first object on the diagram being set via the preferences it is now set from the text description of the sequence. Secondly, you can now generate a PNG image for a diagram in headless mode.

I originally wrote SEQUENCE as a quick and dirty hack and that showed most strongly in the parser and diagram layout portions. At that time the easiest way to set the name of the initial object was to use the preferences. Chris's suggestion prompted me to look at that assumption. With the refactored code in the latest version it turned out it was easy to change things so that the first entry in the sequence becomes the name of the initial object. For example.

(CommentFactory newComment
    (Comment new 
      (IDGen nextID newId) 
      (Transaction add)))

Note that the name of the first method is not shown in the diagram, though there is a tooltip on the GUI now that does show it.

The second change, headless operation, was also much easier because of code restructuring. However, what really made it possible was the java.awt.headless system property. There are now two ways to start SEQUENCE. If you use
java -jar sequence.jar
then the GUI is shown as before. If you use
java -Djava.awt.headless=true sequence.jar <input_file.ext>
then the file input_file.ext, where ext is any extension, is read and a PNG image is written to the file input_file.png I've not yet tested calling this using cgi but it should work.

Here's the executable jar file sequence.jar, and a jar of the source code, sequence_src.jar.

Look here for the latest developments and releases of SEQUENCE.

I've just finished the coding for the next version of SEQUENCE, a tool for drawing simple UML sequence diagrams. It includes no new functionality but should provide a better base for future development. Next I'm going to try using it in the UML IntelliJ plugin so that I can get a better sense of what is needed to make it easy to plug in to other tools. After that I think I'll experiment with supporting different syntaxes for writing the diagrams. Here's an "executable" jar file, which should run with java 1.4 using

java -jar sequence.jar

and here's the source.

Look here for the latest developments and releases of SEQUENCE.

Bob Lee has produced a fantastic application by combining the SEQUENCE tool I wrote with his own jAdvise (a much more sophisticated piece of code). It produces sequence diagrams from executing code and is the sort of thing the inspires, and embarrasses, me into picking up SEQUENCE again and making some improvements.

Look here for the latest developments and releases of SEQUENCE.

In July I wrote a little LGPL program for UML Sequence Diagram Sketches. I've now taken the time to make a couple of improvements in response to user requests.

• The diagram can now show a notation next to the return arrow. So, for example you could show the return type.
• There is now a very basic preferences system so that you can change the colors that are used in the diagram and choose whether or not to display return types.
• You can now include spaces in object names, method names, and return types by surrounding them by single or double quotes.

So, for instance, this diagram is produced from this text.

(Comments newComment
  (CommentFactory newComment "a new comment"
    (Comment new 
      (IDGen nextID newId) 
      (Transaction "add(this)")))
  (Comments addToCache))

Here's a screen shot of SEQUENCE in action and finally links to an executable jar file and a jar file containing the source code.

Look here for the latest developments and releases of SEQUENCE.

As part of working on the design on MBlog I've been producing quite a few UML Sequence diagrams. I started out sketching these by hand which is quick, apart from the constant erasing and redrawing, but does make it difficult to publish them on the web. I then tried using the OpenOffice.org draw program. However, I found I was spending more time making the drawing look pretty than expressing what I wanted. Next I looked at ArgoUML but with that tool you have to enter a lot of information that isn't needed for a simple sketch before you can get any diagram. Finally I decided that it would be simpler to produce my own simple took.

The end result is an interactive editing tool called SEQUENCE that produces pictures like this from a textual input like this

(Comments newComment 
  (CommentFactory newComment 
    (Comment new 
      (IDGen nextID) 
      (Transaction add)))
  (Comments addToCache))

It's written in java and required java 1.4.0 or above to run. I've released it under the LGPL and you can don't load the executable and source as one jar file. Just unjar it and use java -jar sequence.jar to execute. Look at the README file for more info on how to build it from source. I hope to make improvements as needed and apologize for the current complete lack of comments.