Dwight Shih: Software

Tue, 28 Oct 2003 11:58:19 GMT

If you're reading this, then please update your links. The new home is http://www.ideoplex.com/blog/topic/software/ with a new rss feed.

PS I could use some google juice at the new site.

The lights are On

Fri, 03 Oct 2003 13:00:40 GMT

The lights are on at my new digs. Unfortunately, I don't know how to implement http redirects from the Userland Radio Community Server. Please update your links to the new location.

Going Dark

Wed, 01 Oct 2003 13:50:35 GMT

Take the First Step will be dormant for a few days. I'm in the process of moving to my own domain and will be posting infrequently until the process is complete.

I'd buy Radio Userland Again

Sat, 27 Sep 2003 23:02:39 GMT

Mark Beaty also asks whether Radio Userland is worth $39.95 – I think so. The primary contenders for hosted weblogs are Userland, TypePad and Blogger. The lowest cost TypePad option is $49.50 per year, the free Blogger weblog doesn't provide RSS, and Blogger Pro is no longer available. At $39.95 per year (for continued support and hosting), Radio Userland has an attractive feature/cost ratio.

The real question is whether you prefer smart client/dumb server or dumb client/smart server? I like having a lightweight desktop CMS, so I like Radio Userland – your mileage may vary. Both Userland and TypePad offer a free 30-day trial. My advice is to try them out before making a decision.

In fact, I'm willing to pay Userland more. I'd pay for my own domain name. And I'd also pay to be on a faster server – especially for referrer statistics. Since I don't have that option, I plan to move to my own hosted space in the near future.

Tue, 26 Aug 2003 22:58:27 GMT

Mea Culpa: I was taking another look at the Hibernate documentation in preparation for playing with persistent subclasses when I came across the mutable property. And I realized that I had said that Hibernate shouldn't be used for immutable classes when I meant to say that you need to be wary of comparing object references from different Hibernate sessions. I've corrected Hibernate Prototyping with the BeanShell.

IT Still a Great Career

Mon, 25 Aug 2003 23:33:38 GMT

Nothing is better than getting paid to do something that you would do anyway. There aren't many professions that you can say that about, but I think that's still true of IT. IT lives in a junction of logical thought and creative expression that stretches and challenges your mind like few other things can.

Yes, IT is under attack from outsourcing, foreign competition and a poor economy. But what isn't? And while outsourcing support looks good on the bottom line, it's often more of a cost shift than a savings – fine when shifting costs to your customers but not so good when shifting costs to your business units.

So I think that it would be a mistake for Tim Bray to guide his son away from this profession. He should make sure that he has exposure to other careers. But if the kid has the knack (he certainly has the genes), then I wouldn't fight it.

RSS, Email and 1-to-1 Marketing

Thu, 21 Aug 2003 12:47:25 GMT

To my way of thinking, RSS is most effective as a broadcast medium while email is most effective as a narrowcast medium. When we're broadcasting, we're trying to generate buzz – an awareness of who we are, what we do, and why we're good people. We're interested in the aggregate effect: how many readers, reader retention, and the like. But when we're narrowcasting, we're trying to elicit a specific reader action. Our focus is on the individual response.

In 1-to-1 Marketing, we want to take members of our broadcast audience and convert them to narrowcast and eventually customer. The evolution from broadcast to narrowcast to customer necessitates a loss of anonymity. We develop more information about individuals so that we can target information and proposals for them.

If RSS is to play a significant role in that evolution, then it needs to distinguish between readers and become part of the process of learning about individual readers. Returning to yesterday's request for a standard block of [anonymous] IDs, many people won't want to be a part of that process. It's best to recognize that and provide a mechanism that works within your overall marketing effort.

RSS User IDs

Wed, 20 Aug 2003 11:47:36 GMT

Well, I guess I wasn't paying close attention to the feedback on Tim Bray's counting RSS subscribers – Greg Reinacker describes a method for automatically assigning RSS user IDs (and Derek Scruggs' work on counting RSS subscribers). I have my misgivings, but it looks promising.

Derek has concerns about aggregator support for HTTP 301 redirects and ETag headers. I'd like to add aggregator support for user IDs to the list. It's the wild west in RSS and aggregators right now and people will be hopping around for a while. So we need to easily transfer user IDs from aggregator to aggregator. And we need to balance that against the ability to refer others to RSS feeds without piggy backing on existing user IDs.

Plus, I think that people will always want a safety net of anonymity. So it might be nice to reserve a standard block of IDs for that purpose – an aggregator could then be configured to randomly use an ID from that block for a given feed.

I still think that email marketing has a lot of life left in it. But maybe RSS is ready to take on more of the load than I had thought.

Marketing by RSS

Tue, 19 Aug 2003 13:48:34 GMT

I love RSS as much as anyone else, but we don't do anyone any favors when we refuse to take off the rose-colored sunglasses. Chris Pirillo throws some brickbats at an RSS doubter, but I happen to agree with the doubter on several points:

You can't reliably measure exposure via RSS.
You can't control how RSS is displayed.
RSS doesn't build a user database.
RSS is difficult to customize - as a response driver - the way email is.

Tim Bray brought up the issue of RSS Subscriber Counting before, but the nay-sayers shut down the conversation before we had a good answer. The most valuable subscribers are the most likely to be sitting behind a proxy server and the most likely to be lost in the shuffle. Just how is RSS going to address that?

Maybe I'm dense. But I don't see how anyone is going to build a RSS user database, segment the users and target the segments independently – remembering that a user may belong to multiple segments. I happen to believe in 1-to-1 marketing, how does RSS fit into that world?

And don't expect to control presentation in my RSS aggregator. I don't think one-page aggregators are going away and I don't think anyone is up to the job of blending dozen's of presentation formats on the same page.

Now, maybe spam spells the end of email marketing. But I think email is important enough that we'll fix it before it dies. And that we'll see RSS become one of the tools in marketing's toolchest – supplementing email, not replacing it.

Hibernate Prototyping with the BeanShell

Mon, 18 Aug 2003 13:01:29 GMT

Just playing around is one of my favorite ways of becoming familiar with software. Let's see how we can use the BeanShell to prototype Hibernate. I'm partial towards the BeanShell because it's embedded in my Java Development Environment for Emacs. But if you're so inclined, then Jython will probably do as well. Just in case there is a lurking configuration gotcha, here's my current Java software configuration.

I must confess that I wasn't planning on using the BeanShell. I was planning on adding a simple interpreter with java.io.StreamTokenizer to allow interactive manipulation of Keyword and KeySet objects. And then I realized that by setting the fork attribute of the java task to true separated my application from the console input. And setting it to false terminates the application with an java.lang.ExceptionInInitializerError. The BeanShell was my ticket out.

BeanShell support requires just a handfull of minor changes to our build file. First, the BSH property is added to reference the BeanShell jar and it is prepended to classpath.run to form classpath.bsh. Second, a new bsh target is added in parallel to the run target — note that we use class bsh.Console rather than bsh.Interpreter because we still lose access to console input because of the JVM fork. And Finally, the dist target was modified to include a bsh sub-directory.

<project default="all">
         <!-- ... -->
  <property name="LOG4J"    location="/Projects/Java/Lib/log4j.jar" />
  <property name="BSH"      location="/Projects/Java/Lib/bsh.jar" />

         <!-- ... -->
  <path id="classpath.bsh">
    <pathelement location="${BSH}" />
    <path refid="classpath.run" />
  </path>

         <!-- ... -->
  <target name="setup-run" depends="clean-run">
    <condition property="LOG4J_OUT" value="log4j-to-stdout.properties">
      <istrue value="${TALK}"/>
    </condition>
    <condition property="LOG4J_OUT" value="log4j-to-file.properties">
      <isfalse value="${TALK}"/>
    </condition>
  </target>
  <target name="run" depends="compile,setup-run">
    <java classname="Main"
          fork="true">
      <classpath refid="classpath.run" />
      <sysproperty key="log4j.configuration" value="${LOG4J_OUT}" />
    </java>
  </target>
  <target name="bsh" depends="compile,setup-run">
    <java classname="bsh.Console"
          fork="true">
      <classpath refid="classpath.bsh" />
      <sysproperty key="log4j.configuration" value="${LOG4J_OUT}" />
    </java>
  </target>
  <target name="clean-run">
    <delete verbose="${TALK}" file="hibernate.log" />
  </target>

         <!-- ... -->
  <target name="dist">
    <zip destfile="distrib.zip"
         basedir="."
         includes="build.xml,src/**,cfg/**,bsh/**"
         excludes="src/prj.el"
         />
  </target>
         <!-- ... -->

</project>

Next, we'll create a Scripted Object to simplify our interaction with hibernate. The Hibernate method returns an object that provides easy access to the most common functionality: open, save, find, delete and close.

import net.sf.hibernate.cfg.Configuration;
import net.sf.hibernate.SessionFactory;
import net.sf.hibernate.Session;
import net.sf.hibernate.Transaction;
import net.sf.hibernate.MappingException;
import net.sf.hibernate.HibernateException;

Hibernate() {
    Configuration cfg = new Configuration();
    cfg.addClass( hb.Keyword.class );
    cfg.addClass( hb.KeySet.class );
    SessionFactory factory = cfg.buildSessionFactory();
    Session session = factory.openSession();

    void open() {
        session = factory.openSession();
    }

    void close() {
        session = null;
    }

    void save( Object o ) {
        session.saveOrUpdate( o );
    }

    void delete( Object o ) {
        session.delete( o );
    }

    Transaction transaction() {
        return session.beginTransaction();
    }

    Object findByName( String className, String objName )
    {
        java.util.List existing;
        if ( objName == null || objName.length()==0 ) {
            existing = session.find( "from " + className );
        }
        else {
            existing = session.find( "from " + className +
                                     " as o where o.name='" + objName + "'" );
        }

        if ( existing.isEmpty() ) {
            return null;
        }
        else {
            return existing.get(0);
        }
    }

    return this;
}

Finally, two methods were added each of the KeySet and Keyword classes. The KeySet class gained an add and a remove method that simply provide access to the corresponding methods of the java.util.Set member variable. And the Keyword class gained methods for hashCode and equals — this insures that Keyword objects are equivalent when their String member variables are equivalent.

public class Keyword {
    //...
    /**
     * Hashcode generation
     */
    public int hashCode()
    {
        return ( this.name == null ) ? 0 : this.name.hashCode();
    }

    /**
     * Equality test
     * @param other The Object to be checked for equality
     */
    public boolean equals(Object other) {
        boolean equality = false;

        if ( this.getClass() == other.getClass() ) {
            Keyword otherWord = (Keyword) other;

            if ( this.id != unset_value && this.id == otherWord.id ) {
                equality = true;
            }
            else if ( this.name.equals( otherWord.name) ) {
                equality = true;
                if ( this.id == unset_value ) {
                    this.id = otherWord.id;
                }
                else if ( otherWord.id == unset_value ) {
                    otherWord.id = this.id;
                }
            }
        }

        return equality;
    }
    // ...
}

And now we're ready to play with the BeanShell (starting with an empty database). By the way, if you're anything like me, then the number one thing to remember is use print rather than println.

We can use the BeanShell to see that we ~~cannot use Hibernate for immutable objects~~ need to be careful when comparing objects from different sessions:

1.3b2 - by Pat Niemeyer (pat@pat.net)
bsh % source("bsh/Hibernate.bsh");
bsh % import hb.*;
bsh % hb = Hibernate();
bsh % x = hb.findByName("Keyword","this");
bsh % y = hb.findByName("Keyword","this");
bsh % hb.close();
bsh % hb.open();
bsh % z = hb.findByName("Keyword","this");
bsh % hb.close();
bsh % print( (x==y) ? "equal" : "not-equal" );
equal
bsh % print( (x==z) ? "equal" : "not-equal" );
not-equal
bsh %

We also see that Hibernate performs a shallow save rather than a deep save:

1.3b2 - by Pat Niemeyer (pat@pat.net)
bsh % source("bsh/Hibernate.bsh");
bsh % import hb.*;
bsh % hb = Hibernate();
bsh % tx = hb.transaction();
bsh % a = new Keyword("red");
bsh % s = new KeySet("colors");
bsh % s.add(a);
bsh % print(s);
{-1:colors|[-1:red]}
bsh % hb.save(s);
bsh % tx.commit();
// Error: // Uncaught Exception: Method Invocation tx.commit :
                                 at Line: 1 : in file: <unknown file>
                                 : tx .commit ( )

Target exception: net.sf.hibernate.TransientObjectException:
                                 object references an unsaved transient instance
                                 - save the transient instance before flushing

net.sf.hibernate.TransientObjectException:
                                 object references an unsaved transient instance
                                 - save the transient instance before flushing
	at net.sf.hibernate.impl.SessionImpl.getEntityIdentifierIfNotUnsaved
                                 (SessionImpl.java:2357)
	at net.sf.hibernate.type.EntityType.getIdentifier(EntityType.java:55)
	at net.sf.hibernate.type.ManyToOneType.nullSafeSet(ManyToOneType.java:33)
	at net.sf.hibernate.collection.CollectionPersister.writeElement
                                 (CollectionPersister.java:458)
	at net.sf.hibernate.collection.Set.writeTo(Set.java:226)
	at net.sf.hibernate.collection.CollectionPersister.recreate
                                 (CollectionPersister.java:692)
	at net.sf.hibernate.impl.ScheduledCollectionRecreate.execute
                                 (ScheduledCollectionRecreate.java:23)
	at net.sf.hibernate.impl.SessionImpl.executeAll(SessionImpl.java:2101)
	at net.sf.hibernate.impl.SessionImpl.execute(SessionImpl.java:2077)
	at net.sf.hibernate.impl.SessionImpl.flush(SessionImpl.java:2017)
	at net.sf.hibernate.transaction.JDBCTransaction.commit
                                 (JDBCTransaction.java:57)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke
                                 (NativeMethodAccessorImpl.java:39)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke
                                 (DelegatingMethodAccessorImpl.java:25)
	at java.lang.reflect.Method.invoke(Method.java:324)
	at bsh.Reflect.invokeOnMethod(Unknown Source)
	at bsh.Reflect.invokeObjectMethod(Unknown Source)
	at bsh.Name.invokeMethod(Unknown Source)
	at bsh.BSHMethodInvocation.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.Interpreter.run(Unknown Source)
	at java.lang.Thread.run(Thread.java:554)
bsh % tx.rollback();
bsh % hb.close();

We're done for now. You're ready to download the source to prototype Hibernate with the BeanShell and play.

Disclaimer: I don't claim to be an expert on hibernate. Please send comments and corrections.

Drawing the Line

Thu, 14 Aug 2003 15:33:21 GMT

One of the hardest tasks in developing new systems is knowing where to draw the line — include too much and you'll never finish, include too little and all you have is a toy. So I think that Joi is being a bit harsh in his guess that there were people who were voicing concerns who had more vision. The problem lies in separating the true visionaries from the false prophets. SMTP and IPv4 have had a pretty good run over the past few decades — not too bad for what were essentially 0.x releases.

Now if Joi wants to throw some brickbats at those who deny that there is a problem or those who stand in the way of improvement while waiting for a perfect solution, then the line forms behind me.

Welcome to the Neighbloghood

Wed, 13 Aug 2003 12:51:08 GMT

I was doing the usual obsessive compulsive review of my referrals when I came across fredshouse.net. Gene and I go waaay back, and I'm happy to welcome him to the blogroll (maybe this will get him off the snide at Technorati).

In other blogroll news, the BallBlog is joining the blog gang at FanBlogs. I think that we're going to see more blogging confederations as individuals find themselves unable to write as frequently as they'd like.

Maybe it's a function of the tools, but I'm surprised that I don't see more confederations formed by a central blog linking to contributor blogs. It's hard for an individual to maintain critical mass over multiple categories — just take a look at my Sports Category for July. But a group can easily maintain an on-topic critical mass while letting the individuals maintain a more eclectic style at home.

Three Laws of Nonsense

Mon, 11 Aug 2003 13:50:38 GMT

From Column two, a reminder of why we need to understand stakeholder perspectives before reaching conclusions:

The source of nonsense is that for every piece of nonsense there exists an irrelevant frame of reference in which the item is sensible.
The persistance of nonsense comes from rigorous arguments from inapplicable assumptions.
The diffusion of nonsense results from the fact that people are more specialist than problems.

Full Posts vs Headlines

Sun, 10 Aug 2003 13:27:02 GMT

Sean Bonner would like for everyone to change your RSS feed [to] display your WHOLE post. I think that Sean is talking to the wrong audience — he should be appealing to the NewsReader developers.

I choose to make the full content of Take the First Step is available in my RSS feeds. But if someone has made a conscious decision to have excerpts rather than the full post in their feed, then that's fine by me. In fact, if their website is part of their brand, then that's the right choice for them.

What Sean really needs is a NewsReader that acknowledges that we live in a world of Always drifting between On and Off. A reader that would let him mark articles to be downloaded and read at a later time. And eventually, a Reader with predictive capability that could pre-fetch articles for you.

via Lockergnome's RSS Resource.

A Persistent Collection with Hibernate

Wed, 06 Aug 2003 13:10:55 GMT

Our series on Hibernate continues with the addition of a Hibernate collection. The collection is a basic building block in programming and storing Keyword objects inside a KeySet collection object gives us an easy way to query and display our persistent objects.

The first step in implementing our KeySet class is deciding whether there will be a one-to-many or a many-to-many relationship between KeySet and Keyword objects. A Keyword object may not be contained in multiple KeySet objects in a one-to-many relationship and it may be contained in multiple KeySet objects in a many-to-many relationship.

This example will use a many-to-many relationship. This requires a new table with two foreign keys tying KeySets and Keywords rows together — a one-to-many relationship would require a foreign key in the Keywords table that referenced the KeySets table. The KeySet.hbm.xml file follows (comments show the SQL used to create the respective tables). It is quite similar to the Keyword.hbm.xml file with the addition of the set tag.

<hibernate-mapping>
  <!-- CREATE TABLE KEYSETS ( ID IDENTITY, NAME VARCHAR(25) );
    -->
  <class name="hb.KeySet" 
         table="keysets">

    <id name="id" 
        type="integer"
        column="id"
        unsaved-value="-1">
      <generator class="identity"/>
    </id>

    <property name="name" 
              column="NAME" 
              not-null="true" 
              unique="true"
              />

    <!-- CREATE TABLE KEYSET_WORD ( SET_ID INTEGER NOT NULL,
                        KEY_ID INTEGER NOT NULL,
                        PRIMARY KEY ( SET_ID, KEY_ID ),
                        FOREIGN KEY ( SET_ID ) references KEYSETS(ID),
                        FOREIGN KEY ( KEY_ID ) references KEYWORDS(ID) );
      -->
    <set name="keys"
         lazy="false"
         table="keyset_word">
      <key column="set_id"/>
      <many-to-many class="hb.Keyword"
                    column="key_id"
                    />
    </set>

  </class>
</hibernate-mapping>

We will skip the KeySet.java class as it is primarily boilerplate get/set methods and is quite similar to the Keyword.java class. However, please note that there are some changes to our Keyword implementation:

The parameter definition unsaved-value="-1" has been added to Keyword.hbm.xml to explicitly declare an unsaved id value. And the static final int unsaved_value = -1 has been added to the Keyword java file and is used to set the initial value of the id member value. The two values need to match and should correspond to an invalid id value.
The default constructor and the setId function are now protected. Hibernate sets the id when an object is loaded or saved and everything else should leave it alone.
A toString() method has been added for easy output.

In addition, the build.xml file has been modified to add a DEBUG property that defines the value of the debug attribute of the javac task. The DEBUG property is set to true and Java source is now compiled with debug information.

Now let's take a look at some code to load, query and create persistent objects. First, don't forget to add the class to the configuration object. The error message "net.sf.hibernate.QueryException: unexpected token: as [from KeySet as ks ...]" can be a bit perplexing until you've encountered it a few times.

    Configuration cfg = new Configuration();
    cfg.addClass( hb.Keyword.class );
    cfg.addClass( hb.KeySet.class );

    SessionFactory sessions = cfg.buildSessionFactory();
    Session session = sessions.openSession();

Second, let's query for a KeySet object.

        tx = session.beginTransaction();
        List existing = session.find( "from KeySet as ks where ks.name='colors'" );

If we find the KeySet we're looking for, then we print it. Otherwise, we create a KeySet object, populate it with two Keyword objects and persist all three objects.

        if ( ! existing.isEmpty() ) {
            ks = (KeySet) existing.get(0);
            System.out.println( "Read " + ks );
        }
        else {
            Set set = new HashSet();

            kw = new Keyword( "red" );
            session.save( kw );
            set.add( kw );

            kw = new Keyword( "blue" );
            session.save( kw );
            set.add( kw );

            ks = new KeySet( "colors" );
            ks.setKeys( set );
            session.save( ks );

            System.out.println( "Create " + ks );
        }
        tx.commit();

Now, start with a clean database and execute twice:

$ ant run
Buildfile: build.xml

init:

compile:

clean-run:

setup-run:

run:
     [java] Create {0:colors|[1:blue, 0:red]}

BUILD SUCCESSFUL
Total time: 14 seconds
$ ant run
Buildfile: build.xml

init:

compile:

clean-run:
   [delete] Deleting: /Projects/Learn/Hibernate/Simple/hibernate.log

setup-run:

run:
     [java] Read {0:colors|[0:red, 1:blue]}

BUILD SUCCESSFUL
Total time: 13 seconds

Success, we've stopped adding persistent objects to the database with every execution. And we've stored and retrieved objects. You can download the source for this simple Hibernate collection. As a reminder, here is my hibernate software configuration.

Disclaimer: I don't claim to be an expert on hibernate. Please send comments and corrections.

I've Grown Accustomed to Radio Userland

Tue, 05 Aug 2003 12:40:20 GMT

TypePad goes live and it will soon be time to fish or cut bait. Will it be TypePad, Radio Userland, or both? I've been part of the TypePad beta over the past month, and it has been a very pleasant experience. I would not hesitate to recommend TypePad.

TypePad has some features that Radio lacks. It was nice to be able to create an extended post rather than my standard hack of an excerpt on my home weblog pointing to a full post in the software category. And since I tend to ruminate over my postings for a bit, I liked how TypePad let me control the time associated with my post. And while I didn't have any problems with TypePad, I did have some questions and it was good to have an infrastructure for help tickets.

But I've grown accustomed to Radio Userland. I like having a local system. The Radio news reader is still my favorite. And it's a real pain to move a weblog. So right now, I'm leaning towards staying put. I think the next move for Take the First Step will be when I get my own domain name. Now if I could only snag a good name.

This is True

Sat, 02 Aug 2003 14:09:15 GMT

I've been predicting the conversion of newsletters from email to RSS for a while now, so it feels good to be proven correct. The free version of This is True is now available via RSS:

By using a special reader, you can get regular information -- including news and newsletter subscriptions -- from multiple web sites, all in one place. No more running from site to site to see if there are updates you are interested in. This is True's free edition is now available by RSS feed.
...

There's much more info coming, but for now here are some places to get you started (as always, outside links open in a new window):

If you use MS Outlook (not Outlook Express) an excellent integrated reader is News Gator

A web-based aggregator: Meercat

A stand-alone program for Windows: Headline Viewer. Others include NewzCrawler, KlipFolio, and FeedDemon (still in beta)

A stand-alone progrom for Macintosh (OS-X): NetNewsWire

For an interesting tutorial (mainly targeting publishers), see this page.

Fear of Failure

Fri, 01 Aug 2003 22:14:49 GMT

We've all heard the sports bromide play to win. So it's quite interesting that scientists say that managers, coaches and players are too cautious for their own good. It seems that their focus on the worst-case scenario prevents them from following the optimum strategy – fear of failure trumps cold logic.

Contrast that with Silicon Valley — the characteristic that is hardest to duplicate is it's acceptance of failure. A stint at a failed company is a black mark in most places. In Silicon Valley, it's a degree from the school of hard knocks.

My RSS Brand

Mon, 28 Jul 2003 23:39:09 GMT

My RSS feeds contain the full text of Take the First Step. I occasionally provide an excerpt on the main feed, but I always provide the full text in the appropriate category (Software and Sports). This is the right thing for me — the content is my brand.

Presentation is part of the brand for many of us, and Zeldman carries the flag for those who like to see our writing in its visual context. He hand rolls his feed to support his brand. But don't try to extend your presentational brand into my news reader and expect me to be happy about it.

First of all, I like my text black on white and I find a lot of weblogs hard to read because of their color choices. I could put together a local style sheet. But I like to think that people have a good reason for their style sheet choices. And I prefer to respect those choices (but if I could apply style sheets on a site by site basis, then all bets are off).

And Second, my news reader is currently presents up to 100 RSS items on a single page. Even if it were possible to present each item with a unique style, I wouldn't want to look at it. And aside from that, are you really willing to test your style selections on all the popular rendering engines?

If your web site is part of your brand, then use your RSS feed to drive traffic back to it. But don't expect to project your web site presentation back into my news reader. Because it's probably not going to work. And if it does work, then I'm probably going to unsubscribe.

Musing about RSS

Fri, 25 Jul 2003 13:49:05 GMT

The new RSS feeds from InfoWorld are looking good. They now provide a much better summary of the article by including the first paragraph of the article. Now, some would argue that the feed should provide the full article text in exchange for any ads, but I think that underestimates the excerpt value. Because they tell me to ignore InfoWorld much more often then they tell me to pay attention. And I'm willing to trade an ad in my feed for that. Hmmm, no ads today — did InfoWorld drop the RSS ad idea while I wasn't paying attention?

Plus, I think that it's only a matter of time before someone adds predictive capability to a newsreader to pre-fetch articles that you're likely to select. Then we could head off on a plane or train with a stack of bits to read. And why not mark an article to fetch once a network connection is available? On the way in, you could mark articles to read on the way back. For all the promise of Always On, the reality is Always drifting between On and Off — RSS newsreaders should reflect that reality.

And why don't more newsreaders download in the background? I'd much rather continue consuming my feed rather than waiting for an article to load — one of the big pluses of a web-based newsreader like Radio Userland in a tab-cabable browser.

Corporate/Personal Identity

Fri, 25 Jul 2003 03:11:15 GMT

Maybe I'm missing something, but it seems to me that John Robb's missing weblog is not really about control. It's really about the blurring of the lines between our Corporate and our Personal Identities. We don't expect to keep our email addresses when we leave a company, why would we expect to keep a corporate supplied weblog?

If UserLand were to be acquired by another company, then it's conceivable that we might someday see Scripting News sundered from Dave Winer. I'm sure that Dave would try to negotiate ownership of Scripting News as part of any acquistion. But I have to think that Scripting News also represents a significant corporate asset and it might not be on the table.

So the moral is to keep cognizant of corporate identity and assets vs personal identity and assets. Because they're not hard to keep separate if you start out that way. But once they mingle, corporate will win almost every time.

An Envelope, not a Format

Wed, 23 Jul 2003 13:13:15 GMT

RSS 2.0 has been rejuvenated — both the Triumvirate and the SSF-DEV are hard at work. And as I've been thinking about RSS, I think that we need to emphasize RSS as an envelope, not a format.

Because the value of the envelope lies in the package that it delivers. It liberates us from delivery concerns and focuses our thoughts on the package. And it forces us to recognize that the envelope can have different meanings for different packages.

We need to leave some wiggle room for packages to interpret the standard flexibly. And while it would be nice to nail down the guid, we don't really want to shackle all possible packages with our existing weblog/aggregator implemenation baggage.

So please distinguish between what the standard wants, and how application domains interpret.

I Love RSS

Tue, 22 Jul 2003 12:32:32 GMT

Right now, I'm trying out the RSS capability inside OddPost. If I subscribe, then OddPost would become the third aggregator that I've purchased (joining Radio UserLand and NewsGator).

The appeal of OddPost is that it makes RSS available via an IMAP server, providing a single point to read and archive RSS. I'm also lobbying FastMail (my IMAP email provider) to provide an equivalent capability and looking at scripting Outlook and NewsGator. And since I'm already at "Good Enough", do nothing is always a leading contender. We'll see what happens.

Bravo

Sat, 19 Jul 2003 22:00:20 GMT

RSS 2.0 spec to Berkman Center for Internet & Society at Harvard Law School. This is a big step forward. Pie/Necho/Atom seems to be taking a revolutionary path rather than an evolutionary one. And RSS 2.0 seemed to be painted in a corner. But the transfer of copyright from UserLand Software to the Berkman Center opens up an evolutionary path for RSS 2.x.

Of course, now the hard work begins — where does RSS 2.0 go from here?

Controlling Hibernate Output with Log4J

Thu, 17 Jul 2003 13:08:27 GMT

Our Simple Hibernate Application is a bit verbose. That's probably okay for a web application because stdout actually ends up in a server log. But it's a bit annoying in console application. Fortunately, Hibernate uses the Apache commons-logging abstraction layer and Hibernate logging is easily configured.

First, a quick aside on logging. Logging packages are a mechanism that allow a developer to add diagnostic messages to the code and specify the message level and destination at runtime. The design allows the developer to define a hierarchical logging structure in which each level inherits the properties of the level above it unless otherwise specified. Typically, the logging structure mirrors the package structure as that is both simple and effective. The JCL Users Guide is a good place to start for more information.

Apache commons-logging supports the log4j, JDK 1.4, and JCL SimpleLog Logging packages. We'll use log4j because I'm already familiar with it and the Hibernate distribution includes a sample log4j.properties file.

Here are the required changes to our build.xml file (shown in bold). First, there is a new property that locates the log4j jar file. And second, the log4j jar file is added to the execution classpath.

<project default="all">
  <property name="HBM-HOME" location="/Projects/Java/hibernate" />
  <property name="JDBC"     location="/Projects/Server/hsqldb/lib/hsqldb.jar" />
  <property name="LOG4J"    location="/Projects/Java/Lib/log4j.jar" />

  <property name="src-dir"  location="src" />
  <property name="cfg-dir"  location="cfg" />
  <property name="obj-dir"  location="obj" />
  <property name="TALK"     value="false" />

  <path id="classpath.base">
    <pathelement location="${obj-dir}" />
    <pathelement location="${HBM-HOME}/hibernate2.jar" />
    <fileset dir="${HBM-HOME}/lib" includes="**/*.jar" />
    <pathelement location="${JDBC}" />
  </path>
  <path id="classpath.run">
    <pathelement location="${cfg-dir}" />
    <path refid="classpath.base" />
    <pathelement location="${LOG4J}" />
  </path>

  <target name="init">
    <mkdir dir="${obj-dir}" />
  </target>

  ...

</project>

And here is the log4j.properties file from my hibernate distribution.

The first block of parameters define an output channel identified as stdout. This channel directs messages to the standard output.
The second block of parameters define an output channel identified as file. This channel directs messages to the hibernate.log file.
The rootLogger assignment defines the default behavior as directing messages at or more severe than the warn level to the stdout channel.
And the remaining assignments change the output levels to info for the respective packages.

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ##

log4j.rootLogger=warn, stdout

log4j.logger.net.sf.hibernate=info

### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.net.sf.hibernate.connection.DriverManagerConnectionProvider=trace

### log JDBC bind parameters ###
log4j.logger.net.sf.hibernate.type=info

### log prepared statement cache activity ###
log4j.logger.net.sf.hibernate.ps.PreparedStatementCache=info

The easiest solution is to simply uncomment the lines defining the file channel and redefine the rootLogger to use the file channel. This will direct the log output to the hibernate.log file.

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file hibernate.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=hibernate.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ##

log4j.rootLogger=warn, file

log4j.logger.net.sf.hibernate=info

### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.net.sf.hibernate.connection.DriverManagerConnectionProvider=trace

### log JDBC bind parameters ###
log4j.logger.net.sf.hibernate.type=info

### log prepared statement cache activity ###
log4j.logger.net.sf.hibernate.ps.PreparedStatementCache=info

But here's another option. We'll create two properties files, one that directs the output to hibernate.log and another that directs the output to both System.out and hibernate.log. Then we'll use the condition task and the java sysproperty task to specify the desired configuration file based upon the value of the TALK property.

<project default="all">
  < ... >

  <target name="setup-run" depends="clean-run">
    <condition property="LOG4J_OUT" value="log4j-to-stdout.properties">
      <istrue value="${TALK}"/>
    </condition>
    <condition property="LOG4J_OUT" value="log4j-to-file.properties">
      <isfalse value="${TALK}"/>
    </condition>
  </target>
  <target name="run" depends="compile,setup-run">
    <java classname="Main"
          fork="true">
      <classpath refid="classpath.run" />
      <sysproperty key="log4j.configuration" value="${LOG4J_OUT}" />
    </java>
  </target>
  <target name="clean-run">
    <delete verbose="${TALK}" file="hibernate.log" />
  </target>

  < ... >
</project>

Now we can specify via the command line whether to view the logging messages on System.out or not.

$ ant run
Buildfile: build.xml

init:

compile:

clean-run:

setup-run:

run:

BUILD SUCCESSFUL
Total time: 12 seconds
$ wc -l hibernate.log 
      15 hibernate.log
$ ant -DTALK=true run
Buildfile: build.xml

init:

compile:

clean-run:
   [delete] Deleting: /Projects/Learn/Hibernate/Simple/hibernate.log

setup-run:

run:
     [java] 15:38:16,872  INFO Environment:401
                          - Hibernate 2.0.1
     [java] 15:38:16,898  INFO Environment:435
                          - loaded properties ... 
     [java] 15:38:16,942  INFO Environment:450
                          - using CGLIB reflection optimizer
     [java] 15:38:17,029  INFO Environment:460
                          - JVM proxy support: true
     [java] 15:38:17,080  INFO Configuration:283 
                         - Mapping resource: hb/Keyword.hbm.xml
     [java] 15:38:20,273  INFO Binder:176
                          - Mapping class: hb.Keyword -> keywords
     [java] 15:38:21,977  INFO SessionFactoryImpl:140
                               - building session factory
     [java] 15:38:22,114  INFO Dialect:37
                               - Using dialect: net.sf.hibernate.dialect.HSQLDialect
     [java] 15:38:22,167  INFO DriverManagerConnectionProvider:41
                               - Hibernate connection pool size: 2
     [java] 15:38:22,249  INFO DriverManagerConnectionProvider:70
                               - using driver: org.hsqldb.jdbcDriver
                                 at URL: jdbc:hsqldb:hsql://localhost
     [java] 15:38:22,259  INFO DriverManagerConnectionProvider:71
                               - connection properties: {user=user, password=user}
     [java] 15:38:22,260  INFO SessionFactoryImpl:170
                               - Use outer join fetching: false
     [java] 15:38:22,533  INFO SessionFactoryImpl:193
                               - Use scrollable result sets: true
     [java] 15:38:23,623  INFO SessionFactoryObjectFactory:82
                               - no JDNI name configured
     [java] 15:38:23,627  INFO SessionFactoryImpl:287
                               - Query language substitutions: {}

BUILD SUCCESSFUL
Total time: 13 seconds
$ wc -l hibernate.log 
      15 hibernate.log
$ exit

Our application still persists keyword objects without regard for existing keyword objects, but at least it does so quietly. If you're following along, then here is the source for our Simple Hibernate application with log4j. We'll fix the persistence problem next.

Disclaimer: I don't claim to be an expert on hibernate. Please send comments and corrections.