It was basically the COM vs CORBA war. The Workplace Shell in OS/2 was based on inheritance – if you wanted to extend the shell, you subclassed one of the shell objects and overrode functions. Explorer, in Windows, being based on COM, went the other way – aggregation. The shell defined interfaces, and you implemented those interfaces.

A quote from the IBM side:

“Inheritance is dangerous, so Microsoft’s COM won’t support it.
It’s like saying divide-by-zero is dangerous, so let’s remove
the divide operation from our microprocessors.”
— Cliff Reeves, IBM Director of Objects

I wonder if IBM still has a Director of Objects. Anyway, I was reading Effective Java on Safari and I ran across this statement:

The main disadvantage of static factory methods is that classes without public or protected constructors cannot be subclassed. The same is true for nonpublic classes returned by public static factories. For example, it is impossible to subclass any of the convenience implementation classes in the Collections Framework. Arguably this can be a blessing in disguise, as it encourages programmers to use composition instead of inheritance

For some reason I guess I assumed Java would have gone the IBM way (which seemed to be the anti-Microsoft way, and Sun is all about choosing the anti-Microsoft way whenever they can) but fortunately it seems everyone agreed that COM’s model of aggregation (composition) works better in the real world, and that adding functionality by subclassing and multiple inheritance wasn’t the way to build a system. Cool.

To grant the tomcat user admin rights, edit conf/tomcat-users.xml. It starts out looking like this:

Edit it to add the admin and manager roles to the tomcat user:

If you use exactly this, you could then log in as username tomcat, password tomcat. But do yourself a favour and use a real password.

By my count there are 105 steps to follow to create your simple application.

.NET has a lot of convenience functions that make doing common things easy, and the more I work with Java, the more I yearn for that.

Today’s example: I want to load some XML and extract some text from a node.

.NET code:

1
2
3
4
XmlDocument doc = new XmlDocument();

doc.Load("myFile.xml");

XmlNode node = doc.SelectNode("/item/description");

string description = node.InnerText;

The equivalent Java code:

1
2
3
4
5
DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();

Document doc = builder.parse("myFile.xml);

XPath xpath = XPathFactory.newInstance().newXPath();

Node node = (Node)xpath.evaluate("/item/description", doc, XPathConstants.NODE);

String description = node.getTextContent();

Which of these two APIs would you rather work with?

The MetaWeblogAPI uses a hashtable of RSS keys to describe the blog entry, so the obvious way to do it would be to have the pubDate RSS item as one of the keys, but that’s not how it works.

Instead, you have to supply a dateCreated, which they describe as an ISO.8601 date.

Read the description of an ISO 8601 date, and look at the examples. Now look at the PHP code that parses this date (from here):

1
2
3
4
5
6
7
$this->year = substr($iso, 0, 4);

$this->month = substr($iso, 4, 2);

$this->day = substr($iso, 6, 2);

$this->hour = substr($iso, 9, 2);

$this->minute = substr($iso, 12, 2);

$this->second = substr($iso, 15, 2);

$this->timezone = substr($iso, 17);

Not quite an ISO 8601 date parser is it? Turns out you have to specify the date in exactly the format it wants, which is:

1
20050905T12:00:00Z

So now I can control the date I post with. Another little hurdle crossed.

WordPress supports the MetaWeblogAPI.  This API uses XML-RPC.  I started out looking for a Java wrapper for the MetaWeblogAPI, but couldn’t find anything useful.

I found a content management system named Jahai that has a MetaWeblogAPIImpl class, but it doesn’t look like it’s meant to be used standalone. 

There’s a com.sun.labs.tools.blog namespace with some useful classes with names like Blog and MetaWeblogPublisher, which I found in the bloged jar file, but I can’t find any documentation or information on these classes at all.

So what I’ve ended up doing is using the Apache XML-RPC client classes to talk XML-RPC rather than trying to find a higher level interface to it.  It’s a pretty simple protocol, so no big deal.

1
2
3
4
5
6
7
URL blogUrl = new URL("http://my.blog/path.to/xmlrpc.php);

XmlRpcClient xmlrpc = new XmlRpcClient (blogUrl);

Vector params = new Vector ();

params.addElement("blogid");

params.addElement("username");

params.addElement("password");

Object o = xmlrpc.execute ("metaWeblog.getCategories", params);

That gets back an object (a Vector I believe) that contains the categories on my blog.

Next step:  Post something.

Win32 has been how you write Windows software since Windows 95 (and that was based on Win16) – from the very first version of Windows to today, you’re creating HWNDs and sending messages to them, and calling CreateFile when you want a file and so on.

But now Vista is delivering on a whole lot of strategies at the same time.

Avalon / Xaml replaces how you create user interfaces.

Indigo replaces how you do communications.

WinFS (which will probably get rolled into Vista at some point, now that it’s gone from vaporware to betaware) replaces a lot of how you manage your data.

The rest of the .NET Framework (which will finally come with the OS so you can depend on it being there, assuming you’re targetting Vista) replaces just about everything else.

It probably won’t be for another 5 years or so, when developers can start thinking about depending on this stuff, that things will really change, but for Windows developers, it is a pretty big change.

The Mac of course has made these kinds of “forget everything you know and start over with this new technology” changes many times. It’s the courage to do this that has kept the Mac alive, and I think shows that Microsoft is on the right track.

Unfortunately, both companies are radically changing how you develop software for their platforms, and they’re completely different.

As a developer, will I ever get to use Avalon in a real app? I’m guessing not. Making a portability abstraction for Avalon and Xaml is a lot different than wrapping a button or a listbox with a generic API. Every platform has buttons and listboxes; no other platform has a Xaml equivalent yet.

The days of writing software for a single platform are coming to an end. The Mac is selling well and trending up. There’s a real need for a truly cross platform desktop software development environment.

Rich Internet Applications is one way this is heading. Strangely enough, the Flash runtime is one of the best technologies out there for it, since it’s on all the major desktop platforms, and is rich enough to write real apps in. But it’s got a significant “not for serious work” stigma to get over.

I think Java has the potential to be the cross platform rich client platform, but it seems like everyone has forgotten Java on the client. Where’s the Xaml equivalent for Java?

(After writing all this, I found this post that says the same stuff. It’s good to see I’m not the only one thinking this way).

So there’s two things to do:

• Figure out the SQL query to use with Community Server to get the data I need out
• Write some XML code to take this data and write it to disk as an XML file

The SQL Query looks like this:

1
2
3
4
5
6
7
8
9
10
11
SELECT cs_Posts.PostDate, cs_Posts.Subject, cs_Posts.Body

FROM cs_Posts INNER JOIN cs_Sections 

  ON cs_Posts.SectionID = cs_Sections.SectionID 

LEFT OUTER JOIN cs_weblog_Weblogs

 ON cs_Posts.SectionID = cs_weblog_Weblogs.SectionID 

LEFT OUTER JOIN cs_Threads 

 ON cs_Posts.ThreadID = cs_Threads.ThreadID 

LEFT OUTER JOIN cs_weblog_Posts 

 ON cs_Posts.PostID = cs_weblog_Posts.PostID

WHERE 

 (cs_Posts.PostLevel = 1) AND (cs_Sections.Name = N'steve''s blog')

This gets me 3 output columns:  PostDate, Subject, and Body.  Perfect.  Substitute my blog name for yours if you’re going to reuse this query.

Populating a DOM with these is a simple matter:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Element rootNode = xmlDoc.createElement("item");

xmlDoc.appendChild(rootNode);



Element titleNode = xmlDoc.createElement("title");

titleNode.setTextContent(subject);

rootNode.appendChild(titleNode);



Element bodyNode = xmlDoc.createElement("description");

bodyNode.setTextContent(body);

rootNode.appendChild(bodyNode);



Element dateNode = xmlDoc.createElement("pubDate");

dateNode.setTextContent(date.toString());

rootNode.appendChild(dateNode);

Now I want to figure out what the common way to write out XML with Java is.  I found the wrong way to do it.  Actually that page says “Serialization has been left as a task for vendor specific classes”.  It’s hard to believe that something as core as writing XML would be left out of the framework.

Fortunately Sun has a page that shows how to write out a DOM as an XML file (as part of their XSLT tutorial, strangely enough). 

Where in C# you’d simply write:

1
doc.Save("MyFile.xml");

The equivalent in Java is something like this:

1
2
3
4
5
6
TransformerFactory tFactory = TransformerFactory.newInstance();

Transformer transformer = tFactory.newTransformer();

File f = new File("MyFile.xml");

DOMSource source = new DOMSource(doc);

StreamResult result = new StreamResult(f);

transformer.transform(source, result);

I’m not sure why Java is so needlessly obtuse, but there it is.

But now that this part is done, I have a directory containing an xml file containing an <item> for every blog posting I wrote with .Text over the last few years.  391 items.  I’ve put the raw items here.

An idea I’ve been working on lately is using OPML to identify collections of things like mail messages and blog posts, and having web tools work with those collections, wherever they may be, rather than managing their own private copy of the data.  It’d be great to be able to refer to the Flickr metadata they manage for my photos directly, rather than having to do it through their API.  But that’s another story.

I’m not going to go through every step of the process since I’m not really writing a tutorial here, just covering the stuff I’m doing so I’ve got a log of any problems I run into, so I can refer to this the next time.  Getting started doing Java development in Eclipse is something that’s generally covered pretty well elsewhere.

One difference between Eclipse and Visual Studio took a little figuring out is that with Visual Studio, you say Start and it starts the active project, where Eclipse doesn’t have an active project concept.  You can say Run last launched, or you can select a configuration to run.  If you’ve not run your app yet, then you need to create a configuration before you can run it (by selecting Run…, clicking Java Application in the list, clicking New, and picking the class to start). 

Where this is an improvement over Visual Studio is when you’re running the same binary in multiple contexts.  The most obvious place where you’d do this is unit testing – you can create a run configuration for Java Application, one for JUnit, and run either one without needing to change any settings.

Anyway this example was easy to modify into something I could use to read the cs_Posts table out of Community Server.  The only changes were to the connection string, driver class name, and the SQL query text.

Next step:  Writing the records out as XML.