I’ve just arrived home from the Software Development
Best Practices conference in Boston. This is the first year I’ve been to
the east-coast show. I was looking forward to it, and wasn’t disappointed.
The venue was great. Boston’s Prudential
Center is a big conglomeration of an upscale shopping mall, restaurants,
convention center, hotels, and office buildings. It’s quite an interesting place
to wander in. We don’t have much shopping where I live in northern Michigan,
so I took advantage of a few breaks in the action to buy a new watch for my
daughter, gifts for my son, and otherwise bring joy (er, money) to the mall
merchants. It was nice too, to find the Embedded
Systems Conference just down the hall in the Hynes Convention Center.
Lately I’ve developed an interest in Model Driven Architecture (MDA) and the
whole idea of going from model to code, so I tried to attend as many MDA and
executable UML sessions as possible during my two days at the show. Marc Balcer
of ModelCompilers.com gave a good presentation
on Making UML Executable to a packed room on Wednesday morning. Paul
Dorsey followed up with Business Rule-Based System Development using the
UML. I’m told Paul’s presentation was quite good, and I imagine it was,
because by the time I got there the room was full and his audience was overflowing
into the hallway. I didn’t have a prayer of getting in to hear Paul’s talk.
Thursday, however, I managed to get in to hear Paul Francis, from MDA tool vendor
Kennedy Carter, talk on The OMG Model Driver
Architecture and Executable UML.
I’ve always had a tough time coming to grips with executable UML, because for
all the presentations I’ve seen, and articles I’ve read, I’d never, before this
conference, actually seen anyone sit down, create a model, compile it, and run
the resulting executable. So Wednesday I went looking for someone to show me
the goods. One of the presenters took me as far as generating XMI (XML Metadata
Interchange) from a model, but that wasn’t very satisfying. I wanted to see
some executable UML actually execute! Finally, I went next door to the Embedded
Systems conference, and made the rounds of the MDA vendors on the show floor.
Surprisingly, there were quite a few–apparently model-driven development is
used more in the embedded systems realm–and on my third try I managed to find
someone to show me "Hello World" done using UML. He did it by creating
one object, and then creating a state diagram for the object that triggered
execution of a C++ statement every second. The C++ statement he supplied wrote
"Hello World" to cout. I should have paid closer attention, but I’m
fairly certain I was at the I-Logix
booth, and that the tool being used was Rhapsody.
In model-driven development, the idea is to generate as much code as possible
from the UML model. For example, the bulk of the code for the class in the "Hello
World" program was generated by virtue of the fact that we added the visual
representation of a class to a class diagram. Likewise, the logic to control
the loop that displayed "Hello World" every second came largely from
the state diagram and the timeout event used to transition from one state to
the next. The only code we had to write in the traditional manner was the invocation
of cout as the action we wanted in response the timeout event. This brings up
an interesting issue, that of what language to use to describe an action.
If you’re going to have executable UML, you need some way to describe actions
that you want the developed system to perform. You also need building blocks,
small actions that you can combine to perform useful work. To this end, the
Object Management Group (OMG) has defined
a set of action semantics for UML. Don’t confuse action semantics with actual
syntax. The OMG has gone only so far as to define the functionality that a language
should enable, but so far the task of defining and implementing syntax has been
left up to the various tool vendors. There’s actually some controversy in that
some vendors buy into a UML-specific language that is translated to a deployment
language such as C++ or Java when a model is compiled. Other vendors, including
the one giving me the demo, take the approach of using the deployment language
(C++, Java, etc.) in the model. In the long-run, I think the idea of a UML-specific
action language will win out, that multiple vendors will implement different
syntax, resulting in different languages, but all in support of the defined
action semantics, and that tools will translate as needed from one vendor’s
language to another.
In the "I couldn’t resist a good deal" department, would you believe
I bought myself a Z80? Remember the Z80? It’s an 8-bit chip that many years
ago was used in some personal computers. Now, the Z80 is apparently widely used
in embedded systems. That vending machine you buy a Coke from, for example,
might be driven by a Z80. At the Embedded Systems conference, Zilog
had a great deal on eZ80Acclaim!
development kits for only $99, which is half the normal price. I’ve no idea
yet what I’m going to do with this thing, but it just looked too interesting
to pass by.
Wednesday, I attended several sessions by Ken
Pugh, who presented twice in one day, and then led a birds-of-a-feather
(BOF) session in the evening–wow! Ken is a really good presenter. He’ll keep
you awake and interested. In his session on Human Centric Development
Ken talked a bit about personality types, and brought up the issue of introverted
programmers versus pair-programming. Ken’s the first person I’ve seen to hit
that issue head-on, and he had a couple good suggestions, I thought, for approximating
pair-programming without actually programming in pairs. Ken is dead-on in addressing
the issue. Speaking for myself, I could never write code, nor could I write
books or magazine articles, with someone looking over my shoulder. Pair programming.
Wednesday evening, Ken facilitated a session on problems with geographically
distributed teams. I work remotely as an O’Reilly editor, so I attended Ken’s
BOF session. Many issues were raised: poor-quality video conferencing, speaker
phones that don’t work well, cultural issues, language issues–one lady was
on team in which not all members share a common language–the importance of
meeting people in person at least once in awhile, feeling disconnected from
the water-cooler conversations at the office, problems coordinating geographically-separated
developers working on the same code, and more. I don’t recall that we solved
any problems, but it was quite a lively discussion.
And that’s it!
And that’s pretty much all I have to say about the Software Development Best
Practices conference. If you happen to do any work with eZ80Acclaim!, shoot
me an email. I’d love to learn more about embedded systems and how they
are developed. I also wouldn’t mind hearing from people successfully doing model-driven
development using UML.