Slashdot Mirror

Very well pointed out. Professional website themes are inexpensive these day to the point that anyone using hand-scrawls like http://www.graphviz.org/ are just asking for disdain.

A bit of Google-fu reveals that osage, the name of the submitter, is also the name a layout/rendering tool associated with GraphViz. It's likely old enough to fit the "over 20 years" comment and was the de facto standard until a bunch of javascript graph visualization libraries popped up and made it easier to create prettier, interactive graphs. The latter explains why younger developers might shy away from it: it's written in C instead of javascript. And it was started by AT&T Labs Research to fulfill the corporate aegis bit. And there is a banner on the Graphviz homepage trying to attract developers.

So unless this is all coincidence, we may have a winner, which would be sad since I use it on occasion.

A prominent one would be graphviz, of course. But most other software that describes itself as dealing with "mind maps" can only handle a basic tree structure, you're right. Another exception would be Tinderbox, but that's closed source.

I've seen dozens of methods at different companies, but I've only ever seen one that works and it works really well. Many of the top ISP's use a variant of it.

Let the network self document.

What does that mean? Well, typically it means some discipline in how descriptions are written. For instance ISP's will use a standard customer identifier on all ports. An enterprise might just use hostname. From there, tools like Rancid can poll router and switch configs, store them in a version control system, and mail out changes to the entire staff. Rancid is great to use, because it reduces the human work load down to entering a single line for each device (name and OS type), and making sure that the device accepts logins.

Now that all the configs are archived and you have the one true list of devices it's trivial to take that list of devices and feed it to other tools. One of the first might be NetDisco which probes the devices with SNMP and builds adjacency tables, tracks MAC addresses, and so on. From it's database you should be able to locate anything on the network in seconds.

Now that there is a complete picture of the network, it's time for a little scripting. Take the output of Rancid and/or Netdisco, and use it to for instance build an MRTG configuration file, or a list of things for Nagios to probe. It's fairly easy to take the NetDisco adjacencies and run them into a tool like GraphViz to produce a network diagram.

I know of at least two ISP's using this basic formula, and it works really well. Going to an internal web site they can bring up diagrams, usage graphs, MAC tables, IP information and all sorts of other things about any device in the network in seconds. Once devices are in the system it is 100% automated, turn on a new port and it is magically graphed, MAC tracked, and added to the diagrams. Turn it off, it magically goes away. Everything is in version control so old state can be reconstructed. The only human manual intervention is adding/removing one line to the Rancid config when a device is turned up or turned down. I have even seen folks automate that with Netdisco (but, I think that can be problematic, as it's almost circular).

Spreadsheets, Visio diagrams, and the like are always out of date. Someone will always make a change and forget to update it. Some places are only a little out of date, most places are downright wrong. Self documenting is achievable, and always 100% current.

I wonder where we can take a look at this app. Anybody know?

You can find yEd at http://www.yworks.com./ You can find Graphviz at http://www.graphviz.org./

Enterprise Architect is very nice, since you can do forward and reverse software engineering with it.

However, if you do not have the budget allocated for it, a good compromise is StarUML,
which became very nice and usable lately and has the same "feeling" and menu-driven approach
like the old Rational Rose and Enterprise Architect:

http://staruml.sourceforge.net/

http://sourceforge.net/projects/staruml/files/staruml/5.0/staruml-5.0-with-cm.exe/download

As for Rational Rose, the first original version was very good with some known quirks until it
became IBM Rational Rose and was converted into a "super Eclipse" plug-in.

So, if you enjoyed drawing UML diagrams in the old Rational Rose,
then Enterprise Architect and StarUML are the tools that you are looking for.

And if you do not like to draw with a mouse then Graphviz Dot and a good text editor is for you:
http://www.graphviz.org/Download.php

For tracking issues / documents and schedule,
I can recommend either BugZilla, Mantis or BaseCamp:

http://www.bugzilla.org/download/

http://www.mantisbt.org/

http://basecamphq.com/

As for the actual writing part, your company should already have a good set of Word Templates,
to document the actual Sofware Requirement and Specification (SRS), Sofware Design Document (SDD),
Change Request Document (CRD).

Once, you got those set up, then we mostly use MantisBT or BaseCamp to share, comment and track them.

As for producing code documentation, the choice are: Doxygen, JavaDoc, NDoc, JsDoc:

http://www.doxygen.org/

http://www.oracle.com/technetwork/java/javase/documentation/index-jsp-135444.html

http://ndoc.sourceforge.net/

Wow, someone needs to learn how to use GraphViz:

http://www.graphviz.org/

*avoid edge crossings and reduce edge length

As a fun (and possibly time-wasting) diversion, automate the whole breakpoint-call-stack-watching process. Instead of just setting breakpoints, figure out how to obtain stack traces programmatically. Every time the program runs past a certain part of the code, append the stack trace to a text file. Pull out your favorite scripting language and convert this text file into a format http://graphviz.org/ can understand, and you've got yourself a neat little run-time call-graph generator. Of course this is predicated on the fact that you can generate call stacks, i've never tried it in C/C++...

Obviously, it helps if your familiar with graphviz. If you're into graphs and such, it can transform a boring day (week, month...) of trawling through crappy code into a fun experience in scripting and making big fancy-looking graphs to impress your co-workers...

Yes . GraphViz and dot are magic. You still have to read the code of course, but this gives you the map to guide your reading. The pictures are usefully impressive for your new bosses to show that you are making progress too. Really useful for showing up that nuggt of code that gets called from everywhere. http://www.graphviz.org/Gallery/directed/profile.html

OK, unless I get compelling reasons to opt for other choices, I'm leaning toward the Apple hardware. Though I have destroyed one Toughbook...

I'm rather a Unix fan (vastly too old to pass myself off as a boy of any sort) myself. I have to take a minor exception to claiming that any Unixy OS is the best available. It all depends upon what you need to *do* with it. I've called at least four variants 'best'. But that was about 'best for very specific purposes'. Sometimes it's come down to whether you can do non-blocking operations against a PRNG. So that experience may not apply for anyone needing a general purpose machine, though it has for me.

I haven't run into a case where I 'need Windows for high performance work'. For what I do, I've *almost* always found Windows at the low end of the performance scale. But that's just me, and I am a definite corner case. For instance, I rarely use an office suite, whether that be MS Office, OO, etc. Maybe once a day.

KDE apps meet my communications and calendar needs, as does KDE Kile (LATEX) for writing, as most of my writing involves math. KDE Kate can suck for text editing, as it supports only CVS, and I'm sensitive about sources, but there are easy workarounds. Most things I do that involve number-crunching and databases, I've written my own code to automate much of the drudgery away, where things are repetitive. I don't have to put up with spreadsheet charting limitations, in the sense that there are things you can't do with spreadsheet charting that are easy with http://www.graphviz.org/ and other specialized tools.

It will be interesting to see how my old-fart, laptops-are-lame attitude might change with nice hardware. Though some things that seem important to some people, I won't care about at all. DVD playback comes to mind. I have living-room electronics for that. If I get on a plane, I always have a couple of dozen papers to read. I never seem to get caught up on the journals.

These graphics were obviously generated by "dot" of the http://www.graphviz.org/ suite...
I were using those softwares to draw Myspace social networks.
I was convinced it was the more stupid use of Graphviz possible.
This guy demonstrates that I was wrong...

It's not hand drawn. They obviously used dot from graphviz. You can't mistake that layout once you've seen it.

graphviz might also be a way to go, and it's unchained.

You can probably draw the picture you want with GraphViz, found here http://www.graphviz.org/

To use it, you create a text file that defines all your dependencies, it'll look something like this:

    digraph thingies {
        "app1" -> "SAN";
        "app1" -> "Java";
        "client1" -> "app1"; ...
    }

You can then go on to group things together so they show up in meaningful locations on the diagram,
associate pictures with certain nodes, put labels on things, make things in colour, etc.

GraphViz takes care of the laying out parts (where best to put nodes and edges). Sometimes it takes
a while to define everything in format that gets draw neatly, the results are often impressive and
very useful.

On coming to a new job, I've used it to draw all the dependencies between a collection of a couple
of hundred SQL stored procedures in our database. The locals were horrified to have what they all
knew in their gut depicted to them on 35 A3 sheets of paper on a wall :-) It was quite useful for
identifying things recursive calls ("Oh, *thats* why that proc sometimes never ends...").

Isn't that a bit of overkill for an entity-relationship diagram? Have you considered something like Graphviz?

As for batch processing with GIMP, I'm pretty sure it's supported. If you don't like that, you can always use ImageMagick. If you're complaining that GIMP's batch mode won't execute a script against X number of images, have you considered a tiny shell script? Something like:
FILES=`find . -type f -name "image[0-9][0-9].gif"`; for FILE in $FILES; do ...; done

It looks to me like it could be the output of Graphviz.

digraph {
NaCl [label = "table salt"];
Na -> NaCl;
Cl -> NaCl;
}

And then GraphViz turns that into a picture. Specifically, you'll be intrested in the program called "dot" that comes with the GraphViz package.

Hope this helps!

-- Dylan

i take maybe a half-hour to learn the syntax, but if you name the transition arrows you'll get great graphs. http://www.graphviz.org/

If you need to make high level node-arc diagrams of the structure of a site, take a look at GraphViz (http://www.graphviz.org/) It's very powerful, with a very simple text syntax, and saves you the trouble of manually routing the arcs. You might also want to take a look at Asymptote (http://asymptote.sourceforge.net/)

Scotty/Tkined seem to offer all that you need. Decent diagramming, real-time network monitoring and alerting, totally scriptable in Tcl. For graph drawing wizardry, take a look at GraphViz.

Graphviz and GNU GLOBAL used in combination give a graphical and web-accessible view of a large, unknown software system. This will give your team a high-level view of the modules and how they interact. This will make it easier to discern the system design.

You could probably do something with some flat text files, some scripts and Graphviz that would be at least as good as what you have coming out of Photoshop. ...that assumes you have no need to put boobies on your network diagrams.

The problem with any programming language and it's once legacy source code writing style kicks in, this is true for any language, include C, C++ or Perl.

The older the language is, the more chance that you find some unmaintainable legacy source code.

The thing with newer language with Python, Ruby,
PHP, Java and some C++ is that these are "recent" language, therefore, the odds of finding a very old legacy system is smaller.

In 10-15 years from now, you will say that Python, Ruby, PHP or Java is so "unreadable",
because they are no more the "flavor du jour"
and new constructs exists instead. Like most people says about cobol, pascal, scheme, lisp source code.

There is a difference between "unreadable" and "encrypted".
The former was not "expecting" to be unreadable, it is just badly written by mistake or use older construct that nowadays are no more used.
The later was made on purpose, which is the difference.

If you want "unreadable" C source code, take a look at Graphviz Dot, no it's not part of IOCCC and was not make to be part of it, but if you ever try to understand this legacy code, good luck!!!

Disclaimer, Graphviz dot is a nice piece of software, but it cries out loud to be heavily refactored.

In fact, the first two layers were refactored, but the core engine is dated back to the 80's with K&R style and variable/function/struct name being less than 5 characters!

http://www.graphviz.org/pub/graphviz/ARCHIVE/graph viz-2.4.tar.gz

If you want "unreadable" Perl source code,
take a look at any source code, which have:

no "use strict;"
no "use vars qw{};"
use heavily "local"
use heavily "map"
no "return" statement --> $r; == return $r;
use heavily complex non-trivial regexp without documenting them.
no documentation or POD.
use some old perl construct.

Take a look at this one,

clc (gzip'ed tarfile)
Counts total lines, noncomment lines, and statements in C/C++ source.
Written by Brad Appleton in 1995. Implemented in perl.

http://www.chris-lott.org/resources/cmetrics/clc.t ar.gz

I actually just graduated from a university CS program and I found that a laptop was useful in nearly all my classes. I used GraphViz for the finite state machines and related diagrams, and I used LyX for the ordinary notes. LyX, in particular, is really good at thinks like mathematical equations and all the Greek that seems prevalent in CS courses. Some times I'd use Dia for diagrams that aren't graphs.

I guess this thread is probably going to devolve into "is too!", "is not!", but I still have all the CS notes I value in soft-copy form and I expect to keep them backed-up for a long time.

Ian

GraphViz which lets you draw graphs (has perl module too) in different formats including SVG. I believe I once saw a subroutine call tree drawn in it from perl profiler.

Katy Börner and I have been organizing a workshop on Information Visualization Infrastructures, including graph drawing packages. The results are available at http://vw.indiana.edu/ivsi2004/

There are lots of different tradeofs involved. One being interactive vs. static graphics. Another being the size of the graphs.

For static graphs, such as class hierarchies and such, Graphviz (http://www.graphviz.org/ works fine and is easy to integrate in a system. For some graphs, Graphviz will not work at all so you need to try first.

For large or dense graphs, above 1000 nodes or more than 4 times more edges than vertices (5n etc), node-link diagrams don't work at all. You could use a matrix but people are not used at reading matrices.

For interactive visualization of graphs, Jung (http://jung.sourceforge.net/) and Prefuse (http://prefuse.sourceforge.net/) are fine if you have small graphs ()

If you are a graph wizard and want to analyze large social networks, you can take a look at Pajek (http://vlado.fmf.uni-lj.si/pub/networks/Pajek/) but it is not a free software and runs mostly on Windows.

Other packages are ok for simple things, stereotyped things or more experimental things. You need to try them on your own problem to decide.

Thanks to everyone who replied. GraphViz was exactly what I was looking for. The guide seems solid. Apparently there is a decent Java viewer too, but I haven't played with it yet.

Thanks to everyone who replied. GraphViz was exactly what I was looking for. The guide seems solid. Apparently there is a decent Java viewer too, but I haven't played with it yet.

I think both are actually done in graphviz:
http://www.graphviz.org/

Graphviz

It was created with Graphviz.

Unfortunately graph generation is pretty slow, but otherwise it's a fantastic tool.

I tried Dia some time ago and found it very frustating to use, with most of built in objects being too restrictive and lacking enough variety of connection points to terminate lines and arrows.

For line diagrams (e.g. for documenting 3D graphics algorithms), I've moved on to qcad, which is a 2D CAD package.

For OO design, you can try doing this backwards : prototype the interfaces and classes and run doxygen (with dot) to generate inheritance and collaboration diagrams or XML output for post-processing. This probably fits in more with an extreme programming prototype/refactor style methodology than a complete up-front design methodology.

For state diagrams, I've had some success using dot on its own.

Using doxygen and dot has the significant additional feature that the files you edit are all plain-text files, so you can use your existing source revision control system (e.g. CVS)

Even with these packages however, I usually still find a pen and paper (or a white-board or blackboard if available) the easiest and fastest option for sketching out an initial design, or during discussions of various design alternatives with colleagues.

You mentioned molecular figures, so I assume you already looked at software for creating molecular stick figures. Not much, is there?

Gnuplot has amazing capabilities. It's not oriented to 3D realtime animation, but you can get 3D plots...and make animated PNGs to rotate around a plot. Ignore the function abilities, look at the point and line plotting.

Did you do a search for scientific visualization? If you had, one of the things you'd have found is Geomview from the U of MN Geometry Center. Don't know how easy you'd consider it.

Graphviz makes reasonably well sorted directed graphs.

http://www.graphviz.org for dev versions.
http://www.research.att.com/sw/tools/graphviz/ for release versions.

Optimal layouts with mimimum crossing edges for arbitrary directed graphs is a Very Hard Problem Indeed, so don't expect miracles.

Check out GraphViz. Its an open source chart drawing package from the AT&T research people. We've been using it for 6-8 months now to draw all sorts of charts including call trees for a hundred or so shell scripts.

Then input for graphviz is an amazingly simple file which need only contain the relationship between your nodes -- like this:

A->B->C;
A->C;

Graphviz figures out where to draw all the lines and the best placement for the nodes. Of course, input files can be much more complex with many attributes to specify. Graphviz even does spline fits to preferred edge paths to connect the nodes with non-overlapping curved lines. In my opinion, this is much better than Visio's drawing method, especially when you get into densely populated graphs. Visio draws all of its connections at 90 degrees (or we're just stupid and couldn't turn it off) causing lots of confusion and ambiguity in the charts. Graphviz also runs like greased lightening. We looked into scripting Visio and the results were pretty sad. Visio took 3 minutes to generate a diagram of a large program's call tree while webdot took about 2 seconds. This was the hands down decision maker since we were going for dynamic generation for web pages.

The graphviz package includes a utility call webdot that acts as a chart server for the web. You make calls of the form

http://machine1.com/cgi-bin/webdot.cgi/http://ma ch ine2/some/path/mychart.dot.gif

The first machine is the webdot server with webdot running out of cgi. The second half of the url tells webdot where to get its input file (mychart.dot) and the last extension (.gif) tells webdot what output to use. Output possiblities incluing gif, ps, pdf, clickable imagemap, tcl and lots of others. The tcl one is cool because (if the web browser has the pluging) you can zoom in and move around your chart. Obviously, the URL for the input file can be anything including dynamic information generated from cgi, jsp, asp, etc.

Graphviz is cool. We like Graphviz.

Basically, to draw these organizational charts, you just need some perl script that pulls your data from your data store (rdb, ldap, flatfile) and generates the dot file for input. Graphviz can do the rest. The tcl plug-in is especially useful for large, complex graphs.

so now you've got the data in a decent structure. Perhaps you could use graphviz webdot or something to automatically draw graphs from it.

All your events are belong to us.