Monthly Archives: March 2004

If everybody downloaded Whidbey, would you do the same thing?

I hate to post on something after everybody and his sister has posted about it (mmmmm… groupthink…), but I just wanted to make sure that my corner of the world was, indeed, aware that we’ve released the first of several technical previews of Visual Studio 2005. As someone who works off of daily builds and frequently finds that things suddenly stop working for no reason, let me just say that they are strictly “let’s see what’s new” stuff and not “let’s deploy something real” stuff. Caveat emptor. Mileage may vary. See store for more details…

TechEd 2004

Finally got around to adding the little sidebar flair for TechEd 2004… I won’t be speaking this year, but I will be in attendance! We’re hoping to do a book signing and I’m sure I’ll be hanging around the booth a lot. Hope to see you all there!


OK, so the conversion is done. Everything looks OK, but let me know if something isn’t working right. I added a redirect handler to redirect old links to their new location, so let me know if you’re getting broken links, too.

The one thing that .Text doesn’t seem to have is a RSS feed for recent comments. I can work on adding that back in, but it’ll be a low priority unless anyone screams and says that it’s important. There didn’t seem to be that many people subscribed, so…

Getting out of the biz

Those of you who are trying to leave a comment this weekend may notice that you can’t. This is because I’m making a change around here – I’m getting out of the blog software business. It’s been a fun 9 months of ASP.NET/VB hacking, but truth be told, I’m getting tired of having to debug everything myself. So I’m giving in and switching over to .Text. The first step in this process is going to be making the data read only, so I can do all the transformations I need to. Then the blog will be offline for a little while and then it’ll be back, better than before.

See you soon!

Let me be the first to admit it, then…

Joel talks about the fact that the major modern languages have ignored the fact that data access has become one of the most (if not the most) common jobs that programmers have to tackle. He says:

It’s about time that a language designer admitted that RDBMS access is intrinsic to modern application implementation and supported it in a first-class way syntactically.

So let me be the first to admit it: RDBMS access is intrinsic to modern application implementation. It’s the second part of Joel’s statement – the supporting it part – that’s the hard part, though. Makes me think of the Mark Twain quote, “Everyone complains about the weather, but nobody ever does anything about it.”

I think Erik Meijer and the Xen guys have a lot of interesting ideas, though…

This American Life

Over on Carl’s blog, he waxes enthusiastic about some NPR shows including This American Life and asks, “Anyone else listen to these shows on the weekend?”

I’ll heartily second his endorsement of This American Life. In Seattle, they put it on at 7pm on Fridays, just in time to catch me on my way home. When I first heard it, I thought “what the hell is this weird show?” But then more and more often I would find myself sitting in my car outside of my house with the engine idling, listening to the end of some story or segment. I was hooked, and I highly recommend the show to anyone who’s never heard it before.

The best part about the show is that all the episodes are available on for something like $3 apiece. Now when I’m going on a trip, I just buy 3-4 episodes I haven’t heard, burn them onto CD and I have something to listen to on the plane or in the car.

If you haven’t heard the show before, my suggestion is to buy the “Fiascos” episode from Audible and listen to it. The first segment on the Peter Pan production has got to be about the funniest damn story I’ve ever heard. Or buy “First Day” and listen to the “Squirrel Cop” segment. Or just about any episode with David Sedaris. Really, it’s great…

Some further thoughts about permissiveness…

The discussion so far in the comments section of my entry on permissiveness has been interesting. Some thoughts about the comments so far:

  • I should be clear that my entry was more thinking about how the mission and capabilities of VB could be expanded, not narrowed. A key tenet of VB on .NET has been “full access to the power of the platform,” something that we will not compromise on, especially as Longhorn looms on the horizon. Or, to use the vernacular: there will be no dumbing down of the language.
  • I tend to agree with Eric that creating yet another language, even if it’s just a name, should be avoided if at all possible. Partially, this is my historical bias. For the first third of my career, I had to try and answer the question “Should I use Access or VB?” For the other two thirds of my career, I’ve had to try and answer the question “Should I use VB or C#?” I’m just reluctant to entertain the possibility of adding yet another question: “Should I use VBScript.NET or VB.NET?” Which, I should add, takes nothing away from the essential points of the discussion so far…
  • The more I think about it, one aspect of my question about strictness isn’t really whether it’s “good” or “bad” but whether there are some situations where less strictness is an advantage beyond making it easier for beginners. I think Don Box’s point in the past has been that strict type checking makes dealing with things like XML and web interfaces and data more difficult because they force a certain kind of brittleness onto the relationship. If I add or remove elements from my XML stream or my web interface or my SQL table, consumers will break – even if they don’t actually care about those elements! Could looser typing make programming against loosely structured data easier? Interesting question.

And, finally, I should say that we recognize that our goal to make VB the most accessible programming language on the .NET platform is still not completely realized. The process of consuming and digesting the vastness of the .NET platform has been a difficult, long-term process and one that we’re going to be working on for some time to come. The good news is that we’re going to make some huge strides in Whidbey, both in ways that have been talked about (such as the My hierarchy) and some ways that still haven’t been revealed.

Simpler IDE + more permissive VB language = script magic?

I just wanted to take a moment to acknowledge an interesting series of entries by Mike Schinkel (here and here) that were followed up by a reply by Eric (here) and a further reply by Mike (here). To be honest, my reading attention span can be very short and I find my eyes glazing over when I start to read longer-winded blog entries, but these did catch my attention. (My short attention span is, of course, very ironic given that I can be kind of long-winded myself…)

To grossly oversimplify Mike’s points, he feels that

  1. The Visual Studio IDE is too complex for many users.
  2. The Visual Basic language as it stands now is too difficult for many users.

I have absolutely no argument with point #1. The kitchen-sink approach to VS IDE development has had its upsides, to be sure, but the resulting behemoth is a bit too complex even for my taste. And I’ve gotten this same feedback from others as well. This is definitely something we’re working to address in the future.

Point #2 is a little more interesting. There’s the usual problem with the overwhelming size of the Framework and how to make that digestible, but Mike also raises the question of strictness. He makes the argument (echoed by Don Box and others) that many programmers would do better with a world that’s more typeless and less strict than the one they get on .NET. As someone who lives day to day in a strongly-typed world (so to speak), this seems somewhat counter-intuitive: less typing usually equals less performance and less compile-time checking, leaving problems to be discovered at runtime. In fact, one of the major features of this release, generics, is specifically about making it easier to have *more* type safety and better performance at runtime. So the persistent voices in favor of scripting appear to be swimming against the tide. The question is: are they right?

To be honest, I think the whole question deserves more thought. We purposefully spent a lot of time making sure that things like operator overloading and generics work with late binding in Whidbey, so it’s not like we’re closing down that avenue of possibility. But, hmmmm…. Dunno. I’m just going to have to think about it some more.

(“Top minds are working on it“? Does that mean I also get to take a look at the Ark of the Covenant too?)

Events and race conditions

JayBaz points out something that is worth keeping in mind about events: they can be subject to race conditions in multi-threaded scenarios. In VS 2002 and VS 2003, you’ll need to do what the C# folks do and handle the race condition yourself:

Event Moved(ByVal x As Integer, ByVal y As Integer)

Sub Move(ByVal x As Integer, ByVal y As Integer)
Dim temp As MovedEventHandler = Me.MovedEvent

If Not temp Is Nothing Then
temp(x, y)
End If
End Sub

(The names “xEventHandler” and “xEvent” are automagically generated names – the first is the delegate type of the event and the second is the hidden field generated to hold the event delegate.)

In Whidbey, however, we’ve changed the code generation for RaiseEvent so that this will be done automatically for you. We work hard so you don’t have to!

My God, they’re right!

Someone – I forget who – told me that “once you get a copy of your book, it never fails that the first page that you open it to is going to have a glaring error on it, so be prepared.” I thought, “yeah, right.”

So I just opened the book for maybe the second or third time to look something up, and sure enough – right there on the page was a massive, glaring, obvious, how-could-I-and-all-the-other-reviewers-miss-it error.

Ug. I need an aspirin.