Has anyone here ever taken a look at Lattix LDM? I've been doing
some experimenting with Together this month and uml of course, and when I
heard about this I just had to take a look. I was quite surprised to see
how much easier it was to grasp than uml, unfortunately they don't have a
plugin for Pascal or Delphi so I haven't been able to do more than try the
examples.
My history includes quite a bit of design background...both work and
schooling...and as anyone who frequents the Delphi lists knows, I am very
opinionated when it comes to design methodologies and their use in
programming. This is the first one I've come across that holds the promise
of providing the kind and level of structure that can actually help the
programmer without bias or adding its own set of rules! In design systems
and methods, the holy grail is to find a systematic approach to working that
provides direction, structure, repeatability, a testing or validation
infrastructure, and a fully extensible working palette without in anyway
impinging upon the inherent freedom that the creative implementation of
design, ( of any type and for any need ), implies!
Lattix as it stands, is certainly not the all inclusive answer,
however this incarnation does make some suggestions that are very difficult
to ignore. I'm not surprised by this at all, only that I hadn't seen or
considered dependency modeling like this in the past! The biggest single
advantage one can see first when comparing LDM to many other current
modeling methods is that, and as Lattix makes a strong case for, it is truly
and absolutely scalable! Not just in a coding sense, or one of practical
concern, but in the very structure of the matrix that is used to display the
relationships. Unlike UML or other methods, where you always and quickly
reach a point of visual non-clarity no matter the direction you are moving
in and the apparent understanding of the modeled relationships become
subjectively indistinct from the model itself, making it necessary to
constantly be re-interpreting both the visual structure before your eyes and
the data and its relationship both to it and itself! On the other hand, the
matrix method of looking at a solution or sets of solutions, never obscures
the interpretation of the data being modeled. Nor does it ever prevent or
make difficult the expansion or macro-inspection of the data to any level of
complexity and/or dependency required at the moment! My vision of its
abilities provides for one being able to zoom smoothly in and out from the
minor details of a class property right to an overall map of not only the
system but its relationship to any other systems as well...and then back
again! A member of the Lattix software group who called me out if the blue
yesterday and with whom I spent more than two enjoyable hours talking to
about these subjects confirmed that this is indeed possible, and that using
their SDK, its use could be even further extended!
I like the overall dependency model so much more than others that I
was going to try and build an interface that mocks this kind of
system...based on open work at MIT. I wouldn't be able to build any parsing
into it right away that can take a design from project code and factor it
down into the dependency model used by the algorithms supplied by MIT which
Lattix uses to apply meaningful project data to their Matrix interface, but
just having the interface to work with as a manual design tool would offer a
way to enter unit/file/namespace/class data so that one could more easily
see the relationships without all the clutter of typical UML diagrams! In
addition, and unlike Lattix, which uses an Object Inspector like interface
to manually add/edit data, I would prefer to use in-place editing, like in a
tree view control.
But once it was explained to me how the entire model structure as
well as the project schema which is provided dynamically by parsing a Delphi
project into an xml file using tokens and the Delphi project's dependencies,
and that the Java code for the actual plugin that does so can essentially be
used as is once these tokens are added/replaced, I thought instead it might
just be better to take a good look at the SDK and see what I can do with it!
Lattix already has plugins for Eclipse and C++, but their roadmap
doesn't include one for Delphi at this time. They did express great
interest in the idea however as they wish to broaden the scope of it's
working IDE's. And they have made it clear that they will be willing to
offer as much technical help as needed to help someone create such a plugin
for any and all IDE's they don't yet represent.
Of course I don't feel competent enough with parsing and especially
JAVA to take such a project on myself. I would feel more comfortable in
designing a pure Delphi interface client thru which this implementation
could work. But should anyone be interested in discussing this further,
either as theory or as a possible collaborative and open project, please
contact me directly via e-mail. No promises or even a working outline at
this point...just talk to see if indeed it would be a worthwhile and viable
project!
from Robert Meek dba Tangentals Design CCopyright 2006
"When I examine myself and my methods of thought, I come to the conclusion
that the gift of Fantasy has meant more to me then my talent for absorbing
positive knowledge!"
Albert Einstein
__________________________________________________
Delphi-Talk mailing list -> [email protected]
http://www.elists.org/mailman/listinfo/delphi-talk
