A common theme among many reponses I received from href="https://www.xml.com/pub/a/2001/04/18/comicsml.html">my ComicsML
article involved SVG,
the vaguely buzzy W3C standard for
describing graphics through XML. Due
to its name — which expands to Scalable Vector Graphics — I had a
vague idea that it let you write XML elements that described a picture
via plotting points and drawing lines between them, and I guess if I
stopped to think about it, which I didn’t, I would conjure up
pleasantly nostalgic visions of my fourth grade computer class,
drawing pictures on graph paper and then trying to code them in href="https://www.myoldcomputers.com/museum/man/pics/applebasic.jpg">Apple
][ BASIC via blocks of carefully enumerated HLINE and VLINE
statements. (Mine was a picture of a shining Atari logo blowing up an
evil Apple logo, for it would be years before I’d mature into platform
agnosticism, and I suppose I harbored some resentment at this
activity. Anyway:)

After spending Sunday afternoon immersed in SVG specs, articles,
and tutorials, I have found myself bedazzled at its true purpose as
XML’s solution for describing and rendering all sorts of graphics and
animation, so much so that many consider it positioned as competition
for Macromedia’s Flash. (I suspect that if I had any idea how Flash
worked I would have figured this out sooner, but, anyway; there you
have it.) This is very interesting, an open file format not
owned by any one company and therefore generatable through whatever
tool one wishes to use (I used emacs), and which has support from
major vendors — see especially href="https://www.adobe.com/svg/">Adobe’s SVG viewer plugin for
Windows and Mac browsers (which, incidentally, you’ll probably need in order to
see the stuff I point to later in this entry), not to mention that
their Illutsrator 9.0 product can export its files as SVG — and viewable through any application that cares to parse the XML and figure out how best to draw all these flying shapes, given the environment, whether it be a PC’s web browser, or the itty-bitty LCD screen of a palmtop device, or a superprecise plotter printer.

Despite all this, at first I wondered if the Flash-competing angle
was a crackpot viewpoint — I had previously viewed Flash as just
Flash, a domain unto itself — but Dale alluded to this as
well in href="https://www.oreillynet.com/pub/a/network/2001/02/02/epstein.html">a
recent interview, so I would tend to believe him, even though his
interview subject responded by scoffing at SVG’s comparitavely puny
browser penetration figures.

I scratch my head at that, though: to compare market penetration
with regard to electronic media formats that are not only free but
very easy to obtain and use seems a little weird to me. When I hit a
page that wants to show me a little SVG magic, and I don’t have the
right plugin, my browser will beep and offer to go fetch it for me,
and I will say “Duh, OK,” and click the Install button, and there you
have it: one more SVG user, who will use it seamlessly from then
on. It’s not anything like comparing OS usage, or even browser
application usage, as far as I can tell.

Of course, I’m out of luck unless I have a Windows or a Mac machine
handy. My experimentation was made possible by my trusty old home Mac,
but my main box there runs RedHat Linux, and at work I use
Solaris. (Well, there’s a shared Windows box here, but Erik keeps
moving the icons around and confusing me by renaming the computer icon
to I like gherkins or Dorky Plunk Xob or something
every day, so I don’t use it too often.) I wrote a friendly letter to
Adobe thanking them for making a Mac version at all, and added my
voice to what I hope is a sizeable collection of Unixheads who’d like
to share the love as well.

Hey, look, they wrote me back tonight!

Hello Jason,
Adobe has not yet announced any plans to support Linux platforms. As you may
know, there are some Linux SVG development efforts under way elsewhere.
Java based viewers:
IBM at: 
CSIRO at: 
Mozilla:
See https://www.mozilla.org/projects/svg
Amaya Version4.0 (Windows and Unix)
https://www.w3.org/Amaya) from W3C
Batik SVG Toolkit and Viewer
https://xml.apache.org/batik/
SVG announcement page that includes Linux based SVG tools

As for our own plans, we have a policy of not discussing unannounced product,
but I can say that we evaluate support for additional platforms based mostly on
the numbers of seats they represent.

Adobe notes in their online documentation that they consider their
plugin a placeholder until the major browser vendors start supporting
SVG natively. Innnnteresting optimism, and actually encouraging. After
receiving that email, I was most hopeful about that Mozilla page, but
its tone is mostly an expectant “Gee, it sure would be nice to support
SVG, wouldn’t it?” Oh well. This is why open source is beautiful; you
can get away with posting this sort of webpage. :)

Experimentation

A couple of things I made very quickly, hammering in just a few
lines of XML (use the plugin’s contextual menu (accessed via right
mouse button or control-click) to check out the source for yourself,
if you’d like), based on a mixture of ripping off the tutorials
available at <svg-spot> and skimming href="https://www.w3.org/TR/2000/CR-SVG-20001102/">the W3C spec
(palatable reading, but dry; I recommend a beverage on hand to ease
things):

• Look,
  circles! Transluscency! Text!
• All that again,
  except
  with motion on a predefined path, looping indefinitely.

(Note also that href="https://www.sun.com/software/xml/developers/svg/">Sun
Microsystems has an SVG resource page some tutorials that cover
specific sub-topics, and href="https://www.adobe.com/svg/tutorial/intro.html">Adobe has a general
tutorial, though it’s aimed at Illustrator users)

Since I was researching all this with ComicsML in mind, I quickly
homed in on the <image> element, which lets you import whole
files containing raster graphics — that is, the far more common image
format involving descriptions of which bits go where and with what
color on a two-dimensional grid, rather than the collections of
pure-math points, lines and arcs that form the basis of vector
graphics. This, plus the fact it takes the same coordinate and size
attributes of every other SVG element, made it a shoo-in for the first
solution I’ll create to the problem of describing comic panels’
layout. Within a few minutes I had already chopped up my example comic
and recast it in
three directions. Woowoo! It’s not the solution I was envisioning,
but definitely a start in that direction, especially considering that
fiddly bits like figureing out coordinates could be greatly assisted
through a little bit of programmatic magic.

It’s worth noting that importing these graphics goes a little bit
against the point of SVG, since raster graphics are, by definition,
neither S nor V, but the standard would never have caught on had there
not been room made for the well-established Web graphics formats we
know and love. (Well — most of them. JPEG and PNG are represented,
but not GIF. (To which I say: href="https://www.burnallgifs.org">right on.))

Interesting SVG examples

An power plant engineer made an interactive schematic of a power
generation system in SVG, letting you poke buttons to open and close
switches (or something) and watch the little things turn off and on
and spin around and stuff while numbers shuffle past. It’s the
interface the Enterprise’s power generator would have if it was
located in Wisconsin. He made some other SVG stuff, too.

A mad
map of Moscow that makes stunning use of SVG’s zoomability,
starting you a mile high, and letting you zoom, zoom, zoom in until
you can see all the individual shrubs and streetlights that someone
took the time to render. Yikes!

Finally, I like this
self-depreciatory demonstration of how JavaScript and SVG can be
combined to sink the Web into new depths of design depravity, mostly
because it’s on the W3C’s server. (Actually, it’s not all that ugly,
but I appreciate the effort nonetheless.)

The moral of the story, as far as I’m concerned, is SVG
Good, so I’m going to do what I can to support its growth, which
is to say, import its namespace into the ComicsML spec. I think it
will not only help to solve its immediate problems involving layout,
but will enourage comics creators (and their comics’ readers!) to use
this open and powerful language.

This is my first O’Reilly Network weblog entry. Now I am
l33t. Thanks, Dale and Nancy!

What do you think of those little meerkat heads at the
top? Scaled down so much, and lacking their cute little
meerkat bodies, their species becomes disturbingly
ambivalent. I think they look something like a jury of little
Edward Gorey puppets, craning their necks around in unison to peer at
something off to the right, perhaps that there Oracle ad
banner. Bizarre!!

The centerpiece application on the Developer Tools CD that ships with every copy of Mac OS X is an Integrated Development Environment (IDE) called Project Builder. This is a new effort from Apple that is adept at writing C based kernel modules, Objective C Cocoa applications, C++ based I/O drivers, and general purpose Java work. Unlike most Java capable IDEs, it launches quickly and doesn’t completely take over your monitor with tool bars and windows.

When I say that it launches quickly, I mean that it launches extremely fast compared to most of the other IDEs on the market. On my PowerBook G4, Project Builder is ready for action less than 5 seconds after double clicking on the application’s icon. Contrast this to other Java capable IDEs that take half a minute, a minute, or more to launch. To be fair, Project Builder doesn’t sport some the feature list of other IDEs. Notably it leaves interface building to external applications. And that is fine by me as I have been asking IDE makers to make a simplier tool for a long time. One that I can edit, build, and debug code in. Project Builder delivers just this and does it fairly well.

Project Builder comes with starter projects for writing Java applets, Java AWT based applications, Java Cocoa based applications, and a generic Java project type called “Java Tool”. All of these starter projects are set up to easily build reasonable products. In fact, the Java AWT based Application builds MRJ based application bundles of the type that I described in my last weblog entry.

But what if you don’t want to start a new project? What if you want to use Project Builder to work on an existing project? I wrestled with this for a while until one of the Apple developers turned me onto the misnamed “Legacy Makefile” target. The trick is to create a new target of this type, and then customize it to do execute whatever command you need to. The target takes essentially three important pieces of information:

• Program to execute.
• Arguments
• Directory to execute in

With this target, you can execute any command you want anywhere on your system. Really, this should have been named the “Custom Build Command” target type. After finding this out and setting it up to use my own build tools, I have found myself doing most of my day to day Java coding in Project Builder.

Not withstanding the good points, Project Builder is a freshman effort, and there are several rough spots that I hope Apple fixes soon. One such rough spot is that break point makers don’t maintain their relative position as you edit the code that they point to. This means that when I’m in a debugging session, and editing code, I have to keep adjusting my break points.

There also seems to be an intermittent performance issue when debugging Java code. So far, it only seems to strike me when my laptop is configured with a hostname that can not be resolved (for example, when I unplug from a DHCP network). If I have my hostname set to localhost, debugging works fine. I haven’t conclusively proven this yet, and your mileage may vary, but it seems to work for me. Apple’s developers are aware of the issue and have said that they have a fix in the works.

Even with the rough spots, Project Builder is a nice tool. If Apple keeps improving it, I may have finally found a lightweight, fast, easy to use IDE that satisfies. Something that no IDE yet has been able to do for me.

So, I’m a glutton for punishment… not only did I install Windows XP Beta 2 on my computer, but I also installed the Office XP Corporate Preview.

Everything was fine for the first few hours, but something snapped inside Office XP’s innards. Every time I start up an office program (Word, Excel, etc.), it explains to me that “Microsoft Office Professional with Frontpage has detected a significant change in your machine configuration.” Then, it asks me to insert my CD and proceeds to re-activate my product. I’ve tried deinstalling and reinstalling, but so far, it keeps making me activate the product each time I run it.

I hope this is just a glitch with the corporate preview (it is a beta, after all). I’m going to shell out $19.95 for another copy, just in case using a different product activation key helps.

Related link: https://www.jxta.org/servlets/ReadMsg?msgId=3519&listName=discuss

John Beatty, a member of the InfraSearch team (now at Sun), has coded a JXTA binding for XML-RPC. “It embraces the asynch nature of JXTA and has provisions for request handlers (on the server side) and response callbacks (on the client side).”

My.Netscape, a personal portal
sporting hundreds of channels carrying content from individual
providers, has shed its free content and become YAM*, Yet Another My.*. In the process, they also broke RSS 0.91.

A little background

When introduced in 1999, the “My” concept itself wasn’t anything
earth-shattering; after all, My* (semi-) customizable, personal
portals were all the rage. What was unique about My Nescape was its
content-gathering mechanism. Rather than simply carry the standard
for-fee fare, Netscape created a channel description framework called
RSS (”RDF Site Summary”) which allowed individual content providers to
syndicate snapshots of their latest offerings to the portal.

By providing a simple snapshot-in-a-document, web site producers
acquired audience through the presence of their content on My
Netscape. End-users got one-stop-reading, a centralized location into
which content from their favorite web sites flowed, rather than just
the sanitized streams of content syndicated into most portals. And My
Netscape, of course, acquired content for free. [ href="https://www.xml.com/pub/a/2000/07/17/syndication/rss.html">RSS:
Lightweight Web Syndication]

The original version of RSS, 0.9, was based on href="https://www.w3.org/RDF/">RDF (”Resource Description
Framework”), a framework for describing and relating resources on the
Web. This was followed shortly by RSS 0.91, re-dubbed “Rich Site
Summary,” which had dropped its RDF roots and was instead described by
a static DTD at href="https://my.netscape.com/publish/formats/rss-0.91.dtd">https://my.netscape.com/publish/formats/rss-0.91.dtd.
Don’t bother wandering over there though — I’ll explain why in a second.

Over time, folks started using RSS as a method for general metadata
and content syndication. As its use increased, so did its application
broaden. But the format itself remained unchanged, locked into its
static DTD and apparent disinterest by Netscape. Its semantics began
being overloaded, title and description elements being stuffed chock
full of dates, author information, and ad-hoc extensions began
cropping up. Extending RSS became a subject of much debate, resulting
in an eventual fork. The
technical point of contention was over a larger flat-file core with
centralized iterative extension versus a decentralized relational /
modular framework. But that’s a story of another time.

With the fizzling and eventual acquisition of Netscape, the
My.Netscape portal atrophied; down-time, stale content, and broken
links foretold of its imminent demise. Recently revamped and turned
into a My.Yahoo!-alike, its distinctive framework and catalog of associated
channels have been taken offline.

In the decommissioning process they broke RSS 0.91.

RSS 0.91’s reliance upon a DTD living on my.netscape.com has long been
an irritant. The site’s staccato reachability caused some consumers
of 0.91 to turn to non-validating XML parsers so as to still have
access to RSS feeds even when the DTD was unavailable. Many did not.

Matt Sergeant and href="https://www.xmlhack.com">Edd Dumbill today noted the complete
removal of any trace of RSS, including the 0.91 DTD itself
from the Web. Wrote Dumbill in a posting to the href="https://www.egroups.com/group/rss-dev">RSS-DEV mailing list:

This breaks all RSS 0.91 feeds that are processed by a validating XML
parser and that reference the DTD, ie. huge numbers.

It presents us with several problems:
* has anyone got a cached copy
— and –
* the DTD is (C) Netscape if I remember so hosting a cached copy is likely to be a violation of that copyright.

Failing any resolution the best things seem to be:

* short term, remove the DTD decl
* quick-as-you-can, move to a standard that doesn’t rely on DTDs, ie.
RSS 1.0.

RSS partisanship aside, this episode strikes yet another blow against
the use of centralized (specifically copyright) DTDs in an
increasingly distributed computing environment.

Related link: https://news.cnet.com/news/0-1005-200-5726313.html

Yet Another Eliza Descendant, SmarterChild is a bot accessible through AOL Instant Messenger. Add its name to your AIM Buddy List, then try it out for weather, word definitions, movie reviews and times. News.com has more details, including the developer’s plans to use instant messaging as a web services transport.

Related link: https://gaim.sourceforge.net/aol.shtml

“Every time an article gets posted on Slashdot about the AIM service that AOL provides, I see the same comments being made over and over again. A sizable percentage of those comments tend to be misinformed, or sometimes just wrong. So here’s my own thoughts and commentary on everything AOL has done with the AIM service since the announcement of TOC.” — Eric Warmenhoven, GAIM

Related link: https://www-106.ibm.com/developerworks/web/library/wa-sssl.html?t=gr,p=PHP-Perl-J…

IBM developerWorks provides a side-by-side code comparison of PHP, Perl, and Java servlet implementations of three simple Web application examples.

Related link: https://slashdot.org/article.pl?sid=01/04/20/1455252&mode=thread

Guido van Rossum answers /. readers’ questions on Python features and future, licensing hairsplitting with the Free Software Foundation, and says he’s a little tired of the Monty Python gang.

The easiest way of creating a double-clickable Java program on Mac OS X is to use Apple’s MRJAppBuilder. It creates a nifty bundle which contains all of the class and resource files needed by an application as well as some information that helps Mac OS X run it. Unfortunately, the documentation on this tool is not as accessible, or as clear, as one might like. In a very uncharacteristic move for Apple, there isn’t even a help menu.

Luckily, MRJAppBuilder is not very hard to use. After a couple of runs with the tool, I have come up with the following easy to use recipe:

• In the Application tab, fill in the Main Classname text field with the main class of your application. This is the same classname that you’d pass to the Java Virtual Machine on the command line.
• Also in the Application tab, fill in the Output File text field with the path and file name you would like your application to have.
• Click over to the Merge tab and add all the Jar files of your application.
• Click back to the Application tab and make sure that your recently added Jar files are on the classpath.
• Build the Application with the aptly named Build Application button.

After following the above process, you will have an application ready to use or distribute. To be more accurate, you will have an application bundle. This bundle will look to users via the Finder as a single file that aides its ease of use and distribution. But, under the covers is an interesting hierarchy of files that contain the secrets of how your Java application is run when you double-click on it.

You can dig into the innards of your application bundle in one of two ways. The first is to control-click on the bundle and select Show Package Contents from the pop up menu. This will open up a Finder window that you can browser the contents of the bundle with. The other is to dive in using the Terminal. Just `cd [appname].app` (the .app extension is hidden by the Finder but all application bundles have it). The following is an example of one of the application bundles that I created using MRJAppBuilder:

MRJTest.app/
MRJTest.app/Contents
MRJTest.app/Contents/Info.plist
MRJTest.app/Contents/MacOS
MRJTest.app/Contents/MacOS/JavaApplicationStub
MRJTest.app/Contents/Resources
MRJTest.app/Contents/Resources/GenericJavaApp.icns
MRJTest.app/Contents/Resources/MRJApp.properties
MRJTest.app/Contents/Resources/Java
MRJTest.app/Contents/Resources/Java/MRJTest.jar

The Info.plist file is an XML based description of some basic information that Mac OS uses to run the application. Most of the information in this file only makes sense if you have experience with building native Mac OS applications. The key configuration data it contains for our purposes tells the system to execute the JavaApplicationStub executable in the bundle. This stub is a very simple program that it copied from the JavaVM.framework. It looks at the MRJApp.properties file and then starts up a Java virtual machine based on the configuration information it finds there. Here are the important properties from my application:

com.apple.mrj.application.main=com.x180.test.MRJTest
com.apple.mrj.application.classpath=Contents/Resources/Java/MRJTest.jar:
com.apple.mrj.application.parameters=
com.apple.mrj.application.stdin=/dev/null
com.apple.mrj.application.stdout=$SYSTEM
com.apple.mrj.application.stderr=$SYSTEM
com.apple.mrj.application.profiling=false

Having access to all of this information in plain text files means that I can continue to use this created bundle even as my application is updated. For example, if I need to add a library in a Jar file, I can copy it into the Contents/Resources/Java directory of the bundle and add it to the classpath entry in the properties file. Even better, since the application bundle format is so simple, it is possible to set up a few simple build scripts and have bundles created on demand from automated build tools. This bypasses the need to manually execute MRJAppBuilder and recreate application bundles every time a program is updated.

Note: This article assumes you are comfortable using the Mac OS X Terminal and have some familiarity with downloading and extracting Unix packages.

Some of you may have installed the packages on the development CD-ROM that comes with Mac OS X. This CD includes, among many other things, GNU C and a whole bunch of compilation tools. Because Mac OS X is based on Darwin, an open source Unix in the BSD family, you can install a lot of the programs that Linux and BSD users have been enjoying. However, there are a couple of things to watch out for.

When you first download and extract some source code, you might be tempted to edit the Makefile and just run make. Or, you might not know what to do at all. The first thing you should do is cd to the source code directory and read the INSTALL and README files (the name of the source code directory is usually the name of the package with a version number, such as foo-1.2.3).

./configure
Most open source packages include a configure script that determines what type of Unix you’re using and creates whatever Makefiles are needed to compile the application. To invoke this script, type ./configure, and press enter. In some cases, this script might fail. If so, this hint might help out.
Even if that hint works, it might not always lead to a successful compilation. For example, I was able to get lynx to configure on my system, but I got a vicious “signal 10″ error during compilation. I soon learned that the most stable version of Lynx does not support Mac OS X out of the box, but the latest development version does. So, I downloaded that version, and it works fine on my machine!

The configure script is created by the autoconf package, a powerful aid in developing code that compiles on a wide range of Unix-like operating systems.

make
After you configure the source code, run the make command (unless otherwise directed by the INSTALL or README file). This will compile the code. If the compilation succeeds, you should run any tests that were supplied. These can usually be run with the command make test or make check. An error in the tests indicates that something may have gone wrong with the compilation. If this happens, you should review the documentation that comes with the source code for instructions on reporting or correcting the error.

Installing it
If all went well, you can install the program. This is usually accomplished by the command make install, but please review the README and INSTALL files first. You may need to use the sudo command to assert your administrator privileges, as in sudo make install. When you use sudo, you’ll be asked for your password. Please note that this gives you total control over the system - if you’re installing a package that is poorly configured or contains malicious code, you could end up overwriting important system files and damaging your system.

If I’m installing unfamiliar software, I usually run make install without sudo and watch what it tries to do. In most cases, it will copy some files into the /usr/local directory somewhere. For the most part, this is safe, since Mac OS X does not place any critical files in that folder. If you decide to do this dry run, you’ll get a lot of error messages as you do it, since your user account doesn’t have the privileges to create files in /usr/local.

The first thing I needed to do when starting to work with OS X’s Java implementation was set my JAVA_HOME environment variable. Several Java programs use this environment variable to help them locate various JAR files that are not on the default classpath. Since the default Terminal shell on OS X is tcsh, it is easy enough to set your JAVA_HOME to the necessary string as long as you know what that string should be. However, finding the installation directory of Java on OS X was an adventure of its own that led to some interesting questions.

To find the right value that JAVA_HOME should be set to, I first executed a `which java` in the nearest Terminal. this told me that /usr/bin/java was the executable that launched the VM. A quick `ls -l /usr/bin/java` told me that it wasn’t a symbolic link to the JDK installation that I was hoping for. Instead, it is a short shell script that executes:

exec /System/Library/Frameworks/JavaVM.framework/Versions/1.3/Commands/java "$@"

From this bit of information I was able to poke around and find that I could set JAVA_HOME to:

/System/Library/Frameworks/JavaVM.framework/Versions/1.3/Home

This was all I needed to keep everything happy. But the "Versions/1.3" string intrigued me a little bit, so I dug a bit deeper into the directory structure of the framework and actually found that I could us a shorter string:

/System/Library/Frameworks/JavaVM.framework/Home

To solve this problem forevermore, I dropped the following line into my ~/.login file:

setenv JAVA_HOME /System/Library/Frameworks/JavaVM.framework/Home

Now that I had a solution to the problem at hand, I really wanted to know more about how frameworks were implemented under OS X. After all, everything from AppKit to Cocoa and Carbon to OpenGL is contained in the /System/Library/Frameworks folder. I found the answer in Apple’s "Inside Mac OS X: System Overview". In short, a framework is a type of bundle that packages shared libraries along with resources. In addition, frameworks are versioned which should help developers address compatibility problems as OS X evolves.

After wrapping my head around frameworks for a while, I dug into the other kinds of bundles that exist in OS X, including application bundles. It turns out that items that look like single file applications in the Finder are actually hierarchically structured directories containing the program and its resources. I’ll talk more about how you can package up Java applications into these bundles in a future weblog.

Related link: https://www.netbeans.org/ide/support/mac.html

Related link: https://www.netbeans.org/ide/support/mac.html

NetBeans 3.2 is up and running on Mac OS X. However, in order to get it to work, you need to follow these instructions provided by the NetBeans team. They are easy enough to follow as long as you have access to a Windows, Solaris, or Linux machine that you can poach a needed JAR file from. New link: https://www.netbeans.org/ide/support/mac.html

A few weeks ago, I wrote a weblog entry describing my Mac OS X woes. In that entry, I explained how I couldn’t run Mac OS X on my Power Macintosh 7500 with a Sonnet G3 upgrade. Although Sonnet still hasn’t released support for this upgrade, I am running Mac OS X on it right now (I’m typing this entry in the preview edition of Microsoft Internet Explorer).

In my previous weblog entry, I suggested that Ryan Rempel’s Installation Instructions for Mac OS X OldWorld Support were best left to the adventurous and brave. After using Ryan’s instructions, I was struck by how easy it was to perform the install. Of course, your mileage may vary, but if you have time and good backups, give it a whirl.

Related link: https://www.theregister.co.uk/content/2/18233.html

‘Twas just a dream after all: Indrema’s attempt to build a Linux-based super game console hit the skids this week.

In my previous weblog, "Mixing Java and Titanium", I talked about how excited people were about the mixture of Titanium, Mac OS X, and Java. Now, it is time to dig and and see what is really going on here. What is it about Mac OS X that is so attractive? What is the substance underneath the sleek hardware and cool window effects?

First off, OS X is Unix underneath. It isn’t just a "Unix-like" OS, nor is it an OS that exposes only some POSIX-like functionality to C programmers. At any time, you can pop open a Terminal window to examine processes, grep through files, or execute a quick Perl script. Or, better yet, pipe the results of grepping through some files to a Perl script. Thankfully, Apple isn’t ashamed of the Unix foundation of OS X and hasn’t tried to hide it away from the power user. In many respects, I feel like I am running a FreeBSD operating system that lost X Windows along the way in favor of something much nicer. And that can run the latest versions of Office and Dreamweaver instead of requiring me to dual-boot.

Next, the latest and greatest Java Development Kit is already installed by default. For the first time, there is no need to surf over to java.sun.com to pick up the latest bits. As well, Apple exceeded expectations with their implementation of the JDK. Not only are Java threads mapped to Mach kernel threads (which was expected), but each virtual machine instance cooperates with other running VMs helping to increase performance. It does this by caching loaded class files as well as HotSpot compiled code in shared memory. If a class file has already been loaded and optimized by one VM, another VM can just use that code without having to perform the work again.

Finally, OS X ships with a strong suite of development tools. Apple is the first vendor to ship a consumer operating system with a fully functional set of development tools in the same box that is available at Fry’s. For no extra charge. And not only are Project Builder and Interface Builder (Apple’s excellent IDE tools) included, but so are Emacs, VI, and other Unix text editors. This is perfect for those who are comfortable using traditional tools, or who need to use something familiar when the pressure is on.

In essence, even though Mac OS X is strikingly new, it’s also surprisingly comfortable for any developer, Java or otherwise, that has any kind of a Unix background. No matter how pretty the interface is or how cool it is that movies still play as their windows are being minimized, you can get right down to work and get things accomplished. If this is what "Think Different" means, I’m all for it.

Last Saturday I attended a New Media conference at Cal Berkeley’s School of Journalism. One of the most striking qualities of the conference was a sense that not only publishers but also editors, entrepreneurs, and even reporters are just about out of patience with the current (lack of) revenue model. Publishers who a year ago would have tred lightly on issues such as paid subscriptions, big ads, and micropayments were unapologetic about their
need to make their nut. (I have to confess, after six years in online
publishing, that feeling isn’t foreign to me.)

Michael Cieply of Inside.com was on a panel discussing business models
for online publications. Earlier that week, Brill Media and Primedia had
bought Inside’s parent company, and they had annouced that Brill’s Media
would merge with Inside.com to create a paper publication, Brill’s
Inside Content. As a result, both magazines laid off close to half their
news staffs in the week that followed. Cieply said he had met with Brill
last week, who is now saying that in the near future, “Everyone will pay
for everything.” Later, an audience member asked Cieply if he thought
consumers would put up with the paid subscription model (as put forward
by, for example, Salon) any better now than they did in the past, when
it failed Slate magazine. Cieply’s reply was that “a hard-headed
decision is being made that consumer attitudes might not change, but the
people who work on these publications don’t care. We’re after the
largest number of consumers who _will_ pay.”

Travis Smith of Daily Variety echoed that sentiment. In March, Variety
abandoned what Smith described as a confusing scheme that put some
content in front of a paid wall (the day’s front-page features, news on
student films) with other content behind it (archives) and simplified
the scheme: everything is behind the paid wall “with the exception of
classifieds and the staff page — so readers can email us to complain.”
Smith said that over the past six years online publishing has relied on
a single revenue stream, “and I’m not talking about banner advertising.
I’m talking about venture capital.”

It had been a while since I had heard anyone bringing up micropayments
as a valid model for online content, but Nick Denton, a former reporter
with the Financial Times and The Economist who is founder and CEO of
Moreover.com, spoke up in favor of them. “I don’t actually believe that
the subscription model works … Micropayments is the future.” He likes
Paypal, the system that Ebay aficianados use to pay for auction items,
and sees it more in line with the way people browse the web — likely to
pay a small amount for some odd piece of content at a site they may only
visit once a month or so.

The news wasn’t all glum. Charlie Buchalter, vp of media research for
AdRelevance, said that while online ad revenues have suffered, the
number of web users and the time they spend online are at all time
highs, up from a post-holiday dip. “Show me a time over the past 100
years when advertisers haven’t found a way to appeal to a group like
this.” He said average CPMs (cost per thousand, the way advertisers have
paid for banner ad impressions) have dropped from about $35 last spring
to more like $22 now, and he expects them to continue to fall, then
stabilize in the third or fourth quarter of this year. (Note: those are
the published rates, and advertisers usually pay less than that in
practice.)

A parting thought for the day comes from something Inside’s Michael
Cieply attributed to Steven Brill — which is similar to something I’ve
heard several times from Madeline Schnapp, who works in Research here at O’Reilly: If it’s worth knowing, it’s
worth paying for. Looks like we’re going to see a lot of experimention
this year, and a lot of formerly free stuff slipping behind subscription
walls.

A couple weeks ago I received an e-mail from Steve Collins of the International HyperCard Users Group asking if I would help get the word out that HyperCard was in danger of dying unless it was ported to Mac OS X.

Since I have a soft spot for HyperCard in the same way I do for Lego and the original C-64 computer, I wrote up a piece and published it on our Mac DevCenter under the title of, The Death of HyperCard?.

I thought that a few Mac oldies such as myself might be interested in kicking around the topic, so I added our “Talk Back” function to the bottom of the article to allow the one or two interested souls to speak their peace. In honesty, I didn’t really expect much noise.

I was certainly wrong.

Based on the e-mail, the page hits, and the Talk Back postings, lots of people have thoughts about the survival of HyperCard. It’s been great discussion that I know has been monitored by those close to this issue.

If you have a feeling one way or another about HyperCard being ported to Mac OS X, you might want to read the short article and comment at the bottom. Who knows, it might have an impact.

In the meantime, I’ll stay on top of the story and report any breaking news.

At last weeks O’Reilly Conference on Java in Santa Clara I unwittingly became the guy with the coolest toy around. Whenever I pulled out my new Titanium PowerBook to get some work done, people started coming by to ask questions about it. The shiny titanium shell must have had something to do with that. However, as soon as they saw Mac OS X people’s curiosity really peaked. And as I gave demos showing the BSD underpinnings of OS X, and the excellent Java Virtual Machine implementation, they started talking about getting one. Needless to say, I didn’t actually get much work done.

©2001 D. Story/O’Reilly Network

So how did I, a self confessed Unix-weenie and sometimes Windows user end up being an unofficial Mac evangelist? Well, I’ve been looking for years for a platform that combines a good, fast Java virtual machine, a Unix command line, and the ability to keep up with the several thousand e-mail messages per day that I receive. And I wanted a platform that looked good to boot. I should mention that there has been a Mac around the house for my digital photography habit over the last few years, but it hasn’t been something that I have used for serious work.

Enter Mac OS X, a brand new operating system that takes the best of the Mach kernel, BSD, the JDK, and the Macintosh and combines them into one killer platform. As soon as Fred Sanchez, who used to work in the Core OS Group at Apple, introduced me to it several months before Public Beta I was intrigued. Now that it has gone final complete with JDK 1.3 and Hotspot, I’ve taken the plunge and moved to using a Titanium G4 full time. And it has been treating me very well. To be sure, there are a few rough edges, but overall I’m really impressed.

Back at the conference, the folks at O’Reilly noticed the number of people that were interested in this new environment (not to mention that I think a few of them want a Titanium as well) and have invited me to share my experiences with Java and Mac OS X with you in the form of these Weblogs, to give you a peek over my shoulder as I play around with this new system if you will. So, tune in over the next few weeks and I’ll do my best to give an honest hacker’s viewpoint on mixing Java and Titanium.

Cellular antennae disguised as something other than what they are are hardly a new idea. But it’s becoming easier to spot them as they proliferate. Where I live, in Northern California, they’re often disguised as pine trees. But I was amused when I saw a couple disguised as palm trees down in L.A. recently. This one is in the parking lot of In-n-Out Burger on Mission in Sylmar, just off I-5. (Forgive the poor photography; it was one of those soupy Southern California mornings, and I couldn’t do much with it.)

I’m thinking about putting up a page on the
Wireless DevCenter, with photos of interesting disguised radio antennae. Let me know if you have any in your neighborhood, or better yet, send a photo.

CNET News.com”:
“Welcome to a new world of computer programming–and say goodbye to the image of the solitary code jockey working late into the night on a diet of cold pizza and warm cola. Better yet, Extreme Programming can help produce software that is not only of higher quality, but is produced much more quickly than is the norm.”

XProgramming.com: “Extreme Programming, or XP, is a lightweight discipline of software development based on principles of simplicity, communication, feedback, and courage. XP is designed for use with small teams who need to develop software quickly in an environment of rapidly-changing requirements.”

Slashdot: “Of course, distributed hackers have been doing this for years on open source projects. Its not quite as real-time as they’re talking about here, but its fundamentally similiar.”

Extreme Programming Online Resources

• XProgramming.com - An Extreme Programming Resource
• O’Reilly Network: “Extreme Python”
• Avogato: “Extreme Programming and Open Source Software”
• Google Search for ‘extreme programming’

Extreme Programming Books

• Extreme Programming Explained: Embrace Change
• Planning Extreme Programming (The XP Series)
• Extreme Programming Installed(The XP Series)

Related link: https://my.aol.com/news/news_story.psp?type=1&cat=0200&id=0104031004560087

Oxford University and distributed computing company, United Devices, are teaming up to exploit unused PC cycles in an effort to accelerate cancer drug research. “Researchers estimate one million people will participate in the program at least once, making it possible to complete the screening of the 250 million molecules in a year.”

Related link: https://slashdot.org/yro/01/04/03/1535244.shtml

Slashdot takes a detailed look at Microsoft Passport’s Terms of Use. “Passport is the central repository for your passwords and “personal information” I’ve looked over the Passport Terms of Use and tried to give them the benefit of the doubt. But I can’t read it any other way than this.” Passport is the central gatekeeper in Microsoft’s HailStorm Web services framework.

Related link: https://www.salcentral.com/salnet/srchsal.htm

SAL, “The Web Services Network” provides a Web Service search engine, searchable by keyword, provider, and most recently updated schemas. Listing your Web Service with SAL is just a matter of uploading a WSDL schema.

Related link: https://www.freenetproject.org/#news

The latest version of Freenet (0.3.8.1) sports new Freenet Client Protocol (FCP) and XML-RPC interfaces, major boons to rapid, cross-language, cross-platform software development making use of the Freenet P2P framework.