The teams at Microsoft working on the ADO.NET Entity Framework and WCF (ADO.NET) Data Services are wrapping up work for .NET Framework 4, and are ready to kick off the next round of features. This is really part of their open design processes, and they're right looking for your input on new features.

Here's where you want to go:

http://blogs.msdn.com/adonet/archive/2010/02/10/vote-for-future-entity-framework-and-data-services-features.aspx 

Data Services Page: https://connect.microsoft.com/dataplatform/content/content.aspx?ContentID=15540 
Entity Framework Page: https://connect.microsoft.com/dataplatform/content/content.aspx?ContentID=15541   

Leading up to Microsoft’s Professional Developer Conference last November and the release of another “Oslo” CTP, now called the SQL Server Modeling CTP, I had the pleasure of working with the “Quadrant” Program Management team on the series of “Quadrant” videos on the MSDN Data Developer Center.

One of those videos particularly impressed me, and even got me really jazzed about the product itself (a rare event as my friends know that I’m generally not that excitable). This is the “Quadrant” UI Overview, a four-minute demo recorded by “Quadrant’s” UI designer, Stephen Danton that really shows the essential gestures for working within the program’s unique paradigm.

What’s particularly impressive is watching Stephen’s fluidity with these gestures, something he’s of course practiced in the course of working on the product. Those gestures, as you can see in the video, are very simple in themselves, yet mastering those actions will really help one to master whatever database you’re viewing in “Quadrant.” For what “Quadrant” offers is a way to efficiently move in and out of a database across whatever levels of detail you want to see. Ctrl+mouse wheel zooms in and out to any degree. A simple Ctrl+double click on the infinite canvas (workspace), or pressing F12, zooms out to see everything; a Ctrl+click (or F10) on a workpad then quickly zooms into that area. Doug Purdy, in the talk that he and Chris Sells gave at PDC, likens this to the map zooming functions of adventure games. “World of Warcraft for data” is how he uniquely describes “Quadrant”.

Another simple feature is the ability in “Quadrant” to float workpads up above the zoom-and-pan workspace, essentially up into another layer in the third dimension. This gives you a hub from which you can quickly set up islands of certain entities one some other part of the canvas. This is especially powerful when the canvas is zoomed out, as Stephen demonstrates.

The easy and fluidity that these features and gestures provide open up many possibilities. The effortless browsing of relational tables that Stephen shows about three minutes would probably take more like 30 drudging minutes in a typical database tool like SQL Server Management Studio (SSMS). Navigating even through simple datasets in SSMS might involve writing some complex queries, and your views are always somewhat limited (database diagrams, for example, are meant to those relations between tables and allow little customization). But in “Quadrant”, with a few mouse clicks, you can explore as much of the database as you want, organized however you want, and then also edit the database in a far more natural, fluid, and time-efficient manner.

So if you haven’t checked out “Quadrant,” I honestly encourage you to download the latest SQL Server Modeling CTP and give it a try, especially after watching Stephen’s video.

And as a final note, I want to point out a feature of the video to which Mother Necessity gave birth. After Stephen had recorded this video, I suggested that he more explicitly describe the gestures he was using, so it could serve as a training video for the kind of fluidity he demonstrates. However, Stephen went away on vacation shortly before PDC and didn’t have time to make another recording. So Sidney Higa, who was doing the post-production (he’s our technical writer for the “Quadrant” documentation in the MSDN Library), added the little visuals in the video that specifically call out gestures. While these add a little bit of text to read while you listen to Stephen’s narration, to me it seems just the right amount to actually increase my level of engagement with the video, rather than being a distraction. I hope we can employ the same technique in future videos for the Data Developer Center.

Available on my main website: New Year's is Good Timing for New Year's Resolutions!

Comments are welcome here.

I know it's been a while (almost three months now) since I wrote anything about the Microsoft technologies I work with, and haven't reported anything more on the ModelCalc project that I started on last summer. Priorities do change, and throughout most of the fall I was very much focused on merging two MSDN Developer Centers, specifically Data and "Oslo" (now SQL Server Modeling). Both of these live on www.msdn.com/data, and I wrote a post on the Data team blog to tell that story. A big piece I wrote as part of this effort is Data Development Technologies: Past, Present, and Future, a piece that's been very well received (e.g. by Douglas Purdy, for whom I'm now working). I very much encourage anyone working with data development to give that one a read.

That merger was also timed with the Microsoft Professional Developer's Conference in Los Angeles in late November, which was the first conference I've attended in quite a few years. What worked great about the timing of the conference was that we immediately went into the holiday season after that, which was for me mostly a time to catch up with everything I'd been neglecting while focused on the other tasks, and to clean out all kinds of old data, emails, etc., to get a fresher start here in 2010. (I also spent some time figuring out how to combat comment spam on my blog here.)

That said, as my reality rapidly expanded last fall to include various data development technologies like ADO.NET, Entity Framework, and WCF Data Services, I've been focusing lately on projects to get myself up to speed on those goodies. In particular, I'm working up some samples around my personal reading history. I've been keeping this data first in a Word document and then in an Excel spreadsheet since I got out of college in 1990. The list of unique titles (that I've actually) is up now to 497, which is a nice set of data to work with. Eventually that whole set will be accessible through my personal website through WCF Data Services; before then I'll have some portions of the data out with the schema as part of other samples. In fact, the first piece I'm working on has to do with different ways to define and deploy database schema, as I've been working through the different options that Microsoft has to offer.

Any thoughts on such projects are welcome here in the comments, of course. (And I look at the comments before approving them, since most of them are garbage. But I do look and approve the real ones!)

Cases of terminal childhood diseases often awaken our pity, and even dismay at the apparently unfairness of the universe. But in some cases, at least, there is the possibility of real purpose behind what otherwise appears to be a life cut short, a purpose to awaken in us not mere pity, but a deeper compassion and understanding.

This article explores that possibility more deeply. I'd originaly written it in November but neglected to announce it; at least it gave me the chance to make a few edits just now.

Comments are welcome here.

In moving my printer the other day I remembered that the box it was sitting contained about 40 spare copies of my book, Mystic Microsoft!

So I thought I'd offer these to readers of this blog as holiday gifts, completely free (I'll even pay the shipping). In other words, drop me your name and address to kraig (at) kraigbrockschmidt.com along with how many copies you'd like, and I'll send them to you. No strings attached. I'll even sign them! 

I would only request, without obligation of course, that you too enter into the spirit of generosity during the holidays, by giving of your time and/or money to any cause that inspires you.

Update 12/1/09: A good dozen books went out in the last week, but I still have more. Requests are still welcome.

Update 12/15/09: Still 15 copies left, with others heading out to various parts of the world.

Update 1/1/10: Still a few copies remain, so inquiries still welcome. Thanks to all those who've written their appreciation for the gift and haev also paid it forward.

“Modeling” in Code

(Continued from Part 1) Now there are four very important facets of the code structure that have to do with modeling.

(1) First is the inherent disconnect in how these buttons are classified: there are four appearance classifications but only two behavioral classifications, the latter being implicit in the assignment of the Click event hander assignment, which is why I call it an “informal” classification. To tighten up these relationships, we should really have event handlers for each conceptual button type: digit, memory, operator, and function. At the same time, we don’t want to combine the visual and behavioral classifications: each button should have a visual classification that only affects appearance (for the purpose of visual design) and a behavior classification that only affects function (irrespective of a button’s color, for instance).

(2) Second, the OnWindowKeyDown event handler expresses all the keyboard mappings in code such that they cannot be changed unless program is recompiled. To support a class of applications in a runtime, this has to be converted to a data-driven implementation that can accommodate arbitrary mappings.

(3) Third, the two sets of variables clearly separate those that are external—that is, those that have meaning to a user of a calculator—and those that are strictly internal implementation details. I did this intentionally when rewriting the code because the conceptual behavior of any button can be expressed in terms of these few external variables (Accumulator, Stack, Op, Mem, and AllowRepeatEquals). The internal/state variables, on the other hand, are necessary to create the behavior of specific kinds of buttons, such as digits, operators, or =.

I reworking this code, it took considerable tweaking to get a few behaviors working correctly, such as the repeat = key, overwriting the display value at the appropriate times, and suppressing an operation when an operator key was pressed. The problem was that the original code sample overloads the semantics of its EraseDisplay variable with all of these behavioral implications. It’s used not only in the same capacity as our new OverwriteAccumulator, which has a similar meaning obviously, but is also used to decide whether to suppress computation when an operator key is pressed. It’s also used to ignore a repeated = keypress. As a result, it really complicated my effort to clone the repeat = behavior of the Windows Vista Calculator.

More...

As described in the earlier outline for my modeling project (and yes, I know I've been slow getting new posts up), the first step in creating a model-driven runtime for calculator applications is to have a working single-calculator program upon which to base the work—something, that is, that can be turned into a generic, configurable runtime. The primary benefit here is that we’ll then be able to see the incremental stages of development of the process that will, I imagine, shed some light on the general nature of runtimes as compared to specific applications.

It also affords the opportunity to explore “modeling” itself in its different expressions. Fact of the matter is that all software engages in modeling processes: the purpose of software is to essentially configure a universal machine (the computer) to behave in ways that reflect various tasks and processes (whether human or automated). To give a simple example, a spreadsheet models forms and processes that originally existed on paper; the software was modeled after some real artifact. Indeed, when I wrote the Windows 3.0/3.1/NT/95/98/2000/XP/Vista Calculator program, I directly modeled it after the $9.95 “Dynatone” job I’d bought at K-Mart when I was in high school. That is, I made the program behave pretty much like the physical device.

In this two-part article, then, we’ll discuss how the conceptual “models” of appearance and behavior typically manifest themselves in a combination of code plus data, which in our case means and C# and XAML. As you may already realize from your own work, appearance and behavior end up being spread around throughout an application’s code, mostly because writing a single application simply doesn’t require a cleaner separation. Granted, facilities like XAML and “code-behind” have gone a long way to at least separate appearance and behavior, which is fabulous for collaboration between designers and programmers. Yet still, the behavioral “models” in a typical application are not only spread around within the code itself, but is also expressed to some degree in the very structure of that code.

More...

Call it "New Blogger's Dilemma." Many people start a blog with high hopes, yet get stuck early on because of how prominent these first posts will be in the overall mix. I've been facing this with my own here--though I have much to write about that's not related to my work at Microsoft, the question is, where to begin? What subject shall I choose? Spirituality? Politics? Science? The Arts? What do I want to stand out in my tag cloud in the early stages of this blog? It's been a hard choice, but eventually one must choose or perish, blogwise.

So I've finally chosen to start with the subject of children. With a toddler in my life (Liam is almost three), children have been a significant part of my reality in recent years. He's also a primary reason why, as I noted in my "returning to Microsoft" piece, that I'm back at Microsoft in the first place. Recently, too, some friends of mine forwarded a link to Tim Kreider's The Referendum (NY Times blogs) whose ponderances on the fates of the childless (with "an obscene amount of free time") and the child-laden (whose "next thousand Saturdays are already booked") provides much mental fodder.

In recalling my thinking on the subject from some years ago, what might have been a short blog post turned into a longer article, which is posted on my main site. The basic thesis is that the question of which life path is more valid (which is more or less what Kreidler is asking) is not about having children or not having children, but about living either path on auto-pilot versus living either path consciously. Conscious living--making clear, conscious choices based on realities larger than ego-gratification--is really the solution to the perpetual doubt of living on auto-pilot.  

Launching a Learning Project

As Microsoft's program manager in charge of the "Oslo" Developer Center on MSDN (http://msdn.microsoft.com/oslo), you'd naturally have every reason to expect that I wholly "get" what all this "Oslo" stuff is about. After all, I acquire, publish, and manage the DevCenter content that's intended to tell the "Oslo" story.

I must confess that this is actually not the case, at least not yet. Frankly, I still ask myself—quite often, in fact—just what's it's all for and what, in fact, someone really does with it--with the whole of it. Like many people, I can see how certain pieces like the "M" toolchain are useful in and of themselves (writing nifty languages and such), but when you start talking CLR and UML domains or "middle-tier" applications, I'll listen politely while trying to pretend my eyes aren't going glassy.

To my credit, this state of affairs is actually by design, which gives me a perfect opportunity to bore you with the backstory of how, after a hiatus of around 12 years, I found myself back at Microsoft and eventually working on "Oslo." People are going to ask about this anyway, so…well, OK, originally I wrote that whole section right here, conveniently forcing you to indulge my penchant for storytelling. But charity won out in the end and I moved it into its own piece.

So like I was saying, this present state of affairs is intentional. Since the beginning of February, when I officially began this role and could at least differentiate between Microsoft code name "Oslo" and a city in Norway, much of my time has been consumed in just getting my bearings on the project while keeping the DevCenter reasonably fresh. Combined with the demands of the "Oslo" May CTP and my wife's recovery from abdominal surgery, it was only in late summer that I was able to delve into a serious learning project of my own.

My hope is that this effort will lift me out of the slums of ignorance, so to speak, and in the process lay a path for other developers (and mind you, this particular post is just a start, not the complete story). For as much as being embedded in a team that eats middle-tier for breakfast (and effortlessly speaks of app servers, repositories, and domain-specific languages with every breath) makes me at times feel quite alone, it's certain that I'm not. Many developers are surely wanting to slake their thirst for understanding, even while they skillfully feign competence. (But that's OK. We're friends and I promise I won't rat on you.)

More...