Java EE 6 offers significant and compelling improvements over previous revisions of the platform. Java EE is now portable AND lightweight. But what if these improvements still come up short for your needs? Will you have to wait for Java EE 7 to get the features necessary for you to move forward? How do third-party technologies fit into this picture?
Regardless of how sweeping the change, before long, you'll expect more out of the platform. Java EE 6 makes room for growth. This workshop explores the new programming model that was introduced as the foundation of Java EE 6, JSR-299: Contexts and Dependency Injection (CDI).
by Kito D. Mann
Forget about the basics. Everybody knows JavaServer Faces (JSF) is a user interface component-based framework for developing web applications, and that JSF 2.0 is a major leap forward. In this workshop, we'll focus on the things you may not already know.
First, we'll discuss how JSF works as a stand-alone framework, and examine the benefits of integrating with either Spring or Java EE 6 services such as Contexts and Dependency Injection in Java (CDI) and EJB. Next, we'll examine the internal hooks of the framework, such as Unified expression language (EL) integration, and the multitude of event listeners and factories. We'll look at how these hooks not only allow integration with Spring and Java EE, but also allow you to implement your own extensions.
Alternative JVM languages are all the rage these days, and JSF has plenty to offer in that area. We'll look at how the Mojarra and MyFaces implementations facilitate rapid development with support for Groovy and reloading Java classes dynamically. If you're interested in Scala, don't worry -- we'll cover building JSF applications with Scala as well.
One of JSF's key benefits is the ability to use powerful, off-the-shelf Ajax-enabled user interface components that ship with free server-side integration. But a lot of development teams haven't taken advantage of this functionality to build internal component suits of their own. We'll also cover JSF 2's composite components and built-in Ajax suppor, showing how to build an internal component suite that can be used in different applications. When you finish this workshop, you'll be a true JSF Ninja.
by Max Katz
Attendees will learn everything they need to begin developing applications with JSF 2 and RichFaces. We will first start with basic Ajax features in JSF 2 such as sending an AJAX request, partial view rendering, partial view processing using the f:ajax tag. We will then move to the new RichFaces 4 and demonstrate advanced features, tags, customization and richness it adds on top of JSF 2. You will learn how the a4j:ajax extends the standard f:ajax tag as well as how to use other a4j: tags, rich: tags and skins in RichFaces. Hands-on example will be used to demonstrate most concepts and features. Workshop will cover: standard JSF 2 Ajax features (f:ajax), a4j: tags, rich: tags, client-side validation, cloud deployment, Skins
by Max Katz
RichFaces is a JSF framework with Ajax components, client-side validation, cloud deployment, skins, and a component development kit (CDK). This session will briefly cover JSF2 Ajax features and then the extra value the new RichFaces adds on top of JSF2 through its advanced features. Examples will include partial table updates, Ajax queues, client-side validation, GAE deployment, and skins.
Come hear engineers from the Android team at Google talk about the latest advancements in the Android platform, and how you can take advantage of these features to create great Android applications.
Jenkins (formerly known as Hudson) is a continuous integration server that facilitates the automation in software development. In this talk, I'll discuss what's new in the project, including why we renamed, as well as various techniques to get more out of your Jenkins server, such as distributed build techniques, some key plugins, and larger scale choreography that spans across many jobs for sophisticated automation.
by Jason Hunter
This talk gives web developers an understanding of what's going on in the layer beneath their code. By understanding HTTP you can become a more effective debugger, improve your site's cachability, design better deployment architectures, author more useful non-browser web clients such as spiders, and (most importantly) avoid a slew of subtle bugs. With an understanding of HTTP we'll look at advanced topics like HTTP request smuggling vulnerabilities and HTTP tunneling pros and cons.
by Kito D. Mann
Web applications are notoriously difficult test, and even though JavaServer Faces (JSF) is an excellent technology, it doesn't necessary make testing easier. If you want to go beyond black box testing, you need access some of the framework's infrastructure in order to write comprehensive integration tests and unit tests. This means that you either need mock/stub objects, or your tests must run inside the container.
In this session, we'll discuss different ways to test JSF applications, starting from outside the box with Selenium, and then moving inward by looking at tools like JSFUnit and Arquillian, as well as complete mock/stub environments like MyFaces-Test. Along the way, we'll discuss the best use cases for these tools, and point out their pros and cons.
Spring Framework 3.1 continues Spring's mission with a focus on flexible Java-based configuration. This presentation introduces foundational 3.1 facilities such as environment profiles for application contexts, feature specifications within configuration classes, and Spring's new caching abstraction. Finally, we'll cover Spring's ongoing support for enterprise Java specifications: in particular our Servlet 3.0 support.
Java EE is already the perfect solution for complex business/enterprise systems, and the improvements in JavaServer Faces 2.x provide the perfect chance to reach out to the consumer and small business market; JSF is easier to use than it's ever been before, now making it accessible to businesses of all sizes. In order to complete the user-experience, however, one must not overlook the URL.
by Josh Long
This session provides a practical hands-on introduction to the capabilities in Spring Integration 2.0. Along the way, you will learn about Spring Integration's support for Spring Framework 3.0 features such as the Spring Expression Language, ConversionService, and RestTemplate. You will also learn about several new adapters including AMQP, XMPP, TCP/UDP, JDBC, JMX, and more.
by Frank Maker
With great power comes great responsibility. On the Android platform developers have unprecedented access to smartphones resources. However, this opportunity can quickly turn against you with bad market ratings if your application does not respect the battery life expectations of the user. In this talk we will discuss where the power goes in a typical smartphone, the difficulty of predicting power for different platforms and why improvements in battery technology are not keeping pace with increased demand. Different methods for estimating or measuring power will also be considered to empower developers to get feedback on their application's real-time usage. Lastly, we will discuss different profiling and optimization techniques on Android that can help reduce the amount of power consumed.
by Brian Sletten
The steady adoption of REST brings with it architectural properties that made the Web of Documents so successful by freeing documents from their filesystems. Now, the same thing is happening to Webs of Data. REST is opening a door to share interlinked data in the Enterprise and on the Internet. The Semantic Web builds on this and frees the information from its containers whether they are databases, documents or services.
*improved search results
*sharing information on the Web
*weaving information into and extracting it from documents
*organizing content the way you want to see it
If you think the question, "Why should I be on the Web?" sounds silly to modern ears, come find out why "Why should I publish my data on the Web?" will someday sound as silly.
by Fred Simon
Long gone are the days of sticking binaries in Version Control or onto a shared drive. In this session we will explore the various options, changes and the challenges in managing software modules and will explore different approaches taken by build tools such as Gradle, Ivy and Maven. We will demonstrate how to combine your Jenkins build server, Artifactory repository manager and Gradle builds to create a release pipeline that overcomes common problems around continuous release and delivery. It doesn't matter if you are a software developer, a release engineer or a CM, this demo-packed presentation will demonstrate the way your build and development environment will look in the next years!
This session will provide a deep dive on how to quickly and easily develop mobile applications using Adobe® Flash® Builder® 4.5, the open-source Flex framework, and Adobe Customer Experience Management software. Whether building content-rich or data-centric applications, Java developers can rapidly build rich mobile apps for Android™, BlackBerry Tablet OS and iOS devices using one tool, one framework and one codebase. During this session, Christophe Coenraets will develop a mobile application from scratch. He will also provide an overview of Adobe’s mobile architecture, and unveil the latest generations of Java libraries provided by Adobe to build real-time mobile applications.
Many development shops have made the change to the Subversion (SVN) version control system. But why not take the next massive stride in productivity and get on board with Git, a distributed version control system? Jump ahead of the masses staying on Subversion, and increase your team's productivity. Understand how distributed version control systems (DVCSes) are game-changers.
by Ian Hlavats
This informative session demonstrates an effective strategy for JSF UI design and development based on Adobe Dreamweaver CS5 and the Eclipse IDE. Participants will learn how to create and enhance a JSF application using Facelets, the Seam Framework, ICEfaces Ajax UI components, and a MySQL database. Highlights include managed bean code hints in Dreamweaver and deploying the application to JBoss AS
by Craig Walls
This session will look at the various strategies for utilizing a Spring back-end with social and mobile platforms, such as consumption of RESTful services, server-push style messaging, authentication and authorization via Oauth to integrate with social network sites such as Facebook, Twitter, and LinkedIn.
by Ben Adida
Our data is increasingly online, stored by multiple providers: Google, Facebook, Salesforce, and a myriad of smaller web sites increasingly tailored to highly specific tasks. How do/should users log in to all of these sites? How might they share data between sites? In this talk, we'll cover the important technologies in web authentication and data delegation, their trade-offs, and the way in which they can be useful to your web architecture, be it a public-facing site or an enterprise intranet.
Come hear engineers on Android's UI toolkit team talk about features of the UI toolkit that you should understand to write better, faster, and more usable applications. This talk will cover such user interface technologies as views, graphics, animation, and performance.
by Kevin Nilson
Real-time services are key to financial service platforms. E*Trade’s market feeds and account updates are examples of low latency & high volume services being pushed to the browser with Comet. Servlet 3 and WebSocket advances have helped to make comet a real success at E*Trade. This talk covers E*Trade’s real-time services, the unique challenges and how the challenges have been addressed.
by Blake Sullivan and Max Starets
Discussions of JSF performance are often long on speculation but short on specifics. This session will shine a light on (point a profiler at) this topic by breaking down sources of performance overhead in JSF applications. We will examine the impact of existing optimizations (eg. partial state saving, view root caching) and discuss opportunities for future improvement.
by Ken Sipe
In the Java build space, first there was ANT, which provided a reliable way to build without an IDE. Then there was Maven, which provided standardization in build life cycles and dependency management. Yet there still seems to be frustrations with maintaining a good build system... whether it is just too much XML or too many POMs. Frankly XML is just limiting as a DSL for describing a build for anything that falls outside of what the original builders of the framework envisioned. Gradle provides a solution that provides convention over configuration approach to the build process and an approach at building that isn't based on XML.
This session assumes no familiarity with Gradle as it introduces this new approach at building projects. It is very helpful to be able to read and understand groovy to get the most from the session. This session will look at multi-language or polyglot projects, as well as integration to ANT and Maven. It will conclude with building custom plugins for the Gradle build process.
by Kito D. Mann
Now that JavaServer Faces (JSF) 2.0 is out, what do you do with that recently completed JSF 1.x application? Like most Java standards, JSF 2.0 strives for backwards compatibility. However, if you want to use new features like simpler UI components, new events, Groovy support, or the built-in Facelets support, you will have to perform some upgrade steps.
After examining how JSF 2’s support for Facelets in detail, we’ll walk through the process of upgrading a JSF 1.x application to JSF 2.0, pointing out areas that may benefit from new features.
by Chris Richardson
The needs of many enterprises have stretched traditional RDBMS based solutions to the breaking point and as a result, a plethora of new non-relational storage options have appeared. In this talk your learn about some popular NoSQL database including Redis, Cassandra and MongoDB. By bringing traditional Spring values such as portability, productivity and a unified POJO based programming model to this style of data access this session will show how the Spring Framework is evolving to support non relational ('NoSQL') databases as well as complex data processing via Hadoop and updated JPA support.
Startups expecting to need 'web scale' implementations are committing to technologies that might not be a good fit. Doing so can be a dramatic waste of time, money and resources when they can ill afford to do so. Do you really have a Big Data problem? Do you have a plan for what you are going to do with it? Chris will try to explain where he sees Hadoop being used most successfully and will offer up some guidelines on when to consider adopting it and any complimentary technologies.
by Roger Kitain
The HTML 5 Specification is being developed as the next major revision of HTML. The server-sent events portion of HTML 5 defines a data format for streaming events to web browsers, and an associated DOM API for accessing those events, by attaching callback functions to named event types. This presentation willexplain how to use server-sent events in JSF.
by Nathaniel Schutta
The word just came down from the VP - you need a mobile app and you need it yesterday. It needs to be polished and have that design stuff too. Oh and it needs to be on all the major platforms in time for the big marketing push next month. After a moment of panic, you wonder if it's too late to become a plumber but don't worry, there's hope! More and more developers are falling in love with the "write less do more" library and for good reason; it simplifies the job of today's front end engineer. But did you know jQuery could also help you with your mobile needs as well? That's right, jQuery Mobile is a touch optimized framework designed to provide a common look and feel across a wide variety of today's mot popular platforms. In this session, we'll take a look at all that jQuery Mobile has to offer and we'll convert a native application to an HTML5, jQuery Mobile masterpiece.
by Ted Goddard
Mobile applications for iPhone and Android can be effectively developed with JSF 2.0 and ICEfaces. Join this session to learn how to use Ajax Push to build a collaborative mobile application with ICEfaces 2.0.
JPA 2.0 defines the Java EE standard for relational persistence with open source EclipseLink providing the reference implementation along with a number of advanced features including clustered caching, dynamic persistence, and JAXB integration. This session will look at the JPA 2.0 specification and beyond to the advanced features EclipseLink provides to support building Java EE 6 applications.
20th–23rd June 2011