Smalltalk Tidbits, Industry Rants

I periodically see people make the claim that Cincom and IBM are the only major Smalltalk dialects, or the only Enterprise Ready Smalltalk dialects. Now obviously, I'm of the opinion that VisualWorks is the best choice for development, regardless. However, there are other things out there, and they are progressing quite nicely. The Dolphin Smalltalk guys just pushed out an update to their major release 5, for instance. Unlike Java, where you get Sun - or Sun - or Sun - in Smalltalk, we have a wide variety of dialects meeting the diverse development needs of the market. Go visit Why Smalltalk to see what I mean.

With NASA grounded after the shuttle thing, this news is very interesting:

A private manned spaceflight program was unveiled Friday at a desert airport where it has been in secret development by famed aircraft designer Burt Rutan for two years.

A rocket plane, dubbed SpaceShipOne, and the White Knight, an exotic jet designed to carry it aloft for a high-altitude air launch, were shown off in a hangar at Mojave Airport, where Rutan developed Voyager, the airplane that made the first nonstop, unrefueled flight around the world in 1986.

The stubby-winged SpaceShipOne, built by Rutan's Scaled Composites LLC, is designed to carry three people on a suborbital flight to an altitude of 62.5 miles. Rutan set no date for the first attempt, which will come after captive-carry flights and drop tests.

As a big sci-fi and space program fan, I'm always interested in news that looks like progress on that front

I wasn't entirely happy with the real estate the button layout took in the latest BottomFeeder builds. So i rearranged the buttons to the top, and it got a lot better. However, the 'New' and 'Alerts' buttons really shouldn't always be enabled; they should only be enabled if there new or alert items available. That took a little bit of work in terms of state tracking, but it's done now. I think the end result is a cleaner UI. Now, if I get around to finishing the blogger API work, I could send out a general blog posting tool with BottomFeeder as a plugin....

This could be me during the work week....

BottomFeeder now has slightly better international support. It turns out that displaying non-English characters had some basic problems straight from the Http query - the mime code in VW was not getting the character encodings right. That's fixed. Which means that, if your current locale (as set in the OS) has a font matching the one coming in, it will display properly. Unfortunately, if your Locale contains no matching font, it won't. I intend to solve this problem, but have run out of steam for the day. It's a start.

It's only been 10 years since Mosaic came out. Hard to believe....

Deathblogs? Here's a trend I didn't see coming

Finding such weblogs is a challenge, since there's rarely any warning that entries are about to cease. Because idle and abandoned blogs are more the rule than the exception, it's impossible to tell if a site is simply being ignored or its creator has, in fact, died.

But deathblogs, to coin a term, do seem to offer comfort to those left behind, whether the sites are visited regularly or not.

Weblogger Rebecca Kris, a Carnegie Mellon University student, was killed in a car accident last year, leaving her blog behind. The posts call out to her by the dozens -- "Thank you for touching my life" -- hoping, perhaps, that even in the afterlife, we all might have Internet access.

shudder. Who knew?

I saw this comment about EJB on one of the Java advocacy groups:

Question: Someone have a clue how many companies are really using EJB ?

Answer: Only the ones that want to hear the big iron groan under the load

To that I spotted this quick rejoinder:

And .NET is for those that want to hear the small iron groan under the load

lol

Tim Bray is not amused about the current state of RSS. in particular, he complains about two things:

• HTML in the <description> tag
• Relative URLS not working in RSS

Relative urls have been a headache for me in BottomFeeder - based on the information in the data you get, it's sometimes hard to impossible to guess where a link belongs. The HTML thing has been less of an issue for me; maybe I'm just not paying attention, I don't know. Go read Tim's rant in full - it's worth some thought.

I'm off to a new XP group forming up - I'll have news later

I'm off to a new XP group forming up - I'll have news later

So here I am at the first meeting of the Maryland XP group - first thing was organizational stuff - who's here, when to meet, all of that kind of stuff. Hey, I got Smalltalk out there as one of the Productive Events ideas :)

The DC group is a little too far a drive to be convenient for me on an ongoing basis - weekly codefests are a long haul. The Baltimore beltway isn't nearly the hassle that the DC beltway is - so even though this is about as far away mile-wise, it's a lot closer time-wise.

So what's the plan? Next time, it looks like an Extreme Hour is going to be organized. I've never actually been involved in one, so that should be interesting.

So on with the meeting itself - Chris Davies reports on attending an ObjectMentor XP class. The class was taught with both C++ and Java. Sounds like they had a good time - listening to Bob Martin hold forth was probably worth the trip all by itself - agree with him or disagree with him (I've done both), he's a very good speaker.

Now I'm paying. I have to look at C++ code..... Looks like if you're doing C++ development with the MS Visual C++ tools, you're still in hell from a refactoring standpoint. Gads, how to people put up with this stuff?

Interesting conversation with the group though. A lot of smart people showed up, with some interesting viewpoints on XP, how to start using XP, how to advocate for XP.

Hmmm. I'm going to have to take a look at this FitNesse stuff that Ward has been working on....

So here I am at the first meeting of the Maryland XP group - first thing was organizational stuff - who's here, when to meet, all of that kind of stuff. Hey, I got Smalltalk out there as one of the Productive Events ideas :)

The DC group is a little too far a drive to be convenient for me on an ongoing basis - weekly codefests are a long haul. The Baltimore beltway isn't nearly the hassle that the DC beltway is - so even though this is about as far away mile-wise, it's a lot closer time-wise.

So what's the plan? Next time, it looks like an Extreme Hour is going to be organized. I've never actually been involved in one, so that should be interesting.

So on with the meeting itself - Chris Davies reports on attending an ObjectMentor XP class. The class was taught with both C++ and Java. Sounds like they had a good time - listening to Bob Martin hold forth was probably worth the trip all by itself - agree with him or disagree with him (I've done both), he's a very good speaker.

Now I'm paying. I have to look at C++ code..... Looks like if you're doing C++ development with the MS Visual C++ tools, you're still in hell from a refactoring standpoint. Gads, how to people put up with this stuff?

Interesting conversation with the group though. A lot of smart people showed up, with some interesting viewpoints on XP, how to start using XP, how to advocate for XP.

Hmmm. I'm going to have to take a look at this FitNesse stuff that Ward has been working on....

I read this story in Eweek - and it fits with other stuff I've read recently:

As of this moment, the security level of the Internet has taken a big hit. And it's not because of a new worm or some nefarious hacker collective; it's because of a set of badly conceived laws that have been passed by several states.

These measures, referred to as Super DMCA laws (see Freedom-to-Tinker's Super DMCA page) are badly designed laws promoted by the Motion Picture Association of America. Super DMCA legislation has already been passed in Colorado, Delaware, Illinois, Michigan, Oregon, Pennsylvania and Wyoming.

One of the common aspects of these laws is that they make illegal any device or program that can "conceal or to assist another to conceal from any communication service provider or from any lawful authority the existence or place of origin or destination of any communication." Aside from LaBrea, this makes a whole set of common IT programs and hardware illegal, from firewalls to VPNs to privacy applications.

So if you live in one of these states, you are now breaking the law if you run a firewall. And if you're an IT admin that has all of your internal systems running on NAT, you could face as much as five years in prison and up to a quarter-million-dollar fine.

Wow. Cluelessness and venality know no bounds....

Slashdot has a story on Don and John's Smalltalk implementation for .NET. Hat tip to David Buck for pointing this out.

This is just too precious for words. In the RSS/blogging universe, there's this sharp divide between RDF (RSS 1.0) and RSS (every other version). This is part of the whole "David Winer vs. the world" thing going on. I actually have some sympathy with both points of view - I look at RDF, and see needless complexity - it fails the whole XP YAGNI as far as I'm concerned - it was designed based on presumed future needs, something that I always wonder about. On the other hand, it's not as if I've studied the issue in anything like a comprehensive form, and a fair number of otherwise intelligent people sem to think it's useful.

I read this post on the usage of browsers with interest - IE is not at the same level of dominance (at least with the technical user population) that one might think. So I decided to analyze my site logs a bit, and came up with some interesting numbers. I just sliced and diced on things I recognized in the logs. One interesting thing - no one hit the site with Safari today. Here's what I got:

Agent	Percentage of Hits
Internet Explorer	31.8%
Mozilla/Netscape	20.7%
Opera	0.5%

Now, you'll see that there's way less than 100% there. It turns out that a significant proportion of the daily hits on my site are with RSS Agents and Bots. I threw bots into 'other'; here are the RSS stats:

Agent	Percentage of Hits
BottomFeeder	23.1%%
SharpReader	4.1%
Radio Userland	2.7%
Other	17%

Now, the BottomFeeder statistics are elevated for this site, but it's still interesting that about 30% of the site's hits are for the RSS feed. It's also fascinating that Mozilla, rather than being insignificant (as it's often reported), is a sizable chunk. Looks like IE may actually have competition.

There's more ranting about RSS this morning. Ted Leung cites Bill Kearney's post on "bad" RSS readers. What's a bad reader, you ask? According to Bill:

How about we all start mining our server logs and start 'outing' the bad RSS readers? Ones that don't:

• honor scheduling instructions
• use gzip to save bandwidth
• follow and learn from redirects
• use eTags
• understand HTTP headers

Now, BottomFeeder does the big ones there - etags and gzip. I'm not sure what he means by "understand HTTP headers" - too vague. As to schedule - well, that's harder than he seems to think. For non-blogs, there may well be a regular update schedule. For blogs though - they tend to be "as the blogger decides to post". Heck, I've noticed that many of the news sites I read have updates more frequently than their schedule claims - so I'm not sure how much value that tag has in the real world. Supporting it wouldn't be hard; I'm just not sure it buys a lot.

Earlier, I posted support for another Bill Kearney rant on RSS feed bloat. However, I don't fully agree with him. He wants RSS feeds to be headlines only, and have the end user follow the links to full content. That works for news - but I hate that posting mode for blogs. When I said I don't want full content, I meant that I don't want a whole HTML page buried in the description. Headlines only I find irritating.

There's another interesting trend starting to pop up in this conversation thread over on Sam Ruby's Blog. Reading all the way through, I get the distinct impression that these people haven't seen NNTP. Why do I get that impression? Because the whole direction of the comment API, embedding RSS in other contexts, etc. - the direction that's heading is threaded conversations. Well, we have that already, in a non-bloated format - it's called NNTP. I suggest that these guys set up a moderated news group on one of their servers, because it will save them a whole lot of time and effort....

John Parkinson has an interesting article on development:

Back in the late seventies and early eighties, when I managed large, complex software projects for a living, I kept track of which programmers were contributing the most to the code we delivered to our customers. A typical development team consisted of eight to ten programmers writing and testing code for three months or so. We usually had about a dozen teams contributing to a development release, so each year I accumulated 40 to 50 sets of productivity data on both teams and individual programmers, covering the efforts of about 100 people. Between 1978 and 1983, I built up a pretty decent performance database.

The results were hugely skewed. Although the productivity of the teams didn't vary much (and everyone worked about as hard as everyone else), almost 75 percent of the final code came from just 5 percent of the programmers. And just about 100 percent of the "best" code (few initial defects, excellent efficiency) came from this same small group.

I think everyone's seen this - large projects tend to get pulled forward by the efforts of a relatively small subset of the entire development population. On some of thos projects, I was completely convinced that (literally) hundreds of developers could be replaced by a team of 1-2 dozen good people. It would certainly be cheaper than outsourcing. John goes on:

Just this year, I've come across a couple of software products that suggest Power Programmers are coming back into the mainstream. The first is Squeak, a sort of grown-up version of Smalltalk, which a few people will remember as the first real object-oriented development environment. Squeak encompasses an operating system, interactive GUI, development environment and tools that can run on anything (including a chip without a built-in operating system) with minimal porting effort (think a couple of weeks by a couple of people). The Squeak kernel code is only a few hundred "objects," which is why it is so easy to port. Squeak was developed entirely by Power Programmers, led by Alan Kay. It's an amazing example of what Power Programming can achieve. Take a look at www.squeak.org.(Squeak is open source too, and it will be interesting to see how, or if, it survives broader exposure.)

I strongly suspect that most open source projects work this way - out of the large body of people allegedly working on them, it's likely the case that a relative handful do most of the heavy lifting. No reason Open Source would be that dramatically different than any other form of development. Another set of interesting points:

With developer productivity and development process effectiveness high on a lot of CIO agendas these days, I'm starting to think again about applying the practices of Power Programmers more widely. I started by going back to my original data from the Seventies and Eighties. If just a few people were writing most of the code, what did the others do? Maybe if I could just identify the right people, I could get by without the rest.

As you might imagine, things were not that simple. Very few of the people on my teams contributed nothing at all, but a lot of them didn't contribute very much. I would have gotten a few additional points of productivity by eliminating a few people who were, in effect, "defect generators" - just no good at writing code.

I also discovered that although experience mattered, several of the Power Programmers were actually quite junior. And there was some work Power Programmers just wouldn't do - testing, documentation, release management and so on - that needs to get done if projects are to be commercially successful. The less accomplished programmers often ended up with in these roles.

I wonder how XP plays into that testing assumption. I suspect that John's Power Programmers wouldn't do large scale (after development) testing - but based on the people I see involved at the top of XP, I suspect that it's the way it's done, not the actual act. Interesting points anyway - well worth reading in full

Clarence Westberg points out that Alan Kay gave an interesting talk on software and Squeak via this page:

Alan Kay gave a keynote about how much better 1960s software is than today's software, and he gave an awesome demo of Squeak; it's come a long way and it just plain looks fun to use.

Not sure what conference though :)

I spent awhile exchanging email with Bill Kearney today. This was all in reference to this earlier post of mine where I said that there's little point in supporting a feed's stated update interval - and that was the point Bill objected to. Well, there was a reason I said there wasn't much point - very, very few feeds actually tell you what their update frequency is. RSS 0.9x support skipHours and skipDays - hard to deal with, IMHO, and unused by any feed I looked at (including Bill's 0.91>http://www.ideaspace.net/users/wkearney/xml/index.xml] feed, I might add). Then there's RSS 1.0, the overly complex atrocity committed by a bunch of people with way too much time on their hands - no, nothing in the spec to indicate an update interval. I suppose individual feeds could extend their 1.0 feeds with infomration - not that anyone would agree on what that is.... That takes us to RSS 2.0, which has a simple tag - <ttl> (time to live) - that would be easy to support. In fact, BottomFeeder does support it - has since the very first version. But guess what?

So sure, BottomFeeder supports update frequency - but none of the feeds bother with it....

Matt Croyden cites Ara Abrahamian on visual development in this post:

This Visually Explicit Programming thread is so interesting.

Imho the biggest problem of UML and MDA-based software development is that, well, the code isn't even close to what you've diagrammed! I mean take a look at buildings around you. It's easy to map what the architect drew on his board to the real tangible building. With UML the diagrams are something the designer guy draws and understands but the real program has very little resemblance to it! The designer prefers to speak a more engineering-oriented language, UML, while the masons (developers) don't like or understand it because they have to build the damn building and the architecture they are given by the modeling guy is so different from what they build. They speak two different languages. That said there is value in a engineering-oriented bureaucratic approach too, after all the civilization is built by architects rather than masons, right? So fix the gap otherwise just shut up and don't preach it :-)

That matches every encounter I've ever had with modeling tool driven development. Worse, some team members tend to become mesmerized by the design tools, and get overly focused on things like the placement of boxes in the diagrams....

Publishers are taking notice of blogs, but necessarily in a positive light. Via Doc Searls and jd's blog comes this tidbit:

Horgan is a former columnist for the paper who was transferred to the travel writing position earlier this year.

After losing his column, Horgan decided to set up his own Web page, where he has commented on everything from baseball to the Iraqi information minister to same-sex unions. "It kept me happy and gave me a chance to keep doing things that I wanted to do," Horgan told E&P Online. "I do it on my own time, from my own house. I'm not competing with the Courant. I'm not looking for advertisers."

But Toolan sees it differently. "Denis Horgan's entire professional profile is a result of his attachment to The Hartford Courant, yet he has unilaterally created for himself a parallel journalistic universe where he'll do commentary on the institutions that the paper has to cover without any editing oversight by the Courant," Toolan said. "That makes the paper vulnerable."

The editor added that allowing an employee to set up his own opinion blog was a bad precedent. "There are 325 other people here who could create similar [Web sites] for themselves," Toolan said.

So what's next as an employee - soul checks at the door? Sheesh....

Why Smalltalk has an article by David Buck on the effects of changing code. He has some damning things to say about cross dependencies, and how they are worse in C++ and Java, where the static typing is "helping" you:

I get a knee-jerk reaction, therefore, when I see language designs that require wide-sweeping propagation of changes just to make one simple design change in the system. Often, these changes have a domino effect where one change requires other changes and those in turn require others. The end result could be a tremendous amount of work.

I ran into one such case when developing C++ code. I had flagged one method (member function in C++) as const. This means that the method doesn't change any instance variables of the receiver. Over time, I had refactored the member function into several member functions that called each other several levels deep and all declared as const.

I then noticed that the lowest-level function was performing a calculation time after time. I decided that it would be more efficient to calculate it once and cache the answer in the object. By doing this, however, I changed the "const" nature of the function and I had to remove the const declaration. When I did this, the callers of this function failed to compile because const functions are not allowed to call non-const functions. I had to follow the whole tree of calls removing const declarations.

In theory, this propagation could have had a domino effect through the whole system. On large systems, this kind of propagation could make it impractical to change the code.

A similar problem exists in Java's exception handling. Java requires that the programmer specially declare methods that raise exceptions by using a "throws" clause. In addition, any callers of those methods must either handle the exception or declare that they throw it.

Now, consider what happens when you need to change low-level code to throw an exception. Typically, these exceptions are caught at a high level by the application. In order to add the throw at the low level, all methods called between the throw and the catch must be changed to state that they throw the exception. To make matters worse, it's not only that one chain from the throw to the catch that must be changed. The changes branch out into trees of callers and could span many classes throughout the system. If any of those classes happen to be general utility classes or belong to other development teams, it may be impractical to change all users and it would therefore make the addition of the exception infeasible.

and here's the money quote:

Why is Smalltalk with its dynamic typing less susceptible to these problems? Dynamic typing allows the programmer to do the right thing without trying to convince the compiler that it's the right thing. Static typing requires the programmer to provide additional information to the compiler so it can double check the code. This additional information gets in the way when the programmer needs to make changes to the system.

It's a thoughtful, well written article, well worth your time.

Alan Kay's talk at ETCon (link via ted Leung seems to be getting a lot of notice. I think what's going on is that the Java wave has come and gone, and things just aren't that different. Development is still hard; the tools are still not as good as what Lisp and Smalltalk had to offer 20 years ago. Sure, Eclipse is cool - if you come at it from a C language guy's POV. For a Smalltalker, it's just a pale reflection.

So along those lines, I was heartened to see this:

Squeak has been jumping on and off my radar for a few years now. It has a number of desirable qualities: small, totally portable, open-source. From the demos that Cory describes, it seems like there's a lot of functionality. James Robertson from Cincom has been gently persistent at trying to get folks to pay attention to Smalltalk again. My big beef has been the lack of an open source Smalltalk -- but Squeak persistently slipped my mind. Perhaps it's time to go have a look at Squeak...

I'm sure that people who know me will be astonished to see gently used to describe me :) Having more people looking at Squeak can only help the entire Smalltalk community - some of those people will decide to do commercial development with it, and they'll likely have a look at VisualWorks, or Dolphin, or VisualAge when they do.

People are starting to grope towards the idea that static typing is the problem. Take a look here - Ajeru is moving toward a Smalltalk point of view, whether he realizes it or not. For instance:

In mainstream OO languages, objects are associated with classes (types, interfaces, etc) at the time they are created. In the real world, this is not how it works. For example in a customer relationship management application, there will be different types of customers depending on the probability that they spend lots of money. To simplify things, say we have A, B and C customers. Business people talk about A, B and C customers and they specify different rules that apply to A, B and C customers respectively. But we cannot easily have classes for these types of customers because the type of a customer is a dynamic property that changes at runtime. The result is, we cannot capture these business rules in the same way that domain experts do. What we do in our designs is to introduce methods like isAdult() or getCustomerType(). But neither can we use this kind of "typing" to specify constraints, nor can we organise method dispatching based on such types. No polymorphism, just switch statements.

public class A extends Customer {
   definedby {
      getRecentPurchases() > CUSTOMER_A_THRESHOLD;
   }
}

public class B extends Customer {
   definedby {
      getRecentPurchases() > CUSTOMER_B_THRESHOLD;
   }
}

public class C extends Customer {
   definedby {
      getRecentPurchases() > CUSTOMER_C_THRESHOLD;
   }
}

No, it would not be easy, because among other things it contradicts static typing. A pity we must accept the fact that we have been betrayed.

Ok, that's interesting. I think he wants the decorator pattern, not the state pattern anyway - it seems that static typing has already clouded his mind. I found this reference on the fishbowl, where Charles attempts to deal with this. His explanation comes from the Java is all I, or anyone would ever have school of thought:

In Java at least, an object's type represents three different things:

1. The messages that the object will respond to. This defines the object's interface.
2. The code that the object will use to respond to these messages. This defines the object's implementation.
3. An attribute of the object, of type Class.

Sometimes, people get stuck on the third one, and give it far more importance than is really necessary. There is nothing magical about the identity of an object's class. It's just another attribute of the object. Its primary value is as a way of determining which messages we can send to an object, something that is done often enough that Java gives us the short-hand operator instanceof instead of making us call Class.isAssignableFrom(). However, the existance of this operator shouldn't make us feel that the class attribute as an attribute is any more or less important than any other.

Yes, Java is the end all.... All this verbiage spilled because the crowd can't see that static typing is the problem - let go of it, and these artificial constraints disappear. As David Buck said brilliantly:

Dynamic typing allows the programmer to do the right thing without trying to convince the compiler that it's the right thing.

The 2.9 release is getting closer. There are a few UI issues to resolve, but I think those will be easy. I re-did the downloads again - if you look at the dev builds page, you'll see that I've gone back to zip files. The entire directory structure is still being saved, so this change should be minor, and my hope is that it will make it easier to deal with the downloads.

I have so been in this meeting

One more problem to overcome. Say I have a subcanvas, and widgetA is invisible in it. Now say I make the subcanvas invisible, then make it visible again. Is widgetA visible or invisible? The sad answer is that it is visible - the state is not maintained. I'm not sure whether this qualifies as a bug in VW, but it sure is irksome...

I've linked to these notes from Cory Docterow before - Alan's Kay's talk at ETCon is getting a lot of notice. This morning, Lambda linked to it. Something (good) is in the air :)

Ted Leung points out that the Unix Hater's Handbook is now available online. I especially liked this bit of cynicism:

"In my more cynical/despairing moments, I like to tell people that computer scientists regularly reinvent the wheel, doing it a little bit worse each time around."

Heh. Some of us suspect the same thing happens with programming languages in our more cynical moments....

I swear this is my ISP

I notice that Elizabeth Lane Lawley (posting on Evan William's blog doesn't think much of Wikis. Her basic complaints are in the presentation area:

You can spot a wiki page a mile a way. They all look exactly like the pages that my students used to turn out in basic HTML classes back in 1995. All they're missing are the rainbow-colored bars to replace the ubiquitous horizontal rules.

She doesn't get it. There is a problem with wikis, but this most assuredly isn't it. The problem with wikis is the lack of actual collaboration. In my experience, not that many people are willing to add content to a WIki. This is curious in a way, given that the markup is generally simple (regardless of implemementation)- but that's how it turns out. If you set up a Wiki for developers, a small percentage will go out and edit pages. A smaller percentage will create pages. You'll generally find 1 or 2 people willing to devote any time at all to maintenance of the Wiki page space. Now add non-technical people. Those numbers get even smaller. On a regular basis, I'll get email telling me that there's a problem on a Wiki page, along with the fix (for instance, a bad link). This is interesting. Someone went out of their way to send me an email about a problem page. It would have taken less time to fix the page.

Why is this? It's hard to say. It might be an ownership thing - people generally consider web pages to be content for consumption, not documents for editing - i.e., it's not their content, so they don't feel comfortable editing it. That's part of it, I think. There's also the scared by confusing markup crowd - what we (developers) think of as simple markup, non-developers see as confusing notation. Thus email reports - email clients are tools that people feel far more confortable with.

Which takes me back to Elizabeth's post. She seems to think that presentation is the problem, and I'm here to tell her that it's not. I think the population of willing posters to a hypothetical gorgeous Wiki would still be small. It's not the presentation that's the issue here. There's something simpler afoot here, and it's something that plagues web software in general. People like rich client software. People tend to not like basic editing tools - which is what Wikis use. Combine a Wiki with decent posting tools, and I bet you would see more collaboration. Combine it with more pleasant layouts, and I bet nothing much would change

I've decided to support the Comment API that Joe Gregario proposed, and that a lot of the blogging community has picked up. So this blog is now accessible via any tool that supports the API from the client end - which will include BottomFeeder once 2.9 is released.

I'm not sure I agree with his modelers/developers divide. He asserts that MS is a company of "techies" while Sun is a company of "modelers" (let's pause while this Smalltalker picks himself up off the floor. Sun and elegant design.... ROFL). However, in making his point he dissects Sun and Microsoft in interesting ways, and makes this point:

When you reflect on this for a bit, it starts to explain a lot about the differences in philosophy between the two platforms. Microsoft will never, ever produce an implementation of the CLI on a platform other than Windows, because they want to make sure that any implementation they produce is the fastest possible. Let's be blunt: anybody who's looked at the Rotor code and thought about the low-level hackery that would need to go on in order to make it a "real" implementation, and then thought about what it would take to port that to another platform has probably gone insane, raving incessantly and wildly to the cat. Microsoft wants to take full advantage of every last little nook and cranny of the underlying CPU where possible, and that's just not inherently portable. Sun, meanwhile, looks for ways to remove the underlying platform almost completely off your personal developer radar, stressing "platform portability" and "WORA", in order to push a "best-of-breed" solution that allows us as developers to choose, from a flat field of competitors, the best price-to-performance vendor solution we can find. Like good modelers, Sun's vision is to let the vendors play techie, you just focus on building good models that conform to the spec.

I think he's right about the feasibility of the MS .NET stuff on non-Windows platforms. Until or unless MS releases the Office suite on non-Windows platforms, they won't be gung ho about cross platform development.

Ted Leung has another thoughtful post on dynamic and static languages. Ted found Bob Martin's post here on the subject - from Bob:

I've been a statically typed bigot for quite a few years. I learned my lesson the hard way while using C. Too many systems crashed in the field due to silly typing errors. When C++ came out, I was an avid adopter, and rabid enforcer of strong typing. I scoffed at the smalltalkers who whined about the loss of flexibility. Safety, after all, was far more important than flexibility -- and besides, we can keep our software flexible AND statically typed, if we just follow good dependency management principles.

Four years ago I got involved with Extreme Programming. I liked the pragmatic emphasis it placed upon developing software. I also liked the emphasis it put on testing. Since then I have become test infected. I can no longer concieve of writing software without using test driven development. I can't imagine not having a comprehensive suite of unit tests to back up my development.

About two years ago I noticed something. I was depending less and less on the type system for safety. My unit tests were preventing me from making type errors. The more I depended upon the unit tests, the less I depended upon the type safety of Java or C++ (my languages of choice).

I thought an experiment was in order. So I tried writing some applications in Python, and then Ruby (well known dynamically typed languages). I was not entirely surprised when I found that type issues simply never arose. My unit tests kept my code on the straight and narrow. I simply didn't need the static type checking that I had depended upon for so many years.

I also realized that the flexibility of dynamically typed langauges makes writing code significantly easier. Modules are easier to write, and easier to change. There are no build time issues at all. Life in a dynamically typed world is fundamentally simpler.

Now I am back programming in Java because the projects I'm working on call for it. But I can't deny that I feel the tug of the dynamically typed languages. I wish I was programming in Ruby or Python, or even Smalltalk

Very cool - and this is a big change from "back in the day" when Uncle Bob was editing the C++ Report. I'm very pleased with the way that TDD and agile methods have been turning people's heads. Ted added some thoughts as well:

Very interesting... more and more smart, respected people are coming to the conclusion that we can do better than Java/C#, etc. The only thing I can fault in the article is the omission of Lisp in his list of dynamic languages.

I guess life for the Lisp advocates is even tougher than it has been for us Smalltalk guys - we tend to at least be remembered when this topic comes up :) Either way, the Smalltalk community needs to get its act together. If we want to play more fully in the coming rise of dynamic languages, we need to get straight with Open Source - because that's where all the grass roots stuff is going to happen. We can either be on the bus, or watching the bus....

It seems that David Buck's Domino Effects article (which I commented on here) has generated some interest. I saw this post from ceperez this morning:

(citing David's article)

Interestingly, the two examples he sites "const declarations" and "checked exception handling" are vivid examples of the problems of static checking. Both constucts seem to work well for small programs, however they don't seem to scale. Could it be that static typing works well for small programs and more of a nuisance with larger ones? I tend then to agree with the observations, static types tends to propagate throughout a system, and will have a domino change effect. That is, for "Programming in the Large", static type checking is problematic.

However, does that mean that we should get rid of static type checking altogether? I think that's too radical, any kind of static checking is extremely useful. However, we should always make an effort examine the extent of the static dependencies inside our system. Large systems tend to use a combination of both static and dynamic checking. For example, Eclipse is a large scale progam however its able to overcome the problems of static type checking. I don't believe that there's a Smalltalk program of comparable size to the Eclipse project. The evidence therefore exists that you can build large programs with static typing, however its interesting to know how to do this.

Large programs developed in a statically typed language is successfully acheived by exploiting a Component Model. That is, you structure the composability of your application in terms of a component model that uses dynamic typing. The advantage of using a statically typed language like Java over a dynamic typed one like Smalltalk is that with Java you can develop in both modes instead of exclusively in one. I think this alone statement sinks David Buck's arguments for Smalltalk

Using dynamic typing in a language like Java? First off, that mostly concedes the point to the Smalltalk POV - Using dynamic typing this way in Java (or C++, etc.) merely points up the inherent limitations in the static model. If you have to escape the model in order to achieve good results, what does that tell you about the model?

I also find this kind of thing interesting in another way - this post freely admits to a lack of experience with Smalltalk - but is more than willing to assert that Java better supports his "mixed mode" development than Smalltalk. It's clear that David Buck has a good level of expertise in both the static world and the dynamic world - and based on this post, I'm unclear as to how any of David's points have been sunken. Heck, most of the post accepts his points, and then veers off into what looks like rationalization at the very end. I suggest a reading of Uncle Bob's post on static typing and dynamic typing. Combine the points made there with David's article, and I think things will become much clearer.

Bottom line, I don't think the post sinks anything David had to say.

There were some issues with the Comment API code on the server until now. I had developed the code in VW 7.1, but this server is still running 7.1. The Web Toolkit was still evolving between 7 and 7.1, so the protocol that worked to grab the XML fragment for the CommentAPI worked in a 7.1 image, but not in 7. I set up the testbed 7 server locally, and sure enough, the protocol was slightly different. I adapted the code, and now all is well - I got a test comment up a few minutes ago.

Awhile back, I was interviewed with some other folks by the Lehrer report for a story they are doing on blogs and blogging. Here's the email I just got:

After several months of work (and waiting!), the NewsHour story on blogs is airing tonight (4/28/03). Check your local listings for the time your PBS station airs the NewsHour. It should air at approximately 29 minutes past the hour. Whether you were interviewed for this story or provided some background information or assistance, thank you again for your participation. If you have any questions, please let me know! The transcript for this story should appear on the following page in the next couple of days:

http://www.pbs.org/newshour/media/index.html

Cool! My 2 seconds of fame has arrived :)

Brian Livingston of Infoworld has noticed RSS:

I believe this is just the beginning of a tectonic shift that your organization must plan for. Soon after Microsoft made its move, other corporations such as Cisco Systems and Fawcett Publishing started their own RSS-compatible streams.

Dave Winer, the coinventor of RSS, says he was happy to find out that Microsoft's new feeds don't use proprietary tricks. As a result, the Microsoft feeds are compatible with any RSS aggregator.

When aggregators become widespread, many b-to-c newsletters will switch to RSS and drop now highly unreliable e-mail. I wrote three months ago that ISPs such as Hotmail and Yahoo, trying to stop spam, shunt to a junk folder or simply delete 25 percent of newsletters requested by subscribers (see More e-mail scandal, Jan. 6, page 22.)

I guess RSS and aggregation are about to hit the bigtime :)

The NC Download site had a problem this morning, due to a protocol change I made to an underlying piece of code. Unfortunately, the server was still running with the old version of said code, so it never initialized when I restarted the server this morning as part of a test. In any case, the NC is available again - Sorry for the inconvenience

Looks like that blog bit on the Lehrer report will have a bigger audience - Instapundit has blogged it

Cringely has an interesting take on Open Source. Keep reading - he gets to open source in the second half of the article. Here's the gist of his point:

Here is the core argument: There are a thousand Open Source projects that get started out of need or fun, are maintained for awhile for fame, then get abandoned because there is no reason to go on. Eventually, the programmers come to understand that "users" are people who yell at you to fix stuff. So Open Source is inherently flawed. It only works because otherwise unknown programmers can get 15 minutes of fame using the Internet as low-barrier entry into introducing their skill to the world. Since they are introverted nobodies, getting a few emails from unknown users that say "good job!" feels great. But in time, most Open Source projects grind to a halt. The ones that survive are projects like Linux and Apache that have substantial involvement by PAID engineers. One could argue, in fact, that the idea of Open Source software being created by volunteers is a misnomer. Even Linus Torvalds is paid by Transmeta to be the God of Linux

This is an argument I've made more than once - that all the work done to make Linux usable was done once companies like RedHat started paying people to do it. One interesting aspect about an awful lot of open source is usability - it's the kind of drudge work that few people want to do (organizing menus, cleaning up the UI, etc) - but it's also the kind of work that is crucial for widespread acceptance of a product. Love them or hate them, this is something Microsoft has always understood.

Then Cringely goes on with some theories on how MS could crush open source efforts. I'm thinking this wanders a bit into tinfoil hat territory, but here it is:

It is possible to hijack an Open Source project since any Open Source team will automatically bend itself around the party doing the most work. What I find most interesting, however, is applying varying motives to the hijacking. What if Microsoft, for example, suddenly started devoting a lot of resources to Open Source development? They could throw a team at all the key projects. But why would they do that? Well, IBM is already doing it. IBM has hired most of the Apache team. IBM has some major pull on what work gets done and does not get done. In some cases, it is frustrating, and other cases not. However, everybody just accepts it because IBM is paying the bills and people can do what they love. Is there an official IBM party line at Apache? Absolutely not! It is just that none of the Apache developers will talk negatively about IBM, even those that do not work at IBM. So in this sense, it already appears that Apache has been hijacked.

Now consider an evil alternative. Say Microsoft assigns a team of programmers to help some Open Source project. Maybe this time that team isn't specifically identified as being from Microsoft, perhaps it is a Microsoft-funded startup. This team, because of its vitality and funding, quickly takes control of the project and goes running off in some particular technical direction, taking with it the rest of the suddenly re-energized team. But what if this new direction is not a good one? Even worse, what if the team gets far down that lonely road only to have Microsoft suddenly pull the plug, removing its team from the game? Would the project survive? It is hard to say, but if I was Microsoft that's how I would compete with Open Source, by subverting it. Microsoft can't compete on quality or price. And subversion -- since it is subverting a not-for-profit venture -- breaks no laws, nasty as it is.

I think he's wandered off the reservation with this stuff. The usability and paid work - I agree with that. The latter stuff? Tinfoil hat :)

My 15 seconds of fame came and went on the Lehrer Report tonight. Right there at the end of the segment they almost showed a shot of BottomFeeder :)