Don Box, in a comment, clarified that it's "that having to define a new type just to write a program [is] the daunting part," for casual programmers. Absolutely. There's a certain amount of bookkeeping that takes the casual programmer out of the task-solving "flow." This is a perfectly legitimate beef: a parallel to the complaint that checked exceptions interrupt "flow." 

In Danny Boyd's original post, he said that he was seeing "a number of PHP, Perl, and MySQL books appearing on the shelves of my coworkers." This is a perfect example of the Law of Leaky Abstractions applying to Microsoft's Visual Studio .NET. VS.NET attempts to "hide the complexity" of what is, in fact, an architecture that's quite elegant. Since the vast majority of Microsoft documentation conflates VS.NET with "programming .NET" and VS.NET is not presenting a satisfying foundation from which to work, Danny's coworkers are turning away from ASP.NET itself. Danny should buy them all a copy of Fritz Onion's Essential ASP.NET book, which is a "Jolt Award" nominee for best technical book of the year, and whose "Chapter 1. Architecture" is exactly the concise explanation that Boyd's coworkers need.

Open question: would a refactoring IDE help or hinder such casual programmers? Help because of the ease of "doing the right thing", or hinder because of the "just trust us while we do some magic" factor? 

Danny Boyd has written an open letter to Microsoft challenging them on the subject of scripting languages. More specifically, he worries about the "need to produce simple, procedural, functional web-based database applications. I'm talking here about HTML forms that post or retrieve data for editing."

Don Box, where I got that link, concurs with the general sentiment and cuts to the quick with the statement "many of us underestimate how big a deal type definitions are...."

What's interesting, of course, is that to those of us who've drunk the Kool-Ade, types (roughly: what object-oriented programming calls a "class") and events seem to make thinking about programs easier. When you think about a variable, don't you think about the values it can have and the ways you can manipulate it? That's its type. It's just that there are a lot of applications where the only two types that are important are integers, strings, and dates. Three important types: integers, strings, dates, and floating point. Four! Four important types: integers, strings, dates, floating point numbers, and currency... Wait, I'll come in again...

I normally like to be quite specific when reviewing software, and I'm still under NDA regarding Lonestar, but I can make some general comments safely: the handwriting recognition in Lonestar is transforming the way I write. It's a combination of three things: dramatic improvements in handwriting recognition (I doubt many people could read my cursive version of the word "hemorrhage"); the ability to rapidly correct text using a variety of mechanisms (choose an alternate recognition, change individual letters, scratch out and write anew); and a writing window / area that expands as you finish a line of writing.

Writing with a pen bestows a physicality to every letter, makes every word a small unity of expression. The Wacom digitizer tip has a scratchy resistance that's remarkably like the feel of a fountain pen (albeit in an ugly plastic barrel that's too thin and lacks heft). While the keyboard is great for keeping up with a rush of thoughts, a pen is by far the superior instrument for deliberate writing. (Also, for editing -- the Tablet OS already supports the gamut of proofing marks but I'm afraid that we'll have to wait for Word 2006 or some bold entrepreneur before the momentous marrriage of the blue pencil and WYSIWYG.)

A couple months ago, I wrote an 800-word column in longhand using Microsoft Journal; about 10 separate Journal pages (the resolution of the Tablet PC and the parallax challenge of the display forces you to write two or three times larger than how you would on paper). Suffice it to say that transforming the result into a Word draft was a considerable task. In the past few weeks, I've written more than 10 times that length directly into Word with scarcely a bobble (by far the greatest annoyance, and one that I hope will be cleared up before Lonestar is released, is that a space is not automatically inserted between the last word on a handwritten line and the first word of a subsequent line).

Lonestar, when it becomes available, will be a user-installable patch. The alpha is tiny -- about 10MB. If you're buying a laptop, you're nuts not buying a Tablet PC.

These code samples show you how to build VSMacros projects, add–ins, and wizards to make your teams more productive and to bend Visual Studio .NET 2003 to the ways you like to work. via [Microsoft Download Center]

The download is all well and good, but what I love is that you just know that the original description used the phrase "bend VS.NET to your will" and was toned down. Other interesting recent MS downloads have been the Windows Media Player SDK MSDE Deployment Toolkit and an example of modifying the Today screen from the .NET CF.

Way back in October of 2002 we predicted that Smart Display, Microsoft's operating system for wireless monitor that can detach and double as dumb tablets,... via [Gizmodo]

Scoble's learning to program in C#. Next year I'm going to be writing a book for people learning to program. Lately I've been thinking a lot that it might be based on manipulating Office from C#. The gap between "Hello, World!" and "controlling my computer to do cool things" is too large for learners -- who wants to struggle with the concept of recursion when the payoff is "So now you can calculate factorials!" Originally, I was thinking of .NET Terrarium as the context, and that does have advantages but, on the other hand, if you're manipulating Word or Excel or Outlook, you're tying the learning directly to the tools people use every day.

The challenge is making enough money during the day so that I can pull off this project and InkPositive in my spare time. I've passed up some significant opportunities to make a run at these projects (which I hope to eventually profit from), so I've got some exciting months ahead...

Jeroen Frijters wrote a C# program that displays an artificial horizon on his new Thinkpad T41p by reverse-engineering the IOCTL that corresponds to the data provided by the built-in accelerometer in his T41p.  via [iunknown.com]

I think he should "take it to the next level" and write a video game that involves rolling virtual marbles around a maze.

InfoPath and XAML

The scales fell off my eyes this morning when I was answering an email to my recent SD Times article discussing InfoPath. I wrote that column before the PDC and hadn't really thought about it since (it's mostly a criticism of InfoPath's licensing model). But now I see the obvious: if InfoPath 2006 (or whatever) generated XAML, the result would be the exact "stepping stone" between power user and programmer whose absence I lamented in the article.

[W]hat does the inventor of Tetris do for MS?

I don't want to make any stupid assumptions, but my guess is that he designs the cubicle layouts while listening to catchy music... via [Neopoleon.com]

Rory's witty.

Rory wrote a post about strong AI and whether we should spend money there rather than going back to the moon to which Eric replied "...the best goal to push for is solar power satellites...."

I think that solar power satellites is a world-transforming goal that requires government funding, while strong AI is a world-transforming goal that "just" would be accelerated by government funding. While Eric mentions AI's failed promises from the 80s, that was (a) 10 Moore's Generations ago and (b) no one seriously promotes "top-down" symbolic AI as the route forward (except Doug Lenat, who really ought to admit that Cyc is never going to work). As the 100th anniversary of flight is just around the corner, I hope that some bicycle mechanics are tackling machine vision. As Crick said, it's the key...

In a post that's mostly about resource management, Eric Gunnerson mentions an API that I didn't know existed:

desktopWindow.Image = Win32Window.DesktopAsBitmap;

This is quite apropos the discussion of novice versus expert users. Here I've been a user of the .NET BCL for more than 2 years and when I was recently faced with the desire to recreate a desktop effect by compositing, I was stumped (the effect being recreating ink antialiased over a bitmap, but that's beside the point). If you want to be the greatest UI designer of your generation, figure out how to facilitate discovery of alternate paths to accomplish a goal. (There must be a solution that doesn't require a journey into the impenetrable thickets of natural language query. Perhaps a Bayesian analysis of APIs used in a large corpus such as SourceForge / GotDotNet projects...)

(BTW, any discussion of "beginner" versus "advanced" users should take into account that there should be a continuum where "high end" use is Eric's "So I had a problem with resource management that I fixed by writing a program..." )

Like skiers, the average user is a permanent intermediate, neither beginner nor expert. It is a mistake for UI designers to heed debates such as going on in Scoble's comments on UI requests for Longhorn. Even more dangerously, intermediate skills are easy to overlook in usability labs: sit a person down in front of a new application and they will act like a skier on their first run of the new year -- either extremely tentative and "beginner-like" or bold and "expert-like."

But after the first couple sessions with an application, people perform particular tasks with facility. Good UI design does not force the user to categorize themselves as "beginner," "intermediate," or "expert" (as Richard Tallent says, this argues against layered UIs). The key to great UI design is to facilitate the skills of routine tasks to the demands of new tasks: look to videogames for inspiration in the way that a small number of "skills" can be combined to tackle complex tasks.

I first heard the "skier" metaphor from Larry Constantine and Lucy Lockwood.

Keith Pleas has wondered about what language features could be put in Visual Basic .NET that would differentiate it from C# (as opposed to tool features such as Edit-and-Continue). My suggestion would be rules. If C# can become Scheme, why can't VB.NET become Prolog?

Dare Obasanjo sez "...Based on my experiences working with syndication software as a hobbyist developer for the past year is that the ATOM syndication format does not offer much (if anything) over RSS 2.0 but that the ATOM API looks to be a significant step forward compared to previous attempts at weblog editting/management APIs...."

I've come to a similar conclusion about RSS 2.0 vs. ATOM syndication but am still not sure about APIs.

Please, please, please, provide away to aggregate the whole text of the post ?

Some folks (like Tim) have no control as something else does the RSS. Some folks (like Martin) provide the whole text. But some folks only provide an "excerpt" (cant think of an example offhand) and others (Keith springs to mind) provide only headlines.

It's pure and good to have a low bandwidth headline service, but I cant then aggregate and read on the train. Is this a case of premature optimisation ?

via [TWELVE|71 : dull. dull. dull.]

The canonical discussion of FP arithmetic (for this audience, at least) is a 1991 paper by David Goldberg titled "What Every Computer Scientist Should Know About Floating-Point Arithmetic" via [Eric Gunnerson's C# Compendium]

I wrote the following Radio Userland macro so that I can put blog entries in different categories into different places on a page. So, for instance, blog entries in the category "Published" are what generate the "Recent Writing" list here on the right. It may be that there's some built-in macro that allows this sort of thing, but if there is, I couldn't figure it out. If there's not, and you want the code, add this code to your template, replacing the string "Published" with a category of your choosing. (Comments, of course, appreciated) :

<%
local(ret = "");
local(posts);
local(post);
local(publishedItems = {});
local(i = 1);
posts = @weblogData.posts;
for post in posts {
  if(sizeof(post^.categories) > 0) {
    for cat in @post^.categories {
      if nameof(cat^) == "Published" {
        publishedItems[i] = "<p>" + string(post^.text) + "</p>";
        i = i + 1}}}};
for j = sizeof(publishedItems) downto 1 {
  ret = ret + publishedItems[j]};
return ret
%>