March 27th, 2007


Go back to sleep, America.

Not the first time this has happened, either.

While you morons are so busy debating whether we should keep sending the same number of troops to die in Iraq or send even more, the real terrorists are planning new attacks from Afghanistan, Waziristan, and Pakistan. But oh no, we've gotta stay in Iraq! Yes sir! That's what the Prez sez, and he's always right! Never mind that the British government just admitted that there have been 600,000+ deaths from violence in Iraq since the invasion began. Never mind that we invaded Iraq for reasons that were, and are still, manifestly false.

Also, Dick Cheney just vowed there will be no early pullout.

And the Congressional Democrats that you elected sit there and intentionally do nothing - because that will get them more votes in 2008. The deaths of thousands are of no interest to them.

"Go back to sleep, America. Here's American Gladiators - here's 56 channels of it. Go back to sleep!"

Multi-thread safety in the Java memory model.

This talk describes the Java Memory Model and how it affects the ways concurrent software should be written. Recent changes to the memory model, which were incorporated into JDK 5, redefined the semantics of threads, synchronization, volatile variables, and final fields. The new memory model provides efficient and provably correct techniques for safely and correctly implementing concurrent operations. These techniques are compatible with existing good programming practice, although care needs to be taken in a couple of corner cases.

Most programmers can avoid depending on low-level details and instead just use the high-level concurrency abstractions provided in the new concurrency libraries. However, for those who have to write their own concurrency abstractions, understanding the building blocks of concurrency can be vitally important.

This talk will provide a simple and clear definition of what synchronization actually does, define the semantics of volatile variables and the java.util.concurrent.atomic package (and how they can be used to create efficient concurrent implementations), and describe how final fields can be used to provide thread-safe immutable objects without synchronization.