Here are some pictures that demonstrate my additions to Mesquite.

The first half of the summer I worked on getting the Phenex-generated annotations to show up for each cell in the annotations box directly underneath the matrix. See the Phenex tool and the annotations box outlined in green in the picture below:

After that, the second half of the summer was dedicated to getting a visual representation of a given cell’s annotations to appear when the cell was clicked. For this I used Graphviz and the Grappa Java package to generate Graphviz dot graphs. See the Grapviz dot tool and the Graphviz dot graph pop-up outlined in green in the picture below:

It is possible to zoom in on the graph by right-clicking on the pop-up (or Ctrl-clicking for Mac users). There is also a lot more that can be done with Graphviz than generate this simple graph, which leaves plenty of room for advancements in the future.

Of course, to see this matrix in the first place you must import a NeXML file using the nexml package that Rutger Vos wrote. When nexml is installed, you simply open a NeXML file and choose the nexml option among the interpreter options, like in the picture below:

I’ve gotten good feedback on my project from my mentor, which means a lot, and I’m happy to say that it seems like something that will be useful to the evolution-ontology community.

What’s next? Next summer I’ll apply for GSoC again. Before that, in the next couple of weeks school is starting up again and with that new programming projects. In between time I’ll go play outside for a bit, and make this summer a summer in all respects.

Now I’m finishing up the summer with some tasty unit testing. I have to get into a different mindset for unit testing. My first reaction is to skim over the code and think “Yeah, that all works just fine” rather than looking for the smallest units I could test. But once I get into the right mindset it starts to go pretty quickly.

It’s really odd to think I’m almost finished with GSoC. I was pretty unhappy about that until today, when I got an invitation to work on a IR/NLP project that a senior programmer friend of mine is starting this fall. Still can’t believe that luck. Maybe the school year won’t be so CS-deprived after all.

I’m at one of those extra-fun parts in my project where I’m really close to the completion of a mini chunk of the project. I’ve got the pop-up window showing upon a click, with a dot graph in it that is written and read on the fly. The last little bit to do is to make the dot graph reflect the cell that was clicked, rather than just a pre-determined dot graph.

I _think_ I can get that done tonight. I’d love to go to bed having accomplished that.
It’s been somewhat frustrating working with Grappa since there aren’t explicit tutorials; you’ve got to sort out how it works from a given array of example files. On the other hand, it’s that much more satisfying when you get it working. (Luckily I saw that coming, so I didn’t despise it the whole way along.)

On a different topic, I wonder how many other computer programmers are seriously into math and music. I can’t be the only one who sees how perfectly and naturally these three subjects fit together. Every bit of work I do in one subject feeds the others so immediately. If I’m stuck on a computer programming problem then I know I can take a break and do some math or music to attack it from a different angle.

I’m beginning to have a sense for what exactly I do in one subject that will affect something specifically in another. For example, it’s so much easier to sight-read after debugging a program.

I haven’t had much luck converting my close friends. My music friends detest math and prefer I don’t bring it up before mealtime, and my math and computer friends, although slightly more open to the idea, still seem to consider music outside of their talent areas or worse, a lesser endeavor.

I guess I just want to see more mathematician and computer programming rock-stars.

For example, once I got the Grappa DEMO files working there are some pretty concept files:

Not so pretty is when what should look like a graph looks like a scribble. In the picture below, the graph in the DemoFrame _should_ resemble the same graph in ZGRViewer:

Back to the drawing board.

You quickly get better at it as you start to figure out your tester’s level of knowledge, what sorts of things they probably won’t know or could misinterpret, etc. Luckily my tester was really detailed and specific with all of the steps she took, so it was more or less simple to follow her logic and get a picture of what was going on on her end. It still made me wish for something equivalent to Fog Creek’s Copilot, with the addition of limitations to a specific directory, so I wouldn’t have to have access to her whole computer.

I’ve simultaneously been working on the second part of my GSoC project, the visualizations. It took me a bit to get Graphviz, Graphviz Image Viewer and Grappa all working, and I’ve gotten a new picture window to show up when NexmlViewer runs. Currently the picture that loads is just a standard picture on my computer, which is a step away from the dot file I have to get showing up in there. I think I’ll have to make the dot file into a Mesquite component first and then add it to the window. More later.

Here are some simple examples swiped from wikipedia:

Undirected graphs versus directed graphs. First undirected:

 graph graphname {
     a -- b -- c;
     b -- d;
 }

Then, directed:

 digraph graphname {
     a -> b -> c;
     b -> d;
 }

Oh, look, different shapes and names:

 graph graphname {
     // The label attribute can be used to change the label of a node
     a [label="Foo"];
     // Here, the node shape is changed.
     b [shape=box];
     // These edges both have different line properties
     a -- b -- c [color=blue];
     b -- d [style=dotted];
 }

Why do I keep wanting to call it cute? No, no, no, it’s elegant, not cute!

Maybe by tomorrow you will resurface (and hopefully not be alarmed by my numerous emails)  and spare me from my misery.

Now I’m in the testing phase. Which is uneventful so far. All of the little problems that have come up from my mentor have been decently quick for me to fix. As for working with my student tester, I realize now how tricky it can be trying to help someone through steps necessary to get a program working when you’re not sure of their skill level and where they are in the process of getting things set up. Are they struggling with things that you could help them with or are they busy with a different project at the moment? Are they going to be vocal when they run into problems of pretend they understand things that they don’t, letting the problem snowball?

In the meantime I’m learning the dot language and working with graphviz, in prep for the next stage of my project. (Rec: if you’re going to install GraphViz, just save your time fiddling with package managers and compile from source.)

Sifting through message board advice for something that seemed likely to have the least chance of unintended consequences I found this:

I ran into a problem where the Eclipse just hangs and shows a blank screen on start up. On analysis I found that its due to the perspective that its trying to open with. I could not find the problem thats causing this but I wanted to open the project and do some work on the java code base.

Since I cannot change the perspective from the eclipse workbench I looked around and found the file that can be edited to make eclipse open in the perspective you want.

It is workbench.xml file that will be under %workspace%\.metadata\.plugins\org.eclipse.ui.workbench folder. Search for perspectives element and modify it to open up in the perspective you want. For e.g. to open in java perspective you can use the following

<perspectives activePart=”org.eclipse.jdt.ui.PackageExplorer” activePerspective=”org.eclipse.jdt.ui.JavaPerspective”>

Ref: YourMitra.

The corresponding line in my workbench.xml file was <perspectives activePart=”org.eclipse.ui.console.ConsoleView” activePerspective=”org.eclipse.jdt.ui.JavaPerspective”> which, when replaced, allowed Eclipse to come to life once again.

Solved.

On a tangent, it seems like a decent portion of the solutions that work don’t work for the reasons they should. Like in the above, our activePerspective attributes were the same. The problem instead was that our activePart attributes were different. So of course that leaves me wondering if others solutions out there that target fixing the perspective actually work because they coincidentally effect the real source of the problem. And how many solutions in the world are just a fallacy of cause and effect? Can’t help but wonder…