James Gosling talks with Bill Venners about visualizing software designs and understanding large-scale distributed systems.

Read this Artima.com interview with the creator of Java:

http://www.artima.com/intv/visualize.html

What do you think of James Gosling's comments?

Hi Bill and James,

Have you checked out the transaction analysis and visualizations in JInspired's JDBInsight 2.0 product.

The product provides many different views and perspectives of a J2EE component execution path.

Why not download the product and view the included Weblogic SPECjAppserver snapshot? I hope you appreciate the attention to graphic design and usage of Swing.

DOWNLOADS:
http://www.jinspired.com/products/jdbinsight/downloads/index.html

FLASH DEMO (A BIT OLD):
http://www.jinspired.com/products/jdbinsight/flash.html

All the best,

William Louth
CTO & Product Architect
JInspired

"Test and Tune with Insight"
www.jinspired.com

visualizing software designs and understanding large-scale distributed systems

It seems that Gosling is referring to small (method-level) to medium (object or package-level) scale visualization. I love the idea of automatically generating a state-transition diagram from source code. This make me think of Bill V's book-in-progress (http://www.artima.com/objectdesign/object5.html).

I'm not so sure about putting in diagram information (e.g. x, y locations) into java sources, however. Sounds kind of yucky.

I wonder if the things he's working on will work with larger scale intra-package kinds of things. The Pasta tool (http://javacentral.compuware.com/pasta/) is the only one I've seen. There are probably others, but I'm not one that often gets a look at expensive tools.

Gosling has some interesting insights regarding the dependencies in large loosely coupled systems. He basically mentions keeping track of coverage (maintaining a log of who has ever talked to you). This is important where the recipient (server) of requests wants to be kind to the senders (clients).

But on the web, the maintainers of servers rarely take time to look up who links to them before moving or deleting content. This is what makes it a difficult problem -- when people would be required to do a lot of tedious work, it will either get done poorly or not at all.

"Hi, I'm a service. This is what I take. Talk to me."

I've been working with this sort of philosophy for the last few years and have ended up with a Java3D based toolset visualizing j2ee platform deployments in terms of their component-based architecture.

The user interacts with a 3d metaphorical representation of the various j2ee components defined by the JSR77 Management Information Model being introduced in J2EE 1.4.

My aim was to develop a visualisation technology that appeals to the broadest possible user community rather than focusing on the needs of the developer community.

I'm particularly interested in the idea of a visualisation technology that provides the user community with a shared understanding of the product (in terms of its visual complexity) and is capable of adapting its behaviour to the type of user interacting with it.

Pictures and demo applets at:

http://www.btinternet.com/~jpitten/

Hope you find it of interest.

Jeremy

Software visualization is something that is available in lots of ways. At AT&T Bell Labs, they had a software visualization system that was intended to allow code complexity and breakage. It showed you where in the code the most bug fixes had been done, the relative age of the lines of code, and you could take a particular modification request (an SCCS MR of sorts) and ask what code did it touch.

This same system was used to visuallize the 5ESS ODB as well. It told you about references between tables, drew graphs of dependencies, and could diagram key dependencies. It was truely fastenating.

The great thing about this tool set was the extreme simplicity of the meta data. Each attribute that was to be considered had a directory tree. Under that tree was a directory tree that mirrored the original source tree. In that tree were files by the same name as the source. Those files just had markers on the same line numbers as the source file,where that attribute applied.

So, you could go from relationship to source line instantally and provide some very powerful zoom and and drilldown visuallizations.

There are still apparently a lot of people that don't understand what Jini is about. It bothers me that James didn't use the 'Jini' word in the following comment.

>So philosophically, I really don't know. Dealing with
>dynamic systems with pieces that come and go is a really >hard problem. There are all kinds of specialized solutions
>for specialized situations, but I've never seen anything
>like a set of general solutions. In some sense, this
>particular problem feels like one where unreliability may
>be a good thing, just because it makes the whole
>enterprise possible. Maybe people should just get over it.

The Jini infrastructure goes a long way towards solving this exact problem. It provides the UUid value that provides a 'forever' reference to the object. The use of multicast lookup means that a service can appear on any host, and the use of unicast lookup means that you can extend your services into other networks and allow distant clients to locate these disparetly located services.

More importantly is the fact that the contract between client and server is typically at the Java interface level. Thus, the client can just look for something implementing that interface if it needs a generalized service. If it needs a singleton, it can use the Uuid as a starting point. If it needs Authentication and Authorization, the Jini2.0 infrastructure has direct support for X.500 and Kerberos certificates. It also has pluggable Authentication capabilities. I've used this to provide access to linux servers using login information, via PAM, on the server. So, I can put accounts on that server, add policy for the service, and presto, a user providing those credentials (as PAM dictates), gets to use the system how the policy describes.

I've got a list of open source java projects that you could use to build some pretty slick visualizations:

http://www.manageability.org/blog/stuff/open-source-graph-network-visualization-in-java/view