Bill Roper's Journal

I was talking with one of my co-workers today about how to fix some particularly intractable problems with the build, when I suddenly had the "Eureka!" moment and realized how to simplify things. Better yet, not just how to simplify things for me and my group, but for all the people in my related group of co-workers on the other side of the wall.

It's nice when something like that happens.

And so far, it's testing out ok.

Work is going well lately, although a bit disjointed as I jump between projects. But I think I managed to fix a long-standing problem with some of our cookie handling yesterday (with a lot of help from another of our folks who set up the environment and ran the actual tests). We're still testing to make sure there are no cases that defeat the new code, but it's working in all the cases we've managed to recreate so far. This makes me happy.

Home has been disjointed too, but I managed to sneak down into the basement and complete the final fades on a number of tracks. I still need to go spend some time playing with SpectraLayers, but it's been busy and is going to continue being busy for a bit.

Meanwhile, the Mets beat the Brewers tonight to win that Wild Card series, so three out of the four favorites ended up losing. This gives whole new meanings to the word "favorites". (Yes, I know the favorites lose, but they sure seem to be losing a lot in this small sample size of the last two years.)

After my mournful look at the Cardinals' season a few days ago, they have proceeded to grab two wins against the Brewers in 24 hours. This doesn't improve their position a whole lot, but it beats the alternatives.

I have a couple of things going here at home that involve filing forms. One worked, the other didn't. Now I need to figure out what it was I did wrong on the bad filing and whether or not it just cost me a noticeable chunk of money.

I have some code at work that looks like it's working, but the wrong thing is happening. So I need to find out why that's going awry. That will be tomorrow's problem at work.

Returning to the good news front, I did a load of laundry this afternoon and the dryer appeared to work correctly. This makes me happy. I am hoping to remain happy with the dryer, but at least I got to test it before the weekend.

And the trash has gone out, which is always a good thing. :)

One of my co-workers had been working on a project to fix a particular bug, but hadn't made a lot of progress on it. I suggested that I should take it over and do it while he worked on something else, since I have more experience in that neighborhood than he does. He readily agreed.

I showed him some of my interim code and he allowed as to how it was similar to the approach he had taken, but that my code was a little cleaner, because I was more willing to change some things that needed to be changed as part of the fix to knock out things that were going to be weird.

After several hours of effort yesterday and today, I suddenly realized that there was a much simpler way to fix this than the horribly invasive approach I was taking. I went into the base class for the offending group of objects, added a boolean to control an option along with an alternate constructor, and then changed one line of code in that class. And then I went to one of the derived classes and used the alternate constructor to enable the option for that class.

Everything appears to work. And I revised the unit test in the neighborhood and it agrees with me.

I'll do some more testing just to be sure, but I think this particular problem is fixed. :)

It's amazing how easy some things can be once you think about them in the right way.

I suddenly got traction on the work project this afternoon and wrote a whole bunch of code that worked.

I still need to write a lot *more* code that works, but the ball is now rolling downhill, which feels good.

I spent a couple of days this week popping a new feature into some of our code at work. Today, I was finally in a position to test it.

Naturally, it failed.

But then I went and fixed the null pointer exception that had resulted from trying to retrieve a value from one model using a key that belonged to a different model and now everything appears to be working correctly. At least, the cases that I've run are doing the right thing.

So now I've found the bug that was lurking in the new code and can safely check it in.

Or maybe I'll do some more testing first... :)

This turned out to be really simple, but it was really difficult to find this as I was digging through the information on Jackson serialization, so I'm going to mention it here in case it's of use to anyone else.

I have some Java classes that are IDs that we cache so that (if everything goes right) everyone shares one copy of the immutable ID. They can all be represented as a Java String and there is a static valueOf() method in each ID class that either fetches a value from the cache or creates a new value in the cache if you're the first to request this ID. The toString() method generates the String from the ID.

So when you're serializing a bunch of JSON or XML, you want to write out the simple String representation and read in the String on the opposite side and then use it to fetch an ID from the cache instead of creating a new instance of the ID. It turns out that you can do this with just *two* Jackson annotations.

You tag the toString() method with the @ JsonValue annotation. This tells the Jackson framework that this is the only value that they need to serialize out to describe the contents of this class.

For the inbound side of the serialization, you tag the valueOf() method with the @ JsonCreator annotation so that the Jackson framework knows to call that method instead of a constructor.

Two annotations and it all works.

Cool!

It lives! The massive refactoring of code that I've been working on finally does something useful.

Now, I need to make sure that it does *all* of the useful things. :)

Adam Wainwright finally got his 199th win for the Cardinals tonight. This is primarily important, because you have to get 199 wins before you have a shot at getting 200. Now, we'll see if he can do it before he retires at the end of the season.

In other news, I have now fixed the thing that was causing the problem as well as the things that were wrong but weren't the proximal cause of the problem. At least, I *think* the thing is fixed. My *test* says it is fixed.

On the other hand, there's *another* thing that I fixed that I'm being told isn't fixed, but when I tested it on my machine, it was fixed. There are days I wonder what's in any given build that is handed off for testing...

There is something satisfying when you find the source of a calculation problem that fails exactly *once*, after which you have to tear down the entire structure and rebuild it to get the calculation to fail *again*.

Happily, I now know how to make the problem go away, which I will do on Monday.

Now, I am giving it up for the weekend. :)