Bill Roper's Journal

It's been that sort of day.

I spent much of the day at work trying to untangle some of my code that interacts with the Java UI. I have never worked with any of the Java UI code before last week and it is behaving in some extremely mysterious (and sometimes just outright weird) ways. I suspect I will end up sending an email later this weekend begging for an explanation of the weirdness, because I need to sort out the problem and move on. We'll see how that goes.

Meanwhile, I picked up my guitar during a compile and decided to play "The Boxer". My recollection is that playing it in the natural key of G has been causing me to bottom out on the low notes, so I dropped a capo on the neck to move the song up a full step to the key of A.

And then I proceeded to sing the whole song an octave up. Happily, it turned out that I *could* sing the song an octave up, but if I was going to do that, then why did I need the capo?

Brain damage. Clearly brain damage.

Spent some time with one of the other senior programmers on Zoom today discussing the use of Java Enum values across multiple closely related classes and how best to structure this to avoid insanity. He gave me one approach, while I've simplified it a bit, I think, without penalty.

We'll see how this looks tomorrow morning.

When I originally ported our code to Java, it was some years ago. One of the things that I wrote was a fairly robust class to support XML serialization which handled the various types that I wanted to handle as simple calls, burying the translation to and from Strings. It also knows how to detect and avoid duplicating multiple instances of the same object that are in the serialization stream. And it has a SAX-like callback method to allow the classes that it works with to read attributes and contained elements in any order that they are presented.

Overall, it's a nice class.

But Java moves forward and the Jackson libraries now support XML serialization using their own scheme. In this case, you add some simple annotations to the class and now you can read and write an object (Plain Old Java Object, or POJO) belonging to the class in XML as well as JSON.

I spent the last two days adding support for Jackson-enabled objects to my XML serialization library. This was relatively simple, because both my XML serialization library and Jackson's are built on top of StAX, which is a very nice XML streaming system. I had to make a few changes, because I had used the XMLEventReader and Jackson wanted the XMLStreamReader, but that mostly just required me to remove all of the peek() references from my code.

Today, the modified code passed all of the unit tests (and some new tests that I added for the occasion), so you can now read and write Jackson-enabled objects as part of my XML serialization scheme.

It's nice to have a quick win.

And it was back to work today.

Today's lesson was on yet another fine point of Java generics.

I am in a maze of twisting JARs, all alike, except that some work and some don't.

I have become extremely fond of Java's enum types, because there are so many things that you can do with them that you can't do with the C++ enum types. I have managed to work around those differences, but it would be so much simpler if I didn't have to.

And today was back to work (and school) after a two-week break. There were varying degrees of success.

On the other hand, I finally threw up my hands and stopped trying to add a remove method to my Java iterator built on top of my unifying interface layer. Instead, I've coded things using a different approach to what I'm doing.

I've managed to cobble together a first unit test to throw against the wall that found a couple of different (and one pre-existing) bugs and have fixed those. Now that the framework's in place, I should be able to write a lot more test cases fairly quickly to make sure that there aren't more bugs or, if there are, that I can fix them. :)

I have become fond of unit testing...

It's time for another round of comparative programming languages, as I have suddenly inherited a chunk of C# code that needs work. Happily, C# and Java have a lot of similarities, except when they don't.

I spent a couple of hours this afternoon and managed to do a moderate amount of cleanup. There's another bigger thing I want to try on Monday -- because I am *not* going to try it this weekend. :)

Having spent a fair amount of time working with Java Maps, I am being inordinately annoyed by the idiosyncrasies of boost::unordered_map.

I'll fix the code tomorrow.

Finished up the Java code for a fix I was making and fired things up so I could see how it was working. Opened up a model to give it a try.

It was *then* that I realized that the UI for this feature has not yet been ported to Java. It's still in C++ only.

Of course, I haven't ported my code to the C++ side yet. And one library that I was using that made it simple to write a particular routine I need doesn't have any C++ equivalent. I can write the necessary code to do what I need done, but it will take a little time to get it right.

So we'll see how this works next week.

*sigh*