This weekend, I was doing a bunch of digging into how to use some of the open source ORM (Object Relational Mapping) packages out there. That process of technical research follows a pretty predictable pattern:

• do a few Google searches
• open the best results into a bunch of tabs
• read the info
• come up with a few, more detailed questions
• repeat

As that loop progresses, the questions I end up asking Google get more and more specific. By the time I've been digging for an hour or 2, the bulk of the results are starting to come from forums, mailing lists and other discussions of the technology in question.

That's when one of my pet peeves rears its head. You put a fairly detailed question into Google, get a page from a forum where someone asked your EXACT question (including most of the nuance for your specific needs) and, after a few people saying they don't know how or aren't sure, the original questioner pops back in and says, "Nevermind, I figured it out".

And that's it. Nothing else.

Particularly gnarly questions yield more than one such incident. Even worse, there are often 5 or 6 people just as frustrated, asking this person exactly HOW they figured it out. 

To me, this is an online etiquette and/or karma thing. If you go asking other people to explain how to do something, and you figure it out on your own, telling them "Nevermind" is just the first step. It is now your responsibility to explain back to the forum/mailing list/etc. what you did to figure it out. 

Sure, your solution might not work for everyone who will stumble across the discussion, but it's a whole lot better than being mocked by someone saying they *have* the answer, but haven't shared it.

Photo: Dan Zen

I make a swing past a bunch of sites like Freshmeat, C Sharp Source, CodeProject, Codeplex and Sourceforge
every week or 2, looking for new and updated C# (and PHP, etc) projects and libraries that are up to interesting stuff.

One article on CodeProject today caught my eye. The article is entitled: Generate Complete Web 2.0 Applications in Minutes. That sentiment is all over the software development industry. The Microsoft Windows Server 2008/SQL Server 2008/Visual Studio 2008 launch last week showed the attitude at several different points.

Basically, it boils down to excitement at the ability to quickly build "applications" with little more than a wizard. That exact sentiment was expressed to me multiple times at a consulting company I worked with for a while. The person in question believed that if we just used one of these magical tools, our projects would go from a couple of hundred hours down to a single day.

The problem with this whole approach to software development is not that the tools themselves aren't great or that they promise something they don't deliver. It's that they're asking a question that doesn't matter in the context it's getting asked.

That's because neither I nor any software developer that I know is collecting a paycheck or getting an invoice paid for "building applications". At least, that's not what the payment is in exchange for in economic terms. Rather, I am getting paid for *solving problems*.

And, the thing about getting paid to solve problems and magic tools that make some kinds of problems easier to solve this year than last year (which is what most of these tools actually do) is that that just changes the problems that people pay for.

When tools that do easy CRUD generation or data entry applications show up in the marketplace, that doesn't mean that software developers magically get to use those tools to only work 2 hours a week and then coast for the rest. It just changes the kinds of problems that earn developers money.

I love this chain of progress. That's because it lets me solve ever-increasingly difficult problems with the same effort. That's very cool. However, it doesn't promise easy street and it bothers me when that's what's implied by this whole attitude.

Ever since someone gave me an overview of RESTful web development in the same week that someone else gave me an overview of the Atompub protocol, I've been hooked on the idea.

I've tinkered around with starting implementations of both a client and a server on my own ever since. Part of that activity was because there weren't very many tools that supported Atompub. That actually makes doing that kind of development a pain.

That's because you're trying to do both ends of a client-server implementation without having either side ready to work. It's always much easier to work on one end of such a system when the other end is already in place.

While there have been tools for testing Atompub servers, some early servers, etc. out there, but most required quit a bit of yak shaving before you could work on the other side.

Fortunately, that's starting to change. While I still am pursuing my own implementations, I now have adequate implementations to work with on both sides: Windows Live Writer on the client side and Wordpress on the server.

One of the things I'm aiming for in working with this whole chain of tools is a central repository of content that I create: notes, bookmarks, articles, documents, images, etc. all in one place. From there, the content can be pushed out to the various sites I want it on.

Anyway, one of the things that I wanted to do as part of this was to get a copy of all of the content from this site as individual Atom documents. This would give me a large test set of posts that reflect my own real usage.

So, I wrote a bare minimum export to get all ~900 posts. One of the secondary reasons I wanted to use this is that this site's installation of Wordpress is chronically messed up.

Accordingly, a real implementation should actually query the service for the list of posts instead of just looping through the list. For whatever reason, this site's setup, that didn't work, hence the for(i) loop. But, that means some 404 errors in the middle from deleted posts.

Regardless, in just a few lines of C# code, I had a nice directory containing all of my posts. The code follows.

Read the rest of this entry »

Photo by: Bob Jagendorf

Back at the beginning of 2007, I had an idea to highlight some of the amazing photographs that are added to The Commons every day. In my zeal for the idea, I jumped right to trying to do a "Best of 2006" book, but didn't start until January of 2007. Thus was the project doomed to the inevitable interference of life.

Fast forward to early this year and I got the itch to revisit this project. However, fully aware of how easily a grandiose book project could get pre-empted, I instead let it brew for a while before just jumping in where I had left off.

What I've seen works best for side projects like this idea is when things are built up out of small components. Those small components or small tasks lend themselves well to an hour here and there generating actual progress and usable results. There is no grand churning in the background with a final product emerging at the end.

So, for this idea, I think it makes much more sense to use the domains I bought for the project (fromthecommons.com and .org) and the subdomain I set up for the photo version specfically (photos.fromthecommons.com) to do smaller highlighting of great Creative Commons photos on a daily or weekly basis using a blog format.

A later book at the end of the year would thus be much simpler as all of the nominated photos would already be chosen.

So, I set up Wordpress on that domain and modified my tools for finding great photos from The Commons and it's up and running. Because I plan on putting ads up, I'm currently limiting the photo selection to those that are licensed Creative Commons Attribution. While I think that there's clear freedom to also use some of the other licenses, this one is clear and there's no shortage of great photographs to choose from.

The theme I'm using isn't exactly what I want for the long haul and I need to change the photo template HTML a bit, but those are tweaks that can come as things progress. In the mean time, if you enjoy good photography and are interested in open source creative expression, it's probably a site you may want to watch.

Somewhere, at this very moment, in an IT department or team of programmers, someone is planning a scheduled task. That task should run in "off" hours, when no one is around. The immediate suggestion that pops up is MIDNIGHT. There is no debate, no questioning of it and the task is scheduled for midnight.

Unfortunately, in many environments, this scenario is repeated a couple of times a month. I say unfortunate because the original reason for running these kinds of jobs overnight in the first place is that batch jobs that consume computing resources shouldn't interfere with regular daytime work activities. However, when *everything* gets scheduled at midnight (and in many shops, that actually ends up happening), all you've done is shift the bottleneck to the middle of the night.

I've worked in environments where the bunched up batch jobs all scheduled at midnight thrashed the hard drive and CPU all night and are often still running at 9 or 10am the next day.

When we changed the scheduling to stagger them out a bit, from 10pm through 6am, the total burden on the server dropped dramatically and we actually dropped the overall time spent running these jobs just by being more careful about scheduling.

So, if you happen to be in that meeting today and someone says "midnight", please, just check to see what else is running at midnight and consider a different time slot.