Jeff Makes Software

I have to say that the .NET world if fortunate to have a lot of open-source stuff available. I can't even tell you how much I like NUnit.

The problem I find, however, with a lot of open-source software is the complete lack or reasonable documentation. That drives me nuts, although I'm not entirely surprised. It's one thing to give away and share your work, but that scenario doesn't exactly provide a ton of incentive to document it properly.

NUnit ended up being useful to me I think because it was in use at a project I was on, and it essentially has its own book. Most stuff I've encountered doesn't have that luxury.

I'm not suggesting even for a moment that the world would be a better place without these projects, it's just that the price of entry is kind of high for something that is monetarily free.

Yep, the more I think about it, the more I think I want to write another book. I've got an idea that I think will sell, I can write it reasonably faster than the last one, and I'm feeling some enthusiasm for it. I'm going to put together a proposal and see if anyone is interested.

As my role in Maximizing ASP.NET winds down leading to release, I have to say that working with the folks at Addison-Wesley has been a really good experience. They bend over backward to give you the support you need. I felt even before this that they had the best ASP.NET titles on the shelf, and I'm really excited that it was them that picked up the project.

On a side note, I noticed at Border's last week that there aren't really as many ASP.NET books on the shelf as there used to be (casual observation, not a scientific statement). Before Wrox went down the tubes and was sold, there were a lot of really quality niche books that covered specific areas (threading, text manipulation, performance, etc.), and I don't think those areas are being served now. Granted, with such a narrow focus, I don't know what the market is for those books. Did they even sell three or four thousand copies? I get the impression that it's hard to justify publication of anything that doesn't at least get into the five-digit count.

I love ArrayLists. I find them to be among the most useful collections in the .NET Framework. I remember seeing a discussion somewhere a few months ago about making ArrayLists into strongly-typed collections. This was achieved by simply inheriting ArrayList and overriding the Add/Insert methods to make sure the objects being added were a particular type.

I don't know enough about what's going on under the hood to know if there's a performance penalty involved with this. Is checking the type of an object an expensive process?

I mentioned the other day that I was going to revisit the text parsing engine of POP Forums and essentially start over. What a difference that made. In less than a day I turned years of crap upon crap into something much leaner, about a third less code. I got there with about twice the unit tests that I originally had. Around a dozen regular expressions took care of all of my line break and blockquote woes that I kind of eluded to in that last post. I started with the first test, and kept working through them until they all passed. I don't know if it's the most elegant thing ever, but it appears to work. I dropped it into two of my production sites and so far, so good (yeah, TDD makes you that confident).

Since this entire exercise is really about arriving at the next version, I can now think about features. The big question is, do I want to endeavor into the world of allowing different text colors, and perhaps text sizes? On the pro side, it would be something other forums already offer. That's the entire list for the pro side.

On the con side, I have to deal with different implementations of rich text editors, decide how best to present the changes (span tags, probably), decide if the various heading tags make the most sense, and above all, know that I'll be responsible for some forum where I see something like:

o my f***ing god!!!!!!!111 u suX0rZ!!!!111

One must be a responsible code monkey, after all!

While the group of people that use CampusFish is small, I was astounded to see that only 20% of my visitors use Internet Explorer. Wow. Granted, I know several of the users are Mac guys (they blog about Mac stuff quite a bit), and several others are Firefox users. I assume the other 20% are the people I don't know. ;)

Those of you bored enough to read my blog regularly probably know that I coach 17-year-old girls in junior Olympic volleyball. In teaching my kids to improve upon their skills, I frequently tell them not to worry so much about the big picture when I want them to concentrate on the smaller things.

For example, to pass accurately on serve receive, you have to be behind the ball and squared to your target, pushing out with your legs, not swinging your arms. If a kid is diving around because they aren't moving to the ball, I set the goal to simply meet the ball, body firmly in front of it. If they can do that consistently, I'm not as concerned about them squaring to target, using their legs or whatever. It's a little victory toward the bigger goal.

Using test-driven development is a lot like that. You write all of these tests, maybe hundreds, and start to write code that passes the tests. There's no way in hell you'll pass them all the first time you run the tests (if you do, you're doing it wrong). But every test you pass is a little victory toward the bigger goal.

If you can concentrate on said victories, I think you can get a lot more enjoyment out of even the most mundane programming tasks. That's why I like TDD.

Today I reached the milestone I was hoping for in the revisions for CampusFish, my little blogging project. After a year, it has only made enough money to cover the SSL certificate, the domain name and some of the bank fees, but it's worth it because I use it. It's where I drop my F-bombs and frustrations on the world and talk about stuff that no one here would likely care about.

When I first launched the site, it was kind of limited because I was so geeked up about using the POP Forums class library to power it all. It still does most of the heavy lifting, but there are about a half-dozen or so data access methods now that do the rest.

It's a lot more simple than .Text in terms of the code base, but it basically does the same thing. There are some additional features like the photo galleries, a recent comments list for members, private messages, friends lists, profile photos, etc. Even prior to the revisions, it was apparently compelling enough for the small group of users, because they're very active with it. Some are having good times with the custom style sheet functionality.

The fun code exercise in this case was doing the trackback mechanism. It's pretty straight forward once you get your arms around the protocol. Granted, users can choose to disallow public comments entirely, so I don't know how much use that will get.

I've gotta come up with some more interesting style sheets for the users, but that will come in good time.

I decided that perhaps I should rewrite my text parsing engine for POP Forums from scratch instead of trying to band-aid it over and over. So with a clean slate, I have a few decisions to make.

I've noticed that other forums don't get into parsing paragraph tags at all. Instead they use line breaks for everything. What do you think, is this acceptable? If my understanding of XHTML validation is correct, it's OK as long as it's nested within some kind of block element, like <div>. It's certainly a lot easier to parse line breaks instead of properly closed <p> tags, that's for sure.

What's your take? I don't get religious about these things the way some people do, so I'm easily influenced.