Possible library and language changes for Java 7 have been in discussion since early 2007 and many things have been proposed. This talk will focus on those items that are most likely to be included and some of the more controversial language changes that might be included in a future release. For a comprehensive list of almost everything being considered, see http://tech.puredanger.com/java7.

Some examples of topics that will be discussed include: * Java Module System * NIO 2 (new NEW IO) * Swing Application Framework, Bean Binding, and Bean Validation * Date and Time API * Fork/Join framework * JMX 2.0

The Design Patterns book launched a revolution in object-oriented design and provided a vocabulary for OO developers to communicate their ideas. However, in some cases, patterns used blindly can lead to awkward, confusing, or hard to maintain code. It is time for some common patterns used in Java to be reconsidered so that we can derive the benefits from patterns while minimizing their concerns.

This talk will re-evaluate key patterns like Singleton, Template Method, Visitor, and Proxy. These patterns have downsides and in some cases, do more harm than good. Examples of each pattern will be give in Java and examined for clarity, testability, and flexibility. Important problems will be discussed and examples of alternate solutions will be given.

In the Singleton pattern, we'll look at problems like hidden coupling, testability, and extensibility and examine ways to use interfaces and dependency injection to avoid the need for the classic Singleton pattern. We'll also re-examine the double checked locking idiom and update it with current advice.

In the Template Method pattern will look at problems with communicating intent, composition, and API evolution and examine ways to refactor your code to use composition instead by way of interfaces, factories, and strategies.

In the Visitor pattern we'll look at how changes in data structures break existing visitors, problems with intermingling navigation and behavior, return values, exception handling, performance, and more. We'll look at alternative implementations that alleviate some of these problems.

In the Proxy pattern, we'll look at problems with maintaining proxies in the face of interface changes, loss of identity and type precision, and coupling. We'll examine some alternatives like static and dynamic code generation and composition.

Terracotta is an open-source Java clustering technology. It creates a virtual, durable Java heap that is shared across a cluster of Java Virtual Machines. This is done by dynamically instrumenting bytecode at load time to intercept calls to read and write fields, and also to enter and exit monitor locks. Information about these calls is then transmitted to the Terracotta Server (which can also be clustered) and out to other nodes in the cluster as needed. The advantage of this approach is that many Java programs can be clustered without code changes by providing just external Terracotta configuration. Many performance optimizations are performed to minimize communication and locking costs. Terracotta is commonly used for session sharing in web applications, distributed caching, and distributed workflow processing.

This presentation will give an overview of the Terracotta technology, how it's implemented, and common use cases that can benefit from the technology. We will look at some code and cluster some Java applications during the presentation.

Some topics that will be covered include: * Terracotta architecture * Heap replication without serialization * Distributed synchronized and wait/notify, cluster locking * Use cases * Example programs