“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 vendors. I would say the number of exhibitors, as opposed to last year, was reduced by something like 30 percent�the economy has not been good to us.

Once I overcame my initial shock at the conference�s condensed dimensions, I really started looking at what the vendors were showing. As I walked around the floor, I saw several new and old products. I played around with some of the Apple equipment�these guys have done a tremendous job with their OS X gear. I couldn�t help but try and exchange my PC for a Mac box, but alas I could not find a taker.

What I really noticed more than anything was the vast number of mobile device vendors. There was Nokia, Motorola, Nextel, Siemens Mobile, Vodafone, and several others. This conference was starting to look like a mobility conference as opposed to a general Java Symposium. Everyone was showing their MIDP 2.0 devices. It was extremely impressive.

I tried to take an equal look at everyone�s wares, but there just was not enough time, so I focused on the area of mobility that interests me the most, game development�one of the areas that I believe Java can make a tremendous impact. The two most impressive products that I have seen so far are Ajile System�s JEMBlazer and Nokia�s N-Gage.

The JEMBlazer is an extremely interesting product. It allows you to develop your MIDP games and applications and then compile them to a binary image that can be run on a Nintendo Game Boy Advance (GBA). It is extremely cool. They provide a SDK for $199.99 that allows you to both run and debug MIDP games on your existing GBA. This makes Java development for the GBA pretty much a no-brainer. If you are in town, or on the network, you should really check them out https://www.jemblazer.com. They have an interesting business model that will allow the independent game developer to break into the portable device market.

The product that I was most impressed with was Nokia�s N-Gage mobile device. It is a phone, PDA, MP3 player, and gaming device all rolled into one. When you first look at the N-Gage it looks just like your basic game controller that you might find connected to any gaming console, but upon further examination you will see that it is actually a phone shaped like a game controller. It has incredible graphics and its shape makes it extremely easy to manipulate. And to top all of this, you can create your own games using their free MIDP developer�s kit. According to the crew at the Nokia booth, the N-Gage will be available Q4 of this year. I am going to be the first in line.

Well, Day 1 is over�it is 9:00 AM Wednesday Day 2 and it is now time for me to start looking at some of the actual MIDP technical and BOF sessions. After these sessions I hope to provide you with a more technical look at some of the MIDP development being discussed at JavaOne 2003. See you tomorrow.

Lots of people are blogging from JavaOne, and many of them are going to the same talks as I am. So, instead of mentioning the same details that they’re mentioning, I thought I’d go higher-level.

For the most part, the talks I’ve been to so far are from Sun, about things Sun is doing, and cover new specs. There were some interesting messiah-like assertions at a few points. But, all in all, it seems like a perfectly reasonable progress report from Sun to the community.

The conference focus so far is on ease of use. For the most part, this translates into “making Java more accessible, to a wider range of computer programmers, and eliminating a lot of the tedious and error-prone boilerplate code.”

I don’t really have a problem with this (after all, it does solve an important problem), but it seems like a strange focus for a developer conference (it makes sense as a corporate strategy. If I were Sun, I’d want to spur Java adoption too. But is this the focus of a developer conference?).

I also wonder where the current path winds up.

I think Java has evolved quite rapidly. And while it’s still a darn nice programming language, it’s also becoming something else. Java is starting to become a LPL-Set (languages-platforms-libraries set. It’s new acronym I just made up, so I wouldn’t use the phrase “big bag of marginally related stuff”) in which there are lots of distinct, and independent, specialties.

This is nothing new, of course. People have been specializing for years (”I mostly do EJB’s” or “Bob’s our EJB guy” sort of stuff).

The distinction that I’m starting to see is that there no longer seems to be much of a role for a general purpose programmer. The primary skill required of a Java programmer these days seems to be significant expertise in some set of related specifications.

I’m not sure why this bothers me so much. I understand why the trend evolved, and most of the specs seem quite nice, and they solve real world problems. In isolation, they’re all very good things. In combination, however, it feels like a bad thing.

Or maybe I’m just starting to see the dark side of what Joel Spolsky pointed out a long time ago.

A friend of mine recently started including “Lisp is the red pill” in his e-mail signature. I think I know what he means, now. Or maybe I’m over-reacting to a small number of talks and I should really just get back out there and learn some more.

How do you feel about Java these days?

So, JavaOne 2003 has started. What are most people talking about? How great the talks will be? no. How lame the bags are this year :) I haven’t been impressed with the talks so far. It seems to be a lot of Sun employees, many of which obviously don’t seem comfortable talking, and would much prefer to be in a dark room coding. As I talk to the crowd, noone seems excited about anything… and come on, the new Java logo? Give me a break :) The only reason they changed it was because it is an awful logo to shrink (*cough* devices *cough*).

As always, the best part of the conference is just getting to see old friends and colleagues. Hopefully I will see you all around!

TheServerSide will have in depth coverage of JavaOne the morning after. We have a few reporters running around trying to get some real information. Check it out.

JavaOne day one kicks off complete with tied-died J2EE peace protestors dancing outside the Moscone Center and the techno band magnetic poets inside cruising through image and sound on center stage. We are in San Francisco after all.

Jonathan Schwartz keynoted this morning. ‘Java Everywhere’ is the theme we’ll be seeing and hearing this
year due to plans for creating an overlay with Java to make every device speak with every other. A lofty goal, but one backed up with a number of initiatives announced today that are focused on the embedded network.

With numbers flying everywhere in terms of the penetration of various Java platforms and devices, such as 250M Java enabled phones, 300M Javacards, 1.2B (yes, billion) VM’s running, it’s time to unite the various J2SE, J2EE, J2ME, and JavaCard platforms into one. Basically, it’s time we simplify to one common platform, something I think that all of us developers have been saying for some time now. As Guy Laurence, CEO of Vodafone pointed out, there are 4 things that people universally carry with them: a pen, keys, money…and a mobile phone.

It’s time to make the content and applications of the mobile platforms available to the server (J2EE + J2ME = Mobile Enterprise) through web services, with the key issue being compatibility and security. All of this is being demo’ed by GE Medical Systems showing us how XML and Java2D can be run on numerous devices for information on the spot for analysis and consultation in the health care field.

Ease of use and developer community is going to be key as we heard in the Java.net announcement today. And it came complete with a new cup logo unveiling. As Johnathon Schwartz put it, ‘One butt kicking platform‘ with more collaboration, new electrified brand, more market opportunities, communities of developers, and consumer branding . Java.net is a place where all Java developers can go for collaborations, sharing source code (already seeded by Sun), developers blogs and wikis. Javac has been open sourced to be followed by JAXB and JAX-RPC (in July) to name a few. From a conversation I had with Sun Director Ingrid Van Den Hoogen: “The Developer community needs to feel cool again. It’s time to get excited and bring the energy level back up and the infusion back in the community.’

The rally of the developers in the community started with the intent to bring the community playground together. It’s up to all of us to check out Java.net and get involved. Types of content include web services technology, J2SE 1.4, WSDP, JAX-RPC, Java Desktop, and Mobile. Check it out at www.java.net.

Ease of use is key and found throughout all of the platform announcements today. While J2SE 1.4.2 will be released in the next couple of weeks, and J2EE 1.4 delayed waiting for WS-I, we got a glimpse of what’s coming in 1.5. The Tiger (J2SE 1.5) release is going to be the first language features release that will include some cool stuff. Metadata, generics, enum support (C/C++ developers unite), collections as well as API improvements work will allow us to write Java code a lot cleaner. Project Rave (more details on this tomorrow) will provide the ease of use in development tools that we’ve been lacking in the Java community.

Metadata (marker conventions like getFoo/setFoo, naming patterns in EJBs, and Serializeable) will now be key in the language features that allow for annotation of classes/methods/field that can then be used by tool libraries. This will also allow for
simple declarative programming.

Generics will allow some classes to work on lots of types classes and methods (like HashMap)and can map from anything to anything, but everything is treated as an object.
Generics lets programmers express their knowledge of the class and let’s the compile do the work. What this means is that constantly casting objects will no longer be necessary.

We’ll also see iterating over collections syntax improvements, enumerated types, and autoboxing of primitive types. This will let the compile do boxing and uinboxing for us. For example, Integer x= 3 int y=x. And we’ll finally get printf that will allow for output formatting. Every one of these features got a round of applause from the audience.

Ease of Development (EoD) will be the major driving force behind J2EE 1.5 as well. Deployment Descriptors will use metadata so that developers will no longer have to write the DD, but instead can have it generated. The goal is that developers never see the DD but rather just program the metadata in the source code (but deployers still get to see them…lucky them)

There are a number of new J2EE JSR�s that will be getting some air time. For example:


-using metadata to define JAX-RPC servers, EJB 3.0 to reduce EJB complexity (there�s a novel concept), making it easier to define , use metadata , and have a single Java class so that an EJB looks more like normal classes.


-JAX-RPC 2.0 is the center of WS in Ja including: Soap 1.2, WSDL 1.2, WS-I.next


-JAXB 2.0 full JAX-RPC integration, adds full XML schema support, builds on metadata and allows for partial mappings


-JDBC 4.0 is also focused on EoD. We�ll see: automatic driver management, simplified connection creation, easy syntax for using metadata. JDBC will still focus on SQL (row/column) if you want object mapping abstractions use JDO or container managed persistence.


-JSR-223 is the first JSR to officially support scripting languages. We can use it to define rules within the web tier. The reference implementation will use PHP 5.0.

JavaServer Faces (JSF) is going final later this fall and is currently in EA2. JSF is a GUI toolkit with components that run in the web server. The default render is to HTML and then the generated HTML run in the browser. JSF attempts to solve the problem of the web app UI with a Server side user interface component framework for java based web application. More on this tomorrow.

A lot of time today was spent on mobility and the Java Technology for the Wireless Industry (JTWI). JTWI includes MIDP 2.0, server side push, new security framework, wireless messaging API (WMA), multi-media API (MMI). If you are just coming up to speed on the wireless world, check out JSR-185 which provides direction on how the various JSR related to the mobile space fit together. It is the roadmap for the entire wireless space.

There are a number of new J2EE JSR’s that will be getting some air time. For example:

-using metadata to define JAX-RPC servers, EJB 3.0 to reduce EJB complexity (there’s a novel concept), making it easier to define , use metadata , and have a single Java class so that an EJB looks more like normal classes.

-JAX-RPC 2.0 is the center of WS in Ja including: Soap 1.2, WSDL 1.2, WS-I.next


-JAXB 2.0 full JAX-RPC integration, adds full XML schema support, builds on metadata and allows for partial mappings

-JDBC 4.0 is also focused on EoD. We’ll see: automatic driver management, simplified connection creation, easy syntax for using metadata. JDBC will still focus on SQL (row/column) if you want object mapping abstractions use JDO or container managed persistence.

-JSR-223 is the first JSR to officially support scripting languages. We can use it to define rules within the web tier. The reference implementation will use PHP 5.0.

JavaServer Faces (JSF) is going final later this fall and is currently in EA2. JSF is a GUI toolkit with components that run in the web server. The default render is to HTML and then the generated HTML run in the browser. JSF attempts to solve the problem of the web app UI with a Server side user interface component framework for java based web application. More on this tomorrow.

Needless to say, this should be an interesting week.

The last time I was in San Francisco was fifteen months ago. Some act of the convention scheduling gods forced Sun to schedule a bit more than the usual year between shows. So we’ve had a bit longer than usual to wait for the next big round of interesting announcements, Java platform strategies, and cool pens.

It’s important to note that the conference proper hasn’t actually started yet. The keynote is in twenty minutes. This means that all I actually know at this point is that the give-away conference backpack is, while smaller than last year’s, probably more practical. Rather than a big frame backpack thing it’s a small combination backpack/satchel, just big enough for a laptop and a days worth of paperwork. I suspect that I’ll actually use this one, rather than last year’s, which sits in the closet except for occasional use as an overnight bag.

This is, of course, a stretched metaphor. I smell J2ME in the air, aided only slightly by the huge Motorola billboard upstairs. It’s going to be a theme, I just know it. Smaller and more useful makes sense.

Update: 10:35am, Pacific Time. The first general session just got out, and I now actually have some idea of what this year’s conference will be about: ease of development and expansion of the platform. “Java Everywhere.” Overall, I’m pleased. Let’s take it in order:

Ease of Development: This is a big one for me. For Java to compete successfully against .NET, it needs to match Microsoft’s offering feature for feature. In most comparisons, .NET is a non-starter, but it’s extremely strong in the developer tools area for web based systems. Oracle did a demo of JDeveloper 9i 9.0.5’s new JSF GUI, which seemed (at a fifty thousand foot level) to be very competitive. This allays a serious concern I’ve had about Java’s competitiveness in certain areas.

Ubiquity: There are now 550 million Java desktops and 100 million Java mobile devices with as many again to ship in the next six months. That’s a big platform. Sun is launching java.com to preach to the consumer market, and java.net for the developer community. The Java logo has been redesigned for greater consumer acceptance, and the Java Powered ad campaign is being resurrected.

Compared with last year, I came out of the morning session feeling much better about where Java can go, in a practical fashion, over the next year.

More after this afternoon’s technical keynote.

So?

It’s Monday afternoon, the day before JavaOne 2003 begins. I’m here early because I’ve been house hunting in the Bay Area over the weekend. I just got a call from my real estate agent that our offer has been accepted on the house we’ve selected. We’re all set to move from a large, executive home in Orange County to a cramped townhouse in Fremont, a suburb in the East Bay.

I mention these personal facts to point out that my family and I are gambling on the future of the tech industry in the Bay Area. We lived here during the craziness of the dotcom boom, when recruiters seemed to be stalking me and insane amounts of money were flying in all directions.

But things are different now. Since we moved away a couple of years ago, the tech landscape has become more of a barren wasteland. And recruiters, once so friendly, no longer even bother to reply to inquiries. The ones that are still employed as recruiters are inundated with resumes for every job opening they post.

Since the heady days of the boom, industry expectations have settled back to earth and ROI considerations are once again important to those who hold the corporate purse strings. One of the most significant effects of this has been the inexorable, and accelerating, trend toward offshore IT outsourcing.

To someone like myself, who’s been in the computer business for more than a quarter of a century (and always in demand), the prospect of becoming unemployable at 40-something is downright frightening. In the current IT labor market, I’m too expensive to hire. A company can get five people offshore for the cost of one of me.

Now, the standard reaction here would be to call for action to block this trend, legislate against it, restore things to the way they used to be. But, pragmatist that I am, I think that’s an exercise in futility. The market does what the market does - it’s that simple. The only way to influence the market is to offer a better value proposition.

Some percentage of software development is going to be lost to offshore permanently. We just have to accept that as a given - erecting barriers always ultimately fails.

But will all software development go offshore? Is this the end of the software industry as we know it? I think not. In fact, I think the best stuff will remain here. The fun stuff, the stuff we got into the software business for in the first place.

The offshore operations, of necessity to keep costs down, will become rigidly structured, assembly line operations (if they aren’t already). You need an accounting system? Fine they can do that and do it very well. Inventory? Financials? No sweat, done it a million times. But if you need highly customized, innovative, ground-breaking stuff; software that’s integral and vital to a new hardware device or business process or biological model or whatever, you need a tightly focused team onsite that can adapt and react and make it work right now.

It strikes me that this pattern echoes the Agile vs. BDUF debate. Offshore by its very nature has a high communication latency and the customer, almost by definition, is disconnected from the development process. This favors the Big Design UpFront approach. For well-understood business processes, like accounting, inventory, etc, this can and surely will work out fine.

But what of the cross-disciplinary innovations that are the lifeforce that keeps high tech so vital? What about the unique challenges that apply only to narrow vertical markets and cannot be easily commoditized? What do you do when the only way to get the software working is to sit down with the guy who invented the widget or the dispatcher who’s been scheduling deliveries manually for 35 years? How do you achieve the Ah-hah! moment across 12 time zones?

It’s my belief that Agile Development, in one or more of its various forms, will take hold as a way to boost productivity. If an agile methodology can make five local people as productive as 25 offshore, then it once again becomes cost effective to hire people locally. The challenge is to demonstrate the ROI. Agile has to prove itself a superior way of producing results which can’t be duplicated offshore.

The transition will be tough and many of us will have to unlearn things we’ve always taken for granted. I think this may be the beginning of a revitalization of the software industry. Hopefully, it will lead to a better understanding among programmers of the value their work has to a company and how their design choices and develpment methodologies can affect the bottom line.

One thing is certain: we’ve all got to keep learning and growing as professionals. For me, that’s why I got into this business in the first place. I’m optimistic that things will improve and that the tech market in general, the Bay Area in particular, will recover and shake the world once again. This is where the great ideas are born and nourished. This the place where the magic happens. That’s why I’m moving back here - I want to be in position to surf the next big wave. I can feel the swells beginning to rise already.

If anyone mentions H1B I’ll just scream.

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

As promised in my last weblog, I’ve released Antgraph 1.0. This is a little utility I wrote that generates a graphical dependency tree for any Ant buildfile. You can find the tool on my personal website at https://www.ericburke.com.

I use Graphviz to actually generate the graph. Antgraph consists of the following:

• An XSLT stylesheet to convert dependencies in any Ant buildfile into Graphviz/DOT format
• An Ant buildfile to drive the transformation process, so you don’t have to launch the XSLT processor yourself.
• A DOS batch file allowing you to drag and drop any Ant buildfile to perform the transformation.

I hope you find this useful. It’s just a quick hack…it was fun to write. No license. Just free software. Enjoy!

Let me know if you find this useful!

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

I had the chance to attend the Gateway Java Software Symposium last weekend. This was one of a series of weekend technology conferences held in various cities across the United States. If you get the chance to attend one of these conferences, I highly recommend it.

One thing that sets this conference apart from others is the fact that it is held over the weekend. It is painful to give up a weekend in order to attend a conference, however the reality is that many people (like me) have a hard time getting away from work during the normal week. Weekend conferences are more cost effective for employers, as well.

Fluff, or Stuff?

Stuff. This symposium consisted of technical topics only. If you have
a chance to attend one of these symposiums, you will not see vendor
presentations or sales pitches. Instead, you’ll be able to meet and
learn from people like James Duncan Davidson, Jason Hunter, Bruce Tate,
Dave Thomas, Robert Martin, and many others. The topics were mostly
Java-related, although you could also learn about Ruby, XP, Web Services,
Objective C, or even an overview of Mac OS X.

The expert panel discussion was the highlight of the symposium. This
consisted of a little over an hour where eight of the speakers answered
any and all questions from the audience. Several interesting opinions
came to light, including:

• Many of the experts gave high praise to IntelliJ IDEA
• Swing was openly criticized
• Entity beans were bashed
• Heavy use of UML was discouraged. Most seemed to agree that
  UML is best for whiteboard designs
• Rational Rose was not popular among the experts
• We seem to be reaching some kind of critical mass of complexity.
  There is a growing frustration with complicated code and several
  speakers predict a resurgence of loosely typed languages. Ruby
  and Python were mentioned, and one person suggested that
  Smalltalk may make a comeback.
• Everyone on the panel had a great sense of humor and it was
  a very interesting discussion/debate.
• Lightweight, common-sense processes clearly dominate current
  thinking among the experts.

My personal favorite speaker was definitely Dave Thomas, one of the
authors of “The Pragmatic Programmer”. I found myself agreeing with
his philosophies over and over again. He has really influenced me in
recent months, in particular I’ve been trying to expand my knowledge
into other areas thanks to his book and his presentations. My current
goal is to learn Python in the coming months. He talked about Agile
Development, Naked Objects, Decoupling Patterns, and Ruby. Dave also
delivered the keynote address, and he was on the expert panel.

Benefits

You can gain a lot by attending a conference like this. One strategy
is to attend all of the presentations related to a single topic, such
as Struts. This is an excellent approach for
people wanting to learn a specific technology they need to use on
their next project. For experts in particular, I think it is a better
idea to attend presentations on a variety of topics.

One of my co-workers used this strategy: attend presentations from
each of the famous people he wanted to see. I thought this was a pretty
good idea because he got to hear the widest range of opinions and
probably got lots of good ideas for his own development work.

Even if you never plan to use a technology like Naked Objects, you
get new ideas when you spend an hour or so learning about it. Some of
these ideas might just work their way into your next project. And
while you won’t become an expert in a technology from one or two
quick training sessions, you will get a good jumpstart making it
all that much easier to learn the details later.

One thing I learned about was a little tool called Graphviz, a free
tool for generating graphs from simple text file input. I used this
tool the other day to automatically generate graphical charts showing
dependencies in Ant buildfiles. This simple little tool helped me
locate a few problems in a really big buildfile that should reduce
compile times for every team member on my project. Graphviz isn’t
even a Java tool, but attending this conference sparked an idea
that will improve our development environment and save money.

Summary

As I said before, I highly recommend this conference to Java
programmers at all skill levels. You will learn a lot in a short
amount of time, and get a chance to meet some of the best known
Java experts.

One more thing…I’m going to post the XSLT stylesheet and Ant
buildfile that let you generate graphs of any Ant buildfile using
Graphviz. I hope to post it sometime this weekend.

Does your employer pay for you to attend technical conferences? They should.

I’ve spent a lot of time this year traveling around the country speaking at various developer conferences. It seems that the best way to describe the state of mind of many Java developers right now is melancholy. Most people I’ve met lately have been lacking in excitement and enthusiasm, almost to the point of a calm panic. This year’s JavaOne might just be the most important one that there ever has been. It will need to inject developers with a shot of excitement with new technology focuses, new tools, and new answers for some of the same questions that have been lingering around the Java community.

I’m looking forward to landing in SF next week and finding out what this year’s conference will provide. I’ll be blogging techie2techie; none of that marketing hype that seems to be so popular from JavaOne’s past from me. I want to know what’s going to be hot and what’s not, and when I find out, I’ll tell you. I’ll wrap up each day with a blog about the latest and greatest and then you can form your own opinion.

See you at JavaOne.

Mike (and others) have posted on the topic of PostNukes, and are seriously pissed off at what both Marc (and I) have said about the endeavour.

I feel that I need to clarify my statements here. I have partially fell folly to shoving up a few paragraphs on a blog, without taking time to think about them etc etc. This is my fault, and I apologise to anyone who is pissed off at what I said, AND to those who have written good open source CMS solutions in Java.

I am NOT trying to claim that there are not ANY open source CMS solutions in Java. I realise that there are many out there, each different in their own way.

I just happen to be someone who has used PostNukes in the past, and though it was very easy to use, there were TONS of components that you could plug into it due to it’s community, and it just “worked”. I just think that it is kinda cool that someone ported this over to the Java world… that is all.

Also… please don’t mix MY words with those that JBoss / Nukes guys may say. I just linked to the article and said “this is cool!” :)

Cheers,

Dion

Related link: https://www.onjava.com/pub/a/onjava/2003/06/04/nukes.html

I don’t know about you… but I have sometimes been frustrated with Java when it comes to simple CMS capabilities. I have used PostNuke, written in PHP, and it works SO well for small sites. I wanted to have the same in Java, so people could develop great components that sit on top of a rock solid Java platform. I was mentioning this to MarcF, when he told me that JBoss was doing this very thing. PostNuke didn’t scale on jboss.org, so they rewrote it on top of JBoss. I do kinda wish you could install it on any app server easily (not based on the JMX microkernel), but who cares. Let’s write components!

I was looking over my credit card bill, and noticed an entry under “AOL * SERVICES”. Hmm. I am not an AOL users. I have never been an AOL users. I am not even a fan of AOL in any way. Are you being charged too?

I firstly called my credit card company and they blocked any future attempts and opened up a fraud ticket. I was also amazed at how fast the operator let me know the number to AOL. It was as though I wasn’t the first person to call on this matter.

So, I call AOL, and wait for 30 minutes whilst it tells me “why are you on this line? logon to aol keyword blah and we have lots of people waiting to IM with you on your matter”. However, since I don’t have an AOL account, I can hardly logon. At some point I awoke, and an operator greeted me. I told them the story and they quickly got on the defensive, letting me know that they could *try* to end the account (which could take until after the next billing period EXCUSE ME), but I couldn’t get any money back.

I asked them to look at my usage, and they showed that I had never once logged on… HOWEVER “AOL is membership based, not usage based” so I still didn’t deserve any money back.

After patiently trying to persuade them, I got the secret AOL number for “people who can actually do something” and then the scene changed. This operator was VERY helpful, credited my card back for the full amount, and I could be on my way.

The question I have…. is HOW many AOL users are being charged without them even KNOWING that they are. I know for a fact that not everyone goes through their CC bill like I do…. so I bet a lot of people are getting screwed.

Wow. AOL truly IS evil :)