I’m eagerly awaiting the arrival of Mac OS X, which should arrive at my door today. Alas, I just got off the phone with Sonnet tech support, who told me that Mac OS X support is most likely (paraphrasing) “weeks, rather than months or days away.”

That disappointment aside, I’m amazed that Sonnet can do what they do - I find the fact that they can put a G3 into a Power Mac 7200 quite astounding. I’m incredibly pleased with the performance of their Crescendo and Tempo cards, both of which are running nicely in my beige Power Mac, and coupled with an ATI Radeon, play Quake III quite nicely.

O, ye of little faith
Anticipating that it would be impossible to upgrade a 7200, I put a 7500 motherboard in my 7200/75 before taking the G3 plunge. If I had more faith, I could have waited for the Crescendo/7200. This time, I’ll keep reloading the Sonnet Mac OS X web page, waiting for the day I can open the box containing Mac OS X and boot into it on my trusty beige box.

A bell rings.
Argh! the doorbell just rang, and the “world’s most advanced operating system” is on my doorstep! Will I go mad waiting for Sonnet!?

Updated: I received a slightly more detailed answer from Sonnet via email. Apparently, the Tempo Ultra ATA/66 drive controller is supported out of the box in Mac OS X. What I’m waiting on, then, is an update that makes the Power Mac 7500, the Crescendo G3, and Mac OS X one big happy family.

Updated: A couple of people sent an interesting link my way. For the truly brave and adventurous, you might want to see if this helps out: https://homepage.mac.com/RyanRempel/OldWorld/Instructions.html.

Experiments in Meerkat XML-RPC over SMTP using Python and a little hackery; a followup to yesterday’s thoughts on the subject.

rpcmail.py
The script to which an incoming email message containing an XML-RPC request is routed by procmail. Basically a silly proxy between SMTP and Meerkat’s XML-RPC server; yes, I could have merged the two, but the latter is written in PHP and it is Sunday after all.

#!/usr/bin/python
import sys, rfc822, xmlrpclib, smtplib
# Grab the message headers and body
header = rfc822.Message(sys.stdin)
body = sys.stdin.read()
# Decode the XML request, extracting parameters and method
(p, method) = xmlrpclib.loads(body)
# Ick!  If you don't know, don't worry about it :-
params = {}
for pp in p: params.update(pp)
# Instantiate a new XML-RPC Server object
server = xmlrpclib.Server(
  "https://www.oreillynet.com/meerkat/xml-rpc/server.php"
)
# A simple dispatch map of supported methods
methods = {
  'meerkat.getItems': server.meerkat.getItems,
  'system.listMethods': server.system.listMethods,
  'meerkat.getCategories': server.meerkat.getCategories,
  'meerkat.getChannels': server.meerkat.getChannels,
  'meerkat.getChannelsByCategory': server.meerkat.getChannelsByCategory,
  'meerkat.getItems': server.meerkat.getItems
}
# Reply to the sender with the results of the Meerkat
# XML-RPC method call
smtplib.SMTP('127.0.0.1').sendmail(
 header['from'],
 'meerkat@oreilly.com',
 'Subject: re:' + header['subject'] + "n" +
 methods[method](params).read()
)

xmlrpclib.py
Some minor alterations to the Python xmlrpclib module so as to retrieve a raw XML response from Meerkat’s XML-RPC server.

$ diff xmlrpclib.py ../Modules/xmlrpclib.py
585,586c585
<       #return self.parse_response(h.getfile())
<       return h.getfile()
---
>       return self.parse_response(h.getfile())
634,635c633,634
<       #if len(response) == 1:
<       #    return response[0]
---
>       if len(response) == 1:
>           return response[0]

The Request
An XML-RPC request-laden email message sent to meerkat@oreilly.com.

From rael@oreilly.com Sun Mar 25 21:46:17 2001
Date: Sun, 25 Mar 2001 21:43:56 -0800
From: Rael Dornfest 
To: meerkat...
Subject: rpcmail: getItems
<?xml version="1.0"?>
<methodCall>
<methodName>meerkat.getItems</methodName>
<params>
<param>
<value><struct>
<member><name>category</name>
<value><int>18</int></value>
</member>
<member><name>time_period</name>
<value><string>7DAY</string></value>
</member>
<member><name>ids</name>
<value><i4>0</i4></value>
</member>
<member><name>descriptions</name>
<value><i4>1</i4></value>
</member>
<member><name>categories</name>
<value><i4>0</i4></value>
</member>
<member><name>channels</name>
<value><i4>1</i4></value>
</member>
<member><name>dates</name>
<value><i4>0</i4></value>
</member>
<member><name>num_items</name>
<value><i4>5</i4></value>
</member>
</struct></value>
</param>
</params>
</methodCall>

The Response
An XML-RPC response-laden reply to rael@oreilly.com.

From meerkat... Sun Mar 25 22:13:14 2001
Date: Sun, 25 Mar 2001 22:09:10 -0800
To: rael@oreilly.com
Subject: re:rpcmail: getItems
<?xml version="1.0"?>
<methodResponse>
<params>
<param>
<value><array>
<data>
...
<value><struct>
<member><name>title</name>
<value><string>PikiePikie</string></value>
</member>
<member><name>link</name>
<value><string>
https://www.vex.net/parnassus/apyllo.py?i=83041017
</string></value>
</member>
<member><name>description</name>
<value><string>Another Python-driven WikiWiki implementation.
[Win32, Unix]</string></value>
</member>
<member><name>channel</name>
<value><string>Vaults of Parnassus</string></value>
</member>
</struct></value>
...
</data>
</array></value>
</param>
</params>
</methodResponse>

Dave Winer is href="https://www.xmlrpc.com/stories/storyReader$1401">experimenting
with RPC (specifically XML-RPC) over SMTP (read: email). I’ve been doing a little fiddling along much the same lines using SOAP (specifically
SOAP::Lite’s fledgling support for SMTP/POP). Could email possibly be
a somewhat useful Peer-to-Peer / Web Services enabler?

The thought first crossed my mind whilst playing with Microsoft Outlook’s
invite-via-email functionality. Groove, too, uses email as one possible
means of invitiation to a group space. The idea finally took root and
began to grow after a chance mention of a need for store-and-forward
capability in some P2P system or other (I forget which, I’m afraid). I’ve
been trying to shake it ever since.

But email ain’t P2P!

Email is not usually considered Peer-to-Peer in even the broadest of
definitions. It does, nevertheless, fit squarely into what one might term
“Appear-to-Peer” (thanks to Dale Dougherty for his off-the-cuff coinage).
The pedantics of plumbing aside: I send email to you and you (hopefully)
send email in reply. Couldn’t, then, such suspension of disbelief be tolerated
by a P2P or Web Services framework?

For pity’s sake, why?

Email actually solves or circumvents some interesting problems being
re-solved (or not) by P2P and Web Services efforts:

• Firewalls
  Email skirts the firewall issue by remaining simply a pull medium.
• Store-and-Forward
  The winking in and out of existence of Napster nodes is considered
  a non-issue due to the ubiquity of any particular MP3. But what
  of the singleton meant for a particular node — a node currently
  offline. ICQ is (was?) unique in the instant messaging space in
  providing delayed delivery of a message to an offline buddy. POP
  does the same for email
• Unique Addressing
  While an email address is indeed tied to one server (or farm thereof)
  in particular, from the Appear2Peer perspective, rael@oreilly.com
  lives in my email client.
• Deployment
  The pervasiveness of email’s existing infrastructure goes a long way to rendering moot concerns
  about critical mass of deployment.

A pet concept

Not quite worthy of the term “pet project,” I do have an application
swimming about in my mind and ~/src directory.

An RPC-over-SMTP proxy running on the local desktop or server facilitating
communication between local P2P / Web Service apps and the outside world.
The proxy brokers interactions, tracking, routing, storing, and forwarding
the asynchronous requests and responses, cacheing when useful and appropriate
to do so. Obviously the proxy should not be limited to RPC-over-SMTP,
allowing for synchronous communication over HTTP whenever possible.

Dave’s absolutely correct in referring to these shenanigans as “messaging.” . After all, isn’t an email client set to send immediately and retrieve every 1 minute just low-tech IM?

Almost Instant Messaging? MailStorm?

(I’ll continue to fill in this entry as my thoughts and coding coalesce.
And, of course, I invite any constructive criticism you might have to offer.)

Edd Dumbill, Managing Editor
of XML.com posted
to the RSS-DEV mailing list noting the similary of the RSS 0.9-like format
used by Ximian’s Red Carpet software management application to RSS 1.0.

Red Carpet introduces
the concept of a software channel. “You can selectively subscribe to
these channels, ensuring that you only get information about software
relevent to you. If you want to stay on the cutting edge of technology,
Red Carpet will let you get the latest unstable builds, beta tests, and
preview releases. If you prefer something a little more tried-and-true,
we’ve got a channel for that, too.”
[screenshot]

Whilst tinkering, Edd ran across the a
Red Carpet data file,
extracted here in part…

<?xml version="1.0"?>
  <rdf:RDF
    xmlns:rdf="https://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rc="https://www.ximian.com/"
    xmlns="https://my.netscape.com/rdf/simple/0.9/">
    <channel>
      <title>Ximian Red Carpet News</title>
      <link>https://www.ximian.com/news/</link>
      <description>Ximian Red Carpet News</description>
    </channel>
    <item>
      <title>Ximian Evolution Snapshots Now Available Through Red Carpet</titl
e>
      <link>https://www.ximian.com/evolution/</link>
      <rc:icon>https://redcarpet.ximian.com:8000/evolution-snapshot/common/channel-evolution.png</rc:icon>
      <rc:summary>Daily builds of Ximian Evolution and associated libraries are now available through Red Carpet.</rc:summary>
      <rc:channel>Evolution Snapshot</rc:channel>
      <rc:date>982708896</rc:date>
    </item>
    ...
  </rdf:RDF>

“This is very similar to RSS 1.0 <https://purl.org/rss/> but isn’t
quite,” said Dumbill.

Red Carpet proceeded in precisely the same manner as RSS-DEV, beginning
with an RSS 0.9 document and extending its capabilities via XML namespaces.
RSS 1.0 continues a little further, building out 0.9’s extant fledgling
RDF support.

A nip and tuck and the odd rdf:about produces an RSS 1.0 version of
the above Red Carpet’s parser shouldn’t have any trouble chewing…

<?xml version="1.0"?>
  <rdf:RDF
    xmlns:rdf="https://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rc="https://www.ximian.com/"
    xmlns="https://purl.org/rss/1.0/">
    <channel rdf:about="https://www.ximian.com/news/">
      <title>Ximian Red Carpet News</title>
      <link>https://www.ximian.com/news/</link>
      <description>Ximian Red Carpet News</description>
      <items>
        <rdf:Seq>
          <rdf:li resource="https://www.ximian.com/evolution/" />
        </rdf:Seq>
      </items>
    </channel>
    <item rdf:about="https://www.ximian.com/evolution/">
      <title>Ximian Evolution Snapshots Now Available Through Red Carpet</titl
e>
      <link>https://www.ximian.com/evolution/</link>
      <rc:icon>https://redcarpet.ximian.com:8000/evolution-snapshot/common/channel-evolution.png</rc:icon>
      <rc:summary>Daily builds of Ximian Evolution and associated libraries are now available through Red Carpet.</rc:summary>
      <rc:channel>Evolution Snapshot</rc:channel>
      <rc:date>982708896</rc:date>
    </item>
    ...
  </rdf:RDF>

Cross-posting to the Red Carpet mailing list, Dumbill proposed:
“It would make some kind of sense for folks in each project to get to
know each other–RSS 1.0 could benefit Red Carpet, and also Red Carpet
could provide some valuable use-case input to RSS 1.0.”

I’ve got to get out of the house more. I had been working under the delusion that all the good stories about .NET are only available in the digital world. But sitting here in the Cranston, Rhode Island Borders Bookstore cafe flipping through the April issue of Linux Magazine, what do I see but a really interesting article on .NET that I can’t find online.

Mark Mitchell’s article, GCC.NET, covers the technical details of how you could enhance GCC to emit .NET IL. IL is roughly equivalent to Java’s bytecode, although .NET does not execute instructions in a virtual machine (all IL is compiled to native code by a just-in-time compiler). Although it is listed in the online table of contents the article itself does not appear to be available online.

(updated: the article recently became available online)

This issue also has an interview with Dick Hardt of ActiveState in which the conversation turns to speculation about .NET on Linux.

Speaking of .NET on Linux, I recently took a look at Portable .NET, a project to develop an open source runtime and C# compiler for .NET. This implementation, unlike Microsoft’s implementation of .NET, relies on a virtual machine. It looks pretty nice - they have some working code (an implementation of ILDASM) as well as quite of bit of code that’s a work-in-progress. What’s more, the overall vision and design seems quite sound to me.

In the Beginning… was the Command Line

by Neal Stephenson

Paperback, 151 pages, Avon Books, 1999

Simultanously hysterical, pointed, and insightful, Neal Stephenson’s In the Beginning… is a delicious meal disguised as a snack. Hackers and those who’s VCRs are flashing “12:00″ alike are sure to read each page twice or more to be sure they’ve not missed a nuance.

The book is brief history of the computer, from mainframe to GUI. However, rather than soak the reader in only geeky details, Stephenson flips back and forth between user and plumber’s perspectives. Why, if Linux is a (free!) sophisticated tank constructed of space-age technology and Windows a station wagon with “all the aesthtic appeal of a Soviet worker housing block,” is it that everyone is buying the station wagon? Stephenson argues that our inability, given our busy schedules, to spend time comprehending details has us accepting the murky, inconsistent metaphors provided by todays graphical user interface.

Stephenson manages to seamlessly weave together witty personal anectodes and just the right level of analysis in a conversant style that’s informative and a pleasure to read. Throughout, I found myself mumbling both “Heh, I remember that!” and “Hmm, I never thought of it that way.”

By page 10, chortling my way through “If your aim was true, one [modem] cup would wrap its neoprene lips around the earpiece and the other around the mouthpiece, consummating a kind of informational sioxante-neuf,” I thought I’d better make note of some quotables. By page 75, I had 65 more.

‘Nuff said. I give In the Beginning… four out of a four possible Meerkats.

Related link: https://www.ruby-lang.org

An ongoing collection of useful Ruby resources: DMOZ:/Computers/Programming/Languages/Ruby. RubyCookbook.org is a resource for the Ruby community to organize, archive, maintain and distribute a comprehensive collection of Ruby “recipes.” RubyCentral, the Source for Ruby.

I mentioned yesterday that the next version of Meerkat will sport integrated Dublin Core support. Search is now done and shortly we’ll be rolling out a Meerkat searchable via RSS Title and Description, as well as the full complement of 15 Dublin Core elements.

Related link: https://www.cybiko.com/

J.C. Herz, author of Joystick Nation, pointed me at Cybiko, a gnarled bit of colourful plastic billed as: “Cybiko Computer is COMMUNICATION! Chat wirelessly with 1 or 100 of your friends that have a Cybiko Computer, play ripen multiplayer wireless games, send/receive pictures, text files and emails to Cybiko computer’s nearby.”

Related link: https://www.oreillynet.com/~rael/2000/11/10/

While creating an XML-RPC interface to Meerkat was meant as a nice Web service for our readers, it actually afforded me a great start writing a mini Meerkat in a miniscule amount of code without need of database calls and all the rest of the middle-tier hoo-hah.

Related link: https://logicerror.com/blogifyYourPage

RSS-DEV member Aaron Swartz makes syndicating your site’s headlines via RSS 1.0 only a couple of <span class=”rss:item”></span> HTML tags away.

Related link: https://bbspot.com/News/2001/03/perl_test.html

Recent results from standardized Perl Fluency Test showed that 99.99% of US high school seniors can’t read Perl. This disturbing statistic shows that American students are painfully unprepared for life after graduation.

Beginning back in November 2000, I devoted a smidge of my copious free time to learning Python via a project I called Peerkat, a P2P version of Meerkat, the O’Reilly Network’s Open Wire Service. About 95% to completion, work stalled around January due to lack of bandwidth :-\ I hope to pick it back up again and release it as Open Source shortly.

Peerkat’s features:

• Simple
• Small Footprint
• Lightweight
• Local
• Extensible
• Powered by RSS 1.0
• Flavourful: HTML, RSS 0.9, 0.9x, and 1.0, AvantGo Optimised, JavaScript (.js) source, …
• Open Source
• 100% Python
• Cross-Platform (Peerkat should run wherever Python does)
• Browser-Independent
• Built on top of a lightweight database
• Uses “off-the-shelf” Open Source components

In the meantime, I thought I’d share a few screen snaps:

• Default (”Home”) View
• Python Stories
• Login
• Filtering Stories
• Editing a Story
• A Moved Story
• Feeds
• Editing a Feed

The next version of Meerkat will sport Dublin Core support, both in output and searching capabilities. DC elements are incorporated into all flavours, such as the
default and
RSS 1.0 views. Soon you’ll be able to search RSS 1.0 enabled feeds aggregated by Meerkat for all stories by author, publication date, publisher, keywords, and so on.

Related link: https://www.xmlmag.com/upload/free/hotlinks/ednote032101b.asp

XML Magazine Editor-in-Chief Steve Gillmor dives into HailStorm’s underpinnings with architect and Microsoft distinguished engineer, Mark Lucovsky.

Related link: https://www.napster.com/speakout/

What do Dave Matthews, Madonna, Chuck D, Bono, B.B. King, Prince, and other major recording artists think of Napster?

Related link: https://slashdot.org/article.pl?sid=01/03/21/0739222

A Slashdot reader wonders about implementing the Semantic Web’s ideals and using RDF. “The whole point behind the “semantic web” concept is that data is organized online in such a manner, that a variety of different, independently designed machines can use it without compatibility issues.”

Related link: https://www.phpxml.org/

A member of the PHP-XML mailing list posted a pointer to <phpXML/>, a set of scripts bringing the power of XML to “plain PHP”. DOM, XPath, and XSL are only a few simple PHP functions away.

Related link: https://slashdot.org/articles/01/03/18/1339201.shtml

Ovidius writes on Slashdot that no less an American than
Benjamin Franklin shunned patents for his Franklin stove and other innovations, “on the principle that ‘as we enjoy great advantages from the inventions of others, we should be glad of an opportunity to serve others by any invention of ours; and this we should do freely and generously.’ ”

After working with jEdit and Emacs (both fine tools), I have settled on Vim as my XML text editor of choice. This decision happened shortly after I came across Devin Weaver’s xmledit.vim, which does everything I want. (Update: Thanks to Tobias Reif for providing me with a new link for the xmledit script.)

jEdit and Emacs are both fine tools for XML editing, though. jEdit has a great XML plugin that allows simultaneous tree view and text editing, and Emacs has the excellent PSGML mode. For more info on PSGML, see PSGML tricks.

Related link: https://slashdot.org/article.pl?sid=01/03/18/198231&mode=thread

Dave Winer posts to Slashdot that AOL’s ICQ spec is online for developer perusal. ‘With “open” like this, who needs closed?’

Many people are debating how Microsoft will fare if the courts split it into two companies. As I see it, the house that Gates built has been two companies for some time now: the Windows software group and the Mac group.

This light bulb first began to flicker when I launched IE 5 for the Mac. I’d never seen a web browser like this before. It was innovative, standardized, and heaven for bid, handsome. Tell me again who wrote it.

It was such a radical departure for a Microsoft product that I did a little investigating to see how this could happen. I learned that there is a separate Macintosh team within the company, located in Silicon Valley, and that they like to compete with the Windows group. Well, they sure beat the pants of them with IE 5 for the Mac.

Then Office 2001 for the Mac hit the streets. OK, big deal. Office 98 is already pretty slick, and $259 is a lot to pay for a new version of MS Word. I’ll stand pat. That is, until I began to hear the talk about a new contact manager / e-mail client / Palm desktop / application included in Office 2001 called Entourage.

Should I be excited? I mean, if I want e-mail Microsoft style on my Mac, I can get Outlook Express 5 for free.

Well hang on to your hard hat, because Outlook Express is as similar to Entourage as a bicycle is to a Harley-Davidson. Seriously.

Here’s why:

• Entourage is really fast.
• I can turn off HTML formatting in RECEIVED e-mail documents and just view the text and links without all those annoying graphics screaming at me. (Worth the money alone)
• All of that valuable data in my Handspring Visor that I’ve spent months gathering and cleaning — well, Entourage imports it perfectly … including all of my established categories.
• The Advanced Find is amazing.
• Integrated calendar, task list, address book, and notes work beautifully.
• A Palm OS (yes I said Palm) Conduit that enables complete HotSyncing of data with Entourage. And it works flawlessly.
• I can use AppleScript to automate tasks in Entourage.
• Entourage looks, feels, and behaves like a Mac application.

On one screen I can view my monthly calendar, see today’s appointments, review the progress of my tasks, and of course … read my e-mail. Mac users have gone from second class, nonintegrated, incompatible, unorganized citizens to the top of the heap.

Of course this has ruined me. Now when I use Outlook on my Windows ThinkPad, I feel, well, kind of bored — similar to the feeling I’ve been experiencing using IE 5.5 on Windows.

So as far as I’m concerned, Microsoft is already two companies. And that second company is writing some beautiful software.

Related link: https://www.cookcomputing.com/xmlrpc/

“XML-RPC.Net is a class library for implementing XML-RPC Services and clients in the .NET environment.” :-O

Related link: https://oss4lib.org/readings/interview-everitt-manheimer-2001-03.php

Daniel Chudnov interviews Digital Creations’s Paul Everitt and Ken Manheimer about a fundamental commonality between Zope and librarianship — in a word, metadata.

Related link: https://industry.java.sun.com/javanews/stories/story2/0,1072,35371,00.html

Evans Data Corp. surveyed 500 wireless developers and found that almost one third will target forms of Java (especially J2ME) for application development. The Palm Operating System was second choice with 24.5%, followed closely by Microsoft’s Pocket PC platform. The interesting thing to me abou this study is that it clearly lumps together developing for mobile phones with developing for handhelds, like the Palm models or the Compaq iPaq. Java may become a popular platform for phones; indeed, it’s already running on mobile phones, including some iMode phones that NTT DoCoMo is selling. But other than highly-publicized token attempts to port it to Palm, I can’t think of any handheld computers running Java. Can you?

Related link: https://weblog.mercurycenter.com/ejournal/2001/03/13

Dan Gillmor takes a gander at Eazel’s Nautilus 1.0 desktop for Linux, soon to include an integrated RSS headline viewer. “It’s actually an icon, but an extremely smart one. Eazel’s components follow the Gnome project’s Bonobo model. The icons can be resized and manipulated in a variety of ways, but they also meld with the network and file system.”

Related link: https://news.cnet.com/news/0-1003-200-5079895.html?tag=tp_pr

Ximian, nee Helix Code, plans to bring Web Services a la Microsoft’s .NET to *nix operating systems by incorporating “SOUP” (a play on SOAP) into the Gnome user interface.

Related link: https://www-106.ibm.com/developerworks/library/ws-xpc1/?dwzone=ws

O’Reilly’s own Joe Johnston writes part one of what will thankfully be a multi-part series on “Using XML-RPC for Web services” for the IBM developerWorks site.
“Creating an XML-RPC Web service with Perl is almost as easy as CGI scripting. This article will bring you up to speed on what XML-RPC is and how to use Perl’s Frontier::RPC library to create simple clients and servers.”

Related link: https://www.sun.com/smi/press/sunflash/2001-03/sunflash.20010306.1.html

Sun intends to incorporate InfraSearch’s P2P search technology into Bill Joy’s Project Juxtapose (JXTA) distributed computing effort.

Related link: https://lists.infoanarchy.org/mailman/listinfo.cgi/p2pj

Erik Moeller, editor of infoAnarchy, has established a mailing list for discussion of Peer-to-Peer Journalism. “It is our belief that the future of the media is in the hands of the people. We have to build these new media. The faster we do so, the less abuse of centralized media power is likely to happen.”

It’s March 2001, and if all goes well, Mac OS X will come out this month. If Sonnet comes through, I’ll be running the new operating system on the same Mac I’m typing this on (a former Power Macintosh 7200/75 with a 7500 motherboard and Sonnet Crescendo G3).

In addition to sporting a spiffy new interface, Mac OS X is built on top of on an open-source BSD derivative called Darwin. As of this writing, Netcraft’s list of sites with the longest uptimes shows a lot of BSD variants. If Mac OS X follows on the footsteps of its BSD brethren, it could become a popular server operating system.

Microsoft has positioned .NET as a competitor to J2EE. If .NET is to compete head-to-head, it wouldn’t hurt if it ran on popular server platforms. Plus, Java 2 has already found its way into the Mac OS X space, so there is plenty of incentive for Microsoft to try to gain a foothold there.

Server platforms aside, .NET could be the foundation for future end-user Windows applications using the Windows Forms API. Microsoft remains committed to supporting Mac OS X with their current line of products, and I see no indication that they are planning to abandon it in the future.

Let’s look at what one of Microsoft’s top .NET people (the designer of the C# language) has to say. In Episode 7 of the MSDN Show, Anders Hejlsberg says, “And, of course, [the standardization of the common language infrastructure] will inevitably down the line lead to implementations on different operating systems such as the Mac OS and certainly such as UNIX and such as Linux.”

It’s great to see Microsoft engineers thinking different!