UMLet UML drawing & scripting (edit)

UMLet is a basic free and open source drawing tool for UML diagrams. It is witten in java and comes in a standalone version, an eclipse plugin and a web hosted edition (UMLetino). In the market of UML tools (cfr. an earlier blog on Astah) it has a unique take on modelling.

First it is a drawing tool. Real UML tools try to have one model for which each diagram gives a different, but consistent perspective. UMLet just lets you draw and link UML components. But it does not assist you in UML syntax or consistency. Neither does it have any code or documentation generation features as the higher end tools have.
The advantage is that UMLet does not have the overhead of defining the model behind the diagram. Also it does never get in the way when you want to do something that is not supported by UML or your tool.

Second where you expect a drawing tool to be targeted on a strong, intuitive, graphic and interactive user interface, each element in UMLet is backed by a notepad like text specification. You draw your diagrams, elements and connections using a point and click interface. Modifiying elements, changing style and appearance, adding details is done in one associated text box. The text language is compact and simple.  This makes UMLet a very geeky tool. Sometimes you have to compose elements, like sequence diagram lifelines, from several subparts. On the other hand, you never have to wade through a hierarhy of interactions dialogues to fill in all characteristic of an element you have definied.

Once you get the knack of it, the speed of working with UMLet is matched by few other tools.It is a good fit for taking agile modeling  beyond the whiteboard. You can easily extend the toolboxes with elements or create your own. The tool is best used on small modeling efforts, as, being a drawing tool, different diagrams representing the same element will not automatically remain in sync.

The default toolboxes do not have all UML elements and are are a bit sloppy in UML syntax. As you can easliy modify and expand the toolboxes, this can be amended, but there is a risk that UML newbies pick up bad UML manners from the tool:

• uses <<includes>>, <<extends>> instead of <<include>>, <<extend>>
• synchronous messages  in sequence diagrams do not have a filled arrow head
• return arrows in sequence diagrams do not have a dashed line
• no found message in sequence diagram 
• no * cardinality as in the UML standard 

There is a set of "all in one" diagrams that present entire diagrams as one element that you can configure by editing the properties. I did not find any way to interact with them graphically. You are really scripting your diagram in text, like in the LaTeX days of text processors.

Here's a nice intro video.

Sequence Diagram by Charles Babbage

Charles Babbage designed the Analytical Engine, a mechanical computer, in the 19th century. Only a partial trial model was built when he died in 1871:

In his 1826 paper, On a Method of Expressing by Signs the Action of Machinery, he explains the need for a graphical modeling language in his project:

The difficulty ... induced me to seek some method by which I might at the glance of the eye select any particular part, and find at any given time its state of motion or rest, its relation to the motions of any other part of the machine, and if necessary trace back the sources of its movement through all its successive stages to the original moving power.

Babbage later stated:

Without the aid of this language I could not have invented the Analytical Engine; nor do I believe that any machinery of equal complexity can ever be contrived without the assistance of that or some other equivalent language.

In the paper he uses a clock as an example:

The diagram below shows, in the middle columns (READING OFF PART), the hands of the clock (Hour, Minute and Seconds) and to the left the parts (TIME PART) connected to them. The time parts are labeled with the letters you can also find in the drawing of the clock mechanism above.
In the ORIGIN OF MOTION rows in the diagram you find arrows indicating the interactions between the parts. The lower half of the diagram shows a vertical time line with indications of the activity (active, direction of motion, variable speed...) of each part.   
It is interesting to note how close this resembles UML's sequence diagram is, with its object lifelines, message exchange arrows and activation boxes.

Here's an example of a UML Sequence diagram:

Astah: fast modeling

Astah (formerly Jude) is a uml tool that works very well, I only have some minor remarks about the interface:

• did not find a way to make an element unselectable (e.g. when you do not want to multiselect all elements in a package, but not the package itself), like you can in Enterprise Architect.
• you easily select sub-elements when you want to select e.g. a class

Here is a page with some tips for fast modeling from Astah, and a link with keyboard shortcut.
Some more tips

• Association classes: right click on an association, choose convert to association class 

Sequence diagram modeling does not have the same level of perfection in v7.0:

• Astah is in message draw mode, even when not appropriate (if you misclick you add an unwanted message)
• not easy to add methods from diagram to existing classes
• no automatic generation of communication diagrams from sequence diagrams (and vice versa) 
• unlike sequence diagrams, communication diagrams do not
• prompt to add new classes
• support iterations

model translation dictionary

Speaking in tongues: Nice translation dictionary from one modeling notation to another by Scott Ambler

epf composer installation

You can find wikis for some popular software development processes (UP, Scrum, XP...)  at the epf wiki homepage. Any team member participating in the Unified Process project can use the wiki to find guidelines, templates etc to participate in the process.
Whatever process you want to use, you probably want to customise the process to the way you apply it at your company.
The epf (Eclipse Process Framework) composer is an Eclipse based standalone application, which allows you to build your own version of OpenUp or another software development process (e.g. Scrum) you use.

The Getting Started section of the epf site has a fine installation guide, though it's a tad out of sync with the site itself.
Here are the steps I  followed to get it running:

1. Download the composer from http://www.eclipse.org/epf/downloads/tool/tool_downloads.php
1.  I took the latest version (1.5.1.7 at this moment), chose the download for my platform and extracted the zip to disk.
2.  Go in to the installation directory and run epf.exe
3. Download the epf practices from http://www.eclipse.org/epf/downloads/praclib/praclib_downloads.php
1. For openup (or to roll your own stuff) you just take the EPF practices library. Starting libraries for the processes mentined above are also present here, while at other sites you'll find other templates (here's one for TOGAF).
2. Follow the instructions at the bottom of  the page
1. extract the zip file to disk
2. In your running epf application choose File->Open->Medhod Library
3. Browse to the directory where you unzipped the library select it and click OK, then click Finish
4. In the Window menu, Open the Authoring or the Browsing perspective, depending on what you want to do
 

5. Select your software process
 

6. Customise your process

Follow the tutorial section in the manual. There's a preview to see how the generated process page will look and configuration->publish will publish the customised process site.

Defect Driven Design

D³ makes the most sense when you consider total cost of ownership from inception to product end of life. Of all the costs, maintenance is by far the largest. Unfortunately it is a cost that cannot be avoided. However we can avoid the costs of every other phase by simply eliminating them from the process.

A great development process by Kirk Peperdine.

Agile motivation

Nice summary here:

• Upfront planning requires upfront knowledge
• Business does not need perfection, it wants action

Mapping the Unified Process to CMMI

The (Rational) Unified Process (RUP or UP) is an iterative software development process. It was originally developed by the creators of UML at Rational Rose (now IBM).

CMMI (Capability Maturity Model and Integration) is a model that identifies the characteristics for a good software process within an organisation and defines metrics to be used to measure and improve the maturity of this process. CMMI is developed and governed by the SEI at Carnegie Mellon University. CMMI identifies 5 maturity levels:

1. Initial
2. Managed (reactive process)
3. Defined (proactive process)
4. Quantitatively managed (measured & controlled)
5. Optimizing

The table below how well the Unified Process implements the CMMI constellation for Development (CMMI-DEV). The table below groups the CMMI-DEV process areas by category. The higher the maturity level associated with a process area, the darker blue the background color is. For each process area we show how well UP covers this project area, using a crude High-Medium-Low classification. The table is based on data from SEI and from IBM.

CMMI Category	Process Area		Maturity level	UP support	UP remarks
Project Management	PP	Project Planning	2	High	only software aspects no data management
	PMC	Project Monitoring and Control	2	High	no data management
	SAM	Supplier Agreement Management	2	Low
	IPM	Integrated Project Management	3	Medium	weak integration of plans and managing dependencies between them
	RSKM	Risk Management	3	High	should add risk parameters
	QPM	Qunatitiative Project Management	4	Low	no process decomposition no statistical analysis
Engineering	REQM	Requirements Management	2	High
	RD	Requirements Development	3	High	should add allocating component requirements
	TS	Technical Solution	3	High	no alternative solutions no reuse/build/buy analysis
	PI	Product Integration	3	High
	VER	Verification	3	High	should add recording mechanism for reviews
	VAL	Validation	3	High
Support	CM	Configuration Management	2	High
	PPQA	Process and Product Quality Assurance	2	High
	MA	Measurement and Analysis	2	High	should add quantitative metrics and analysis
	DAR	Decision Analysis and Resolution	3	Low
	CAR	Causal Analysis and Resolution	5	Low	support for actions on defects and evaluation
Process Management	OPF	Organizational Process Focus	3	Low	basic support
	OPD	Organisational Process Defintion	3	Medium	basic support
	OT	Organizational Training	3	Low
	OPP	Oprganisational Process Performance	4	Low
	OPM	Organizational Performance Management	5	Low

Project cycle coverage by methodology

Microsoft joins OMG

Continuing their re-commitment to UML, Microsoft has now joined the UML governing body, the OMG.
And it's not only words, they are actual doing things.
Microsoft will include 9 UML 2.1 diagrams in the next version of Visual Studio Team System 10, code named "Rosario".
Why?

• they have not been able to kill UML
• the MDA approach of UML tries to generate programs from models. It is not just drawing anymore, but graphically building real programs. Microsoft has always wanted to have mouse clicking developers rather than the typing type ,so that's a nice fit
• MDA uses a PIM (Platform Independent Model) and a PSM (Platform Specific Model). If you use UML as a neutral language (for the PIM) you can fit in DSL as a PSM. So Microsoft can go for UML without dropping its DSL approach.

Microsoft recommits to UML

Bill Gates reverses the decision to drop UML support in favour of a proprietary Domain Specific Language. UML support will be included in Visual Studio 10.
Microsoft was one of the original companies pushing UML 1.0.
They turned away from UML, when Rational, the creator of UML, was swallowed by IBM.

This is great news for a common modelling language independent of your choice of programming language.

News page...