Archive for the ‘Uncategorized’ Category

Turning 50

Friday, January 16th, 2009

This post is a bit premature as I’ve still got a year to go or so (Jan 17, 2010). Nevertheless, given the significance of the semi-centennial, I am starting my party planning early.

It is my sentiment that celebrating the big “L” (as Julius Caesar referred to it) should be a significant event. What I’ve done is to ask a set of friends to celebrate it with me (most of them are L-ish, too) by proposing some adventure. As long as they’re willing to do it with me and the adventure entails an equal challenge for both of us, I’m game. I’ve suggested that the adventure involve a certain degree of discomfort if not danger. Not “work as an Arabic translator in Mosul”-type danger but perhaps “jump out of an airplane”- or “take a long sail”- type danger. After all, what better way to feel alive than to face death (if only at a hundred paces)?

So far my friends have responded with a language immersion trip (Chinese), a motorcycle trip and golf in far-flung places. I’m still hoping for a long hike, sail or kayak trip, too, maybe a safari. For sure, this will justify buying the Canon 5D Mark II.

Admittedly, these are indulgences. I figure a budget of $50k (naturally) will probably cover all the activities. Although this is a lot of money, it’s cheaper than buying a Porsche 911. Yes, the money would be better spent donating it to UNICEF. I prefer to view this as my own personal economic stimulus package.

When I do embark on these, I’ll try to post here as I experience each adventure. First stop: motorcycle lessons in February.

Why (OS) Architecture Matters

Friday, June 20th, 2008

In previous posts (for example, What Linux Needs to Learn From Microsoft) I’ve complained about the lack of management APIs in Linux and UNIX. Microsoft Windows has a comprehensive set of management APIs for a variety of OS features:

  • Networking
  • File/printer sharing
  • Event logs
  • Registry I/O
  • Service control
  • etc.

Moreover, each of these APIs typically works locally (on the machine the call is made) or remotely (on another machine). How is it that such a comprehensive set of APIs came to be and that these API should so consistently support remote management? The answer to both of these questions is by design.

Let’s understand what this means by going back in time to the late 80’s and early 90’s. I had just arrived at Microsoft back then (from HP). I started working on the Windows 1.04 SDK and then later moved to the OS/2 project.

In the MS DOS (pre-Windows) days, the concept of an API, let alone a network-aware one, was very crude. MS DOS programs accessed the operating system by performing “software interrupts”. An application would set up the x86 registers and would then perform an “Int 21”. The OS would field the interrupt and interpret the registers to determine what to do.

Programming language libraries, for example, the “C run-time library”, added the first primitive API to MS DOS. Instead of performing an Int 21, you could call “open()” or “fopen()” to open a file.

With Windows 1.0, the number of APIs greatly increased. if I recall, Windows added about 300 API including its “kernel”, windowing and graphics features. This number would eventually grow to 3000 in the Windows NT days.

When OS/2 arrived, something else had arrived with it: the local-area network. Networks had been available for some time (Novell Netware, Windows-for-Workgroups, MS DOS LANMAN). OS/2, however, introduced the concept of an operating system that was fundamentally network aware and could provide network services. Unlike Netware, OS/2 was a general-purpose operating system that could behave as a centralized server, too. OS/2 enabled the development of client-server applications.

The presence of networks and of network services necessitated the development of remote management APIs. For example, when a user typed:

net view \\fileserve1

The net utility had to be able to “talk” to fileserve1 and “ask it” what resources it was sharing. At the API level, the operating system needed to provide a NetShareEnum function that included a servername parameter indicating what server was being queried.

How did OS/2 “talk” to servers? Did it have some special protocol talking on some dedicated port just for this purpose? No. OS/2 was built on top of a basic RPC (remote procedure call) protocol that worked “on top” of named-pipes.

Now, I can’t provide all the details and history about how RPC progressed from OS/2 to today. My colleague at Likewise Software, Krishna Ganugapati, however, can. I have a link to his blog on my blogroll.

In Windows NT (later, Windows 2000, Windows XP and now Windows Server and Vista), the RPC mechanism became very formalized. Just about every OS API was written atop RPC. You would define your API using the IDL (interface definition language) and compile it (using the MIDL compiler). The compiler would generate a series of client and server-side stubs that would completely hide the details of RPC. You didn’t have to worry about marshaling arguments or about handling the transport layer. The RPC run-time would take care of communications over TCP/IP or over named pipes (maybe even netbios, too).

Local calls would skip the networking layers but the RPC mechanism would further server to marshal between user and kernel level code.

The key lesson here is that Windows NT was built from the ground up with an RPC, distributed system architecture. UNIX is not (although Sun was an early pioneer in RPC technology and still a key contributor). Linux is not. Neither is Mac OS X/Free BSD.

Admittedly, the RPC libraries might be available for these platforms (altbeit in a neglected state; we’ve made several fixes/improvements to them). The operating systems themselves are not designed from a distributed perspective.

Thus, it’s not suprising that management APIs, especially remote management APIs do not exist for these platforms. The respective vendors are all working on WS-Management or WBEM or some other protocols to help with the situation but they are still, fundamentally, in a weaker position than the Windows NT progeny.

At Likewise, we develop interoperability software that allows UNIX, Linux and Mac OS X computers to work well on Windows networks. In order to provide this software, we have to work with services on Windows that expect to be invoked over RPC.  Although, at first, we “hand-rolled”, these RPCs our most recent software is based on a full DCE RPC implementation. This has greatly facilitated our work and is allowing us to provider further interoperability features between Windows and non-Windows systems. Sometime soon, we will be releasing this software with both our open source and proprietary software products.

…and then I started writing again…

Saturday, May 24th, 2008

About four years ago, when I started my company (Centeris, back then; Likewise Software now), I started a blog describing our early challenges. I maintained it faithfully for about six months, recounting the saga of getting funded, hiring people, getting an office, firing people, etc. Right about then, I started reading about the legal ramifications of blogging and how postings by corporate officers were getting people into trouble. Although I figured the odds of getting into trouble were low, I had enough things to keep me busy and I decided to take the blog offline.

Frankly, it was a relief. Although I enjoy writing and sometimes have trouble stopping once I start, writing on a regular basis can be quite a chore. It may be hard to believe that someone who works 11-12 hours a day can be lazy, but it’s true. If I wasn’t lazy and I didn’t have to sleep or eat or tend to my family, I’d work 24 hours a day. Life at a startup is such that, every day, you work twice as hard as you have ever worked, you accomplish twice as much as you do at a big company, but you end the day further behind on your TO DO list than you started.

I hate to see untended blog sites. There’s nothing worse than seeing a site (usually a corporate one) with a “Hello, here’s my first blog” entry that’s 2 years old. If you’re going to blog, you have to commit to doing it regularly. “Regularity” implies self discipline (well, it also implies a well-functioning digestive/execretory system, but let’s not go there.)

I have figured out self-discipline. Here’s the trick: do things while you’re still not fully conscious.

I figured this out in the context of getting regular exercise. I just could not get myself to the gym on a regular basis. I’d put on the “Freshman Fifteen” (or maybe 30) when I’d started my company. I was so busy, however, that it was easy to rationalize why I couldn’t take a break to go exercise or why I was so tired that I couldn’t get to the gym on the weekends. The trick that worked for me was to start running at 5:30 in the morning (yes, A.M.).

If you wake up at 5:15 A.M. your brain does not function properly. You’ve probably just finished your R.E.M. sleep stage and you’re still trying to figure out what Cindy Crawford was doing in Bellevue, let alone, doing it with you. You stumble out of bed, put your running clothes on and head out the door. 40 minutes later, you take a shower, get some breakfast and head into work without realizing what happened.

Do this about 20 or 30 times and it embeds itself in your reptilian brain. After that, you might find yourself exercising at 2pm in the afternoon. The trick is to ingrain the habit while your reasoning functions are still in a vulnerable state. Once the salivary glands start drooling at the the sound of a bell, your work is done.

And so with writing. I’m going to try to write early in the morning and see how that goes. My topics will inevitably include work-related things. My company provides products that allow non-Windows computers (Unix, Linux, Mac) to work with Microsoft Active Directory. Right now, this is a hot topic. A lot of our business is driven by security problems, PCI/SOX audit compliance and by the high costs of administering computers without centralized account management. Writing about work all the time is boring, however, so expect an occasional reference to funny stuff (Chuck Norris Facts, for example, or “The Flying Conchords”) or to other things that I’m interested in (photography, golf, running, books, etc.).

We’ll see if the 5:30am trick works again. If you start seeing too many references to Cindy Crawford, however, please pinch me…