Finally …

20Jan07

A while ago I stumbled across an exciting tool – exciting, at least in terms of software architecture and software quality. Instead of using boxes and arrows, the Dependency Structure Matrix displays the architecture of an application in the form of a matrix – a much more condensed and accessible method of visualising module coupling.

At the time Lattix had a nice version for Java but not one for .NET – so I thought I wouldn’t mind having a go at it. Finally you can get to try it out by downloading it from my site tcdev.free.fr.

Please let me know what you think

Advertisements


7 Responses to “Finally …”

  1. Hello,

    I just tried your tool on our codebase and I must say the results look very nice (and useful !). It was quite interesting to look at dependencies I did not even suspect existed in our code (the matrix is all over the place, nowhere near triangular !).

    If I may offer a few suggestions :
    – the grouping by namespaces is a good first approximation, but I would still like to be able to sort individual classes across namespaces; for example let’s say we have :
    RootNS.MidLevelNS.MidLevelClass1
    RootNS.MidLevelNS.MidLevelClass2
    RootNS.HighLevelClass
    RootNS.LowLevelClass
    I would like to be able to sort the “MidLevelNS” between “HighLevelClass” and “LowLevelClass”. Unfortunately we have a lot of classes that are not namespaced – a tool such as yours could actually help us identify the logical groupings that we could later manifest through namespaces ! (indeed, the tool could let us define such ‘virtual’ namespaces…)
    – having to look the numbers up all the time is a bit painful. Tooltips would help a lot here.
    – I would like to be able to click (or hover) on a matrix cell and obtain a list of dependencies. This would be very convenient when e.g. a 200-class namespace has an unexpected dependency on another 200-class namespace.
    – cosmetic : freezing the headers when scrolling would be nice

    Finally, what are your plans for the add-in ? I wouldn’t mind helping a bit if the source were to become available.

    Cheers,
    –Jonathan

  2. Thanks for your feedback Jonathon.

    I think what your after with regards to namespaces is known (in DSM terms) as Partitioning and Clustering : closely related modules are identified and proposals made for the merging of certain groups. It’s something I hope to implement in a later version but its likely to be a while yet. Tooltips like you described however should be coming soon.

    As for future plans, the main aim is have a version which plugs in to Visual Studio and SharpDevelop so that you can generate a DSM from your current solution and verifiy as your code develops, that it stays within the defined architecture.

    In the future I’m sure I’ll make the source code available but for the moment there’s a few features I’d like to implement. Stay tuned as they say !

    Tom

  3. Hello again,
    Reflector 5.0 (just released) refuses to load your add-in. Do you plan to make an update ?
    Thanks,
    –Jonathan

  4. Hi Jonathan

    A version compatible with v5 is available from http://tcdev.free.fr

  5. 5 ksbys

    Good site!!!

  6. 6 Markus

    Thank you very much for providing this great tool for free!

    Here is my suggestion for a new feature that would be most valuable for me: Even if you analyze an assembly that is perfectly well designed with nearly no cyclic dependencies etc., the default sorting of the types makes it look like a mess with dependencies spread all over the matrix. If you have more than just a few types, it can take some time to rearrange the types manually to make the matrix look nice.

    So it would be absolutely great to have some built-in sorting that moves all the base types down and high-level classes up. (Please contact me if you need some inspiration on how to do it, I have a very simple idea for an implementation.)

    Oh yeah, and it would be great to have keyboard shortcuts for “move up” and “move down” 😉

    Thank you very much again!

  7. 7 tcdev

    Hi Markus,

    Have you tried the partitioning functionality implemented in the latest version? It’s a bit primitive but it tries to sort the types according to a *lower block triangular* algorithm. It’s purely math based i.e. doesn’t interpret the type in any way. I wanted to stay clear of that because people tend to interpret the type in different ways. But I agree you could say that *base types* could automatically be moved towards the bottom. I’ll have a think about implementing that in a future version as well as the shortcuts that you mention (which have been on my todo list for ages now!).

    Thanks


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s


%d bloggers like this: