JDC 08 Presentations

Configuring the Spring container: away from using XML??

Last November, Spring 2.5 was released. This version of Spring, the de-facto Java EE application platform marks the beginning of the introduction of alternative ways to configure components. In the, we've mainly focused on provided XML as the main language to perform Dependency Injection on object. Since 2.5, Spring has introduced several new ways to doing this.

This session focuses on the various ways of using the Spring container to Dependency Inject objects such as the traditional XML language, the extensible namespaces, the @Autowired and @Component annotations, but also the innovative JavaConfig project that is capable of configuring Java objects using @Bean annotations.

­
Each has drawbacks and advantages and this session will discuss which one you should choose in what scenario. You will walk away with a clear understanding of when XML is a good choice for configuration and when to opt for one of the annotation-based options.

Cool User Interfaces with JavaFX

The Java plat­form has been extremely prevalent on the backend. However good and cool Java user interfaces are like unicorn, often cited but never seen.
Creating cool effects with Java has always been a black art. The Java2D APIs, though powerful, are quite difficult to use.
JavaFX is a scripting Java based scripting language. It allows you to access Java2D features like painters, images, imageop, Swing components, etc easily.
This session will introduce the audience to JavaFX and will show how to perform some common visual archetype like zooming, fade in/fade out, clipping, scaling, etc. We will also show how you can integrate JavaFX intefaces with Java application by using JSR-223 (Scripting for the Java Platform).
­

NetBeans 6.0 - The Only IDE You Need

NetBeans 6.0 has been released recently and the new version brings lots
of innovative features. During this session you can learn how to
benefit from some of the new features, such as support from Swing
Application Framework (JSR 296) and Beans Binding (JSR 295) in the GUI
builder.

NetBeans Profiler is now an integrated part of the IDE and
we'll look at the new tools which help with memory leak hunting. One of
the weaker aspects of NetBeans was it's editor, so there has been
tremendous focus to improve it during development of NetBeans 6.0.
You'll see various features which help developers to write code faster
or make orientation in code easier. Finally NetBeans is no longer just
a Java IDE so we'll look at support for additional languages such as
Ruby and discuss how Java developers can benefit from dynamic languages
on top of the JVM.

The whole session is demo-driven so instead of spending too much time with slides you'll see many of new features in action.

JVM-level clustering can turn single-node, multi-threaded apps into
distributed, multi-node apps, often with no code changes. This is
possible by plugging in to the Java Memory Model in order to maintain
key Java semantics of pass-by-reference, thread coordination and
garbage collection across the cluster. Terracotta enables this using
only declarative configuration with minimal impact to existing code
and provides fine-grained field-level replication which means your
objects no longer need to implement Java serialization. This session
will show how it works and how you can start clustering your
POJO-based Web applications (based on Spring, Struts, Wicket, RIFE,
EHCache, Quartz, Lucene, DWR, Tomcat, JBoss, Jetty or Geronimo etc.).

How To Write Stateful Web Applications That Scale Like Stateless Ones

For years, stateful vs. stateless has been a debated topic. For a long
time you have been told that for example; stateful session beans in
EJB are evil and that in order to scale-out a Web application you can
not keep state in the web tier but have to persist it in some sort of
SoR (database, filesystem etc.).

However, with the recent advent of Web 2.0, we are faced with new
possibilities and requirements. Today we can, for example, write
thin-client web applications that has the feature set of a rich-client
but at the same time are highly responsive and almost gives the
impression of being run locally. This all brings back the importance
of statefulness. We now have a new generation of Web frameworks such
as RIFE, SEAM, Spring Web Flow, GWT and DWR that all focus on managing
conversational (stateful) state that can be bound to a variety of
different scopes. In short; stateful web applications are back.

This is all great, but it returns us to the initial problem: How can
we scale-out and ensure high-availability of a stateful application?

In this session we will not only discuss the challenges in terms of
scaling out a Web 2.0 stateful application, but also introduce you to
Terracotta's* JVM-level clustering technology and show you can use
that in a practical way to write stateful web applications that scales
like stateless ones - without sacrificing simplicity.

POJO Scalability and Large Workloads with Terracotta

In this practical session you will learn how to build a highly
scalable work management framework using standard JDK 1.5 and POJOs,
and how to turn it into a distributed grid implementation by using
Terracotta's* JVM-level clustering.

We will start with a discussion of Data Grids and the Master/Worker
pattern -- one of the most useful parallel programming design patterns
in use today. You will learn about the identifying characteristics of
the pattern and how best to use it in the real world. Following that,
we will cover the production implications of operating and scaling a
reliable work management framework, and give examples on how to
address real-world challenges such as dealing with very high volumes
of data, handling work or worker failure, ordering, routing schemes
etc.

You will learn:

* How to identify cases where the Master/Worker pattern is the right solutions
* How to build a scalable work management grid framework with 100%
POJO-based Java
* How to cluster the JVM and effectively use Network-Attached Memory

Network-Attached Java Collections

The Java runtime library has a rich set of abstractions for data
structures, such as Collection, List, Set, Map, Stack, Queue,
Iterator, Deque etc. It also provides various implementations of these
interfaces to serve a wide range of use-cases; from trivial
implementations for single-threaded usage to implementations highly
tuned for concurrent access.

Wouldn't it be great if the same interfaces could be used to abstract
away the complexity of not only multi-threaded access and coordination
but also access of distributed shared state and resource
coordination/guarding? If the distributed shared state could be
continuously available "on the network"' -- for any client to use --
using Network-Attached Memory (NAM), an appliances-like infrastructure
service similar to how Network-Attached Storage (NAS) abstracts away
the disk usage.

In this talk we would like to discuss how the Java collection
interfaces can be distribution agnostic and help to hide complexity of
the distributed infrastructure through the use of NAM enabled through
Terracotta's* JVM-level clustering technology. We will also discuss,
the need for and the implementation of, different optimizations -
similar to the optimizations that the JVM's JIT and optimizing
compiler does at run time.

Automated testing of Ajax Applications

Traditional practices for automated testing of non-Ajax web applications
from the Java Platform rely on full page refresh and generally cannot
handle advanced JavaScript techniques. The next generation of Web
applications are making advanced use of JavaScript, including Ajax. Ajax
transactions require just as much verification and scrutiny as full page
transactions, so a testing solution is required that allows this. This
presentation surveys the state of the art in automated testing of Ajax
applications.

Enterprise Grade Ajax and JSF

This presentation demonstrates how JSF and AJAX are perfect together. We
begin with an insight into the design heritage of JSF, and how that
heritage puts JSF in good stead to be productive in the AJAX
world. Building on that foundation we dive into the code from the page
author and component developer's perspective. We close with a look to
the future and show how JSF is being used for mobile and disconnected
applications.

Scripting JSF

The benefits of scripting languages for web development are well
known. Python, Ruby, Perl, and other languages came to prominence
largely due to their suitability for web development. With the inclusion
of JSR 223 in the Java platform, Scripting will be fully supported. This
presentation will present some trends for using Scripting to develop
applications for Java EE.

De-mystifying JSF

In this 90 minute session, Ed Burns will clear up the fog that sometimes
surrounds people's understanding of this Web Application Development
Framework. Ed is well suited to the task, having helped shape the design
of JSF from its inception up to the present day. Upon leaving this
session, the participant will know what JSF is good for, why it is good
for these things, and how to be productive using it.

Everyone already knows what a web-application is and when it's
appropriate to use them. Therefore, the session skips the small stuff
and starts out by building a strong foundation by exploring the four
pillars of JSF: the View, Model interaction, the Lifecycle, and the
Navigation Model.

With these concepts firmly understood, we cover some JSF design
principals and patterns used all over JSF. Patterns discussed include
decorator, singleton, strategy, template method, and observer. For each
pattern, its use in JSF will be covered in detail, with emphasis on how
the pattern is used to enable developer customizations.

The participant then learns about Type Conversion, Validation, Events,
and the flexible rendering model.

A running example will be constructed throughout the presentation.

OpenEJB3.0

  EJB3.0 is the latest public specification which covers the JEE EJB technology. It added a lot of new features which made EJB  development more easy and fast by using the new annotations feature of Java 5 in what is called *Dependency Injection*. This specification also introduced the *Interceptors* which provides a mechanism to handle life-cycle and other events either on the module level or the package level or the class level or method level. It also changed the persistence mechanism relative to former EJB specifications specially EJB2.1 by introducing the JPA (Java Persistence APIs). It also took care of migrating existing EJBs from their current implementation to cope with EJB3.0 . All this besides the normal well known services and features already introduced in former EJB specifications like transactions, security and timer service among others .

  OpenEJB3.0 is an Apache EJB3.0 container implementing the standard EJB3.0 specification and adds its own flavour by extending this specification to make the developer's life easier so they can be more efficient and productive. I will try in this talk to show how developers use OpenEJB3.0 to get all the benefits provided by EJB3.0. I will try show this in a practical way - full featured medium-sized real life project - by going through a real life project and how we can design and implement it using EJB3.0 technology APIs and using OpenEJB3.0 as our testing and production environment .

Practical Aspect Oriented Programming

  Aspect-Oriented Programming (AOP) complements OO progra­mming by allowing the developer to dynamically modify the static OO model to create a system that can grow to meet new requirements. Just as objects in the real world can change their states during their lifecycles, an application can adopt new characteristics as it develops.
AOSD attempts t­o aid programmers in the separation of concerns, specially cross-cutting concerns, as an advanced in modularization.

In this session, I will give you an overview about AOP and how it can be used, how to remove the cross-cutting code like Logging, Security …etc

­
I will try to introduce an advanced usage of AOP like performance monitoring, static code analysis, design pattern implementation and DLA.