I've had a tablet PC for about three years running XP tablet edition, and I've used the journal extensively. The multilanguage recognizers are extremely handy for practicing a foreign language--I used it every day through two years of Japanese in college. I wrote a small app to help first year students practice hiragana and katakana using the recognizer to validate individual characters and passages. There weren't enough people with tablets or digitzers at the time, but I should dust it off now that vista ships with ink support built into more (all?) versions.

I love it when software developers criticize UIs created by professional designers. Probably every computer-illiterate person you know would prefer the sorts of screens you linked to. When (normal) people plug hardware into a computer, they're usually ready to face some sort of programmer-design UI that has a whole bunch of widgets and grids that force them to learn new metaphors for interacting with their device. The Zune interface tries to make it *appear* as friendly to put new content on your Zune as it is to play content on the Zune itself.

I've had this argument with lots of different .NET and Java programmers: either you're excited about the new stuff or you dread it, seems to me. I'm not in the dread camp. For example, .NET 2.0 gave me a bunch of new controls and framework extensions that made the apps I was already building much faster, and helped me design my newer apps a lot better. .NET 2.0 added WAY more language-changing features to the CLR than 3.5 has. Anonymous methods, nullable types, and generics provide most of the foundation for LINQ, and have had a significant impact on the way I code, at least. If you take the time to learn them (they are optional, except for the newer framework parts that only use generics), they can make hard things easy, and easy things cleaner, resulting in more comprehensible code.

Marc Clifton wrote:

But extension methods is, I feel, unique to .NET. The quote even says that.

They aren't. See Ruby mixins and the decorator pattern. The implication made by the article author is only that extension methods aren't a standard OO concept.

Marc Clifton wrote:

And frankly, I don't think it's well thought out, for reasons I previously stated.

Now we're just beating a dead horse. You're entitled to your opinion on whether or not EM is well thought out, but you haven't presented any evidence. All we have to go on is the weird "there goes Microsoft again!" tone of your initial post, followed by at least 20 posts explaining in detail that you're wrong.

Marc Clifton wrote:

Put yourself in the position of a teacher, who's introducing extension methods to students. So much of what is taught nowadays seems to be "ooh, isn't this a cool technology that you can do x, y, and z with".

Agreed: if you try teaching every bit of syntactic sugar before your students understand control structures, data structures, and classes, you'll probably confuse the heck out of everybody. After they understand the basics, what's the harm? A great example of how the simple addition of partial classes can help n00bs in .NET 2.0 is the winforms designer: the designer now isolates all of its changes in the

.Designer.cs file. In 1.0 and 1.1, a complicated form quickly became enormous and unwieldy, and accidental modifications could blow up the designer.

Marc Clifton wrote:

No. I'm sorry, but I will question

There was no implication that LINQ couldn't have been done without extensions, you came away with that on your own. He described the problem (needing to extend IEnumerable(Of T) in order to support LINQ, but not wanting the trouble of breaking or replacing it), a solution (extensions), and then three full paragraphs explaining how extensions just provide easier syntax without affecting the compiled output. That's the usual definition of syntactic sugar, my friend.

Extensions are just syntactic sugar covering the actual static method implementation in the IL. Reflection will have no trouble sorting them from the native type's members.

I don't mean to sound like a jerk (which is just a pre-apology for sounding like a jerk ;) ), but they DID say it as clearly as everyone else here did. It looks like you jumped to conclusions looking for the most fishy-sounding quotes, and started attacking a strawman. For example: "This is not a standard object-oriented concept; it is a specific Microsoft® .NET Framework implementation feature. While this feature opens up a new set of possibilities, it's worth noting that the underlying intermediate language (IL) code generated by the compiler is really doing nothing new or specific to the .NET Framework 3.5. In actuality, it is simply making a shared method call. This means you have the capability to use this feature in Visual Basic 2008 to target earlier versions of the .NET Framework. It shouldn't introduce any additional security issues since this feature doesn't change the type being extended and doesn't actually do anything that you couldn't already do with earlier versions of the Framework." That stuff in bold is the text immediately following your "red flag". Pretty much answers all of your concerns. I don't even get the red flag comment though: if you don't trust the implementation of the .NET framework, what are you doing programming with it? Are you also mistrustful of CAS, delegates, enums, and foreach? There is no overriding global standard for implementing garbage-collected, language-neutral, object-oriented frameworks...so it's pretty much ALL ABOUT the "implementation features". Get used to it.

One more detail: I went looking for XMetal specifically because of Authentic performance problems. My team was writing an editor based on another department's existing framework, but the borrowed code was excruciatingly slow with any schema-based XML document over 1/2mb. Their editing control was written in C# as a thin wrapper around the Authentic ActiveX control, so we started looking for drop-in replacements. Just seeing both controls render simple, unstyled XML showed a big enough performance diff to convince our users to fund the per-seat XMetal costs. Just scrolling a 2mb document in Authentic was awful, so we never looked back. YMMV--that was back in '03/04, so maybe Authentic has improved. I think someone already mentioned this: if you want a really interesting browser-based solution to rendering UI from XSD, check out XForms. It will take a lot of additional plumbing before major browsers have native implementations, but there are plenty of plugins that can render them today.

You didn't specify whether you need to generate the UI from an unknown XSD at runtime (rough equiv. of magic), or if your schema is known at design time, so I'll tell you what I know about both. I've built a couple of apps using Altova's Authentic framework, and SoftQuad's XMetal/XMAX control to embed editing features for static XSDs in .NET apps. Both of these frameworks have a client component that you need to install to use the ActiveX control, and both have styling features that range from basic to super-advanced, and both have a really awful-looking basic mode that quickly generates a UI from a static or inferred XSD. Both of these frameworks also have a stand-alone editor with navigation and form-like features, but they are both very document-oriented. I've also built several Infopath projects for simple apps that had static schemas. Infopath is an excellent option to prototype UIs that will eventually be bound to XML documents, fragments, or relational databases, but only if you already have it or you have the budget to buy it. XMetal has a hefty per-seat cost while Authentic is free, but XMetal's ActiveX control and stand-alone editor are much better, IMO. I've used all three on different projects, and the users were generally happy with the results. The dynamic-UI-from-runtime-specified-XSD story is pretty bleak. You're pretty much limited to a few very experimental frameworks (do your own googling for the latest smoke and mirrors), or full-fledged XML/XSD editors like XML Notepad from Microsoft (free, small, simple, stable), or legacy dedicated editor/designers like Spy, Sylus Studio, etc. (most have lots of warts). The few frameworks I've seen that could generate UIs at runtime from user-specified XSDs only supported a subset of the XSD spec and created absolutely heinous UIs--nothing you'd want to throw at a user. Not that full-fledged editors are any better for the user; they're all slanted toward the developer/admin role. I agree with the poster who compared this endeavor to asking "Given the C# spec, does anyone know of an app that can generate progams for me?" Assuming you're trying something sane, like starting with a static schema at design time, the best .NET method I've come up with to create validating UIs is: 1. Use XSD.EXE (comes with visual studio) to generate serializable classes from the parts of the schema that need to be bound to UI controls 2. Manually create UI/user controls and then databind your components to the XSD classes 3. Add exceptions to the property setters in

Misogyny and racism in the same thread. Way to go (presumably white and male) CPers.

Similar functionality has existed for some time on http://local.live.com[^](the Microsoft equiv of google maps) in the form of the scratch pad, which lets you add trails, areas, pushpins, etc., and associate text, photos and custom URLs with them, and then share them alone or in groups for other people to use. Live.com maps have better imagery than google for my city, so I started using live to create maps last year. I've used it to create maps for friends to find bus routes to and from particular locations in terms of how far they would have to walk to and from the relevant bus stops using the trail feature. Knowing outdoor distances in feet is pretty important when it's below freezing outside ;) J

Java IDEs that feel a bit like VS.NET...I've heard very good things about JBuilder, but I've only ever used Eclipse and Netbeans. Netbeans 5[^] is really, really nice: very accessible to the new user, runs on anything, supports CVS and lots of app servers, EJB wizards, nice GUI builder with bindings to everything, TONS of plugins and an active 3rd party dev community (nothing like Eclipse, but very impressive). I've also heard good things about X-Develop[^], esp. from hobbyists who play across mac/windows/linux, but again, haven't used it. Personally, I'm not really sure what you mean about Eclipse "not feeling right", so unless you can be more specific (dude, you can customize _everything_ in Eclipse), you should just hit google and start plowing through the free product demos. What's with the bad signal to noise ratio in the lounge? This question would be much better answered in the programming forums.