“JIRA 2: Because you’ve got issues” is the back of the t-shirt that Mike gave out today. A nice aussie slogan if I ever saw one. JIRA is the great issue tracking tool. You should check it out… a good example of software that does what you want.

I don’t know about you, but I subscribe to some nice folk who blog on freeroller.net (which is a nice service). However, my aggregator seems to like to download the same RSS items again and again (from time to time). It seems to get tricked by the URL changing in the RSS feed from: https://roller.anthonyeden.com/* to https://www.freeroller.net/* and back, and also https://freeroller.net/*. Is this just me? How come the URL changes on some of the RSS feeds?

For example, I have 3 items with exactly the same content, but pointing to:

If even just the <guid> element in the RSS feed didn’t change, then the RSS readers would be able to detect the duplications.

Have you downloaded the new jdk 1.4.2? Maybe I have forgotten, but I don’t remember having to go through questionaires from Sun before I get to the download. Most of the checkboxes were unchecked, but one was sneakily on.
Just let me download a JDK! :)

I also first downloaded: J2SE v 1.4.2 with NetBeans IDE v 3.5 Cobundle by mistake (as it is the top set of links). Maybe I am wrong, but I think more users want to download it without NetBeans.

Well, it will be interesting to see if it really does perform so much better like Sun has claimed!

The TSS Symposium is chugging away nicely. It is nice to see a small conference with good sessions after JavaOne. The most fun, for me, is getting to meet all of the great speakers at the conference. People rarely do look like their blog/reputation makes you imagine …

Unfortunately, I have a damn cold which I am trying to fight off. The first day was busy for me too, as I gave a JDO talk, and ran hard core tech talks. Today should be a bit more low key.

The sheraton resort is out in Wakefield, but we managed to get to Harvard square last night for some fun. I am really excited about moving there in a few weeks.

Well, now to see Mike Cannon-Brookes talk, followed by Bruce Tate and Vincent Massol.

The things best done at the symposium are:

Related link: https://news.com.com/2100-1007_3-1021452.html?tag=fd_top

According to CNET News.com’s Declan McCullagh: “A federal appeals court dealt a legal blow to Sun Microsystems on Thursday, tossing out most of a preliminary injunction requiring Microsoft to carry its rival’s version of an interpreter for the Java programming language.”

Should Sun appeal this ruling; what do you think of all this?

Related link: https://www.theserverside.com/home/thread.jsp?thread_id=19988

Red Hat has come out with plans to work more with the Java platform. Redhat’s CEO has said that have been working for five years on open source versions of Java technologies such as Just In Time compilers and Java Virtual Machines in a clean room environment, and has requested the sponsorship of Sun to go ahead with the full-scale project. I hope this happens. Linux distro’s should all come with JVM’s installed and ready to go!

I used to be in the habit prefixing object field references with “this”. I’d write code like this:

class Person {
    private String firstName;
    public String getFirstName() {
        return this.firstName;
    }
}

It seems harmless enough. But things get out of hand rather quickly:

class Person {
    private String firstName;
    private String lastName;
    private String middleName;
    public String getFullName() {
        return this.firstName + " "
                + this.middleName + " "
                + this.lastName;
    }
}

As you sprinkle in more and more “this” references, the code becomes increasingly cluttered. I found myself asking:

Does this really help?

I think the code is more readable when written like this:

class Person {
    private String firstName;
    private String lastName;
    private String middleName;
    public String getFullName() {
        return firstName + " "
                + middleName + " "
                + lastName;
    }
}

Just sit back and look at the two code examples. Which is more visually appealing? Which one looks cleaner? Do the “this” keywords add clarity, or make the screen busier?

Yeah, But…

Some people will disagree with me on “this” topic. They will argue that any field adorned with “this” is obviously an object field, while other fields are obviously local variables. I used to fall into this camp. I got into the habit of writing code in this style and prefixed all fields with “this” even when the code was painfully obvious without the extra clutter.

Can anybody honestly argue that this method is confusing?

public int getAge() {
    return age;
}

age is obviously not a local variable. Adding the “this.” prefix only adds clutter, making your code less readable. Heck, good IDEs like IntelliJ IDEA even highlight object fields a different color, further removing the need for “this”.

DRY

Don’t Repeat Yourself. If you really insist upon adorning your object fields with some token, I will argue that “this.” is a horrible way of doing so. Instead, consider prefixing your field with a consistent name or character. I’m not crazy about prefixes, but they beat “this” because of the DRY principle. For example:

public class Person {
    // show both ways...
    private String _firstName;
    private String lastName;
    public String getFirstName() {
        return _firstName;
    }
    public String getLastName() {
        return this.lastName;
    }
    public String getFullName() {
        // oops...forgot to prefix with "this" on our lastName
        return _firstName + lastName;
    }
}

Did you see what happened? In the getFullName() method, I forgot to prefix the lastName with “this”. The code works fine, but this violates the DRY principle. If you adopt the “I shall prefix all fields with ‘this’” mantra, you are advocating reliance upon humans to manually remember to prefix all object fields with “this” over and over again. Relying upon humans to manually copy a prefix over and over is a recipe for inconsistency because you are repeating yourself all over the place.

Adopting a prefix like “m_” or “_” is preferable to “this” because the compiler ensures consistency. It does not rely on human programmers to remember to repeat the “this” prefix over and over.

Let me repeat: Do not Repeat Yourself.

Like I said a few paragraphs back, I don’t like this approach, however it is better than the “this” convention. I’m just presenting it as an option.

Your Code is Too Complicated

What if you have some really complicated method that uses a combination of local variables and object fields? Don’t you need to prefix object fields with “this” to avoid ambiguity?

no.

I don’t buy the argument. To me, it sounds like this:

“This method is too complicated to understand. I’m looking at the code and I cannot tell which field is a local variable and which field is an object field. My solution is to add MORE code by prefixing all object fields with ‘this.’, making the code even more cluttered.”

I propose another solution: refactor the code until it is simple enough to understand without the “this” adornments.

On a Related Topic…

Study up on XP and see what the experts have to say about comments. If code is too hard to understand, adding more comments should not be your first reaction. Instead, think really hard about finding ways to simplify your code so the comments are not necessary.

Be Open Minded

Coding conventions are a religious issue, to be sure. I myself used to believe in the “this” convention as you’ll see if you read any of my books. I must confess that it was difficult to give up the habit, and I still find myself habitually typing “this” occasionally.

My advice to anyone is to be open minded about your coding habits. It is really easy to fall into the trap of immediately disliking new ideas because they are foreign to you. If you are in the habit of prefixing your code with “this”, code that does not follow the convention will look ugly to you at first glance. It did to me. All I can say is that I have changed my outlook and I like the simpler style better. You might also if you give it a chance.

Conclusion

1. Absolutely trivial methods do not need the “this” prefix. Surely you will agree that this is simple:

   public int getAge() {
       return age;
   }

2. The “this” convention violates the DRY principle. It forces you to manually replicate “this” all over the place. If you forget to follow the convention, the code works the same and the compiler issues no warning.
3. If your code is too hard to understand, try to simplify it rather than to adorn it with “this” prefixes all over the place.
4. If you really need to differentiate local variables from object fields, consider prefixing your object fields with “_” or some other character. You can always refactor your code later - using IDEA or a similar refactoring tool of course - if you decide you don’t like the convention!
5. Don’t blindly follow conventions for the sake of following conventions. Follow conventions because they improve your code. If the coding convention encourages repetition, increases clutter, and relies upon human consistency to be effective, maybe the convention is flawed.

Do “this” prefixes improve clarity or make code more complicated?

Related link: https://hci.stanford.edu/captology/

Ever have one of those nights when you discover that there’s somehow, magically, a hole in your brain, and an obvious idea that you’ve completely overlooked? It happened to me last night, at a talk on Captology.

You see, I’ve been designing and building a shareware application in my spare time (it’s a fun and useful product; we’ll ship the first version in August). So, I’ve been working hard on things like memory footprint and usability, and finding a feature set that captures the core functionality (so it’s useful) while still being implementable by a small team of programmers (as of yesterday, there are three of us working part-time).

Last night, I went to Mark Finnern’s Bay Area Futurists Salon. BJ Fogg was talking about Captology. The idea behind captology is simple: computers (and other technological devices) can be used to persuade people to do things. Not just by displaying advertisements, by also by subtly rewarding “correct behaviors.” The element of interactivity that computers provide makes them enormously different from more traditional attempts at persuasion (for example, billboard advertisements).

This is interesting. Designing software to persuade people to do things. It’s not the approach I typically take (except in the inadvertent extreme case of “well, if they do that, the software will crash. And then they’ll learn not to do that”). And, with some exceptions (software for the children’s market) it’s not the approach most software takes (though things like wizards and training features are often added later). Most software development is about functionality and usability, and only incidentally about modifying the user.

Or is that true? I’m now beginning to wonder.

In any case, the scope of this is huge. It’s not just about getting people to buy stuff. You can also try to change opinions, get people to join the army, and so on.
Examples ranged from Amazon’s Gold Box to the talking Barney.

And I realized last night that I’d been missing something. The goal of a shareware product is to get people to buy it. So maybe, the UI, instead of being designed for functionality and ease of use, ought to be designed to convince users to buy it. Maybe I should be trying to think of subtle conditioning techniques that will encourage the user to spend money.

In the light of morning, I tend to doubt it. Or rather, I think that designing for functionality and ease of use is the way to convince people to buy shareware. The plural aspect (”people” and not “person”) is important though– a user interface designed to convince a particular user to buy a piece of shareware is not necessarily the way to get a large number of sales. I think simplicity, ease of use, and functionality win the day when you factor in publicity channels and word of mouth. Trying to hard to capture a single user’s money is a “win the battle and lose the war” sort of thing.

But captology’s an interesting idea, nonetheless. And something we should all know more about, if only to avoid being conditioned by our computers.

Also highly recommended: the related web-credibility project.

Got a captological example to share?

I have tried more RSS readers, than you have had hot dinners. I have finally settled to have something that integrates with my email. Each blog has a folder and posts are filtered into the correct folder.

Bob Lee wrote fetchrss to help with this endeavour, and recently released it via the new java.net portal (fetchrss.dev.java.net).

I have been using News Gator which plugs into Outlook (I know, I know).

Are there any other tools that people are really getting into wrt RSS?

Related link: https://www.cnn.com/2003/TECH/internet/06/18/download.music.ap/index.html

I read this article on CNN.com today where Senator Orrin Hatch proposes a radical idea: trash your PC if you download music illegally more than two times.

I’m generally more interested in writing about programming, but this is such a stupid idea that I could not resist mentioning the article.

I do not endorse stealing copyrighted material. I support fair use - if I purchase a song or movie I should be able to play it on any device I own and make backup copies. I should not be able to illegally distribute the media to other people. Surely we can solve this problem without resorting to government-sanctioned viruses that destroy your computer!

Here is a quote from the article:

“I’m interested,” Hatch interrupted. He said damaging someone’s computer “may be the only way you can teach somebody about copyrights.”

Here’s an idea Senator Hatch might be interested in. After someone speeds in your car three times, blow up your car. It doesn’t matter if you, your spouse, a friend, or your child was driving. Just blow the damn thing up so you learn your lesson about speeding.

Does anybody think Hatch’s idea is good?

In previous blog entries, I covered writing the
absolute basics
of applying for a job and talked a little bit about

writing a resume. In this entry, I’m going to talk
about the cover letter. But first: a disclaimer. Please keep in mind that this is an idiosyncratic point
of view, based on my experience in interviewing and hiring
people over the last three years. I’m not claiming deep wisdom
or scientific truth here, just trying to share a few helpful pointers.

My guess is that about half of the resumes that crossed my desk over the past three years had cover letters, and only about 10% would be considered “good” using the criteria below. Which means that if you can write a good cover letter, you’ve already started pulling ahead of the pack.

And now, the FAQ.

1. What is a cover letter?

   It’s a short (one or two paragraphs, five or six sentences) letter that introduces you to the person who’s reading your resume. The goal is to create a positive first impression. If you can convince the person screening resumes that yours is worth a look, you’ve made progress.
   

   
   The key words are “short” and “first impression.” Don’t go for the Olympic medal in cover-letter length here; the gold medal is fatal and even the bronze will hurt your chances.
   

2. When should you include one?

   Always. Even if you suspect the company is just scanning resumes into a keyword database, it doesn’t hurt. It never hurts to include a cover letter, and it often helps. Conceptually, think of a cover letter as the job-hunting equivalent of “web site personalization”– just as web sites tailor their presentation a little bit depending on who’s viewing the page, but keep the basic content the same, you should tailor your presentation a little bit (the cover letter) while keeping the basic content (the resume) the same.
   

   And wouldn’t it be cool if those resume sites allowed you to upload an XML / XSL pair of documents, so that you could tailor what your resume looks like based on what the viewer wants to see? Maybe this is the long-awaited killer app for the semantic web– Resumes are emphatically someplace where markup to distinguish important information really really really makes sense.

3. What if I’m applying via e-mail?

   You should still include a cover letter. The goal is to make a positive first impression; why would that change if you applied via e-mail? You’re either attaching your resume, or including it at the bottom of the e-mail; the top of the e-mail should be a nicely written cover letter.
   

4. Should I address the person by their first name in the cover letter?

   Absolutely not. Similarly, don’t use slang or smilies or common “internet” abbreviations or vernacular (no RTM or ROTFL or …).
   

5. What should I say in the cover letter?

   You’ve got five or six sentences. In those sentences, you need to say hello, mention an interesting thing or two about yourself, and close gracefully.
   

6. But I don’t know what’s interesting about me?

   Neither does the person reading your resume. Figure that those three sentences in the middle are going to motivate the person reading resumes to read yours with extra attention and help you stand out from the pack. Sentences like “As you can see from my resume, I have 4 years of EJB experience” are fairly common in cover letters. But they’re not very good. First, the “As you can see,” clause is verbose and annoying. Second, the question you’re really trying to answer is not “what is your experience” (the resume will cover that) but “why is your experience relevant or compelling.”
   

   
   Among the best things to mention are experience with the companies target market, competition, or customers. Experience with those means that you’re already familiar with the corporate subtext and culture; there’s less educating that will have to be done and there’s a possibility you’ll have useful contacts. It also shows that you’ve done a bit of research on the company, and that you’re serious about the opportunity.
   

   Familiarity with the companies products is also a good thing (if you’ve used it at a prior company, mention that. You were part of the target market; that counts as familiarity). What makes this sort of information even better is that it’s often not obvious from your resume, and it’s often not mentioned in the job advertisement.
   

7. What’s the worst cover letter you’ve ever received?

   The worst cover letter is no cover letter. I’m always astonished when I get an e-mail whose subject line is “Application for Job” and whose body consists entirely of an attached resume. A close second are the one-sentence cover letters (”Dear Sir, Plese read my resume. Thanks, xxx”).

Got any cover letter do’s or don’ts to share?

I do a lot of development using PostgreSQL. My only peeve has been that it is a pain to work with it on Windows.

There is a way to do it via cygwin, but what a pain that is.

There are also commercial solutions, but it is hard to fork out money just to be able to do some dev! I have actually been using VMWare, and accessing postgresql running in a Linux emulation windows. This works, but it is slow, and VMWare can be a hog.

Now things have changed thanks to PeerDirect, and UltraSQL. They have a beta of a port which seems to be working well for me, and will hold me over until PostgreSQL v. 7.4 which is meant to have native windows support!

Download the PostgreSQL Windows port

Also checkout the docs on the windows side of things:
https://techdocs.postgresql.org/guides/InstallingOnWindows

PostgreSQL is a great DB, and as Windows support improves, it becomes even more useful. I really want to thank all of the developers that have worked on this product!

There has been a lot of debate on the various new Tiger language improvements. One of the most debated is the new static import functionality: static import java.lang.Math.*;

This would allow the math geeks to use:

 return cos( sqrt(9) );

instead of:

return Math.cos( Math.sqrt(9) );

but this is controversial…

People are discussing the feature on TSS and elsewhere.

Cedric puts up a defense

The new feature does allow you to bypass qualifying static methods all of the time, and also static variables:

static import javax.naming.Context.*;
...
settings.setProperty(INITIAL_CONTEXT_FACTORY,
	"weblogic.jndi.TengahInitialContextFactory");

One of the main considerations was the fact that currently a lot of people place “constants” in empty interfaces, and have their classes implement that interface to suck in the values. Some people really think this is an antipattern as it tightly couples components together and can be dangerous.
The “right way ™” to do things with 1.5 is to create a class that can’t be instantiated, and use static import to read in the values.

Nic has an interesting idea.

He would like to see an alias setup. If you work with SQL dates and normal Java dates you can get fed up with qualifying the class name all the time:

new java.sql.Date(new java.util.Date());

Nic suggests aliasing:

import SqlDate=java.sql.Date;
import StrangeDate=blah.blah.blah.blah.Date; 
new SqlDate(new Date());

Now that would be a change :/

The language talks at JavaOne had a good attendance. At first you may feel “geez, how about getting real security in EJBs … that is more important than a damn for shortcut”. But these things do matter.

I have been involved in many communities, and maybe none like the Perl community. Since they are lead by a linguist (Larry Wall), the language is very different. You may say that it is too complicated, too easy to make it look like line-noise, etc…. but has two characteristics:

• Fun: You can do things how you want, and have fun trying to do weird things [yes, this may not lead to the best code ;)]
• Restricted: You do not feel at all restricted with this language. You can do things however YOU want [again, maybe not the best idea for the masses

For me, items like a simple foreach construct help a lot.
Now code like Cedric’s and Cameron’s go from:

public boolean containsAll(Collection c) {
  for(Iterator iter = c.iterator(); iter.hasNext();) {
    if (!contains(iter.next()) {
      return false;
    }
  }
  return true;
}

to:

public boolean containsAll(Collection c) {
  for (Object o : c) {
    if (!contains(o)) return false;
  }
  return true;
}

Not a BIG deal sure, but a bit cleaner none the less. Then you get to nested loops like:

List deck = new ArrayList(52);
for (Suit suit : Suit.VALUES)
   for (Rank rank : Rank.VALUES)
      deck.add(new Card(suit, rank));
      Collections.shuffle(deck);

and you see the beauty come through (and it just works… no chance to screw up a “i.next();”.

I may have prefered to have foreach as a keyword here (or even like Perl where you can use either), but again, that isn’t a HUGE deal to me. I do worry more about adding “enum” as a keyword, as how many times have you done: Enumeration enum = …; (Rickard has pointed out).

Along with Generics, Enums, Autoboxing, metadata, and the rest… 1.5 will be a brave new world. I know it will take awhile to get here, and will take even longer to work out how best to use things like metadata… it has brought back some fun to our language. Let’s keep it coming.

Is it just me, or did we have a month of good, old-fashioned, internet time in the web browser universe just now. After years of dawdling (the pace of Mozilla Development), inactivity (Internet explorer 6 was released in 2001), or announcements of minor interest (and, yes, I count Safari in here), the past month saw:

1. The claim by a Microsoft employee that IE 6 is the last
   “standalone” version of Internet Explorer.

2. Microsoft dropping IE support for the Mac entirely.
3. Microsoft paying AOL $750 million to settle claims arising from the “cutting off the air supply” days.

I’m not sure what this means. Maybe it’s just the usual shenanigans, coupled with coincidental timing. But when you throw in Safari and Firebird, it feels like something’s shifting (on the other hand, the shift hasn’t fully registered out there yet).

What’s going on? Got any theories?

On Thursday, I sat in on five sessions, and gave a talk at 4:00.

I’m not sure that there was anything at all interesting in the sessions I attended, but that might have been my pre-talk focus (the day of a talk, I tend to have a one-track mind).

I was struck by how much nicer MIDP seems these days. 2.0 is significantly more friendly. I really like the Push Registry; it seems like a very nice bit of useful functionality. I’m less clear about the timer service that’s coming in EJB 2.1; that strikes me as a little too special-purpose for a spec. In both cases, the question is: did this need to be in the specification. For MIDP, the answer is clearly yes. For EJB? It’s less clear.

Maybe the interesting thing is that, in both cases, we’re thinking about the platform as a container, managing code. Which, in a very real way, is the Java revolution in a nutshell.

I also spent some time trying to find out where AspectJ is (it went unmentioned at this year’s JavaOne) and why IBM was almost completely absent. No-one seemed to know the answer to either question.

I didn’t go Friday, because the value I was getting from most talks was close to zero. Other people have said it (including Sue Spielman in these very weblogs) but it’s worth repeating: Many of the speakers this year were awful.

More generally, JavaOne also raised the question about the utility of conferences. Do they, in this age of webs, hyperlinks, and readily accessible technical documents, make a lot of sense? Do presentations that focus on specs make a lot of sense? My guess is yes, but that we should start screening talks differently. The barriers for a talk at a major conference should include:

1. The speaker should have demonstrated expertise in the subject area.
2. The speaker should have significant speaking experience.
3. Sitting through the talk should give the attendee more, or significantly different, information than they could find out in a comparable length of time searching the web.

I have no idea how to enforce these (especially the last one), but it’s clear that many of the talks I attended wouldn’t have passed these criteria.

Lest this seem too grumpy, let me hasten to admit I enjoyed JavaOne. I did learn a fair amount, speaking is always fun, and running into people I don’t see often enough made the week worthwhile.

How would you improve JavaOne?

As this year�s conference wraps up, I thought I�d do a recap of the good, the bad, and the ugly. First the good. While there was a lack of big bang technical announcements, the overall feeling at the conference was a good one. It seems like developers are getting down in the trenches again and all of the water-waders are gone. I spoke with lots of people, the majority of whom were glad about Sun deciding to try and focus the community. I whole-heartedly agree with the roll out of java.net giving the community a way to all be in one place at the same time. It should really help a community exchange to take place instead of our having to deal with all the fragmented places everything is in now.

While the consumer branding probably isn�t going to determine the success of the platform, the initiatives going on around the branding will. I was assured by the likes of Simon Phipps that there is a Sun team already in place that is listening carefully to the webloggers and postings taking place on java.net so that suggestions, improvements, and innovations will occur. I�m sure we�ll see some improvements including a couple already in the works for providing a stats engine and a way to recognize contributors on the site. Since java.net is basically a self-governing site, it will be interesting to see if some of the more critical Sun comments will remain on the boards, or if they will mysteriously disappear. We�ll see as things progress, but as a community site (and not a Sun site), hopefully we will see the former and not the latter.

I�ll combine the bad and the ugly. Let it be heard loud and clear�we need a more varied set of presenters. Almost every single speaker was a Sun employee or employed by one of the major vendor sponsors. I thought the session content of many sessions I sat in on and many of the speakers themselves were horrible. What looked to be an interesting topic would drone on with 20 minutes of introduction leaving 40 minutes for anything useful, which really ended up being maybe 5 minutes of real information if we were lucky. The technical depth was definitely lacking. While I didn�t attend any of the offerings of the Java University, I was talking with some folks at the hotel before catching my plane and they felt that even the full day courses were not as technical as they have hoped for. Most of the speakers seemed like it was their first time speaking in front of a crowd bigger than their development group (if they have even done that), and it showed. Let�s try and get a variety of speakers next time. I doubt many attendees want to pay $2K to be put to sleep.

And what was up with the mismatch of room sizes and topics? I saw some sessions in the Esplanade that were � full and others in the Hall E rooms that had an entire crowd standing outside being filtered in by the people-counting session police. I felt bad for them as they were certainly taking on the brunt of people�s frustrations. I saw some pretty rude people giving them a hard time. Give �um a break people, they were just trying to do their job. Let�s get a pre-signup servlet hooked up to the session selection on the JavaOne site. At least that will provide a better idea of how popular a topic is going to be so that the rooms can be better allocated. While standing room only certainly makes the speakers feel good, it doesn�t do much for the audience members, especially when they can�t get in the door.

The pavilion was noticeably smaller this year, but still had a number of interesting things to see. The mobile vendors were in full force with some of the devices that we�ll see being rolled out in Q4 here in the States. The gamers were getting full airtime in terms of development opportunities, devices, and market potential. Other, perhaps more practical, vendors like SolarMetric at the JDOCentral.com booth were toting their Kodo JDO implementation. The whole topic of object persistence seems to be taking a front burner in many shops as the entity bean debates continue. Anyone who has built a system requiring DB interaction (which is probably most of us) should take a look at what JDO can provide.

And please, if we�re going to be pushing the mobile market, please get conference-wide wireless access.

Overall, I had a good time at this year�s conference. JavaOne is still the place to be to get the full feel for the industry buzz. Not to mention having the opportunity to throw back a few beers with old and new friends.

If you attended this year’s conference, what did you like the most?

It�s 2:30 PM Friday and it is time to capture my final thoughts for JavaOne 2003. During the last day and a half I continued my quest for Mobile knowledge with several more MIDP sessions and it turned out to be a most interesting experience.

I started Thursday with a radio interview on Sys-Con Radio. This is one experience that I have never had. We talked about what I do in my professional capacity, training and consulting, and then talked a bit about what I have been discussing in these weblogs, J2ME. You can listen to my experience on the radio with Sys-Con at https://www.sys-con.com/java/javaone2003/radioview.cfm.

After the Radio interview and a little lunch, I spent the rest of my day in more mobile sessions. The first session Creating Cross-Platform Mobile Applications with Java 2 Platform, Enterprise Edition (J2EE) and Java 2 Platform, Mobile Edition (J2ME) session�yes that is the real title, was really one of the better sessions so far. The talk was given by Martyn Mallick and it contained a great deal of information about JTME application development.

Martyn talked about the two different application models of a J2ME application, Mostly Connected and Mostly Disconnected. He talked about some of the major considerations you will face when developing mobile apps including pausing your app for a voice call, having no keyboard, device security, and network connectivity. Martyn discussed different methods of connecting to the server-side (he recommended using SOAP over HTTPS). He also gave an interesting statistic�he said there will be more than 100 million Java enabled mobile devices shipped in the year 2003. This is remarkable.

Another session that was extremely interesting was Considerations in Implementing a MIDP Instant Messaging Client. In this session we discussed challenges that the speaker and his company ran into when developing a mobile Instant Messaging (IM) client for the MIDP platform. It started off well enough, but the end result was that he chose to throw out Java all together and implement the application using native tools. This was a bit disappointing, but it was interesting to go through the evaluation process of each of the technologies needed to develop an IM client using SMS.

Well, that about does is for JavaOne 2003. Overall, the show was a lot of fun and a great learning experience. I was disappointed in the reduced exhibitor attendance. I hope this is just a sign of the economy and not of lost Java momentum�we will see. It is now time for some lunch and a movie. We are going to check out the Matrix Reloaded at the Metreon�s IMAX theatre. I hope you have enjoyed this year�s coverage. See you next year.

JavaOne really did push the Mobile side of things. My fellow brit from Vodafone made it seem like all Java developers should rush out and start programming games for J2ME. If we do that we make “ONE MILLION DOLLARS!”

I definately understand that they want to push this market. And I certainly know how nutty people are about their mobiles. I can’t tell you how many times I have seen a group of friends walking down the street together, yet they were all on the phone / texting. It actually started to drive me a bit nuts to be honest :)

If you haven’t looked at J2ME, you will probably assume that MIDP 1.0 allows you to do so much stuff, and that SO many apps are using it. I am not too sure if this is true.

MOST apps that I have seen are not written to MIDP, as you just can’t do too much with it. A friend works for a company that has to support RIM, Palm, and PocketPC. The client UI is written from scratch. They just had to drop down to the proprietary APIs to get their stuff done.

I think that MIDP 2.0 is much needed, and it will still be some time before you can write an app that just runs on any device in a decent fashion.

At JavaOne various vendors try to run talks in the pavillion. There are even “theatres” setup for this if you want to use them. Even though there was a lot of room for the theatres, I barely saw anyone listening to someone presenting there. Same goes for the pavillion talks, unless:

• The booth is giving away something [no matter what people seem to want to give out, people want it… even if it is junk!]
• There are girls dressed like Laura Croft [SpiritSoft]
• Ted Neward is giving a talk at the Oracle booth

There was a nice group assembled to listen to him speak. He is a great speaker, and it was fun to hear his thoughts.
It was even more fun seeing him in an Oracle t-shirt :)

Nice meeting you Ted.

There has been a lot of talk about EoD at JavaOne. I have heard a lot of developers talking abotu metadata, and how it will make dev so much easier. I have also heard skeptics, who think it will really take time for us to grok metadata use.

Ara (Mr. XDoclet) talks about this himself in his blog.

I am a fan of projects such as XDoclet/EJBGen/etc, but I have seen @tags overused myself. Having the kitchen sink in javadoc tags in your code doesn’t help anyone. Linda D, the EJB spec lead, talked about how some examples she has seen look like the XML DD has just be showed into @tags.

So, metadata will be good for some things, but we need to tread carefully, and not try to get into the “new coolness” and try to put everything into metadata

The funfest part about being here (other than getting to see people that I don’t get to see all the time) is never knowing what could happen next. This morning I skipped breakfast on the trek to the Moscone Center and instead went to check my email. When in doubt between food or email, always pick email. Next thing I know, I’m sitting next to James Gosling with about 10 other people at a pancake breakfast meeting talking about subjects that ranged from the prolific hotspot devices located throughout Hong Kong to having Java devices tell when milk has expired in your refrigerator. Pancakes will just never be the same.

Today I’ve continued to sit in on some of the sessions focused on the mobile technology and good ‘ole J2EE as well as taking a few spins around the pavilion floor. With a smaller vendor presence this year, the floor is almost manageable to get through without need to take a tent and sleeping bag with you.

With all of the talk about mobility development, I took a look at the new Metrowerks release of Code Warrior Wireless Studio that has the first release of on-the-device- debugging for the Sony Ericson T610, a very cool looking phone. Sony is the first vendor to support the Java Debug Wire Protocol (JDWP) over a TCP/IP connection. If you’ve debugged mobile apps before, you understand that this is a very important milestone for us. Using the emulators is good enough for maybe 90% of debugging, but you really need to be able to do final testing on the device. Now you can set breakpoints in the code that will be hit off of the running device.

I also spent some time talking with Mark Roth, the spec lead for JSP 2.0, about the new emerging tech coolstuff site. This is new site that is being federated with the java.net site to allow internal technologies at Sun to be shared with the community. Mark spent a weekend building a project called TLDDoc, for JSP Tag libraries. It’s a way to generate JavaDoc-like information for tag libraries for JSP 1.1,1.2, and 2.0. It can be customized using stylesheets so you can have the information displayed as you wish. He’s been using it for his work and found it useful, so now everyone can take a look. Check it out at out at www.sun.com/developers/coolstuff and click on the TLDDoc project. If a project is being downloaded and used a lot from the coolstuff site, it will be moved to the mainstream java.net site.

It was good to see that the ‘Advanced J2EE Patterns’ had a full (more like overflowing) room which hopefully means that developers are applying patterns to their architectures. This session is really the launch of the updated patterns catalog. I had a chance to get an advanced copy of the 2nd edition of ‘Core J2EE patterns’ (which I’m sure most of you have the 1st edition on your shelf) . It’s worth your time (and money) to take a read through the new edition. There are 6 new patterns (including one for web services) and revisions to the original 15. New code samples, overhaul to UML diagrams, and the introduction of the micro architecture which is how to reference patterns in a course grain solution by leveraging the J2EE patterns underneath.

There are 2 new patterns in each of the tiers. Presentation tier includes Context Object
for keeping protocol specific information encapsulated, and can be used for request, context and configuration. The Application controller is used for centralizing and modularizing action and view management. There’s also a new ‘bad practices’ added to the presentation catalog. Preaching about adhering to MVC and using view helper components that can be accessed across views has been heard loud and clear. However, using scriptlets as helpers is a bad practice (duh). Refactoring and using tag files in JSP 2.0 and the JSTL can help eliminate this need to use scriptlets. New business tier patterns include Business Object and Application Service. Business Object addresses conceptual domain model with business logic and model, while Application Service addresses the problem of centralized business logic across several business-tier components and services. Use an Application Service to centralize and aggregate behavior to provide a uniform service layer. In the integration tier, Domain Store – is called the ‘mother of all patterns’. JDO is a realization of the domain store pattern and addresses the entity bean debates going on in many shops. The Web Service Broker provides access to one or more services using XML and web protocols.

So that’s it for today. I’ll give you my overall thoughts on this year’s JavaOne and a wrap-up tomorrow.

We’re now most of the way through the JavaOne conference. No big news this morning, since there was no general session and, as a result, no big announcements or new themes. Mister McNealy is up tomorrow morning for the close.

Yesterday’s keynote began with a comedian. The cynic buried deep within me (somewhere right next to the surface) suspects that they didn’t have quite enough to fill the two hour block. Although, since it managed to run half an hour over, maybe I’m just being cynical. I suppose it made sense to get everyone into a good mood, because the demos that came next were, ah, risky.

The big deals were Project RAVE and Project Relator. RAVE is a visual JSF tool, and Relator is a visual J2ME application assembly tool. Both were very impressive–and both are very early stage. We won’t see versions of either until the end of the year or early next. And that’s why the demos were a bit heart-stopping: the first attempt at the RAVE application didn’t quite run. The second did, and worked well, although I suspect that it would have been risky to deviate too much from the script. The speaker from SAP (”the company that provides software to the companies that you wouldn’t want to work for”) encountered a similar problem with his demo, which was ultimately overcome. Inadvertent comedy was thus avoided.

The delay’s a shame, because Rave and tools like it are critical to Java’s future success. Java, right now, is not a hit with the “departmental” developer: the legions of 4GL programmers still building most of today’s business applications. Conversely, this is .NET’s strongpoint: they didn’t want to lose the VB developer community, and it looks like they haven’t.

The other big annoucement was from HP and Dell, both of which are going to be shipping the latest JRE, standard, on all new systems. Unless, of course, customers request otherwise. But it’s big news, since HP/Compaq and Dell, together, ship most PCs and laptops. The annoucement didn’t, however, cover J2ME on the two companys’ Windows CE palmtop offerings. This is where I’d like to see more of a push.

I had a chance to ask about this afterwards, and, according to the Sun senior executives in the room, consumer devices are expected to be the real drivers of J2ME adoption. I’ll buy this, but I do think it leaves a large development segment unexploited: if the PDAs that corporate users carry can’t easily run Java, then Java won’t be used for corporate handheld applications. I’m a lot more excited about palmtop applications than cell phone applications: games are nice, and there are lots of ways to push information out to a cell phone, but a lot of attractive mobile applications need a bit more processing power, a bit more local storage, and a slightly larger screen.

Of course, what everyone was waiting for was James Gosling, who, as usual, didn’t disappoint, even though I didn’t snag one of the T-Shirts he lobs into the audience (the nearest one landed among a throng of international journalists sitting the row behind me, and that wasn’t a scramble I wanted to join).

This year’s demos started out with the obligatory Java-at-JPL session, followed by some interesting uses of JXTA (for monitoring bay area traffic) and J2ME (cell phones reading you directions, dynamically adjusted based on GPS). Of course, the really cool bit involved the robot: a full industrial automation demo using Auto ID and RFID (Radio Frequency ID) chips to handle inventory management. The message: industrial automation isn’t just for industries anymore.

Like them or not (the privacy implications may be substantial), RFID chips are going to be a big deal over the next year. Java can only benefit from being an implementing technology in this space.

RFID Scary? RAVE funny? Crawford tedious?

Related link: https://www.c2.com/cgi/wiki?PairProgrammingTestimonials

Check out this page and scroll to the bottom, look for Mario Aquino’s posting.

Mario describes how he encouraged the students in his course to try out pair programming. It sounds like it worked out pretty well.

It�s 6:00 PM Wednesday evening and I have just enough time to pen my experiences from Day 2 of JavaOne 2003. Today was focused on gaining a little more knowledge about MIDP 2.0 and what can be accomplished with it. While attempting to gain this knowledge, I attended several sessions, but I got the most out of two sessions in particular Advanced MIDP Programming and Developing Games with MIDP 2.0.

In the Advanced MIDP Programming, which was delivered by Brian SingYun Chu and Stuart Martin Marks, was extremely interesting. They spoke about some of the more advanced issues that you will need to be prepared for when developing MIDP applications. They specifically talked about creating multi-threaded components to do your network reads, while not interfering with the presentation layer. They also discussed some techniques that can be used to maintain the current state of a paused application and the reload that state when the application is started again. This session was loaded with lots of examples and extremely pertinent information�you should definitely get the slides when they become available.

The other session that I really enjoyed was Developing Games with MIDP 2.0 by Mark A. Patel. This session was extremely informative and had some great examples. With the addition of MIDP 2.0, Sun has really helped the game developer get a great jumpstart on the development of mobile games.

The API is extremely simple to use and understand. It is essentially made up of a few basic classes. The first of these classes, GameCanvas, contains all of your paint and input methods. The TiledLayer class provides the mechanism to build and manage a tiled background for your application. The Sprite component provides all of you animation tools, including built-in features for collision detection. And finally all of these components are tied together by the LayerManager, which as it sounds manages each layer of your mobile game.

Well, that about does is for my Day 2 of JavaOne. It is now time for some baseball. When I got back to my hotel, there was a mob in the lobby. I thought it might be someone like Gosling, but it turned out to be the Atlanta Braves�they were staying at our hotel and my business partner scored some tickets behind home plate. So now it is time to jump on the BART and watch the A�s get beat by the Braves. See you tomorrow.

I went to four talks today. Nothing much to note. The one about EJB 2.1 was interesting; it contained some very nice examples of why people are buzzing about metadata.

I also walked around the pavilion. Some very interesting stuff being shown. And some nice niche applications (for example, J42. Nice to see them surviving).

More interesting was the hallway buzz. You see, there is a big conspicuous absence here. IBM is not here. There’s no IBM. IBM? Not present. They’re not sponsoring, they don’t have a booth, they’re conspicuous, and I mean conspicuous, by their absence.

Unless, of course, I just completely missed something.

Where do you think IBM was?

Day 2 at JavaOne started with the introduction of J2CE � that�s Java 2 Comedian Edition. Not only do we have a new edition, but everyone at the keynote was J2CE certified by Don McMillan an engineer/comedian. Isn�t an engineer that�s a comedian an oxymoron? Comedians abounded though as everyone kept their sense of humor through a couple of demos that went awry. As Rich Green, VP of developer Platforms put it, �we�re turning up the developer volume�.

Let�s see what else is happening today.

First, after all of yesterday�s talk about Microsoft pulling Java from all Windows platforms, the industry answered back with an announcement from HP and Dell saying that they will ship the latest versions of Java with all PC and personal systems for Windows and Linux. While technically you�d be able to download it anyway onto your system, it�s one less thing to have to do.

Tim O�Reilly threw his weight behind the focus on the corporate developer, chiming in with his support of the scripting support in Java JSR-223, tools plug-in JSR-198, and java.net (for which O�Reilly is managing the content and site). Add the today.java.net to your bookmarks as it is now the daily newspaper for the java community.

Why should we pay attention to the scripting languages? Well if we�re going to hit the goal of 10 million Java developers, here�s why:


1) Lower the barrier and entry point for the corporate developers


2) Internet paradigm shift. If you go back to sites like Amazon or like Google and take the programmers out, those sites stop working.

As Tim said �PHP are the stokers feeding the fire. Without the stokers, the fire goes out.�. For more info check out the JSR at https://www.jcp.org/en/jsr/detail?id=223

There�s also more about Sun�s Project Rave, a developers platform focused on the corporate developer. Its purpose is to create a visual environment that can be used to quickly create solutions. And quickly it does. The demo to build a travel web services based app that can talk to corporate database was going smoothly. Using Project Rave, standard HTML components that can be created by any web editor were added along with.some JSF components, providing server side components for GUI layout.

Next database support was wired to the JSF components. Point and click for Java. Finally.

Next SQL was visually manipulated back into the visual editor and locate web services using UDDI and standard JAX-RPC. Add the web service and it shows up just as any other datasource. Cool�well, except for the HTTP 404 error that came up on the screen. Live demos are fun for everyone, except for the person actually doing them. After a database crash, application rebuild, Project Rave showed that it truly is possible to whip an app together, under pressure, in no time flat. Check out Rave at www.sun/software/projectrave and take a look at the EA that will be coming this fall.

Project Rave incorporates JSF. As promised yesterday, here are some more JSF details for you. JSF attempts to solve the problem of the web app UI. It�s a server side user interface component framework that fits into the �get the corporate developers on java� mode.

One of the JSF requirements is to suck up the VB corporate/IT programmers into the Java platform. JSF can be used with (or without) JSP and HTML based clients and sits on top of JSP 1.2 (or higher) and Servlet 2.3 (or higher). It provides JSF tags to talk to JSP and APIs that can talk directly to a Servlet. Using a component model, there is a UIComponentBase class that comes with standard components for things like forms, hyperlinks, input fields, layout management and handling parameter lists. You basically wire the components to model beans. Value references are an extension of JSP 2.0/JSTL and strongly typed events and listeners are possible. There is also a set of standard converters provided for data transformations data as well as validators for checking input values (string lengths, ranges, etc). There is a default rendering model, providing HTML, which is a library of renders in a RenderKit.

You can also write your own plug-ins. The EA2 allows for a pluggable navigation model. The navigation model decides which component tree is currently being processed, what application action was invoked, and what the outcome returned by the Action is. All of this is configured in a faces-config.xml file. In the next EA, Managed bean creation will be introduced that allows for the server to look for, and create if required, beans. If all of this sounds very Struts-like to you, it�s because it should. The spec lead is Craig McClannahan, the same of Struts fame.

We also got a look at Project Relator. Simplicity for mobility is what Project Relator is about. Exposing the same backend used in the Project Rave demo to mobile devices using a J2ME connection wizard and then selecting and exposing web service. Get this, a one button click generated J2ME and J2EE code. This code was then exported to build the GUI to match the app use cases, drag, dropped, and populate with appropriate relationships (hence the name project Relator). This app then ran in both the emulator as well as on a PDA and mobile phone. Project Relator is in EA now. Check it out, I know I will. It looks to be very cool.

Speaking of mobility, I sat in the Security and Trusted Services API for J2ME which covers the new JSR-177. This has to do with how all of the security protocols will be supported and defines how permissions are used to protect access when applications are deployed on MIDP 2.0 devices and on the JavaSmart card. It includes support for formatted digital signatures and user credential management which includes creating certificates, signing , adding and deleting user credentials. This also provides an access control model that allows security element (SE) control over the usage of its resources, providing fine-grained access control. This should make it a lot easier for developers to write secure mobile apps without having to worry about the actual implementation details. This is a JSR to take a look at if you�re working (or thinking of working) in the mobile space.

See you back again tomorrow.

My plane touched down at 9:45am. I stepped out of the airport to overcast skies, 50 degrees, and what I would imagine to be 70 percent humidity�I was in San Francisco!

After I checked in to my hotel, I grabbed a quick lunch at Chevy�s (one beef taco and one chicken) and headed across the street to go through registration and get my badge. At JavaOne, we do need our �stinking badges.�

I got to the Moscone Center around noon and went through the relatively painless registration process and began my tour of JavaOne 2003. Today my focus was going to be on the exhibition floor. I wanted to see what the latest cool stuff was and who was creating it.

The first thing that I noticed as I crossed the threshold of the Exhibitors Hall was the reduced number of vend