JavaZone 2007 - Podcast

JavaZone 2007 - GlassFish - Delivering a better application server, one step at a time

GlassFish - Delivering a better application server, one step at a time

GlassFish is a recent and active open source community which has delivered a production-ready Java EE 5 compliant application server in May 2006. Although missing clustering capabilities, this first version is used in production by several demanding web sites and applications. Grizzly (nio web framework), web services, documentation, administration, and monitoring tools are some of its key features. Also, full Java EE 5 support means you can use features such EJB 3 and JPA (Java Persistence API), the new JAX-WS 2.x Web Services stack and JSF (JavaServer Faces) 1.2 MVC framework.

This session will focus on Version 2 of GlassFish (due to be released in the Fall of 2007) and will cover clustering, OpenESB (a JBI implementation) integration and the new Web Services stack called Metro (JAX-WS and WSIT, aka "project Tango" combined) for secure, transactionnal, asynchonous, and reliable Web Services. Performance and ease-of-use features are also key features in this release. Some of these features will be demoed during the talk including IDE integration.

Open Source clearly isn't about good enough and the GlassFish community believes that there's still plenty of room for innovation at the application server level. So this session provides technical details on the preview of GlassFish v3 (modular HK2 architecture, startup time).

Finally, the presentation will touch on the GlassFish community from users to partners.
This is a 1-hour technical overview for a developer audience which includes /several short but live demonstrations/.

JavaZone 2007 - Refactoring HTML

Refactoring HTML

As web sites transition from simple content to full-blown, two-way applications the legacy cruft of the past ten years is becoming apparent. There are millions of sites and billions of pages that have been around since the 1990s. Many of these pages were designed for browsers like Netscape 3, Internet Explorer 2, or even Mosaic. They may have been redesigned several times, but the underlying structure and markup remains the same; and this is becoming a problem. These pages don’t work well with modern technologies and tools like AJAX, DOM, E4X, JavaScript, and more.

Consequently, many web developers and designers find themselves faced with legacy code for the first time. Until recently most sites and pages just weren’t old enough for legacy issues to be a major concern. While legacy issues and the tools and techniques for managing them are well known to programmers, web folks are just now learning about these problems. As web designers begin to grapple with the legacy issues that have hampered programmers for so long, they’ll need to learn the same refactoring techniques programmers have used to manage these problems.
This talk help web designers, web authors, web programmers, and webmasters learn the tools and skills they need to clean up their sites so they can take them to the next level. Specific goals include improving accessibility and usability, optimizing search engine placement, and reducing the overall cost of development for web sites. by converting sites to web standards: XHTML, CSS, and REST.

JavaZone 2007 - Mule 2 and Beyond

Mule 2 and Beyond

Mule is the leading open source ESB and integration framework. It's focus has always been on the developer with the aim of simplifying the difficult task of implementing an integration or SOA project. The focus Mule 2.0 is to make things even easier, more powerful even more robust. This talk will pivot on some of the new features of Mule.

- New Xml configuration. Xml editor and developer friendly - no more class names!
- The new extensible configuration model
- Enhancements to the Mule runtime environment
- How mule works with BPM and where BPEL fits in
- OSGi support, For dynamic component loading and hot deployment
- Data Streaming support

Ross will also discuss the Mule roadmap for 2007/2008 including new arrivals in the Mule ecosystem and some a couple of Mule Customer case studies.

JavaZone 2007 - The Top 10 Ways to Botch Enterprise Java Application Scalability and Reliability

The Top 10 Ways to Botch Enterprise Java Application Scalability and Reliability

This follow-on to last year's JavaOne sleeper hit "The Top 10 Ways to Botch an Enterprise Java Technology-Based Application" explores best practices for protecting against scalability and reliability in Java Enterprise Edition applications and compute grid environments. Starting with simple abuses of messaging and clustering technologies, this presentation navigates a wide swath of options available to enterprising architects seeking to limit the effectiveness of scale-out environments.

After last year's presentation, we were disappointed that some attendees mistakenly used this information to avoid pitfalls, errors, and other common causes of project failure. We hope for better results this year.

JavaZone 2007 - Style and Taste in Writing FIT Documents

Style and Taste in Writing FIT Documents

FIT is a framework that comes in various guises (Fit, Fitnesse, Fitlibrary), and can be used in different ways. The core principle behind writing FIT documents is to promote better communication between the stakeholders of a system. By using FIT, we can get our customers more involved in the design and specification. With the help of FIT documents, we will collaborate more closely and evolve a better shared understanding. As the system evolves, the collective set of FIT documents will provide a living specification - the place that everyone refers back to, to understand what the system actually does.

In principle, using FIT is a good thing, but in practice we find that some teams struggle to use FIT documents effectively. Based on our experience, we provide our advice on what to focus on, and what to steer clear of when writing FIT documents in your team.

JavaZone 2007 - Building Real Swing Applications

Building Real Swing Applications

There is plenty of literature on Swing. However, we feel it pays too much attention to low-level technical details, and specific, isolated problem domains. This presentation will focus on the greater picture, the key design issues and their collaboration essential to creating viable applications; real applications.

We will present our view on the essential design issues that need to be addressed and how all the pieces fit together. Even though we will talk about Swing, the presentation is suitable for anyone involved in rich application development.

With more than twenty years of Java experience between them, this presentation will be given by Escenic's Harald Kuhr, part of the core team developing Escenic Content Studio, and Bouvet's Swing expert Yngvar Sørensen.

Agenda

Introduction
Demo
The essentials
- Application life-cycle
- Configuration and resource management
- Actions/commands and execution strategies
- Data binding
- Input validation
- Undo and redo
- Data transfer (cut/copy/paste, drag/drop)
- Other things to keep in mind
Summary
Q & A

NOTE: The presentation will be given in Norwegian only.

Required experience:
Some Swing programming preferred

JavaZone 2007 - Building scalable, reliable, secure, RESTful services

Building scalable, reliable, secure, RESTful services

While WS-deathstar may get a lot of attention in the scalability, reliability, and security areas, RESTful HTTP services have a lot to offer you that you may not be aware of. What's more, the resulting architecture may be simpler and more easily maintained. This session will examine strategies for building scalable, reliable, and secure RESTful web services for the enterprise environment, and examine the reasons for doing so. Along the way we'll cover topics such as ETags, SSL, idempotent methods, various programming toolkits, XML Encryption/Signature, and much more.

JavaZone 2007 - Advanced JPA Topics

Advanced JPA Topics

The Java Persistence API (JPA) is fast becoming the popular choice for object-relational persistence not only in Java EE environments but also in enterprise applications that make use of other technologies, such as Spring. Since the JPA standard has taken hold, the developer base has gotten more experienced with the persistence model, and the questions that arise are now more of an intermediate or advanced nature.

In this talk we will introduce a few of the common features and use them as a platform on which we can discuss some of the higher order JPA topics. As part of this discussion we will show how to use multiple persistence units, define and tune identifier generators, create and invoke native queries, and use XML mapping files for overriding annotation metadata. We will also show how JPA can be used in Java SE and Spring environments.

While attendees that have some experience using JPA will profit from this talk, even those who are interested in JPA, but who have not yet started writing applications with it, could also enjoy it. Some kind of experience with Java persistence would be beneficial, though.

JavaZone 2007 - The State of Ajax

The State of Ajax

Join Ben and Dion as they walk attendees through the rapidly evolving and often confusing Ajax landscape, covering the important topics and trends that will affect how you develop web applications. Far from a fickle fashion, Ajax is continuing to revolutionize the way software is built, from providing the new model for desktop applications to the new model for mobile applications. The Ajaxians will start the keynote analyzing the large impacts Ajax is having on the development landscape, including the latest in end-to-end JavaScript (i.e., JavaScript serving up JavaScript to the client) and server-less Ajax. They'll next discuss how the frameworks are changing to make development easier and it better address the challenges of cross- browser development. The final part of the talk discusses the state of the browsers, the Ajax community, and the future.

JavaZone 2007 - Enterprise Service Bus HOWTO: From Software Selection to Mission-Critical Application Deployment

Enterprise Service Bus HOWTO: From Software Selection to Mission-Critical Application Deployment

This is a comprehensive, hands-on tutorial to using the Mule ESB in a mission-critical production environment. This HOWTO is based on the speaker's experiences deploying Mule ESB at the largest educational toy company in the United States and at the largest company in the world. The presentation will cover such topics as: how do you select an ESB? As a developer, how do you start working with it? How do you integrate it with Spring or other frameworks? Learn how to define the business and technology requirements, compare the characteristics of several ESBs (commercial and open-source), review the ESB architecture, and participate in a short development workshop. Bring your laptop!

- About the speaker (qualifications)
- Do you need an ESB?
	- Enterprise integration architecture concepts
	- Services-oriented architectures, messaging, and web services
	- Enterprise service bus evolution
	- Commercial ESBs
	- Open-source ESBs

- Decision cheat sheet:  commercial or open-source?
	- The Mule ESB
	- Download, installation, and configuration
	- Integrating third-party adapters
	- Application integration
	- Defining the endpoints
	- Message routers (synchronous, asynchronous) and transactions
	- Translators
	- Extending Mule to handle application-specific messages, routing,
          translators, and service objects

- Deploying the ESB
	- Embedded in a custom application
	- As part of Spring or other framework
	- High-performance dedicated deployment (server selection)

- Production deployment
	- Planning deployment
	- Deploying the ESB and associated applications
	- System monitoring
	- ESB and application monitoring
	- Disaster recovery and fail-over

- Expanding the ESB from a single application to becoming the enterprise backbone
- Conclusions
- Q&A

Expected audience:

Software engineers, systems architects, and integration specialists rolling out new applications based on SOA who are in the process of selecting modern and reliable integration platforms, and who want to learn more about the differences between ESBs, their configuration requirements, development and integration effort, and operational characteristics.




The attendees will learn:

How to select an ESB

How to integrate exisiting (Java 1.4, legacy) applications and new technologies

How to integrate non-Java technologies into an enterprise application (i.e. .Net)

How to extend the ESB functionality through the service managers, routers, translators, and filters written in Java

How to integrate the ESB in the environment by embedding it into the application or leveraging a framework like Spring

Cost control is an imperative; approaches to reduce costs

How to deploy and monitor ESB-based applications (tools discussion)

A list of open-source technologies that meet of exceed the feature sets of commercial applications at a fraction of the cost and that will keep the IT organization engaged by participating in a community effort

JavaZone 2007 - Domain driven pointcut design

Domain driven pointcut design

AOP has become a buzzword that almost every Java developer have heard. Netherless, AOP is still an exotic technology that is not the first thing that comes to a mind for most people when a trying to solve new tasks. The main reason for that is that many developers find it difficult to think in terms of AOP and AOP is mainly associated with logging, tracing, caching, and other trivial crosscutting concerns. As I will show AOP can be used for much more interesting things. This presentation summarizes ideas from several articles and blogs written by some of the most influential AOP gurus and presents examples inspired by real projects. Following topics will be covered:

What are the most common problems of software projects using AOP?
AOP \!= obliviousness
AOP and DDD
Applying OOP design principles to AOP
Examples

Outline:

Introducing AOP
- Raising application abstraction level with AOP
- AOSD paradox and solution to it
AOP and DDD
- types of pointcuts
- concern semantics mismatch
- pointcut design guidelines
AOP-aware interfaces
- AOP-aware interfaces vs conventional OOP interfaces
- Problems of common domain model for different application layers
Several examples
summary

Language:

Norsk

Level:
Intermediate

Required experience:
Noe forkunnskap om AOP and enterprise Java applikasjoner

Expected audience:
Utviklere og arkitekter som er interessert i AOP, og som ønsker å lære mer om effektiv bruk av AOP i enterprise applikasjoner.

JavaZone 2007 - Ruby Tooling, State of The Art

Ruby Tooling, State of The Art

Java integrated development environments (IDEs) have offered unparalleled productivity tools for developers. Refactoring, code completion, and static code analysis are all made possible by the Java programming language's static typing system. Dynamic languages, on the other hand, have traditionally left much to be desired in the tools department. Their proponents have argued that tools are not as necessary, because there is less code to write, and that unit tests can replace static checking. With dynamic languages such as Ruby being hosted on the Java platform, new efforts have been made to bring the features of Java IDEs to the dynamic language world. The results are promising: as a dynamic language developer, you can have your cake and eat it too. This technical session covers recent developments for Ruby in the NetBeans IDE and discusses future directions for research in this area, such as direct and statistical type inference, wide-ranging refactoring support, more-accurate code completion, and multilanguage editing and debugging.

JavaZone 2007 - Developing Rich Desktop Applications using Qt Jambi

Developing Rich Desktop Applications using Qt Jambi

In this session we intend to demonstrate to the audience, using source code examples and live demos, how it is possible to develop rich, snappy, native-looking, desktop applications using the framework Qt Jambi.

Qt Jambi is the Java version of the popular Qt C++ cross-platform framework, opening a world of possibilities for Java and C++ programmers alike. It is an officially supported technology aimed at Java programmers who want to create great-looking GUI applications using a first-rate GUI framework.

The Qt C++ framework has been at the heart of commercial applications since 1995. Qt is used by companies and organizations as diverse as Adobe®, Boeing®, IBM®, Motorola®, NASA, Skype®, and by numerous smaller companies and organizations. Qt's classes are fully featured and provide consistent interfaces to assist learning, reduce developer workload, and increase programmer productivity. Qt also has a long history in the Open Source community, among other things as the foundation of the K Desktop Environment (KDE).

In our presentation we will demonstrate Qt Designer by example and at the same time introduce Qt Jambi's signal and slot mechanism, layout management, and Qt Jambi's ability to customize user interface look using cascading stylesheets (CSS). We will also demonstrate some of basic of Qt's model view framework.

Qt Designer is a WYSIWYG tool for graphically designing user interfaces. Qt Designer can be used purely for GUI design, or to create entire applications with its support for integration with popular integrated development environments (IDEs), like Eclipse. Using Qt Designer for our examples, we will see how Qt Jambi's layout management and signals and slots works. Signals and Slots are Qt Jambi's object communication mechanism, gluing components together in a simpler manner than traditional listener interfaces.

Attendees to this presentation are expected to gain insight a new way of developing desktop applications using Java. Expected requirements from the audience is a basic knowledge of the Java Programming Language and GUI development.

JavaZone 2007 - Experiences on using Spring WebFlow with JSF

Experiences on using Spring WebFlow with JSF

When making large web application controlling page flow is traditionally not very flexible or maintainable in mainstream web framework like STRUTS or JSF.

This talk shows how to use Spring Web Flow (SWF) to control flow and what benefits and problems we experienced on a large JSF-based project. The benefits include richer model for the lifecycle of objects and more configurable flow between web pages. The problems ranged from the usual headaches of using XML closely tied to Java classes, bugs in the current implementation and the need to make a good design for how the flow should be.

The talk will discuss some of the limitations in SWF, like no support for inheritance, and provide some work-around’s.

Description of SWD taken from www.springframework.org:

“Spring Web Flow is a next generation Java web application controller framework. The framework provides a powerful system for implementing navigation logic and managing application state consistently across a variety of environments.

Spring Web Flow is a component of the Spring Framework's web stack focused on the definition and execution of UI flow within a web application.

The system allows you to capture a logical flow of your web application as a self-contained module that can be reused in different situations. Such a flow guides a single user through the implementation of a business task, and represents a single user conversation. Flows often execute across HTTP requests, have state, exhibit transactional characteristics, and may be dynamic and/or long-running in nature. “

Required Experience:
Knowledge of JSF

JavaZone 2007 - How to develop an insurance sales web application in 6 months

How to develop an insurance sales web application in 6 months

This talk will explain how it was possible to develop an advanced and easy to use insurance sales web application in only 6 months, and at the same time ensuring adherence to good architecture principles and software development practices. The factors that that made the project a success and the lessons learnt in the following areas will be presented:

Methodology and project organization
GUI design and usability
Architecture and technology
Development tools and process

The audience should gain a better understanding of how to set up and run a successful enterprise Java project.

JavaZone 2007 - From Bestimate to Estimate – techniques and perception management for estimators and their customers

From Bestimate to Estimate – techniques and perception management for estimators and their customers

Our reputation as estimators –even when we us agile methods -- is bad. Agile methods provide useful techniques and practices for teams and their customers to improve accuracy without creating illusions of precision. Many of our estimation problems come from misunderstanding and miscommunication about what estimates are and confusion with other related concepts like planning and targets. Where do errors come from, what can we promise and how do we best serve the primary purpose of software estimation process?

Intro – a typical conversation about estimates. 5 min
What is an estimate (accuracy, precision, … a glossary) (15 minutes with quiz)
Estimation purpose and how much estimation do we need (10 min)
Techniques for estimation (10 min)
Techniques to talk about talk about our estimates – perception management (10 minutes)
Q and A – capita selecta

Required experience:
All levels interested in estimation – as estimator and as customer of estimates.

Expected audience:
All involved in estimation and planning processes and sales, managers and executives who expect and use the results of that process.

JavaZone 2007 - Quick and Easy Profiling with Integrated Tools

Quick and Easy Profiling with Integrated Tools

Have you ever struggled to figure out why some part of your application runs slowly? Have you ever seen hard-to-reproduce OutOfMemoryErrors that shut down your application?

What do you need to make profiling of a Java application easy? The answer is simple: powerful tools that are well integrated into your development environment. Recent advances in the JDK software have increased the power and flexibility of profiling tools for the Java platform. Further advances in integrated development environments (IDEs) have made profiling tools even easier and more convenient to use. Finding performance problems, threading issues, and memory leaks has never been easier. This session focuses on specific advances in the integration of powerful profiling tools into the NetBeans IDE and includes demonstrations that show specific use cases.

Outline
1. What sorts of problems can an integrated profiler help you solve?

2. The state of the art today: NetBeans Profiler version 5.5.1

3. Case Study: A memory leak in HttpUnit.

4. Upcoming enhancements to make things even easier: A preview of NetBeans Profiler 6.0.

5. Case Study: JRoller performance problems.

Required experience
Attendees are expected to understand the basics of performance and memory usage problems in Java applications.

Expected audience
Anyone who has experience with or wants to learn more about tracking down performance bottlenecks and memory leaks in Java applications.

JavaZone 2007 - An Agile Approach to Requirement Specification

An Agile Approach to Requirement Specification

We started of with a brief project description sounding something like this: “Our current intranet is out of date and we need a new one to meet our current needs”.

Together with the customers project manager we toured the company and performed a number of workshops and interviews, gathering only the high level information we needed to specify and prioritize the “most wanted” requirements as User Stories.

Using techniques as Behavior Driven Development, User Stories, MoSCoW prioritization, Planning Poker and a lot of facilitation we developed the requirement specification, without tons of documentation and months of work.

No thick documents. No nitty gritty details. Only simple and clearly defined goals, user stories, estimates and a high-level plan for the project well anchored with the sponsors – and employees. The project is accepted and will now continue with the detailing of user stories to acceptance tests for implementation along the iterations - until the customer has the intranet they need.

This talk is about how an agile specification approach and a team based on trust can specify the necessary requirement in a few weeks with same – or better – results, as opposed to spending months on detailed documentation. By the time Tom does his talk the project will be done and he will share the actual results with you. Was this agile requirement specification approach really that good? What could have been improved?

OUTLINE

Project background - (5min)
The Challenge – “Our intranet is falling apart – we have no time to loose!” (10min)
The Process – “We need to prioritize and figure out where we can start – without knowing all the details” (25min)
The Result – “20 hand written user stories – will it do?” (10min)
Q & A (10min)

Required experience:

Experience from system development projects

Expected audience:

Systems Developers, Project Managers, Technical Project Managers, Business Analyst

JavaZone 2007 - Hvordan holde seg oppdatert på Java fronten

Hvordan holde seg oppdatert på Java fronten

Hver 17. mnd kommer det en ny versjon av Java. Java Community Process er aktiv som aldri før - 700 personer/firmaer bidrar kontinuerlig til Java Spesification Requests. Nye språk kommer inn i den offisielle platformen (Groovy, JRuby, Scala) og et hav av rammeverk er tilgjenglig for deg som utvikler. Hvilke av de 323,000 treffene på "Java framework" i google er relevante? Hvilke av de 272,000,000 linkene om Java burde DU ha lest? Sitter du i tidsklemma og sliter med å følge med? Få gode tips og kilder på hvordan henge med. Etter en kort innledning prøver vi i fellesskap å finne de beste metodene for å finne informasjonen, slik at du kan beholde nattesøvnen intakt.

JavaZone 2007 - Rich Applications using JavaFX Script

Rich Applications using JavaFX Script

This session provides an introduction to GUI development with JavaFX
Script,
an object-oriented, declarative Java scripting language.

JavaFX Script is a statically typed language that allows good integrated

development environment (IDE) support and compile-time error reporting
and has type inference, declarative syntax, and automatic data binding
with full support for 2-D graphics and standard Swing components as well
as declarative animation. You can also import Java class files, create
new objects for the Java platform, call their methods, and implement
interfaces for the Java platform.

IDE plug-ins are available for both the NetBeans IDE and Eclipse. Both
plug-ins support as-you-type validation, code completion, syntax
highlighting, and hyperlink navigation (with Control-mouseover).

JavaFX Script attempts to demonstrate that we're not exploiting the full

capabilities of the Java platform for GUI development and that, together

with supporting tools, the Java platform is

highly competitive with or superior to competing GUI development
platforms such as Adobe Apollo, Ajax/DHMTL Macromedia Flash/Flex/Open
Laszlo, Microsoft WPF/XAML,
and Mozilla XUL.

JavaZone 2007 - The Hundred Kilobytes Kernel (HK2)

The Hundred Kilobytes Kernel (HK2)

The java.net project "Hundred Kilobytes Kernel" (HK2) is a module subsystem coupled with a simple yet powerful component model to build software. It is a great technology to use in any Java software development and can be used in small devices such as phones up to enterprise applications. HK2 is designed to be friendly to existing technologies such as OSGi but it will also provide a path to the implementation of modules (JSR 277) in Java SE 7. HK2 is used as the foundation for GlassFish V3.

 
Outline

    * Introduction to component models, 2 min
          o OSGi
          o JSR 277
    * HK2 overview
          o Modules, 20 min
                + Modules
                      - Module definition
                      - Module packaging
                + The module subsystem
                      - Instances
                      - Unloading
                      - Modules and classloaders
                + Repository
                + Registry
          o Components, 20 min
                + Services
                      - The build system
                      - Runtime
                      - Instantiation
                      - Life Cycle
                + Inversion of Control
                      - Injection
                      - Extraction
                      - Instantiation cascading
    * Live demonstration, 5 min
    * How HK2 is used in GlassFish V3, 5 min
    * Q & A, 10 min

Required experience

    * None

Expected audience

    * Architects and developers

JavaZone 2007 - Code Organization Guidelines for Large Code Bases

Code Organization Guidelines for Large Code Bases

Structuring a large code base maintained by multiple teams working in parallel can be a real challenge. If you are not disciplined about code structure overtime you will end up with a tangled, unmaintainable mess that cannot adapt to change and risks ossifying into legacy. In this session Juergen and Arjen will pull from their experiences working on large projects to provide important guidelines on code structure. In this session we will pull from their experiences working on large projects (including the Spring Framework) to provide general guidelines on:

- Packaging and package interdependencies
- Layering and module decomposition
- Evolving a large code base

We will also discuss how tools can play a role in enforcing architectural soundness.

Attendees will leave with practical techniques to improve and sustain the overall structure of their code bases, as well as an understanding of the benefits gained by doing so.
Outline:
After a short introduction and agenda, we go into code organization. We will explain why code organization is important, but also see that it is often ignored.

Next, we will talk about package interdependencies, and show typical examples of code bases that get this wrong. This section will take approximately 10 minutes.

Then, we go one step up in granularity, and we talk about module decomposition. We discuss the properties of a module, and talk about the subtle difference between layering and modules. This section will also take about 10 minutes.

Then we will look into the Spring framework. We will talk about the evolution of Spring, and the challenges that were tackled when Spring 2.0 was released. This will take about 15 minutes.

We will also look at some tools which help you managing such a large code base. We will show these tools in a demo. This will take about 15 minutes.

Finally, we offer a summary, and have about 10 minutes left for Q&A.

Required experience: Basic knowledge of basic code quality measures is useful

Expected audience: Developers working on larger code bases

JavaZone 2007 - Enterprise Comet - No Plugins, No Polling, No Pain!

Enterprise Comet - No Plugins, No Polling, No Pain!

There is a common misconception among many end-users, consumers, and developers that Ajax is the ultimate solution for the Web, and that it can provide all the same functionality as a rich desktop solution. Sure, Ajax can cover most of our expectations for a rich client, mimicking functionality provided by a desktop application, but there is still one area that has yet to be fully integrated - scalable server-initiated message delivery - Enterprise Comet.

Comet is an advanced technique to enable real-time messaging from a Web server to one or more browsers, even if some of those browsers are behind a firewall or proxy server. Imagine being able to monitor any real-time data source from server statistics to your favorite stock portfolio, directly from your Web browser with no polling, no plugins and no pain!

Grizzly enhances the Glassfish project with Comet support via Asynchronous Request Processing (ARP), addressing any server-side scalability concerns with Comet. The Dojo organization provides the Bayeux Protocol, used to coordinate shared access to the Comet notification channel coming from the server.
In this talk the presenters will discuss scalability, security, and performance implementing support for Enterprise Comet using GWT, Bayeux, Comet, and Grizzly.

JavaZone 2007 - Java Grid Computing with AOP

Java Grid Computing with AOP

The topic of this presentation is about innovative use of AOP in open-source Java grid computing framework that is trying to change the grid computing landscape in much the same way as Spring or JBoss have changed JEE landscape in the last couple of year – removing complexity, clutter and over-engineering of traditional computational grid solutions.

The presentation will concentrate around live demonstration of writing a simple application like a HelloWorld and grid enabling it to run on a small grid right in front of the audience and with audience participation. Demonstration will be performed on Windows XP using Eclipse 3.2, Java 5 and GridGain framework (LGPL open-source Java grid computing framework available at www.gridgain.org). CDs will be made available before and during presentation for anybody who would like to become a part of ad-hoc grid during demonstration (simple 1-minute installation for Windows XP/Vista or Linux is required).

All coding during demonstration will be done live. Detailed and in-depth explanations will highlight that grid computing in Java can be fun, simple and productive to use in everyday applications and systems. Special attention will be paid to the fact that grid computing can be used by businesses of any size: small, medium or large. Real-life examples will be discussed.

Technical content of the presentation will focus on how AOP is used in this example to achieve transparent grid-enabling or grid-enabling without even touching a source code. It will also discuss during live demonstration some of the innovative features of GridGain such as peer-to-peer deployment and hot re-deployment, resource injection, unique support for split/aggregation and Spring/JBoss integration.

Outline:
It’s important to note that 1/2 (30 minutes) of the entire 
presentation will be devoted to a live coding demonstration and slides 
only support introduction and conclusion parts of the presentation. 

* Introduction 
   o Nikita Ivanov 
   o GridGain, www.gridgain.org 
   o Live demonstration

* Why is Grid Computing? 
   o Grid computing 
   o Huge potential 
   o However, compute grids today are 
   o Leading to 

* Why Java? 

* Why AOP? 
   o Grid enabling Java application = grid enabling a Java method call 
   o Grid enabling is a cross-cutting concern 
   o Transparent grid enabling 
   o AOP in GridGain  

* Live Demo 
   o Windows XP, Eclipse 3.2, Java 5, GridGain 1.0 
   o Join the grid (DVDs are available) – Win32/Linux/Mac OS X are welcome! 
   o We will take simple HelloWorld Java app 
   o We will grid enable it using GridGain 
   o We will run this example on the grid right from the Eclipse 

* Conclusion 
    o Grid app in less than 30 minutes from scratch 
    o Transparent grid enabling 
    o Transparent deployment 
    o Grid logic is separated from business logic 
    o Fun, simple and productive :-)

Required Experience:
Java 5
Basics of AOP

Expected Audience:
Audience is expected to include developers, architects and technical managers who are interested in grid computing technology that breaks away from traditional mold and makes Java grid computing fun, simple and productive to use.
We are expecting this talk to be really interesting and popular among he attendees as it includes a live end-to-end demonstration of something that not so long ago would require weeks and months of just configuration and was part of only privileged projects in the government research and large corporate sectors.

JavaZone 2007 - Simplicity - Lessons learned from enterprise application development

Simplicity - Lessons learned from enterprise application development

Simplicity is perhaps the most important quality of software development. This session provides lessons learned from simplifications in an enterprise application development project. After more than two years of development the program seemed increasingly far from completion. Multiple re-planning exercises turned out to be futile. The projects were weighed down by complexity, preventing progress and destroying morale.

The presentation will give concrete examples of how things can be done in a simple manner - as well as hideous examples of complexity - in areas such as platform and infrastructure, methodology and documentation as well as development, testing and change management. Why do you need a Business Process Engine when the standard Java Runtime is sufficient? How many people should be involved in deploying an application to system test? Should you roll your own component instead of acquiring a third-party library? Seeking simplicity in all areas is likely to result in considerable increased velocity, and arguably lead to increased maintainability and testability.

- Introduction - Simplicity is the opposite of complexity (5 min)
- Simple platform - The JRE and lightweight frameworks (5 min)
- Simple infrastructure - Redundancy, scalability and transactions (5 min) 
- Simple deployment - Self-contained and automated (5 min)
- Simple design - Domain-Driven Design can lead to Big Design Up Front (5 min)
- Simple documentation - Travel as light as you possibly can (5 min) 
- Simple functional testing - Tester Developers and Developer Testers (5 min)
- Simple technical tests - The unit test from Hell, and other tests to avoid (5 min)
- Simple code - Threading madness, and how TDD keeps you honest (5 min) 
- Simple development environment - Shrink-wrapped and ready to roll (5 min)
- Simple operations - Start, stop, rollback and monitor (5 min)
- Simple configuration management - Lists are waste; prevent bugs from slipping in (5 min)

Required experience:
The presentation will touch many areas of enterprise application development, from testing and development to infrastructure and deployment. Experience from a Java development project is recommended, but except a few examples the presentation does not require deep technical knowledge.

Expected audience:
The presentation is from an architects perspective, and should be relevant for developers, testers, project managers and architects.

JavaZone 2007 - Ajax i praksis -- en hvit tornado?

Ajax i praksis -- en hvit tornado?

Ajax-teknikker gjør det mulig å gi web-applikasjoner et brukergrensesnitt som ikke tidligere lot seg realisere i en nettleser. 'Bygg for alle'-prosjektet har brukt Ajax for å realisere et svært dynamisk brukergrensesnitt for registrering og publisering av informasjon om tilgjengelighet i offentlige bygg. Dette erfaringsforedraget diskuterer hvordan Ajax påvirker MVC-arkitekturen til systemet, samt demonstrerer hvilke utfordringer man står ovenfor ved bruk og testing av Ajax-funksjonalitet.

  - Bakgrunn og motivasjon for løsningen (5 min)
   - Arkitekturen i løsningen (10 min)
       - Datadrevet metamodell m/ dynamiske dialoger
       - Ajax og MVC
           - omfattende bruk av Ajax og asynkronitet i web-løsning
               - treeview er Ajax
               - alle dialoger under er Ajax-basert
       - Ajax og web-rammeverk
           - mister mye web-rammeverk funksjonalitet v/ bruk av ajax
           - hva vi valgte
               - Yahoo UI Library
               - Velocity
               - Spring MVC
               - Servlet
           - Hva vi ikke valgte
               - GWT
                   - hot, men ferskt når vi startet prosjektet
                   - metadatastrukturen vår kunne bli en utfordring
   - Erfaringer og gotchas (20 min)
       - Ivaretakelse av tilstand på flere nivåer i klienten
       - Asynkront kommandogrensesnitt basert på XML
       - Divider/scroll-bar problematikk
       - Enkoding-problematikk v/ dynamiske skjermbilder
       - Feilhåndtering og validering, tilbakemelding
       - Asynkront kommandogrensesnitt basert på XML
       - Retur av html til placeholdere
       - Nyttige utviklingsverktøy
   - Testing av Ajax-funksjonalitet (10 min)
       - Utfordringen med testing av JavaScript
       - Selenium + Fit
       - Testing mot flere browsere
   - Spørsmål (10 min)

NØDVENDIG ERFARING:
Noe erfaring med utvikling av web-løsninger er fordelaktig

PUBLIKUM:
Alle med interesse for moderne web-utvikling

JavaZone 2007 - EDRP - Håndtering av domeneobjekter i overlappende kjernesystemer

EDRP - Håndtering av domeneobjekter i overlappende kjernesystemer

Har du utfordringer med koplekse data fra flere fagsystemer? Blir systemet ditt tregt fordi komplekse data krever lang tid for å lastes?

Dagens virksomheter har ofte et forretningsdomene som spenner seg over flere ulike underliggende kjernesystemer, ofte referert til som silo applikasjoner. Domeneobjektene er adskilte med ulik datakvalitet og gjerne med SLA'er av varierende kvalitet. Dette medfører en arkitektur som skaper integrasjonsutfordringer og som vil får store konsekvenser i en tjeneste orientert kontekst.

Typiske tilnærminger til disse integrasjonsutfordringene er master og multi-master strategier. Man har et kjernesystem som opptrer som master og er ansvarlig for å synke mellom "slave" systemene, eller en master for hvert kjernesystem.

Enterprise Domain Repository pattern (EDRP) ser utfordringen med at samme data lever i forskjellige fagsystemer. Ved å benytte EDRP oppretter du komplekse objekter en gang. Deretter legges dette objektet i cache, for rask tilgang ved senere bruk. Når du oppdaterer data som berører objektet som ligger i cache, reflekteres dette direkte til alle brukere av tjenesten. Ved at oppdatering også går gjennom EDRP tjenesten vil alle brukere, og alle fagsystemer, ha mulighet til å få med seg oppdateringen.

Vi vil i dette foredraget vise hvordan man kan ta kontroll over forretningsdomenet og integrasjonsutfordringene ved å benytte EDRP. Vi vil se nærmere på hvordan EDRP baserer seg på tjenester som korrelerer data fra flere kjernesystemer. Tjenestene vil eksponere forretningsinformasjon fra flere kilder samstilt, og i tråd med virksomhetens egne definisjoner. Ved hjelp av eksempler vil man se hvilke gevinster man får ved å benytte EDRP kontra en master/multimaster strategi.

* Introduksjon (1 min)
* Målet med foredraget (1 min)
* Typiske integrasjonsutfordringer i dagens virksomheter (10 min)
	o Overlappende kjernesystemer
	o Master strategi
	o Multi-master strategi
* Tjeneste kategorier (5 min)
* Enterprise Domain Repository Pattern (20 min)
	o Hva er det?
	o Hva løser det?
	o Hvorfor?
	o Når bør man bruke det?
* Erfaringer med bruk av EDRP (10 min)
* Kilder (1 min)
* Q&A (10 min)

JavaZone 2007 - Apache Tuscany - Building SOA Solutions With The Service Component Architecture

Apache Tuscany - Building SOA Solutions With The Service Component Architecture

Apache Tuscany provides an open-source services infrastructure for constructing SOA solutions from heterogeneous and distributed services. To make the implementation and deployment of services straightforward Apache Tuscany is based on the widely supported Service Component Architecture (SCA) specification currently being standardized at OASIS. With the Tuscany implementation of SCA, application developers can easily create, reuse and customize services in different languages, for example, Java, BPEL or various scripting languages, and then assemble and deploy them in a distributed environment. Through slides and examples this talk will introduce SCA and the Apache Tuscany project. It will show you how to get started building and connecting services and how this approach simplifies the task of building SOA solutions. What’s the problem – 4 minutes
What are the business drivers for SOA and what are the problems being faced when using today’s development technologies.

Service Component Architecture (SCA) – 6 minutes
A description of how SCA provides a programming model for SOA and how it helps solve the stated problems.

Apache Tuscany – 8 minutes
A description of the Apache Tuscany open source project. The features available today. An explanation of how to get the software and run the samples. Some examples of how the software could develop in the future. An invitation to get involved and an explanation of the different ways to do this.

Building a Service. – 5 minutes
How to build a service to expose service interfaces. This also shows how to exploit this service from client code

Connecting to other services – 5 minutes
How to connect the service we have just created to other services that we may create or reuse from other applications

Extending the application by adding in more services – 5 minutes
How functionality can be reorganized and extended using the SCA model

Alternative bindings – 5 minutes
SCA and Apache Tuscany is designed to support many pluggable binding technologies so we look here at how different communication protocols can be selected.

Alternative data bindings – 5 minutes
A variety of data formats and representations are also supported. We take a look at how different data bindings can be selected and used.

Bringing it together – 5 minutes
Demonstration of an example SCA application.

Summary and references - 2 minutes
The contents of the talk are summarized and we review the stated problem and the SCA based solution in Apache Tuscany. A set of references for further information is provided.

Q&A – 10 minutes

Required experience:
The talk is aimed at competent developers who want to apply these skills to SOA. No prior knowledge of Tuscany or SCA is assumed but knowledge of programming languages in general and some desire to understand how to apply existing programming skills to build distributed services is assumed.

Expected audience:
Architects, designers and programmers faced with the challenges of building SOA solutions. This talk presents an infrastructure for building and deploying the services of an SOA using the consistent model provided by the Service Component Architecture.

JavaZone 2007 - Rapid 3d Game development with Java

Rapid 3d Game development with Java

Java has penetrated most areas in software engineering today, from small embedded device to large, distributed enterprise systems. However, one area where Java still is absent is 3D desktop games. This session will demonstrate how easy it is to write a complete 3D game using Java and show that it is a viable platform for writing real, commercial desktop games. It will focus more on the different software components and less on 3D APIs, so very little knowledge about OpenGL and 3D programming is required.

Presentation agenda

    * Introduction to game demo
    * Tools, APIs and frameworks
    * Java OpenGL
    * Custom scene-graph and loading of 3D models
    * 3D navigation
    * Collision detection
    * Multi-player solution

Required experience: Intermediate Java experience

Expected audience: Anyone interested in writing 3D applications and/or games using Java

Additional information: The game will be a very simple third-person shooter with multi-player support. The entire game, source code, models and textures included, will be available as open-source online after the conference.

JavaZone 2007 - JavaScript Puzzlers - Is your IDE a Fifth Wheel or the Sixth Sense?

JavaScript Puzzlers - Is your IDE a Fifth Wheel or the Sixth Sense?

During this session Mike will challenge you with several JavaScript puzzlers. You will investigate some tricky parts of error-laden JavaScript code and see for yourself whether an IDE is just a useless "5th wheel" when struggling with errors like these, or if it could serve as your 6th sense and provide extra insight into code problems. Expected audience: Developers.

JavaZone 2007 - Write Better Code, Faster, with Java Generics

Write Better Code, Faster, with Java Generics

Generics are the largest and most important change to the Java programming language since it was introduced. Although the fundamentals of generics are easy to absorb, misunderstandings persist and common use-cases are not well understood. For example, what is “migration compatibility,” and why is it central to the design of generics? What strategies do you have for migrating an existing library? What pitfalls need to be avoided when combining generics and arrays? What do wildcards really represent, and how should you use them? This session will use the ideas underlying generics to answer these and other common questions.

• Motivation for generics (5)
	o Cleaner code, stronger compile-time typing, more expressive interfaces
• Benefits of implementation by erasure: migration compatibility (15)
	o Migration strategies: surface generification, stubs, wrappers
• Problems with erasure (15)
	o Array typing vs generic typing, converting a collection to an array
	o Principle of Truth in Advertising*, Principle of Indecent Exposure*
• Wildcard types: what they are and how to use them (10)
• What next for generics? (5)

Experience: Participants should be familiar with the basic ideas of generics

Audience: Practising programmers working or soon to work with Java 5 or Java 6

JavaZone 2007 - Apache Wicket: web applications with Just Java

Apache Wicket: web applications with Just Java

Why stop object oriented programming at the web tier? Why settle for legacy ridden, prematurely optimizing, mind numbing frameworks when instead you could be having fun coding again? Enter Apache Wicket! In this session, I will show you how you can use Apache Wicket to develop web applications with Just Java and Just HTML. I'll talk a bit about Wicket's philosophy and why it's developers believe it is important to take a novel approach. And then, because only code really talks, we'll take a deep dive to look at how to develop some custom, reusable components.

JavaZone 2007 - Rasjonelle beslutninger ved valg av metoder, teknikker og verktøy

Rasjonelle beslutninger ved valg av metoder, teknikker og verktøy

Dårlige valg av metoder, teknikker og verktøy i systemutviklingsprosjekt kan ha alvorlige konsekvenser, for eksempel i form av lav produktivitet og kvalitet. Beslutninger ved valg av metoder og verktøy bør derfor i størst mulig grad være basert på gyldige forskningsresultater og systematisk innhenting og kritisk vurdering av erfaringer, dvs beslutningene bør være ”evidensbaserte”. Utgangspunktet for presentasjonen er at hyppig benyttede informasjonskilder, slik som guru-uttalelser, demonstrasjoner og referansekunder, lett gir et feilaktig bilde av gevinster og ikke minst at svært få innen IT-bransjen har fått opplæring i bruk av evidensbaserte beslutningsprosesser. Presentasjonen vil inneholde praktiske øvelser med formål å bedre deltakernes evne til å:1) formulere problemstillinger som utgangspunkt for valg av metoder, teknikker og verktøy, 2) innhente relevant og balansert informasjon fra forskning og praksis, og 3) vurdere informasjonens og argumentasjonens gyldighet i forhold til valg problemstilling. Outline:

1) Øvelsesoppgaver (10 minutter)
2) Eksempler på typiske prosessmangler ved valg av metoder, teknikker og
verktøy. (5 minutter)
3) Kort øvelse relatert til vurdering av argumentasjon i tekst skrevet av
høyt profilert XP-aktør. Brukes til å illustrere mangler mhp hvordan vi
leser og vurderer argumentasjon, og hvor lett vi dermed blir påvirke av
retoriske og markedsføringsmessige virkemidler. Gjennomgang av sjekklister
og gode råd for hvordan vi bør vurdere argumentasjon av denne typen. (15
minutter)
4) Gjennomgang av stegene for evidensbasert systemutvikling. Applisert på
valg av metoder og verktøy. (15 minutter)
5) Gjennomgang av øvelsesoppgaver fra 1) + spørsmål. (15 minutter)

Expected audience:
Utviklere, arkitekter og prosjektledere som ønsker å ta bedre beslutninger.

JavaZone 2007 - AJAX made easy with DWR

AJAX made easy with DWR

Direct Web Remoting (DWR) is an open source AJAX library. Its focus is on the core of Asynchronous JavaScript and XML(AJAX) programming; communication between client and server without having to load a whole page for each interaction. DWR basically lets JavaScript invoke Java functions on a server just as they were JavaScript functions running on the browser. The library supports a wide range of frameworks like Spring, JSF and Hibernate. For more advanced applications it also supports reverse AJAX. This means that the server can “push” data to web browsers instead of just having to respond to requests from the browser. Despite all its features DWR is quite easy to use and get started with and fits well into most Java Web applications. Therefore it is one of the most widely used AJAX frameworks around.

This presentation is meant as an introduction to DWR. Its first focus is on DWR's features with examples on how they can be used in web applications. The second focus is on how to set up and to create an application. This will be accompanied with a few hits and tips from the use of DWR on real world applications. The purpose is for the attendants to be able to start using the basic features of DWR after the presentation.

*Introduction – 5-7 min
  *About the presentation
  *About the speaker
  *A DWR teaser
  *Presentation outline
*Features - 6 minutes
  *Possibilities
*Examples – 9 minutes
  *Exploring the features
  *What can we use DWR for
*Set up – 6 minutes
  *Getting ready for creating the application
*Demonstration – 12 minutes
  *Creating a little application
*Some tips along the way – 5 minutes
  *Learn from some common mistakes
*Summary – 2-3 minutes
*Questions and Answers - 10 minutes

Required experience:
Basic knowledge about HTML, JavaScript and Java Web application development.

Expected audience:
The presentation is for those that want to get an introduction to one of the best known AJAX frameworks we have today and have some knowledge about Java Web development. They will know how to start using DWR on AJAX applications.

JavaZone 2007 - Plain Old Java DSLs

Plain Old Java DSLs

In contrast to general programming languages like Java, a Domain Specific Language is a programming language that is target towards a particular kind of problem. Even if DSLs have been around in various forms for ages, the rising popularity of dynamic languages has made them a hot topic again. Most of the attention has been on how one can use these dynamic languages constructs to craft embedded DSLs. Unfortunately, most developers cannot use Ruby or Groovy in their everyday work and the advantage a DSL has to offer remains a theoretical possibility. This talk will introduce you to a variety of design philosophies, design patterns and programming techniques you can use to define embedded DSLs using nothing but plain old Java. After attending this talk you should be able to use your Java skills to “extend” the language to enable you to write code that reads like plain English.

• A brief introduction to Domain Specific Languages 
• Design philosophies 
	o What makes Ruby “elegant”? 
	o Humane Interfaces 
• Designing DSLs in Java (Patterns & Practices) 
	o The Builder pattern 
	   - How the builder pattern simplifies object model assembly. 
	   - Using Java 1.5 static imports to extend the Java vocabulary. 
	   - Demo: “Skipping two versions” – Language level XML support in Java 1.5 (See 
                 http://andersnoras.com/blogs/anoras/archive/2007/04/25/xml-dsl-for-java-1-5.aspx 
                 for an example) 
	   - Demo: Building a DSL for XHTML Documents. 
    o The Fluent Interface pattern 
	   - Creating expressive APIs that read like plain English using the fluent interface pattern. 
	   - “LINQ for J” - Extending Java with a query language. (See http://andersnoras.com/blogs/anoras/archive/2 
          007/03/23/guess-what-i-m-up-to.aspx for an example.) 
	   - Demo: Adding query capabilities for any Iterable resource. 
	   - Demo: Extending Hibernate to support the query DSL. 
• “There is more to Java than Java” - Using the Java 1.6 scripting features to create dynamic DSLs.

JavaZone 2007 - Building Enterprise Applications with JavaServer Faces, Spring, and JPA

Building Enterprise Applications with JavaServer Faces, Spring, and JPA

For developers who are currently using Spring and JavaServer Faces together, this session explains how to handle common application development concerns such as conversational scope, transaction management, and application partitioning. Specific tools such as Apache MyFaces Orchestra, Spring Annotations, and Spring WebFlow will be discussed. At the end of this session, developers will understand how to build a full-stack JavaServer Faces/Spring/JPA application with features similar to those of JBoss Seam.

JavaZone 2007 - Building a Service Oriented Architecture with ServiceMix

Building a Service Oriented Architecture with ServiceMix

There is a big buzz and a lot of hype about Service Oriented Architecture (SOA) and the Enterprise Service Bus (ESB). A solid SOA architecture allows you to use standards-based, pluggable, and loosely coupled services to integrate and communicate the critical business logic from disparate systems. Apache Service Mix is one of the first ESB implementations in open source to offer a solid foundation for building SOA applications. This session will cover Apache ServiceMix and how it implements Java Business Integration (JBI - JSR208) covering Service Engines (SE), Binding Components (BC), and how the different components communicate via the Normalized Messaging Router (NMR). It will also demonstrate coding and wiring these components together to show how to begin building a SOA based application with a real world example.

Outline:

1) Business Integration Problem
2) Past solutions
3) SOA - What is it?
4) ESB and open standards
5) JBI - What is JBI and why is it the answer?
6) JBI - The Answer
7) JBI Overview
8) ServiceEngines and Binding Components
9) WSDL
10) Messaging, Normalized Messaging Router
11) JBI Artifacts
12) ServiceMix - Opensource ESB JBI JSR-208 Compliant container
13) JBI ServiceMix Components
14) Developing and wiring a ServiceUnit
15) Xbean/Spring
16) Realworld examples
17) WSDL First
18) Loan Broker (JMS based Soap Messaging)

JavaZone 2007 - Aspect Oriented SOA: Injecting Aspects into Composite Applications using OpenESB

Aspect Oriented SOA: Injecting Aspects into Composite Applications using OpenESB

One of the design patterns of SOA is to move control flow to an
orchestration component which connects multiple reusable services into a
composite application. The result in practice is that these
orchestrations, often bpel processes, tend to be a mixture of business
services which offer well-defined business value, and technical services
which offer technical capabilities which are always required in IT
solutions – for instance authorisation, logging, etc.

What is required is an aspect-oriented approach where these technical
services can be injected into a composite application. This allows a
business process to concentrate on business functionality, remain
understandable to business analysts, and most importantly, allow
different aspects to be injected within a business process thereby
removing the need need to have multiple versions of the same process
depending on the governance contract it is expected to meet.

This talk discusses and demonstrates how an aspect-oriented approach can
be implemented for composite applications which are developed and
deployed to OpenESB. OpenESB is an open source, ESB implementation based
on the Java Business Integration (JBI) standard.

It will show two design patterns for injecting patterns into composite
applications. The Facade pattern allows the user to apply a chain of
aspects that serve as a façade to a deployed provisioning service. The
Weaving pattern allows the user to weave an existing application with
chains of aspects between services within a Composite Application.

OpenESB supports different types of aspects:

- Technical aspects. For instance, authentication, authorisation, and
caching.

- Aspects which enforce enterprise integration patterns. For instance,
scatter-gatherer, queueing, auto-reconnect, and prioritisaton.

- Business aspects. For instance, chargeback, audit trail, and lease
management.

Finally the presentation looks at how version 2.0 of JBI will include
standards support for service invocation interception and policy
enforcement for improve aspect orientation

- Introduction: SOA and Composite Applications:
- Patterns for injecting aspects into a Composite Application
- Aspects that can be injected into composite applications
- Demo
  + Show how to implement Caching, Data Transformations using the Gateway approach
  + Show how to implement Caching, Data Transformations using the Weaving approach.
- Improvements to version 2.0 of the Java -Business Integration standard
for supporting Aspect-Oriented Composite Applications
- Summary

JavaZone 2007 - Deploying Maven in the Enterprise

Deploying Maven in the Enterprise

Deploying Maven in large organizations is not an easy task. Primarily it 
requires a change in mindset on how to create and maintain your software 
codebase over time. In order to successfully introduce Maven it is 
important to setup the necessary infrastructure components correctly. 
This includes the installation of Maven, a company internal artifact 
repository, establishing project object models and continuous 
integration, integrated with the company source control system. Also an 
internal Maven Proxy should be set up, in order to build on top of 
external repositories if this behaviour is desired.

The presentation takes a practical approach to establishing all the 
required infrastructure components based on best practices and real-life 
project experience within large enterprise projects.

I will address common challenges when deploying Maven and related 
products. Maven requires a somewhat different mindset than traditional 
solutions, like using Ant for purposes of build and committing binary 
artifacts to version control. Traditionally, many companies have 
invested lots of time into developing their own build scripts on a per 
project basis and these are very rarely reused. With Maven, the approach 
is different - the idea is to deploy a company-wide infrastructure which 
should be reused by all projects. Also, when reusing in a large 
enterprise context, the advantage of common rules for placing source 
code and configuration files are truly helpful as they secure an 
enterprise-wide point of standardization. Internal frameworks are much 
easier to reuse than before by continuously  deploying company internal 
snapshots thus making them available for clients. Also, automation of 
code metrics and different types of reports are easy to publish.

Other challenges one typically faces, of which will be addressed as part 
of the presentation are:

- Implicit plugin versioning often causes problems. Without explicitly 
setting versions, the latest/greatest snapshot will always be downloaded 
and the quality of those can vary.

- Many third party frameworks are distributed with poor dependency 
definitions, causing many unnecessary artifacts to be downloaded and 
deployed through transitive dependencies.

- From time to time, people make mistakes like redeploying new versions 
of artifacts based on existing versions. This will cause clients to 
never download the new versions of those artifacts.

- When introducing many frameworks at the same time, one risk that 
several artifacts have dependencies to different versions of the same 
artifacts and this can cause some difficult to solve side-effects in the 
runtime.

- Many companies carry legacy build solutions and it is possible to 
integrate those with Maven. However, a mix of Ant, Maven1 and Maven2 is 
never a good idea in real-life.

Outline:

    
* Why Maven is useful in an enterprise context beyond building and developing standalone applications. 

* Establishing an enterprise-wide artifact repository based on available open source products, like Maven proxies. 

* Configuring the project object model to integrate the repository and source control. 

* Establishing continous integration with Continuum. 

* Q&A

JavaZone 2007 - Scripting in Java 6

Scripting in Java 6

Java SE 6.0 introduces Java Specification Request (JSR) 223, the 
Scripting for the Java Platform API, which allows you to evaluate 
scripts from within a Java application. Scripting languages have the 
advantage of being dynamically typed; they are in most cases 
interpreted, and do not require variable declaration or compilation.

We will look into Project Phobos - a lightweight, scripting-friendly, 
web application environment running on the JavaTM platform. With Phobos, 
you can write web applications using several different scripting 
languages. The interactive development environment allows you to avoid 
explicit compilation and deployment steps, but still retain the power of 
the Java platform.

After attending this session you should be able to harvest some of the 
advantages of the scripting API -for instance by starting to use the 
Phobos web application framework in your projects.

Outline
• Introduction (5min)
° JSR223
• Examples of script programming on the Java platform (20min)
° JRuby
° JavaScript
° Velocity
• Phobos (20min)
° Lightweight, scripting-friendly, web application environment
° Demonstration
• Conclusions (5min)
° Summary
° Benefits
• Q&A (10min)

Level
Introductory / intermediate

Required experience
Curiosity

Expected audience
If you want to learn more about the scripting abilities in Java you should definitely attend this session

JavaZone 2007 - JavaScript erstattet med GWT. Hvordan gikk det?

JavaScript erstattet med GWT. Hvordan gikk det?

Foredraget drøfter i hovedsak hvilke utfordringer som kan
oppstå ved innføring av AJAX i en webapplikasjon, og
hvordan disse ble løst ved bruk av Google Web Toolkit (GWT). Vi
vil presentere versjon 1.0 av applikasjonen basert på JavaScript
og tredjeparts AJAX biblioteker, samt endringene i versjon 2.0 ved
innføring av GWT.   

Erfaringene fra versjon 1.0 sammen med nye krav gjorde at vi måtte
velge en annen strategi for utvikling av versjon 2.0 av applikasjonen.
Spesifikke områder som vil bli belyst er integrasjon mellom Spring
MVC og Google Web Toolkit, og hvilke implikasjoner det får for
systemets arkitektur. Vi vil også ta for oss kodeeksempler,
byggstøtte, feilsøking og testmuligheter for begge
versjonene. 

Siste del av foredraget tar for seg hvilke fordeler og ulemper vi ser
ved innføring av GWT, og hvilke utfordringer vi står
ovenfor ved videre utvikling av produktet.

1. Introduksjon
 
- Foredragsholdere og introduksjon til prosjektet
 
2. Hovedinnhold
 
- Versjon 1.0: Krav, valg av teknologi, arkitektur og utfordringer dette gav. 
- Versjon 2.0: Nye krav, nye valg av teknologier og ny arkitektur 
- Integrasjon mellom GWT og Spring. 
- Verktøy-/byggstøtte 
- Demo. 
- Fordeler og ulemper med valgt GWT løsning 

3. Spørsmål og svar 

Required experience: Det kan være en fordel å kjenne til
JavaScript. Tilhørere bør ha grunnleggende kunnskaper om
AJAX, samt Google Web Toolkit. Det er også en fordel å ha
kjennskap til Spring. 

Expected audience: Personer som har interesse av AJAX-løsninger.

JavaZone 2007 - Bringing Life to Swing Desktop Applications

Bringing Life to Swing Desktop Applications

This session discusses advanced painting techniques in Swing that make it possible to implement many neat effects, including translucency, nonrectangular components, overlay and transition animation effects, and many more.

Outline:
 - Advanced effects
 - Custom components
 - Playing with opacity
 - Custom RepaintManager
 - GlassPane
 - Layering in UI delegates
 - Rainbow demo
 - Q&A

Required experience:
Basic knowledge of the Swing library is required
Expected audience
This presentation will be interesting for active Swing users as well as for people who want to discover Swing capabilities