My previous posting about Ruby generated a lot of noise and very little light -- that is, not much in the way of compelling reasons to learn the language. So I went to a couple of Seattle.rb Ruby users group meetings and spent time with 3 uber-geeks. Now I at least have the beginning of an understanding of what's interesting about this language.

Mike Levin has posted a new podcast interview with me, recorded 1/4/06.

The Java hyper-enthusiasts have left the building, leaving a significant contingent of Java programmers behind, blinking in the bright lights without the constant drumbeat of boosterism.

There's one rather mind-bending idiom that appears periodically in Java generics. Here's what it looks like: class SelfBounded<T extends SelfBounded<T>>

There appear to be some strange side effects on packages when using generics.

I'm hoping this is an obvious one and that my brain is just fried from over-generification.

I came across another generic puzzle and hope that someone has some insights.

I set out to explore how the compiler treats a plain List vs. a List<?>, and in the process found something mysterious.

I need to use the collective-consciousness of the Artima community, like genetic algorithms, to come up with a set of canonical use cases for generics.

I was poking around in the Standard Java Libraries looking for examples of generic code, and came across something curious.

Up until now, whenever I've tried open-source Word clones with my books, they've collapsed to the floor, babbling and drooling.

In my posting "Mixins: Something Else You Can't Do With Java Generics?", someone suggested (incorrectly) that this was just the C++ "Curiously Recurring Template Pattern." The analog of the CRTP does work in Java, but is it good for anything?

Someone pointed out that Josh Bloch suggests using interfaces to produce the effects of mixins; this is a common pointer when justifying the lack of multiple inheritance in Java. I've translated yesterday's C++ mixin example based on this idea.

The paper "A First-Class Approach to Genericity" introduces the idea of the mixin, which seems to be quite a powerful concept, and then shows that you can't do it with Java generics. I wonder if anyone has any alternative approaches to this problem.

The Concurrency chapter is finished (hurray!), and now I re-wade into the mysteries of Java Generics. The chapter isn't looking as bad as I was remembering, but there are still some issues that I'm struggling to understand and explain.