Parleys.com

UI test automation is, nowadays, a commonly used approach. First, because of the tools offering, second because different organization started to realize (if they did not do it before) how high is the defect cost, so they started to think about getting more from testing while spending less on it. For many, it becomes obvious pretty soon that the automation is not as beneficial as if first seemed.

Oracle Coherence enables in-memory data management for clustered J2EE applications and application servers that makes sharing and managing data in a cluster as simple as on a single server. Developers can easily take advantage of Coherence features using the standard Java collections API to access and modify data, and use the standard JavaBean event model to receive data change notifications.

This session will introduce Coherence and explore how it can be used to reliably cluster, scale-out and obtain high-performance continuous availability for data and stateful applications.

Compass is an open source Java Search Engine framework, allowing the integration of search functionality into any application. One of Compass main modules is a Spring integration module, heavily used among Compass user base.

In this session, we will first review the main features of Compass, focusing on Compass extensive integration with Spring. We will then see how Compass can be used to add google like search capability to Spring's petclinic sample with almost no coding involved using JPA and Annotations.

There are many sides to agile development, but it is all too common
to focus on only one or two, depending on personal interests, job role,
background, etc. A manager may focus on organizational and process
aspects to the exclusion of technical ones, whereas a developer may
have a complementary view. Different developers may focus on different
details to the exclusion of others: one developer may value emphasis on
a loosely coupled architecture but be less concerned by testing,
whereas another may view agility solely in terms of unit tests and task
automation. Each perspective is valid, but missing the other
perspectives means missing the whole picture.

This talk focuses on six sides of agility, which notionally form the
faces of a cube, and how they trade off against one another in
different situations. Practices, organisation, architecture, tools,
skills and attitude: each of these has different consequences and
different applicability depending on the context. For example, if a skilled team of developers wishes to adopt a more agile approach in a legacy project without tests, they are better off in the short term avoiding TDD and unit test coverage, and instead focusing on other matters of practice,
tooling and architecture. By contrast, an unskilled team on a new
project are often well served by adopting a TDD approach early and forming a clear understanding of the architecture they are working in and on.

There are many sides to agile development, but it is all too common to focus on only one or two, depending on personal interests, job role, background, etc. A manager may focus on organizational and process aspects to the exclusion of technical ones, whereas a developer may have a complementary view. Different developers may focus on different details to the exclusion of others: one developer may value emphasis on a loosely coupled architecture but be less concerned by testing, whereas another may view agility solely in terms of unit tests and task automation. Each perspective is valid, but missing the other perspectives means missing the whole picture.

This talk focuses on six sides of agility, which notionally form the faces of a cube, and how they trade off against one another in different situations. Practices, organisation, architecture, tools, skills and attitude: each of these has different consequences and different
applicability depending on the context. For example, if a skilled team of developers wishes to adopt a more agile approach in a legacy project without tests, they are better off in the short term avoiding TDD and unit test coverage, and instead focusing on other matters of practice, tooling and architecture. By contrast, an unskilled team on a new
project are often well served by adopting a TDD approach early and forming a clear understanding of the architecture they are working in and on.

During this Jazoon keynote Ted Neward talks about why the next five years in IT will be about languages. The programming language virtualization, tools, linguistic focus and expressiveness are different forces that are coming of age. Not to mention the impact of the over-used and over-hyped Domain-Specific languages. How will these languages tackle the evolving application security demands or rich user interfaces, Ted Neward approaches these questions in his own unique style.

Google Web Toolkit (GWT) provides you with a great way to develop Ajax applications in the Java language. It allows you to develop 'fat clients' for the web, without having to know the ins and outs of JavaScript and all the corresponding browser incompatibilities.

This session will provide you with an introduction on building web-based, 'fat clients' with GWT. The focus of this session will be on integration between a GWT client and your Spring-managed back end. Bram will also discuss tips and tricks for working with GWT. During this session, Bram will demonstrate how to build a simple GWT client and connect it to an existing Spring-based back end application.

Most of us are familiar with Spring mostly as platform for simplifying the development of our JEE applications using POJO based approach. Our solution still rely J2EE as the container for addressing the high availability and scalability of my application. In most of high performance/low-latency environment this combination was hardly sufficient and most people found themselves building infrastructure outside the JEE stack to address their scalability and performance requirement. In most cases this was achieved by turning their Tier based application into SOA/EDA combining In-Memory-Data-Grid (IMDG) share state between their services and Messaging Bus (ESB) to enable loosely couple communication between those services.

In this session we will introduce a new framework - OpenSpaces that takes those different patterns and creates a simple platform on top of Spring - OpenSpaces. Openspaces simplify significantly the way we can build such applications by integrating POJO driven services with the Data and scale them out as a single unit - a processing-unit.

Light weight SLA driven containers enables the deployment and management of those services over a dynamic pool of machines, in addition to that we will discuss how in future OSGI will be used to provide dynamic services and enable the management of their lifecycle independently even if they share the same VM. All this together makes the entire development of large scale application as simple as writing any other standalone Spring application today.