Archive for September, 2007

Notes on Enterprise Architect

Friday, September 21st, 2007

What I don’t like:

  • I want to create a constructor, but more often than not I forget to remove the void return. Hence it creates a method called ClassName with a return type void on code generation. Surely it should be smart enough to realise that this is a constructor-like signature?
  •  I want to be able to delete elements from my design easily. Why can’t I? No, really..WHY?
    • Selecting multiple classes from a class diagram and hitting delete only removes them from the image, not EA as a whole. Ok, I don’t mind that so much… it’s a half decent failsafe. But WHY OH WHY isn’t there the ability to click on an item in the project view tree and press delete on my keyboard? What is this CRTL-D bollocks?
    • Better still, why on earth can’t I delete multiple items at once? This is ridiculous.
  • Seems I can’t attach relationships to each other easily and then move them all about at once. This drives me insane.
  • Clicking on the same spot of a class seems to bring a different prompt/dialog/result each time… gah.
  • Overall, it’s just the worst HMI/HCI I’ve ever used in a mainstream application.

In short, it’s about as powerful as it is not usable. There’s got to be better options? Perhaps I’ll stick with Umbrello or ArgoUML in future? But of course, they’re not as feature-rich. Further investigation required.

What I should have already known about OO…

Monday, September 3rd, 2007

I recently had the opportunity to partake in a course on Object Orientated Analysis and Design. Over the course of 5 days, I managed to get a clearer understanding of OOD than I had in 4 years of University. The key? The obliteration of buzzwords, and the abstracting away from the technical implementations of OO. With what seems in hindsight a logical choice, our presenter seperated OO into two parts: Abstract OO and Concrete OO. The Concrete part of course deals with the language-specific features of OOP; Encapsulation, Dynamic Binding, Inheritance, and so on. Abstract OO on the other hand deals with the three foundations of the concept, as opposed to the implementation of it. These are Classification, Specialisation, and Polymorphism.

Now when I went to university, OO was taught hand-in-hand with a language. I’m starting to think that this should not be the case. The risk here is that the student, as I did, forms definitions for terms like Polymorphism in a Java/C++/C#/etc-only context. In reality, no language is the same and there are subtle differences in the way that each implements OO concepts. By splitting OOP into concrete and abstract concepts, the idea of Object Orientation itself is also much easier to grasp. I can now explain, without using buzzwords or just repeating the question, what terms like Specialisation actually mean. The same could not be said of me while I was at University- and the worrying thing there is the fact that I still scored quite highly.

What that means for the students who didn’t score quite as high as me is worrying- especially those who didn’t bother to learn things like UML- have they just spent <insert ridiculous amount of money here> on a 3 or 4 year degree without actually learning anything?