I'm happy to see that Steven Sinofsky has started up the Building Windows 8 blog, http://blogs.msdn.com/b/b8/, that will be exploring many aspects of the product I've been working on since Oct 2010 but haven't been able to say anything about! Hopefully I'll be able to start blogging on developer-related subjects here soon. In the meantime, I'll be seeing you at the //Build conference in Anaheim in a couple of weeks.

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   

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.