robjsoftware.org

Hello everyone. Ah me. We live in Washington now! (State, that is.) We’re happily ensconced in a nice rental home in Kirkland, and so far just about everything we hoped for from the move has happened — we have less commute, cooler weather, a better school for our daughter, and my wife no longer has to work. And my new job at Microsoft is going very well so far, though I’ve actually been there less than a month — I took May off to help our family settle in, and THANK GOODNESS, because moving is a LOT OF WORK even once you actually arrive!

But so far so good up here… I’m sitting in our living room looking out at the evening sky and the pine trees across the street, through the full-length windows and French door that front our house. It’s beautiful up here.

I can’t say too much in detail about what I’m working on, because Microsoft (like Google) is mighty touchy about confidential projects. But I can make some general observations after being back on the inside of the Borg for a few weeks. (I was amused to discover that they remembered me! I interned at Microsoft in 1988 and 1989, and I guess they gave me employee number 40775, because when I signed back up they gave me the same number back again. People were like, why are you 40775 rather than 263484? Microsoft’s gotten BIG over the years….)

It’s very curious how deep the not-invented-here goes at Microsoft. It seems to be partly historical — Microsoft was such a winner-take-all company for all of the eighties and nineties, it sank deep into the marrow of the company. And it is partly reactionary — the rest of the industry reacted so negatively to that aggressive attitude (antitrust suits, pitched legal battles with Apple and Sun, etc.) that it drove Microsoft even further into its own corner. I’ve got kids now, and I think a fair bit about sibling rivalry, and how kids (and adults, and nations) tend to define themselves in opposition to one another… sometimes your identity emerges through your interactions with your peers. That’s definitely happened to Microsoft, and as a more than thirty-year-old company, it’s going to change only slowly if at all.

Regardless, Microsoft really is its own technological world now. And this has its good points and bad points. Coming from the Java world, and from California where lots of my friends are vehemently anti-Microsoft, it’s a bit bemusing to see it all with an outsider’s eyes… plenty of my new colleagues have been here for decades, which is almost unimaginable to me. It’s certainly part of my value here, that I’ve got recent experience with how things are on the Outside.

I can’t be too specific, but there are quite a few areas where I feel like Microsoft’s internal technical isolation is hindering them… particular tools that seem like a step backwards, or particular design problems where it seems like there just aren’t quite enough people providing fresh ideas. The relative isolation of the Microsoft software stack can seem a bit… I don’t know… lonely? The “us vs. them” thinking is hard to escape in the blogosphere, and it’s such a polar choice — either you’re on Windows / .NET, or you’re not. And if you are, you’ve got to pay to play — at my last startup, we were a Linux and Java shop, partly because it got the job done and partly because it was free. (Though as one of my new cronies says, the people who won’t pay aren’t customers anyway, because how can you make a business out of non-paying customers? That’s a very deep-seated belief in Microsoft-land, and you know, there’s some truth to it.)

But on the flip side, there are some real advantages to owning all the code you could possibly need to run an entire industry of PCs. I’ve spent the last two months spinning up on LINQ, one of the coolest new features in C# 3.0. It stands for Language Integrated Query, and on the face of it it seems like syntactic sugar to let you write SQL-like code in C#. But it turns out that under the hood there’s a lot more to it — it’s implemented via compiling language statements into expression data structures, that can then be rewritten, reparsed, and used to generate entirely different kinds of language output. It is very cool technology, very useful for creating domain-specific languages — in fact, it’s rather along the lines of my extensible language rant from a few months ago.

And it would not have been possible if Microsoft didn’t completely own the C# and Visual Basic languages, and have the resources to come out with a new iteration of the language spec, and all the compilers and tools to support it, simply because they thought it was a good idea. Compared to the slowness of Java’s evolution (how long has the closure spec been rattling around?), Microsoft’s ownership is yielding real benefits to .NET programmers. (OK, so the closure spec is deeper and wider-reaching than C#’s lambda expressions, but nonetheless there are several intersecting features in C# 3.0 that are all needed to make LINQ work, and I don’t see Java catching up very quickly.)

It’s also pretty amazing to see the breadth of the expertise here — my team happens to be pretty closely connected to Microsoft Research, which is teeming with world-class experts. If you look at the roster (Simon Peyton Jones, Don Syme, Erik Meijer, Galen Hunt, Nick Benton, Martin Abadi, Luca Cardelli… heck, search ‘em yourself!), you’ll see a whole lot of people who’ve driven the world of software forwards. Microsoft has a deep commitment to that goal, even if their not-invented-here, no-open-source mentality gets in the way sometimes. So it’s exhilarating to be part of that mission.

Microsoft is a colossal company, and I’m fortunate that I’ve landed in a very ambitious and solidly supported team — in fact, I can’t think of any job I’d rather have in the industry. I’m feeling very lucky indeed, and I’m doing my best to get productive quickly — this opportunity isn’t going to come along again anytime soon!

And, that said, I’m obviously not doing very well on keeping to my blog schedule. Realistically this blog is going to slow down a bit, probably to more like once per month. Eventually — once our team’s incubation project goes public (knock on wood!) — I’ll hopefully have another blog on msdn.com where I’ll blog semi-officially about our technology. But this blog will be my personal property into the indefinite future. Stay tuned!

Well, this post has been a long time in coming. Finally all the stars have aligned, and I can announce to the world (i.e. you!) that I have accepted a job at Microsoft. My family and I are moving up there in just a few more weeks — we sold our house (in one week flat! amazing what price reductions can do), and are in escrow. Which also explains the loooong delay since last post.

What exactly will I be doing? I’ll be working for a technical strategy incubation team, which kind of sits in between research and line development. We’re working on a new operating system stack from boot loader all the way to applications. I can’t really say much more, except that what we’re doing is not entirely unrelated to the Singularity operating system.

Having spent the last twenty years in the bay area, hotbed of anti-Microsoft sentiment, I am pretty sure that I have quite a few readers (and friends!) who will be wondering why exactly I’m joining the Evil Empire. Especially when I interviewed with quite a few other places, including Amazon and Google. What’s up with that?

There are a few answers to that question:

• I don’t like how Microsoft has abused their monopoly power, but I also have been a Windows user for the last sixteen years, with quite reasonable satisfaction. So I personally have never quite swallowed the “Microsoft is Satan” kool-aid.
• The more blogs I read by Microsofties (especially the anonymous ones), the more I see that Microsoft’s internal self-assessment is by no means all rosy. Microsoft engineers seem quite aware of when their stuff sucks. The existence of the team I’m joining is arguably proof of that exact fact.
• It’s possible that working for Microsoft will circumscribe what I can blog about without making lawyers mad. However, that’s just as true of Google, which is also notoriously secretive. Google also has had quite a few criticisms directed at its business practices. Basically, size, confidentiality, and ethical qualms seem unavoidably linked. (It’s true that Google does more open source stuff than Microsoft, but that may be changing as well.)
• If our stuff is great and makes it into Microsoft products, it could potentially make life better for a whole lot of people. Operating system work at Microsoft can have a broad impact in a short time, if it’s successful.

I’ll also be working with some old friends from my Xanadu days, along with some relatively well-known other folks, including Pavel Curtis and Chris Brumme. I got to meet a good cross-section of the team and I’m very jazzed. My research paper addiction paid off handsomely, it turns out!

I spent the entire last week of February interviewing. I did get offers from other places, each of which I greatly appreciated.

I got a great offer from the Prime team at Amazon, also, which seems like an extremely sharp group; I will definitely be keeping a close eye on Amazon as they grow their distributed infrastructure business.

I also interviewed with a startup, which I expect to do very well (keep an eye on Apptio — though they’ll be rebranding themselves soon!). If I hadn’t spent the last ten years in startups, none of which has (yet) had life-changing success, I would have probably jumped on them just for the raw upside potential; as it is, though, I’m ready to try a megacorp.

(To my Google friends: Google was very interested but ultimately turned me down. Might have partly been timing issues on my end. So, looks like it’ll be a while (at least) before I’m working with you all. I’ll also need to pull back from the GWT project. It’s been a great few years in Java-land but it’s time for a change, and I’m looking forward to C# generics

All in all it was a very difficult choice across the board!

In general the whole week was the most fun I’ve ever had interviewing, despite the fact that I had a big bandage on my head for most of the week (beware of low pine branches after dark!!!). I sincerely thank everyone who took time to meet with me in person or by phone over the last few months.

Now to start walking the fine line between saying too little and too much. I don’t plan to go dark on this blog, though I also won’t (yet) be able to say much about my day job here. But that won’t stop me from the general research paper talk to which you’re already accustomed!

Late. Again. I assure you there are perfectly good reasons for this that, I further assure you, you do not want to know. Good news is things have radically improved in the last few days and the future is extremely bright. I’m squinting right now, in fact.

There are some architectural patterns that just Feel Right. That feeling of rightness isn’t always reliable — it can lead you pretty badly astray — but still, it’s there. And sometimes, what do you know, it even is right.

For years now I’ve been following research into microkernels, starting back in the early nineties when I was reading about Amoeba, an old-school distributed system structured as a set of small components. The idea of structuring an operating system as a set of isolated pieces, protected from each other and passing data only by well-defined messages, seems conceptually clean. It’s started to gain traction lately with projects such as the L4 kernel, the Coyotos project, and Microsoft’s Singularity, and IBM’s K32.

Interestingly, one of the biggest obstacles to the wider use of microkernels is Linus Torvalds. In late 2006 he had an online spat with Alex Tanenbaum, developer of Amoeba (back in the day) and Minix3 (new hotness). Linus has been saying for years that microkernels are a crock, and that operating systems are best built with extensive use of shared memory, because — in his view — what operating systems do is provide coherent views of shared state to multiple processes, and without a single shared state available to the whole kernel, providing a coherent view becomes much, much harder. Linus draws a parallel between microkernels and distributed systems, pointing out that distributed protocols are really hard to implement, precisely because you don’t have common state.

Personally, I agree strongly with Tanenbaum’s (and Shapiro’s) rebuttals. Tanenbaum points out that distributed protocols also have to deal with partial failure and reordering, which are not problems that microkernels have. Inter-component communication within a single machine’s operating system can be radically simpler than communication over a network (even though multicore machines do start introducing some timing variability). Also, of course, shared state in a monolithic kernel still requires concurrency management, and the complexity of managing concurrent access to shared kernel state is by far the biggest single source of Linux kernel bugs. Just look at all the work on massaging the locking patterns in the Linux kernel (getting rid of the Big Kernel Lock, etc., etc.). For Linus to claim that micro-component kernel development is more complex than monolithic concurrent state management is… well… not as obvious as he seems to think.

Shapiro points out that all robust engineering practice has shown that high reliability requires high isolation between small, robust components. He claims, and I agree, that there are no large-scale highly reliable systems that are not built from small, modular, isolated pieces. Certainly Erlang provides another data point that high reliability comes from many small interacting components, rather than from large-scale shared state.

Small, modular components get you other benefits, such as upgradeability (if your microkernel tracks references between components and manages inter-component message passing, you can upgrade individual pieces of your system without shutting things down — Erlang applications also work this way). Security is also enhanced if the compromise of a single component doesn’t expose the entire state of your kernel.

There are also interesting parallels between building single-machine operating systems as sets of modular services, and building large-scale Internet systems as sets of modular services. In both cases, you want to build something big and reliable from individual pieces that communicate over explicit interfaces, and that can be individually quickly restarted when they fail. In an operating system, your drivers are the flakiest piece, and when they die you want to be able to reload them without the rest of the system batting an eye. In an Internet service, your individual servers are the flakiest piece, and when they die you want to be able to fail over to other (mostly identical) servers without batting an eye. Isolation between components is critical in both cases, and you want to build your whole system in a layered way with redundancy and restartability at all levels.

Linus is correct that distributed transactions (for example) are hard to build out of individual components. But it’s also true that as you scale, distributed transactions are one of the biggest architectural system-breakers. Amazon, for instance, doesn’t use them (see also here), instead relying on careful ordering of service updates to preserve consistency in the face of intermediate failures. And many microkernel operating systems are also structured to avoid multi-component consistency interactions wherever possible.

So I think this is a rare example of where Linus is squarely on the wrong side of history, and where Linux will likely fall behind other systems that push towards greater modularity and greater internal componentization. It’s an interesting question whether large-scale Internet services will, over time, make individual-server operating systems less important — in other words, whether most applications will migrate to a highly-managed cloud, in which case most computers will wind up being more like thin clients, with all the action happening on a virtualized pool of services. But even in that case, the companies building those services will still want to leverage multi-core technology to the max, which essentially means building their individual service instances using highly isolated component architectures. Having such an architecture at the base of the operating system can only help achieve that goal, and it’s sad to think that Linus (on current evidence) will get in the way of that for Linux.

Yikes, just missed my two-week window. Too much happening, too busy… get used to it, folks, it’s here for the duration, e.g. until this summer, after we’ve sold our house. Enough of that! Onwards!

Research papers are one of my biggest Internet weaknesses. Another one is post-mortems. If we learn from others’ mistakes, then post-mortems are solid education… they’re experience reports in their most tangible form.

For some reason, it seems there have been a whole slew of interesting ones on the net recently. Here they are:

• Lambda the Ultimate cited this analysis of why Symbolics failed, as footnoted by Daniel Weinreb. Short story: too much technology, too little business focus. Still, interesting to get the inside view.
• Even better are Daniel Weinreb’s posts about the history and impact of Object Design and Objectstore. Orthogonal persistence once seemed like a Really Good Idea to me, until we tried it at Electric Communities in the mid-nineties and couldn’t make it work. Even so, it looks like there are some valid use cases that Objectstore exploited about as well as possible. Did you know Amazon evidently relies on Objectstore caching for their entire inventory database?
• Switching gears almost completely, from civilized discussion to rabid flaming, Zed’s infamous rant on leaving the Ruby community deserves mention. (WARNING: SOME NOT-SAFE-FOR-STRAITLACED-WORKPLACES CONTENT!) I have to admit I have a weakness for, shall we say, colorful language. The BileBlog (WARNING: DITTO!) was entertaining for a long time, though recently it’s gone dark… maybe Hani decided the career impact wasn’t worth the flameful fun. I’ve been tempted to go balls out and get explicit here, but the more I consider it, the less necessary it seems. Wait, that was all a huge digression away from the facts, which are that Zed’s rant is entertaining but I have no idea how accurate it is, and his comic self-promotion makes it hard to tell when he’s being serious and when he’s not, which hinders his message. He kind of wants to have his cake (“I’m so awesome, truly”) and eat it too (“Can’t you tell I’m mostly joking?”), which doesn’t do him any favors.
• Meanwhile, the poor beleaguered Open Source Applications Foundation recently announced that Mitch Kapor is washing his hands of it all. No more funding on his nickel, almost two-thirds of staff laid off, and Katie Parlante left to try to turn it all into real revenue somehow. After six and a half years of Python hacking, they still barely have a usable application. Scott Rosenberg already told the whole epic story, but this seems like almost the last gasp. Open source projects can perish without clear architectural and requirements leadership, and OSAF will forever be the paradigmatic example. (I largely agree with, again, Dan Weinreb’s take on it all. I wonder if a good dose of RPython would help out Chandler at all?)
• Finally, this isn’t new news (totally the opposite!), but I’ve got my own personal post-mortem skeleton in the closet, namely my involvement with the legendary Xanadu project. I’m quoted in the Wired post-mortem article. Some of what I said there was classic “this kid is young and bitter” uncensored vitriol. I’m glad that the brilliant people I worked with there understood that, because I want to work with some of them again some day! But overall, there is a lot of truth in that article, and it’s just a great read regardless. (Warning: that link is to the printer-friendly version, and Wired, under their new Conde Nast overlords, has lost their web-fu and has broken image links everywhere. Doesn’t matter; the text is all that counts in this instance.)

I’ve made some whopper mistakes in my career — some quite recently — and it’s too bad it will be a long time, if ever, before I get to tell the tales. (The downsides of modern tight-lipped corpocracy….) Still, we (hopefully) live and we (hopefully) learn. The more post-mortems, the better!

It’s almost terrifying how busy things are right now in robjsoftwareland. Moving with two young kids is just not the best idea from any kind of sane logistical perspective. Trust me on this. PLEASE. My life is a continual rolling boil of domestic packing and repacking and remodeling and general chaos, and it will continue for months to come.

But I cannot and will not go dark on this blog. So, a quick update:

1) The video from GWT2007 got posted! If my previous posts about my RPC talk made you curious, you can now see for yourself. I’m amused at the Sartre reference that snuck into the video I think it came out quite well overall (with the caveat, as before, that an unexpectedly large portion of the audience were newbies who didn’t get the most out of it). The other talks are also online — now I’ll get to see the ones I missed! I’d also recommend Billy Hoffman’s talk on security (warning: one short NSFW item in there!).

2) I’m currently putting all research papers and language-y thinking on hold for a few months. Instead I’m getting back to basics. All my side reading/hacking time is going into plowing through these two books: Introduction to Algorithms and Artificial Intelligence: A Modern Approach. I’ve generally in the past spent most of my time reading current research, because books get out of date so quickly. Well, not these two! They come pretty darn close to being timeless.

One quick brain teaser from the algorithms book: Everyone knows how to write a recursive algorithm to print an inorder traversal of a binary tree. Almost everyone knows how to convert it to an iterative algorithm using an explicit stack, too. But the book mentions that — if your binary tree contains parent links as well as child links, and if you can test pointers for equality — you can actually write an iterative algorithm to do an inorder traversal without keeping an explicit stack… in other words, an iterative algorithm that uses constant space (rather than space proportional to the depth of the tree). It took me about twenty minutes to figure it out. How about you?

3) One of the more interesting posts recently on good old Lambda the Ultimate was this post by Paul Snively asking whether syntactic or semantic theory is the way of the future. Most approaches to programming language theory historically have been largely syntactic, but there are a number of recent papers that take a purely semantic view.

While I’m still learning this field myself (and haven’t spent nearly enough time on the basics — Pierce’s syntactically-oriented Types and Programming Languages is on my reading list, but so far I’ve only dabbled), it seems to me that semantic approaches have an intentional stance that might make them fundamentally more general. For example, this paper on semantic verification of a simple compiler makes the point that a typed assembly language program can only go wrong if it tries to treat a given memory location as being of an unsafe type, but that there might be possible values in that memory location which can be safely interpreted as other types without inconsistency.

This approach reminds me of the Logic of File Systems paper, in which file systems are modeled in terms of their beliefs about the contents of memory versus disk. It’s a fascinating philosophical view, to think of programs as enacted, operational beliefs and to consistency check them on that basis. A program only goes wrong if its beliefs are inconsistent with the contents of the machine, as opposed to being inconsistent with its own source text (represented as base terms of the program). It’s going to be fascinating to see how far the semantic approach can be pushed.

That’s it for early January — see you in about two weeks!

Sigh, another two weeks gone by without a post. Still, that last post was a doozy, so cut me some slack, willya? Incidentally, my readership has increased by 50% in the last two weeks according to Feedburner. I am honored to have all of you paying attention to me, and I will try to be worthy of your eyeballs and neurons.

This post is going to be a bit of a catch-all: some about me, some about my last big-ass posting, and some about the GWT conference.

First, sorry I missed last week — I got another cold (endemic in the wintertime with two young kids in the house), and my wife kicked into moving high gear. Yes, we’re selling our house, for a wide variety of reasons I will discuss in personal email if you’re interested enough to send me some. (Not in the comments, sorry!) We’re shooting for having it on the market March 1, which means there is no time at all to waste. I’ll be doing no hacking for the next two and a half months, that’s an absolute given. I’ll keep up the blogging, but weekly may be tough; bimonthly WILL happen if it kills me!

Which is all too bad, in a way, because there’s plenty to do in hackland. My manifesto was rather well received. The comments on the post itself have a number of intriguing links. I also posted about it on Lambda the Ultimate, where it got a number of other fascinating responses. Thanks to all who engaged with it in either location. I am sorry I won’t be able to touch it until March first at the earliest, but that’s the nice thing about research — interesting ideas don’t go away!

I also wanted to give an update on the GWT conference. My talk was quite well received if the consensus speaker’s feedback was anything to go by. I appreciate the appreciation, to say the least. I did hear that there was a significant fraction (over 50%?) of the audience that felt it was too technical. Evidently a substantial quorum of GWT2007 attendees were relatively unfamiliar with GWT at any level. I apologize to anyone who wasn’t experienced enough to get the most out of my talk; I hope that you can find helpful material on the GWT site and/or any of the various GWT books. I’ve put my slides online for anyone interested. Evidently it’ll be Youtubed sooner or later, but I’ve yet to get a date on that.

The last morning of the conference, we had a participatory breakfast session where Joel Webber and I led a discussion of declarative UI and declarative data binding in GWT. One thing that was clear from my talk is that there are a lot of people doing form-like web applications, and GWT underserves that population right now. Joel spent some time going over the declarative UI work he’s doing; he specifically mentioned that various internal Google customers want him to ensure that you can write a GWT-XML document that lays out a GWT widget tree with HTML fragments mixed in almost arbitrarily. This seems like a win insofar as Joel’s talk on performance specifically mentioned that innerHTML is your friend; the DOM is faster at inserting HTML fragments than it is at handling individual DOM element insertions. So everyone keep an eye on Joel’s stuff as it hits the incubator.

I asked the table what kinds of form-data-binding approaches would be most useful to implement. The consensus seemed to be split. A number of people were familiar with the JSF-like structure of binding to backing beans and using expression language to specify the coupling from bean fields to the UI. I mentioned JSR 295 and various people expressed interst in that. There is a recent thread on the GWT contributors forum about some community work in this very area, which I look forward to investigating in depth (in early March! ). Check that thread out if you want GWT to do this. I talk at more length there about a potential GWT EL parser.

There was one gentleman (whose card I got, and subsequently lost; please contact me again, sir!) who was a forceful advocate of an XForms-like approach; evidently XForms lets you declaratively specify data dependencies within your model, and allows you to lay out interactions witihn your UI purely in your interface specification. This was pretty much news to everyone at the table. I will definitely have to look into XForms now. However, it seems to me that a JSF-like, JSR-295-like bean-binding approach covers many of the basic use cases people want, and should certainly be a near-term project.

OK, that’s it for this week. Happy, happy holidays to you all!

I’ve been working on a truly monster blog post, nothing short of a manifesto for a growable programming language. It’s about four pages long now and roughly 90% complete. All I have to do is Google up the two dozen reference links.

But I can’t quite get to it tonight, because tomorrow is my presentation at the GWT conference and I’ve been tweaking my slides semi-compulsively.

So, hopefully I’ll see several of you tomorrow at the conference, and stay tuned later this week for my Big Fat Language Rant! Your patience is very deeply appreciated.