Skip to main content

JavaOne report: Everything Else

Posted by emcmanus on May 29, 2008 at 9:18 AM PDT

This is the fifth and last installment in my summary of the
sessions I attended at JavaOne this year.

The previous installments
covered Java
futures
,
Java
programming practice
,
concurrency, and
JMX stuff.

Once again, the titles here are not always the ones that appear
in the conference programme. I tried to undo the mangling that
the Trademark Police typically impose on talk titles, so let me
just state up front that Java, JMX, and JVM are trademarks of
Sun Microsystems, Inc., and any other abbreviation beginning
with J has a sporting chance of being one too.

Here are the sessions summarized in this installment:

The Garbage-First Garbage Collector

Jamming with Java: Making Music with JFugue and JFrets

Semantic Web for the Working Ontologist

General Session: Extreme Innovation (the Toy
Show)


TS-5419, The
Garbage-First Garbage Collector
, Paul Ciciora, Antonios
Printezis. Antonios (Tony) presented the "Garbage-First"
Garbage Collector, nicknamed G1, which will be showing up in
an update of JDK 6. This is an improved version of
the CMS
collector
(also originally designed by Tony). The new
collector is better because it does not fragment memory as CMS
can, and it does not require tuning the sizes of separate
memory areas as CMS does. The performance should also be
better. What made this presentation work was the
painstakingly-constructed diagrams, which really helped
understand the underlying ideas.

Tony talks more about this in
an interview
on the JavaOne website.

TS-5263, Jamming
with Java: Making Music with JFugue and JFrets
, David
Koelle, Matt
Warman. JFugue is a very
nifty system that allows you to represent MIDI sequences with
strings. This is hugely easier to work with than
the javax.sound.midi
API. JFugue adds useful notions like repeated patterns, which
can be submitted to arbitrary transformers. It supports
tapping out rhythms using arbitrary characters and then
applying a substitution that says for example
that * means a snare drum eighth-note
and . means an eighth-note rest,
so ..*...*. is a pattern that hits the virtual
snare drum on the weak beats in 4/4 time.

Pedant moment. The melody shown for Frère
Jacques in the slides had a D instead of a C as the
fourth note, which means it wouldn't work as
a round.

JFrets builds on JFugue to provide an app that does guitar
tablature. I don't have much to do with tablature but JFrets
seemed pretty useful for those who do.

TS-5555, Semantic
Web for the Working Ontologist
, Dean Allemang. I
generally try to fit in at least a couple of sessions that are
completely unrelated to my professional activities, and this
is one. I chose this one because, like many people, I'd heard
the term "semantic web" being bandied about but I didn't have
any real idea of what it meant. Also, I know Dean from way
back.

I think this area suffers from frightening terminology such as
"ontologies" and indeed "semantic web" itself. It sounds a lot
more complicated than it actually is. Which is not to say that
it is simple.

The basic idea as I understand it is that today we have this
fantastic web of human-readable information. We'd like to build
on that infrastructure to create a web of machine-readable
information as well.

Some questions are rather easy for people to answer by browsing
the web. For example: who were the speakers at JavaOne 2008?
But programs can't easily answer such questions because the
human-readable information on the web isn't formally structured.
The Semantic Web would allow web pages to be structured in a way
that allows a program to understand them, without needing to
build logic into the program for each information set.

There's an obvious parallel here with web forms intended to be
filled out by humans, versus web services APIs intended to be
called by programs. I don't know enough about the area to be
able to say whether this might mean there is a sort of rivalry
between web services and the semantic web.

I found it possible not to be scared by the word "ontology" by
mentally replacing it with "schema". An "ontology" represents a
set of concepts and the relationships between them. Well if
that isn't a schema, it's near enough to one for me.

One thing Dean stressed is that it isn't necessary for some
standards body to create all the world's schemas. The semantic
web includes support for mapping between the concepts of
different schemas, for example to say that "address" in my
schema is the same as "location" in your schema. Of course
there could be subtle differences in the semantics (perhaps
"location" can represent the North Pole while "address" can't),
but you can still get a lot of useful work done even with these
mismatches at the edges.

And that's enough about the Semantic Web to be able to avoid
sounding stupid when talking about it at parties. This talk,
and the fact of writing it up, has led me to discover some
promising starting points for further exploration, of which the
best I've found is an article
called Giant
Global Graph

by Tim
Berners-Lee
.

Sun
General Session
, Extreme Innovation, James Gosling
and guests. Also known as the Toy Show, this is the annual
overdose of geekery where James shows all the latest nifty
stuff. It also doubles as a good way for the conference
organizers to persuade people to stay around for the last day of
the conference.

Unusually, I was right there at 8:30am when the show was due to
start, because I knew that the first item would
be VisualVM, being
demonstrated
by Tomas
Hurka
and my
teammate Luis-Miguel
Alventosa
. Equal measures of pride and stress for them, I
think, as they stood up and demoed their stuff in front of
thousands of people in a huge dark auditorium. In the event, the
demo went off perfectly, as did the other demos from this session. (Unlike the first general session of the conference, but the less said the better.)

If you
use JConsole,
you should check out VisualVM.

Among the many other nifty things in this session, I liked the
contraption
that Greg
Bollella
built to show off Real-Time Java.

width="500" height="332"
title="Greg Bollella shows his Real-Time Java contraption to James Gosling (photo by Yuichi Sakuraba)">

Little coloured balls circulate through the plastic tubes,
occasionally encountering pinball flippers or
a bean
machine
. Eventually each ball falls past a colour detector
and into a sorter. The Real-Time Java system has to flick the
right switches while the ball is in free-fall so that it ends up
in the right bin. Plain Java wouldn't be up to the job (what if
a garbage collection happened at just the wrong time?), but
Real-Time Java is. The box at the bottom of the picture is Project
"Blue Wonder", a collection of Sun technologies suitable for use
in industrial control processes. You can see more details in the
video
of this part of the session.

But the thing that impressed me most, along with most of the
people I was talking to, was
the Livescribe
smartpen. It records your pen movements as you write and can
upload them to a computer to reproduce what you wrote. It
records ambient sound at the same time and can upload that as
well. If you go back to something you wrote and touch it with
the pen, the pen can play back the sound from the time you were
writing. You can also search through your writing on the
computer (handwriting-recognition algorithms seem to have
improved without bound since the last time I was paying
attention) and play back there the sound from what you find.
There were some other nice demos: drawing a toy piano keyboard, then having
the pen sound the notes from the keys you touch; or touching a
word with the pen and having it pronounce the equivalent word in
Arabic. But even without these I thought the pen would be
invaluable to anyone who has to take notes often, for example
students. It's not even very expensive: $149.

Jeff bought one
for his wife (one can't buy such trivia for oneself of
course) and she's apparently very happy with it. The pen needs
special paper, but I noted with approval that Livescribe will be
making software available so that you can print it yourself if
you have a good-quality printer.


Well that's it from me about JavaOne for this year. Back to
more mundane blogging...

[Tags:










.]

Comments

Hi Eamonn. I am glad you went to Dean's talk on semantic technologies, we need more IT management (and especially app mgmt) experts versed in this. You say that you picked this session because you wanted something "completely unrelated to [your] professional activities". But did you still feel that way when you exited the session? I hope not. I think many of these technologies are indeed very relevant to our work. I described here how it applies to CMDBf, for example. But it's not just CMDBf, it's any model-rich management application.

Hi Éamonn, I'm looking for a way to give different "MyDesc" for mbean operations and params, without using Spring. I defined an annotation and used @DiscriptorKey, so that "MyDesc" will show up as a Descriptor in MBeanOperationInfo and MBeanParameterInfo. However it works only on the mbean interface. If I have two classes implementing the same interface, I wish to annotate "MyDesc" on the classes so they have different values. What I think I can do then is to extend the mbean interface with a new one for each class, with the annotation as the only difference. Is there better way to achieve that? So the answer may be Class is not serializeable so class level annotation is not accessible to JMX client. But isn't interface also a class, why annotation on interface is available? And another question for remote client to invoke mbean operation (one client to connect to multiple JMX enabled applications). If I use JMX.newMBeanProxy(), it requires the mbean interface to be on my client's classpath. So: 1. Should I extract all mbean interfaces in an application to a separate jar, and give it to my client classpath? What if interfaces in different applications have same package and interface names? 2. Should I always use MBeanServerConnection.invoke() instead, any other ways? Thanks Michael