I now have three separate Web servers running on my desktop: IIS 5.1, which I use for ASP.NET development; Radio Userland, which I use to maintain this site; and ZoneAlarm Pro, a personal firewall. I can't help but wonder if all these servers adversely affect my system's performance. Can anyone refer me to information on this subject?
I do know that the latest release of ZoneAlarm has a problem with a few of the sites I visit regularly. Here's one: http://www.1sttech.com, my credit union's Web site. The home page starts to load -- I can see the title and a customized vertical scrollbar -- but then it just sits there, unless I deactivate ZoneAlarm. What's up with that?
I discovered a revolutionary piece of software last week: Life Balance, from Llamagraphics, Inc. Most To-Do List apps encourage you to prioritize items by urgency: their due date. If you're like me, your life is full of things you consider important, but which aren't really urgent. Some of mine are: Be a better husband; learn to speak Chinese; improve as a musician; get in better shape; cultivate personal relationships, etc. Life Balance is revolutionary because it helps you prioritize by what's important, not merely what's urgent. (Not only that, but it's the first widely-available Windows app I've seen that's written in .NET.) I urge you to check it out.
In other ego-surfing news, my article "A Tale of Tabbed Pages" is featured in the premier issue of ActiveUp Software's monthly newsletter. ActiveUp, you'll recall, is the creator of the excellent HtmlTextBox, which figures prominently in the content management system I've been developing for FTPOnline.
Received the coveted link from Robert Scoble today. I guess now I'd better come up with something to justify all the traffic I'm about to get!
I've received some good feedback from my article, "Is Inheritance Overrated?" The real issue, it seems, isn't inheritance, but rather strong typing. One of the requirements of this project is that it be more or less self-maintaining: new content types will be added fairly often; my bosses don't want me to have to go spelunking in the code every time that happens. An advantage of my generic framework is that the app's users can maintain the system simply by creating templates and editing data; few (if any) changes to the underlying code will be required. David Bayley thinks the generic framework will be more difficult to maintain than a strongly-typed object model. What do you think?
Interesting piece at Jakob Nielsen's useit.com. Although primarily about Flash-based Web applications, the article makes several good points about the usability of Web apps in general, to wit:
- Web apps are often used infrequently (perhaps just once) and without extensive training. They must, therefore, be simple, without excessive features;
- Web apps should provide an overview of features and basic task flow, so that users can quickly understand what the app does and how it benefits them;
- Web users tend to ignore anything that looks like an ad. If you over-promote features of your site (with graphics, animation, etc.), users are likely to miss it.
Like many VB programmers, I'm only marginally familiar with implementation inheritance. Oh, sure, I understand it in theory -- I've read all the standard primers ("A dog and a cat are both animals, but they speak differently...") -- but I have yet to use it in a real application. So I was enthusiastic when it looked like my current application, a content management system written in ASP.NET, would provide an ideal opportunity to get my feet wet with implementation inheritance.
The app deals with content objects which are displayed within placeholders in page templates. When a page is requested, the system retrieves the relevant content from the database, binds the data to a user control, then inserts the user control into a placeholder on the page. There are several types of content: home page lead, home page non-lead, feature article, product review, etc. As I designed the various content objects, it occurred to me that they shared certain features in common: they all, for example, had a title, description and publication date; all home page items had a URL to which they linked; all article types had an author and one or more pages. They all needed to know how to load themselves from and save themselves to the database. So, I thought, why not create a base ContentItem class containing the shared properties and methods, and inherit the more specific types from this base class?
In my initial proof-of-concept, that's exactly what I did. Specific content types inherited from a base ContentItem class; when they were serialized to the database, they looked like this. Everything worked as expected; this inheritance stuff was a piece of cake!
As I started to flesh out the prototype, however, it became apparent that my design was pretty maintenance-intensive. Each new content type required me to create two user controls and associated code-behind classes: one of each to load/edit/save the content, and another to display it on a page. Although the new classes could inherit common functionality from my ContentItem and ContentDisplay base classes, I'd still have to create, test and debug them. In addition, the XML stored in the database was version-specific: If I later changed the design of a class, it wouldn't know how to deserialize data saved by an earlier version of the class.
One way to reduce the maintenance burden, I thought, would be to create a generic edit form: The form's code could read its layout from an XML file and dynamically create the necessary controls. That was simple enough (I'll write about it in a future article); the hard part was figuring out what to do when the user clicked the 'Save' button: I'd still have to create an instance of the correct content class and manually assign the form's field values to the associated class properties. Nor did this approach do anything to reduce my class development burden, or avoid the version-specific nature of the serialized XML.
Finally, I concluded that inheritance was not a good fit for this application; it was simply more trouble than it was worth. I refactored the design to use a generic content object, which consists of a simple collection of items. My generic edit form could save itself by simply looping through its controls and adding a name-value pair to the content object's Items collection. I'd no longer have to create new classes for each new content type, and the serialized XML would no longer be version-specific: the content object would neither know nor care what items it contained. To add a new content type, all I'd have to do is create a simple form definition file, and a user control to display the content.
Is it just me, or is this a well-known downside of implementation inheritance? Does inheritance work best in cases where the object model is relatively static? Or are there ways to efficiently handle situations like this one, and I just don't know them yet?
You may have heard this story, about a man who allegedly burned his, uh, lap's top while using his laptop. But I think this version, which was automatically translated by Google from the German-language CNN site, is far more amusing. Source: Larry O'Brien's Weblog
Apropos of nothing... Have you seen the Apple "Switch" ad featuring Ellen Feiss? Apparently she's attracted considerable attention because she appears rather... mellow in the ad. Now, at last, after turning down offers from Letterman and Leno, Ms. Feiss has granted her first interview. Too funny.
Update: My referer logs have alerted me to the fact that, as a result of this item, my site now appears in the Top 10 results of a Google search for "Ms. Feiss." Now I face a dilemma: Do I honor my stated purpose for this site, to discuss primarily ASP.NET development issues? Or do I generate traffic by shamelessly pandering to the techno-zeitgeist? ;-)