[Arch] UML Tools for Mac OS X

Following up a question I received via Twitter, and the fact, that a significant part of the developer-community is using Macs, I thought this might be a good opportunity to discuss some "UML Options" for the Mac. Now, this article is not meant as a definitive answer, I would hope for some follow-ups by readers in the comments.

Ok lets start: First there is heavy weight stuff, most notable Visual Paradigm. A warning: this is a fat tool. However, among the fat tools it is the one I liked the most. I am not using it any more, but it is generally rather easy to use and very feature rich. However, it is a pretty expensive commercial tool. Yes, they have a "community edition", because it is cool to have a community edition these days. But this one was (when I used it last year) rather a joke. See it as a test-preview.

There are also other commercial tools as well, e.g. Omondo. I have not much idea about this one though. Anyone?

On the other end of the spectrum are tools like UMLet (or Violet), which are also Java-based and work more or less good also on the Mac. These tools are very basic and one should not expect much. They are definitly not suited for "real" projects or commercial application, but can be a nice option e.g. for educational purposes. Sometimes one just needs to create some simple UML diagrams for a presentation, paper or book. For such purposes these tools might be useful. Plus both are Open Source tools.

The probably best free (but not Open Source) UML tool, and the one I would recommend is BOUML and this is sure worth a try. The main issue I have with nearly all free/OS UML tools is, that they are often driven by a single person or just very few developers. Hence the future of the particular tool is always a little unclear. To make things worse, there is no accepted open file-format for UML diagrams, that would allow easy exchangeability of the tool. Hence selecting a UML tool is always sort of a lock-in situation.

Also a consideration could be ArgoUML, which is also an Open Source tool and maybe the oldest one around. Has some issues as all OS tools, but apparently has a functioning community.

Finally there are some more or less general purpose drawing programs, that can be used for technical diagrams like EER or UML models as well (with some limitations) like OmniGraffle or Concept Draw and finally also OpenOffice Draw can be used for general purpose vector-oriented diagrams.

Would be happy about comments, experiences and further suggestions!

[Pub] Mule IDE

I published an article about the new Mule IDE in the current issue of the Eclipse Magazin. In the article I give an overview about Mule and how the IDE supports developers to model their Mule applications. The IDE provides the following features:

• Mule project wizard
• Mule runtime configuration (you can define different Mule runtimes)
  
• Graphical Mule Configuration Editor
  
• Start your Mule Server from your IDE

More information about the Mule IDE you can find on the Mule IDE homepage.

[Misc] Design or Platform skills?

Martin Fowler writes in his last blog article:

"Imagine a hiring situation. There's two candidates both with a few years of experience. In the blue corner we have someone with good broad design skills in the style of design that you favor [...]. However she knows nothing of the particular platform technology that you're using. In the red corner we have someone who has little knowledge (or interest) in those issues, but knows your platform really well - edge cases in the language, what libraries are available, fingers move naturally over the tools. Assume all else about them is equal (which it never is except for thought experiments like this) and that your team doesn't have any gaping holes that this candidate might fill. Which one would you prefer?"

In the following discussion he analyses why he would prefer the person with the design skills, but read it for yourself!

I mean, he is discussing the topic quite balanced, still I have the feeling that he underestimates the importance of platform skills. My impression is, that in the last (10) years platform knowledge became significantly more important (as the "big" platforms, e.g. Java, .net grow in terms of tools and features). Actually, writing a non-trivial application in, say Java, demands a very good knowledge about available libraries, the "best-practice" tool chain (build automation, testing), component frameworks, server frameworks, configuration management, testing frameworks, JVM issues, and so on. There are so many odds and ends you better know for not wasting unnecessary time or going into a unproductive direction.

Plus, I would wonder how a person that has really deep knowledge about the specific platform and tools (as I mentioned it above) could be unskilled in design issues anyway. Just be dealing on an intimate level with modern frameworks like Spring, Guice, Eclipse RCP, Maven, GWT and other open source projects you get an idea about how to design applications properly!

Plus I find it easier to get a new team member on speed that is very good at the platform details but has some lack of knowledge in patterns and design then vice versa. Why? Because in the starting phase this person would rather implement "details" that are designed by more experienced staff or work close with experienced staff. However, I know that this new person does not make platform-rookie mistakes in the implementation process that turn out to be "time-bombs" in the later phase of the project. Getting a broader "design-oriented" view is only a matter of time for a bright person.

Am I naive here?

[Pub] Modeling Complex Systems with UML (ICEIS)

The development of complex systems calls for appropriate tools; however, at an the beginning of a project powerful tools that enforce too much formalism early on may hinder designers more than they provide support. For sketching UML draft models the Open Source tool UMLet has become quite popular and warrants an evaluation of the tool’s usability compared to industry standard tools.

Ludwig Meyer presented the paper "Explorative UML Modeling: Comparing the Usability of UML Tools" at the 2007 ICEIS in Funchal/Madeira.

The paper argues that there are three main ways UML tools are used in large scale software engineering:

1. to exploratively sketch key system components during initial project stages
2. to manage large software systems by keeping design and implementation synchronized
3. to extensively document a system after implementation

Professional tools cover (3) to some extent, and attempt to cover (2), but the vast number of programming languages, frameworks and deployment procedures makes those tasks all but impossible. By aiming at these two goals, tools must enforce formal UML language constructs more rigorously and thus become more complicated. The can become unsuitable for (1).

The paper discusses explorative UML modeling and compares the industry standard Rational Rose and the open-source UML sketching tool UMLet (available at http://www.umlet.com). It defines usability measures and assesses both tools' performance using 16 representative use cases that are typical to the creation and modification of UML diagrams.

Dindin Wahyudin (Edited by Alexander Schatten)

[Arch] Domain Driven Design - Presentation

In this presentation Eric (specialist in domain driven design and autor of the book domain driven design ) steps through a Cargo sample, where he give an example how to identify objects and put them in a relation. When dealing with domain driven design you will realize that complexity is in the domain and this complexity will be also found in the model.

Eric point to a very important thing in domain driven design: The language and naming of objects. The complexity of implementation can be reduced through good domain design. This fact is represented in his sample by using Leg-Based and Stop-Based models. Depending on the used model there is a major impact on the implementation details. While designing the domain model it is necessary to validate the model by playing different scenarios (use cases) with the model. The language of the model depends on the context in which the model is used.

The presentation gives a really good introduction in Domain Driven Design (DDD).

[Pub] ICEBE Conference: Agile Business Process Management with S&R

Currently the International Conference on E-Business Engineering (ICEBE) is taking place in Hong Kong. I am presenting a paper dealing with agile business process management, a joint work with Josef Schiefer.

The core consideration is, that business strategies that were successful in the 80s and 90s are not necessarily successful in todays fast changing and connected economy. We seem to be moving from traditional over dynamic/virtual enterprises to a general structure of agile enterprises. Haeckl an all suggest a move from "Make-and-sell" towards a "Sense-and-Respond" strategy.

Speaking of agility: what does agility mean: it is generally spoken the capacity of a system to react to unforseen changes in the systems environemnt. We all know, that the software industry faced and still faces issues, as meanwhile requirements often change even during the engineering process, so that it is often not clearly known in the beginning which product is needed in the end. The consequence is clear: software developers have to "embrace change", meaning that they have to develop their software in a way, that change requests during the process can be handled.

Business process management will, this is our theory, follow the same route in the next years. Top-down plannes processes will not support changes in the business infrastructure and will be a legacy. Future business IT will have to cope with ever changing processes. Adaptiveness will take precedence over short-time efficiency considerations and plan-driven operations. In other words, the faster competitor will win, not the one who is (in thery) more efficient.

This apparently also poses significant challenges on software engineers who have to deal with such infrastructures in the future.

In our paper we go into more depth and introduce the architecture and implementation of sense-and-respond systems that allow agile reaction on real-world events. To sum it up:

• We need real-time business information with minimal latency
• Automatic discovery of situations and exceptions and generation of appropriate reactions
• Generating more accurate forecasts in near-realtime using "live" and historic data
• Integration of internal and external data sources
• Not only "backend infrastructure": Focus on tool support for various target groups and problem domains
  

For more information, check out our paper and also download the presentation to get the figures.

[Pub] Concepts and Models for Typing Events for Event-Based Systems

We are happy to inform you about our new paper Concepts and Models for Typing Events for Event-Based Systems that will be presented at the DEBS’07.

Event models have a major impact on the flexibility and usability. Therefore, we introduced concepts and approaches for representing, structuring and typing event data and introduced event models of existing event-based solutions in our paper. The paper discusses concepts of organizing event models, introduces basic typing concepts for structuring event data and also introduces more advanced typing concepts such as inheritance, exheritance and dynamic type inferencing. The typing concepts are illustrated with the event-based system SARI and compared with existing event stream processing systems.

The paper can be downloaded at:
http://www.senactive.com/cis/digitalAssets/5502_DEBS_Paper_EventModel_Camera_Ready.pdf

[Tech] Software Reusability

A Myth or Reality?

Several days ago a topic with the title "Software Reusability: Myth Or Reality?" was posted on Artima. Following the comments on this post since the first publishing I think you should take a look there too. Developing SW for 6 Years now (by far not that long as the poster) I have to agree with him. The problem with reusability is that there are several issues that must be fulfilled that libraries objects .... can be reused.

1) Clean self speaking code

This is one of the biggest challenges in SW projects. You need seasoned developers with a passion for SW development and time to write code in that way. Today commercial projects first off all don't have time to do this. Time is a big factor in this game. On the other hand teams in companies have developers with different levels of expert knowledge and it's very difficult to teach "junior" developers until normal working time.

2) Documentation

From my point of view, documentation is important but not as important as the first point I mentioned. We have to differ between 3 kinds of documentation:

a) Tests: they are the best documentation of a program because their actual status (which is documentation) can be verified easily by executing them.

b) Code Documentation: all the xDoc stuff developers write over methods classes and even in code to explain the behavior of the code they have written. The problem with it is that they are getting useless as far as they are not updated with code changes (which is often the case). In difference to Tests they can be just verified if someone reads them and expects something that is not fulfilled.

c) Diagrams: all the UML Stuff which in my opinion is even more difficult to hold up to date.

Answers?

I would answer the question raised in the article as follows:

1) Is reusability something that can be trained for?

I don't think that schools/universities can train developers to program with reusability in mind. Only persons that had to use libraries or old implementation in a project now how it feels not being able to use 1000LOC that where written for a similar domain and can't be reused for the new project. This feeling makes most of them think about possibilities to write code in a other way.

2) Should reusability be a requirement?

It depends on the project. There are projects where it definitely should be a requirement. The interesting question here is how we will measure it? I would say there is no metric that can describe how reusable code is - except for the first two points tests and code documentation I mentioned above. In my opinion it is not enough to say we have 89,9% test coverage and 70% in code documentation. These two values just say nothing about code reusability.