Your current filters are…
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 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.
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.
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 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 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 Allen Holub
This session examines Platform as a Service (PaaS) in detail. Looking first at the definition and various PaaS offerings, the session will cover the benefits and disadvantages of PaaS offerings. Then we will use an Open Source Java PaaS (Stratos) as an example to look at issues of multi-tenancy, isolation, resource sharing and security. It will cover Paas in public and private cloud.
by Dan Allen
This talk unveils the missing link in enterprise Java development: simple, portable integration tests. While development life is simple with unit tests and mocks, they only take you so far. Arquillian, a container-oriented testing framework layered atop TestNG and JUnit, tears down this barrier. It brings your test to the runtime rather than requiring you to manage the runtime from your test.
How many times have you wanted to start a new project in Java EE, but struggled to put all the pieces together? Has the Maven archetype syntax left you scratching your head? Everyone else is talking about Rails, Grails, and Roo, and you're left thinking, "I wish it were that easy for me." Well, there's good news: You don't have to leave Java EE just to find a developer tool that makes starting out simple. Seam Forge is heating up Java EE, and is ready to work it into a full-fledged project.
It's also an incremental enhancement tool that lets you to take an existing Java EE projects and safely work-in new functionality. Seam Forge comprehends your entire project, including the abstract structure of the files, and can make intelligent decisions of how and what to change.
Whether you want to get your startup going today, or make your big customers happy tomorrow, Seam Forge is a tool you should be looking at. Attend this session and get started - today!
The strongest aspect of JRuby is its integration of the Ruby language atop the JVM, giving the developer a choice of the best libraries and tools from both ecosystems as well as a more flexible way to glue Java libraries together.
We'll explore this flexibility through several examples in the areas of scripting Java, builds, testing and web development. You'll leave with several new options for improving your overall Java development experience and injecting freshness, productivity and even happiness into it!
The JRuby team has been proclaiming JRuby on Rails as the cure to legacy Java blues for years but we've been lacking a compelling example that developers can use as a guideline for how to achieve this. We'll discuss and demonstrate three possible approaches, allowing for a minimal, medium, and large amount of reorganization to an existing project. Each approach will build upon the previous one, showing developers how they can take an incremental approach to introducing Ruby into an existing Java environment to increase development productivity.
20th–23rd June 2011