I’m back from Brazil. This was a fairly bizarre experience — Sao
Paulo is enormously big (20 million people) and also the world’s best
argument for zoning laws; Ean Schuessler is a virtuoso of weird on the
level of Survival Research Labs; and for some unfathomable reason
Bruno refers to me only by my last name, which would seem military if
the city and its inhabitants weren’t so militantly disorganized.

Over the next few days I’ll write up my notes from this trip.
Well, the ones I can understand (I wonder what “The Big B! And on!”
might mean… all I can recall is that it is something snarky), and
the ones that are suitable for public consumption.

The chaos — and I don’t want to overemphasize this, as it was not
inconvenient and in fact lovable in a certain way — began as I got
through customs. Instead of seeing Bruno (or one of his countless
friends who he got to help him with the conference), instead I was
greeted by Simon Phipps holding a sign with my name on it. Simon is a
great talker and we sat at a cafe in the airport for a couple of hours
and had the first of the many interesting conversations I would have
over the next week.

Also I wanted to mention that Bruno and the rest of the Sou Java
crew did an excellent job with this conference. It was very well-run,
and both the speakers and the audience were excellent. Also the
organizers went far beyond the call to make sure we had an easy time
getting around in Sao Paulo.

Maratona

The first event was called the “Maratona 4 Java”. It took place
in a number of different cities around Brazil (and in Austin, TX). I
stayed in Sao Paulo for this, though. For this we went to a
university, seemingly hours away, which is big enough to be considered
its own city within SP.

Geir talked first, about Harmony of course. I didn’t take too
many notes on this, as it largely seemed to be the same talk he gave
at OSCON. However he did mention that he now works at Intel. And, he
mentioned the code contributions Harmony has gotten since OSCON;
namely some core class library code from IBM, some of the security
code from Intel, and various other bits. I was a bit surprised to
find that Tcl is now an Apache project. Also he mentioned about the
idea that it would be cool if Sun donated code to Harmony.

Flavio Bergamaschi

Flavio Bergamaschi from IBM gave a talk called “The IBM
Contribution to Apache Harmony”. Flavio is a Brazilian who lives in
England and seems to be a kind of senior engineer — one recurring
theme for me this week was that these larger companies have relatively
rich internal career paths, and many of the participants here had
“juice” but were not in management. I suppose that is one of the
benefits offered by employment at an enormous company like IBM or Sun.
As I (gracefully) age I find I think more and more about what my job
might look like in ten years, or twenty.

Flavio is super friendly and knowledgeable. He spoke in Portugese
so I mostly took notes based on his slides… which were quite good —
next time I give a talk I plan to make nice graphics and stuff like
that. Up until now I’ve been embarrassingly low-touch.

One note I have is, “functional units allows separable life-cycle
and trivial switching implementation”. I’m not totally sure what this
refers to, but I think to this idea that keeps coming up on the
Harmony list about managing the core classes via some OSGi-based class
loader scheme. I did finally think of a concrete benefit this could
provide — if you have a core library that depends on something like,
say, Apache’s commons-logging (think mx4j), you could use that while
not exposing its existence on the boot class path to application
classes (which is critical). Given that we haven’t actually run into
this in practice, though, I still suspect this approach is a lot of
complexity for little gain. I find the posts on the Harmony list
about this to be quite vague… be concrete, people, not abstract!

IBM’s medium term vision for Harmony is: run the Eclipse compiler
on it by 3Q05 (this works with the IBM Harmony contribution if you use
the closed-source VM they provided), run Eclipse and Derby by 4Q05,
and run Geronimo by 3Q06. I think gcj can do all of that today :-).
This is an aggressive schedule for a new project.

I took a quick stroll through IBM’s code contribution a few weeks
back. It includes a bunch of NIO-based character set encoders;
Classpath largely relies on iconv, so this is probably
worth picking up. (Though for gcj, it is less clear… one point I
make in my talks is that with gcj and Classpath, we efficiently reuse
a lot of other free software, which is good at development time and
good at runtime.)

Me

I gave a talk next, which was another revamp of a fairly standard
gcj talk I give — it covers our goals, what we can do, some
information about the implementation and the status, and a short demo
(in this case of Eclipse and of AWT). My notes on this are mostly
about my emotional state, as I’ve found that to be the most important
part of a presentation (once I realized that I have already mastered
the actual content). I thought it went pretty well overall.

In the question section, Geir suggested we revamp gcj-jit to work
properly. He also suggested that we hook into class loaders to
compile entire jars at once. We’ve discussed this before on the gcj
list, and unfortunately I think that, first of all, it isn’t trivial
as many class loaders do a lot of work by hand (I think the OSGi
loaders do this) — meaning that we would have to break our rule about
not requiring application-level changes. Also, compiling an entire
jar at once is notably unfriendly to the system (though we could use
aot-compile-rpm to work around this).

Evolving the Java Language

Next up were a couple of guys who, I think, came from the local
university. They had a presentation on evolving the Java language
that they got from Sun. I only read the slides of this talk as it was
given in Portugese.

The slides were quite nice though. They touched on a number of
things I think about in the isolation tank in the basement bathroom.
So, for instance, the slide about Java Principles said that Java is
designed with the idea that reading code is more important than
writing it, that simplicity matters (having a clear semantic model,
and having programs mean the same thing everywhere — in contrast to C
and C++). They are most interested in new features that improve
developer productivity while preserving simplicity and clarity; though
the slides didn’t indicate how the language designers go about
measuring this. Language design remains unscientific in this respect.

There was some mention of putting XML support directly in the
language, but they skipped this slide too quickly. I’ve heard of this
before but never really looked into it; hopefully I’ll pass on gcjx
maintainership before this, whatever it is, becomes real.

There was also a list of rejected features, which includes just
about everything that I hear requests for — multiple inheritance,
operator overloading, AOP, continuations, preprocessing or macros,
multiple dispatch, and multiple return values.

One point that was made is that Java is also a platform. Folks
can write their own languages which implement some of these features
and simply compile to the JVM. This won’t help with things like
continuations though, which I think would require VM support… I
asked about that but didn’t get a really good answer.

It sounds like javascript and/or groovy will be part of the
official platform soon, like in Mustang. We’ll name the next
generation VM “Yikes” in honor of this.

Update

Mark pointed out that I misspelled everybody’s name. I fixed
that.