I was at a seminar yesterday with other attendees from various companies. Of course, introducing myself as a Microsoft employee, and compounded by the fact that the two instructors had worked with Microsoft in consulting capacities, I was automatically approached as an individual representative of the whole company. In this way, any reference that was made to Microsoft was addressed to me as if it was something personal. One of the instructors at one point asked my permission to tell a story about Microsoft that had nothing to do with me.

With this kind of response, which is just as true today as it was twenty years ago, I wondered if the same thing would happen if I was an employee of, say, Boeing. That is, would people expect me to be answerable or responsible for their experiences with a 737 in the same way they do about their experiences with a Windows PC? It didn't seem like it.

What I realized is that people approach Microsoft employees more personally because their own relationship to Microsoft is essentially a personal one--personal, daily, and often for-much-of-the-day interaction with a Windows computer of some kind. Their interaction with most other things, like a Boeing 737, is much more sporadic and much less personal (the airline owns and operates the airplane). And so the tendency is to then project that intimacy with one's computer--more speciifcally, the software--to a personal representative of the company that makes it.

It's also that 90% of computer users are on Windows, so any group that contains professionals--which are the kinds of people you meet in such seminars contains probably 90% Microsoft customers. And those who aren't probably have a strong opinion as to why, because of their intimate relationship with another computer system.

I have a hard time thinking of any other technological relationship that gets projected in this way. With automobiles, there is much more of a mixture--many manufacturers, many different models, so a representative from, say, Chevrolet, wouldn't have the same experience unless they were specifically attending a meeting of Chevrolet owners.

Personally, I'm not bothered by how people respond to learning that I'm employed by Microsoft. I'm not in the least way shamed by the relationship and, in fact, deeply honor it. Indeed, when I attend such seminars and hear some of what people experience in other workplaces, I'm increasingly grateful for the fabulous environment in which I'm blessed to spend my professional hours.

It's great to be working within a department at Microsoft that is not only building some great technology, but also expanding! The Data & Modeling Group of which I'm part, and which owns technologies like the ADO.NET Entity Framework, WCF (ADO.NET) Data Services and the Open Data Protocol (OData), and other new stuff including the SQL Server Modeling technologies that I've written about on this blog (the "M" language, "Quadrant", and SQL Server Modeling Services).

There are opportunities within software development, testing, program management in most of these teams (around 30 open positions); we're looking for both individual contributors as well as team leads. These openings are listed on Microsoft's career portal, and the following search URI will give you the list (plus a few others in the larger Server & Tools Division--this is as close as I could get in the search):

https://careers.microsoft.com/Search.aspx#&&p4=all&p0=DMG+Quadrant+Modeling+DIT+%22Data+Tools%22&p5=2134&p1=1%2c17%2c3%2c19%2c15%2c20&p2=all&p3=1014

Oh, and if you apply for one of these positions, I appreciate being listed as a referral (you know--our management is giving out prizes for this sort of thing!).

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.

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!)

After publishing Mystic Microsoft in 2007 I gave a couple of interviews that are available online.

7/15/2007: Appeared as a guest on Pathways, a show on the public radio station KBOO in Portland, OR. Available as audio.

11/26/2008: Appeared on Present! with Mel van Dusen on KMTV in Mountain View, CA. Video on YouTube.

Written June 30^th, 2009

This is meant to be an insert within a forthcoming "What Exactly Does One Do With 'Oslo'?" article; originally it was part of that piece but tended to make the whole thing somewhat lengthy!

Some of you may remember the work I did in my "version 1.0" career at Microsoft, which spanned the years between 1990 and 1996. During most of that time I worked as a software engineer in the Developer Relations Group (which eventually turned into Developer & Platform Evangelism) with the purpose of helping developers outside of Microsoft understand and apply our technologies. In this capacity I ended up as the industry expert on the OLE and COM technologies. This put me on stage at many developer conferences and saw the publication of Inside OLE 2 (1993) and Inside OLE 2^nd Edition (1995).

At that time, the focus was pretty much on desktop applications; client-server applications were really just starting to hit the mainstream, including web applications. And that was the very point at which I retired from the high-tech scene altogether. (For the complete story of my first career, which many people tell me isn't actually boring at all, see my book, Mystic Microsoft.)

Thus I completely missed out on the evolution of Microsoft's component technologies beyond the desktop. While people like my friend Don Box were circling the globe talking about DCOM, .NET, and all kinds of new middle-tier and enterprise-level stuff like Microsoft Transaction Server, App Server, BizTalk Server, and what have you, I was off doing completely different things (see www.kraigbrockschmidt.com). To what extent I fiddled with technology, it was pretty much still limited to client apps, managing a few Access databases, and putting together some simple websites. What I learned of .NET was pretty slim, just enough to be mildly confused.

Ironically, the chap who was my direct manager when I wrote this, the very visible Chris Sells, got started in all this shortly before my exit. Having started his path with COM at one of my presentations, he eventually worked with Don Box at DevelopMentor where he earned his living, as he puts it, "telling people how to minimize round-trips in DCOM." Since then he's been pretty deeply immersed in the heart of efforts like Microsoft code name "Oslo."

More...

A Short Introductory Guide to the Microsoft code name “M” Modeling Language (Part 2 of 2) [Complete article available in Word Format (196K) for nice printing]

Compiling "M"

Of course, having a bunch of "M" code sitting around is well and good, but to make all those types, extents, and functions useful they must be turned into actual database constructs.

This basically means compiling the "M" code and generating output that can be used to populate a database. For this there are two options:

• Compile "M" from the command-line using the m.exe tool (generally found within Program Files\Microsoft Oslo\1.0\bin)
• Compile "M" from within Visual Studio using the "MCompile" element in a project file. (This option is installed automatically with the "Oslo" SDK. This option instructs MSBuild.exe to invoke m.exe automatically.

Note: it is also possible to dynamically parse and compile "M" programmatically, but that's beyond the scope of this article.

The "M" compiler, as shown in the diagram below, simply parses the "M" and generates some kind of output that can be used to create a database. Typically this is an "M" image (or MX) file that can then be fed to the image loading utility, mx.exe, for deployment into a database. (At which point it becomes accessible to applications or runtimes that make use of that database. Note that "Repository" is shown in this diagram but can be any SQL Server 2008 database.)

Alternately, you can use the "M" compiler to generate SQL statements that can then be deployed using the sqlcmd.exe command-line tool. Let’s look at these different compilation methods in turn. We’ll come back to the matter of installation/deployment later.

More...

A Short Introductory Guide to the Microsoft code name "M" Modeling Language (Part 1 of 2)  [Complete article available in Word Format (196K) for nice printing]

Note: the contents of this series of articles originated from a PowerPoint presentation from Chris Sells that we used to ship with the code name "Oslo" Community Technology Preview (CTP). Since a slide deck isn't the most accessible format for publication, I converted its contents into a more textual form here.

Hello "M": Types, Extents, and Functions

"M" is the code name for Microsoft's new modeling language. It came about because the team developing Microsoft's set of modeling tools (code name "Oslo") realized a certain class of developers—mostly those who are accustomed to writing source code in text—would want to have a means of modeling data and application behavior that didn't force them to use visual tools. And, of course, that other means is itself text.

"M" was thus born as a human-friendly textual language to augment or complement graphical tools as well as machine representations. It's meant to have direct correlations to T-SQL and, as we will see, the code name "Intellipad" tool gives you the ability to view T-SQL equivalent output for "M" statements. "M" is also intended to be a modern type system that enables compile-time verification and validation while not imposing any particular data storage or access technology. For complete details, see the "M" Overview (MSDN Library), "Oslo": The Language (video from PDC'08), and the "M" Language Specification (MSDN Library). Here we'll just dive right into the basics of the language.

Everything in "M" begins with a module statement like this:

module
    {
    }

A module in "M" can then contain four different constructs:

• Types specify constraints over sets of values
• Extents specify storage locations
• Functions specify parameterized queries (these were formerly known as "computed values")
• Languages define the tokens and syntax rules for domain-specific languages

In this article we'll be covering the first three. For more information about defining domain-specific languages in "M", see the "M" Language Specification (MSDN Library), DSL Tutorials (MSDN Library), and the video Modeling in Text (in five parts).

More...

It's been a long time coming for me to finally get a blog going. That I've done it was pretty much motivated by the need to post materials related to my work at Microsoft, which will likely form the bulk of the first entries. But I'll also be using this space for non-Microsoft stuff too, things that aren't lengthy or polished enough to warrant being an article on my main website.

I've actually hesitated for a long time to create a blog because of the whole commenting business. Yes, I know this is a big part of the democratic information/web 2.0/social bit, but fact of the matter is that most comments on blog posts leave much to be desired where thoughfulness is concerned (and sometimes prove that the commenter didn't actually read the post). The last thing I really want when I post a carefully thought-out article is to have oft-random comments and rants carelessly negate the points I'm trying to communicate. In other words, I believe that an article should carry more weight than the comments, and that an article should be presented in its own context without the distraction of comments.

This way, the main part of kraigbrockschmidt.com is a resource for people who are interested in what I, individually, am sharing with them. Thus anything produced in that spirit will continue to go on that part of the site. I'll make a reference to that piece on this blog and invite comments here; that way, there is still a space for discussion that won't othewise interfere with the presentation of the work itself.

Most of my Microsoft-related stuff, on the other had, will go directly here because obtaining feedback is one of the primary reasons for writing such pieces in the first place. (A curious side-note is that at Microsoft I'm part of a group that's focused on 'modeling' where software engineering is concerned, while 'modeling' has another place in my life in terms of model rockets and trains, thanks to my almost three-year-old son.)

In any case, this blog is up and running now using BlogEngine.NET, which is an easy system to work with on an ASP.NET-oriented website.

For more about my intentions for the blog (any the name I chose for it), see the About "Luminarity" page.