Java-Powered Cross-Platform Mobile Applications with PhoneGap
It is easy to not see the forest for the trees with some architectural approaches and never realizing that the approach is the root cause for many problems faced. This talk focusses on the most common anti-patterns in architectural approach with real world examples and the real damage it does. Ram will discuss ideas that will help you spot them and mitigate them.
Neo4J - High Performance NoSQL Graph Database
The world is a graph - and Neo4J can help you to interact with it. In this presentation we’ll look at the strengths and weaknesses of graph databases and the kinds of use cases that they fit for. We’ll then briefly look at graph based queries and how to get the best of both world using the cross store persistence capabilities of Spring Data.
Getting started with node.js
A hands on introduction to the one non-JVM framework you need to know.
If you need to scale large numbers of relatively lightweight requests, node.js is a technology you need to understand. We’ll look at the use cases, the strengths and weaknesses, how to get started with node.js and how to test and deploy your node.js applications effectively.
Building Maintainable Web Apps with HTML5 and Dart
Dart is a new structured programming language designed for the Web. In this talk, we’ll look at the motivation for Dart, language syntax and features, the Dart Editor, using the Dart JS compiler, and the Dart development cycle with frog server and Dartium. We’ll also look at improvements to the DOM, several sample apps built with Dart, and see how easy it is to use Dart with HTML5+CSS to create rich client applications that scale.
Testing Groovy and Java Systems
One easy way to add Groovy to existing Java systems is through testing. Writing tests in Groovy is easier than Java, without worrying about deploying Groovy in production. Groovy provides several capabilities to simplify testing, from GroovyTestCase and its subclasses to built-in mocks and stubs to the popular Spock framework. This talk will review the available options and demonstrate how to use them on combined Groovy and Java applications.
Introduction to PhoneGap Mobile Development
An introduction to working with PhoneGap. The main focus will be on Android development, but iOS will be discussed as well. I’ll walk folks through the process of installing the necessary bits and how to create a PhoneGap project in Eclipse. I’ll demonstrate PhoneGap running on real devices.
Creating Mobile Friendly Sites with jQuery Mobile
An introductory look at the jQuery Mobile framework. The focus will be on using the framework on web sites, but I’ll demonstrate using jQM within a Phonegap-wrapped application as well.
The Fundamentals of Enterprise HTML5 Development
Developers are facing a new era of development with HTML5 for both mobile and desktop environments. It was once laughable to put mobile focused development ahead of the desktop, but those days are over. Whether you’re focused only on mobile, desktop, or both, there are a few critical questions which must be answered:
Wesley will attempt to answer these questions with the latest market data and live demos. Attendees will learn what it takes to build a scalable, enterprise, HTML5 based application for both desktop and mobile environments.
The slides are not available.
All about Caching.
I have talked to a lot of people about Ehcache over the years. What people find most valuable, and what stays with them, is the underlying caching theory - you can see the light bulb go on.
In this talk we will start with a performance problem and lead you through solving it with caching, discovering a long the way the problems of distributed caching and their solution. This will equip you with the tools to analyse a performance situation and to see whether a cache will help and what type of cache to apply.
The Java SE Platform: Rebuilding Momentum
The Java SE platform has experienced a tremendous amount of positive evolution and adoption thanks to ongoing community participation. In this session, you’ll learn about new features in the latest Java SE 7 release including Project Coin, Invoice Dynamic, Fork/Join Framework, and NIO.2. You will also learn about plans for major feature changes in Java SE 8 such as Project Lambda and Project Jigsaw. Lastly, an overview of the OpenJDK Community will be provided including community processes and structure, benefits for participants and the entire Java Ecosystem, and finally referencing exemplary model participants as examples and summarizing their driving forces for participation. This session will be relevant to both technical audiences wanting to learn more about Java SE and the OpenJDK community structure.
Nothing matters more than coding fast
This is not a talk about speed coding, or writing thousands of lines of crappy code in a weekend. This is a talk for software craftsman who test drive clean code, but who also have a nagging feeling: “Man, I know I could be doing this faster.” We’re going to discuss everything from touch typing, to keyboard shortcuts, to faster pair programming techniques, to hardware, to build automation, to staying in the zone, to caffeine consumption, to ergonomics, to music and headphone selection, refactoring, language and framework selection, tech debt management, rapid prototyping, whiteboard design sessions, back of napkin mockups, guerilla tactics for getting in front of requirements and staying there, and what to do when you’re 30 lines down a stack trace and someone wants to tell you about something funny their kid did over the weekend.
Build Trust in Your Build to Deployment Flow!
Frequently deploying to production puts bigger pressure than before on DevOps to make sure the good, qualified application is provisioned with no mistakes.This session will explore some common pitfalls with traditional Continuous-Integration that increase risk, introduce manual input and human error, and generally make DevOps cringe before hitting the “deploy” button.
We will then demonstrate automation techniques that overcome these issues using popular tools, like Maven, Gradle, your CI server, custom scripts and a Binary Repository.
Whether you are building software for the cloud or in-house, this presentation will show you how to have completely automated production builds that release applications which are fully traceable, managed and ready to be provisioned with no fear!
Making Java Bearable with Guava
The presentation covers the Guava library developed by Google (http://code.google.com/p/guava-libraries/). Guava provides collection extensions to the Java Collection API and, along with this, a cornucopia of time-saving utilities that bring Java as close as possible to some of the more functional and dynamic language competitors like Scala, Ruby, and Clojure. The presentation focuses on the following topics: how to make Predicates and Functions; how to use new collection constructs that make life easier, including MultiMap, BiMaps, and MultiSets; how to set up and use Guava preconditions; and how to create truly immutable collections, and more. All of this is done with Java.
Radical NoSQL Scalability with Cassandra
Want to go deep on a popular NoSQL database? Cassandra is a scalable, highly available, column-oriented data store in use at Facebook, Twitter, Reddit, Rackspace, and other web-scale operations. It offers a compelling combination of a rich data model, a robust deployment track record, and a sound architecture, making it a good choice of NoSQL databases to study first.
In this session, we’ll talk about Cassandra’s data model, look at its query idioms, talk about how to deploy it, and look at use cases in which it is an appropriate data storage solution. We’ll study its origins in the Amazon Dynamo project and Google’s BigTable, and learn how its architecture helps us achieve the gold standard of scalability: horizontal scalability on commodity hardware. You’ll leave prepared to begin experimenting with Cassandra immediately and planning its adoption in your next project.
Per request, the presentation slides won’t be made available.
The Groovy Web: groovlets, Micro-frameworks, and Grails
Groovy has several ways to make web development easier. Groovlets are part of the language, are easy to use and deploy, and are the basis of larger frameworks like Gaelyk. Groovy also supports the new style of web development with micro-frameworks. One in particular is Ratpack, based on the Sinatra project in the Ruby world. Finally, there is Grails, the elegant combination of Groovy DSLs with Spring and Hibernate. This talk will demonstrate them all and discuss where each is useful and appropriate.
Introduction to Heroku
Heroku is a Polyglot Cloud Application Platform that makes it easy to deploy Java, Play! and Scala apps on the cloud. Deployment is as simple as doing a “git push”. This session will teach you how to deploy and scale Java, Play! and Scala apps on Heroku.
Intro to Play Framework - Making Java & Scala Web App Development Fun
Java User Groups and the Java Community Process: a winning combination
The success of the Java language and platform depends on community support and participation. Java is developed through the Java Community Process, which is open to all members of the Java community. Recent changes to the process, introduced in JSR 348, make it even easier for developers to observe and to participate in the work of the JCP.
Even before these changes Java User Groups had begun to participate in the work of the JCP. Now that two JUGs (SouJava and the London Java Community) are represented on the JCP’s Executive Committee we are beginning to explore ways in which the energy, enthusiasm, and expertise of the JUG community can be harnessed to further advance the Java platforms.
Most developers understand the value of participating in open-source projects. This session will explain the benefits of participating in the JCP. We will explain how the JCP is is organized and how Java standards are developed. We will discuss the current state of the Java platforms, explain how the JCP is helping to evolve them, provide practical advice on how you can participate through your local Java User Group, and explain why participation is good for your career.
Bring your questions, your suggestions, and your concerns. We want to hear from you - the foundation of the Java community - and to explore new ideas for community participation.
Native Android Development with Spring Android
This session will provide an introductory overview of Android’s architecture and the layout of an Android project. When building Android apps, you may want to take advantage of a third party library, like Spring Android. You can do this through the use of various Maven plugins and tools for enabling dependency management in your Android project. We will walk through how to set up and configure an Android project using Maven. Many applications consume data from various web services, and we will discuss how the Spring Android project can help.
Spring Android provides an abstraction for consuming RESTful services and marshaling the requests and responses to JSON or XML. Lastly, Spring Android supports the use of Spring Social on Android, and we will discuss how Spring Social can help you connect your apps to OAuth protected services like Facebook and Twitter.
Porting Your Game to the Web using NaCl
This talk will introduce Native Client, covering the nuances of porting your existing C++ game. We’ll talk about the application specific problems, how to deal with the Pepper Thread, along with platform APIs like FileIO, rendering and Audio. In addition we’ll cover common issues with the Chrome Web store, distribution, and monetization. Finally, we’ll be talking about exciting news and roadmaps for native client moving forward. If you’re interested in NaCl, or want to learn more, this is the talk for you!
Introduction to the PlayN Cross-Platform Game Library
This session will introduce you to the cross-platform game library we created in the process of porting Rovio’s “Angry Birds” to the browser, which we’ve called “PlayN”. You’ll learn how to use this library to write games in Java that run on modern web browsers, as well as on Flash and as Android and iOS apps. We’ll also discuss some of the challenges of building games that target the web, from arithmetic and rendering performance, to rendering and audio bugs, hiding network lag, and avoiding garbage collection pauses.
A walking tour of Spring 3.1
Spring 3.1 is here, and it offers a LOT! The question is - what does it offer for you? Josh Long will introduce Spring 3.1 in this fast paced tour of all the new features, including profiles, Hibernate 4 support, XML free web applications, numerous updates to the code-centric component model, the environment abstraction, a caching abstraction, an improved REST API, and much more. Josh introduces numerous new features in terms of an application that he’ll introduce along the way.
The Gradle Will Rock
The Gradle build tool is one of the most successful projects in the Groovy ecosystem because it addresses a difficult problem – every major build is a custom build. Gradle builds are written in Groovy, so the full power of the language is available if you need it. Gradle supports Maven project structure, repositories, and processes without being bound by its limitations. This talk will cover the basics of Gradle both through simple projects and by examining the build files for other open source projects. With major systems like Grails, Hibernate, and even the Spring Framework moving to Gradle, this is a technology worth taking the time to understand.
The Hitchhiker's Guide to the JBoss Galaxy
JBoss by Red Hat contributes to numerous OSS projects and the overall open source ecosystem is constantly producing new tools, frameworks, engines and techniques. If you are “building your stack” for your next project, trying to navigate the vast OSS world can be a bewildering and complex undertaking. In this session, we will highlight some key technologies that have a tremendous impact on the typical enterprise application. Most importantly we will provide guidance into how JBoss is making your custom application development more productive.
Some of the technologies to be seen via live demonstrations:
Video recording of this session available at:
Easy Mobile Development: Appcelerator Titanium Introduction
This session will walk you through the details of building great apps for the Android and iOS platforms. We’ll talk about Titanium development, its ecosystem, and architecture. We’ll spend time looking at lots of code - we’ll build an app, in fact, while we discuss and explore the framework. We’ll also spend some time discussing best practices, what to expect when developing against it, and the limits of this type of development.
Large Scale Data Analysis Tools
“Big Data” has all the marketing and buzzword glamour of “Cloud” or “Social” nowadays. But there are serious tools out there to handle serious amounts of data. As with any task, you should use the right tool for the job at hand. This talk will navigate the vast and growing Hadoop Ecosystem as well as some new entrants to the emerging realtime stream processing market. From ingest to batch processing to querying, from scaling to extending to visualizing, there are a lot of systems that could make their way into your application’s stack. We will visit the more promising of these systems via case studies and real-world examples.
Google TV Basics and Boundaries
This session will introduce you to building Android applications for the Google TV platform. You’ll learn what “Smart TV” is, or should be; what the landscape for multi-screen, multi-device development looks like; where Google TV fits and why it matters; how to build basic applications for Google TV; and some valuable tips about design and development practices for the big screen.
What's new in Spring Integration 2.1
For a minor release, Spring Integration 2.1 delivers some major features. Channel Adapters are now available for AMQP-based messaging via RabbitMQ. Message Store implementations are now available for a number of NoSQL data stores, including GemFire, MongoDB, and Redis. Other noteworthy additions include JSR-223 scripting support, stored procedure adapters, and a new Content Enricher component. Attend this session to learn about these new features, and don’t worry if you know nothing about Spring Integration yet, we’ll begin with a quick introduction.
A talk on general best practices in Scala, taken from real world experience and examples in the book Scala In Depth.
Why you want to learn Scala
This talk covers the basics of Scala syntax and why it’s a language that all developers should get to know. This talk covers the underlying philosophy behind the language as well as the core features that make it wonderful to use. This is an introductory talk and no prior knowledge of Scala is assumed.
Mobilize JBoss AS 7.1 - How to Develop Mobile Apps for the Cloud w/ OpenShift
Join us for a technical how-to session on how to develop cloud ready iPhone and Android apps for the cloud. Let’s skip having to learn three different languages and jumpstart the development process using what you already know. We’ll utilize Appcelerator’s Titanium IDE to create a native mobile application targeting multiple mobile platforms. Best of all we’ll be running everything on on JBoss AS 7.1 with a MongoDB back-end. Nothing complicated, nothing convoluted. Just straight ahead mobile development goodness with Titanium, MongoDB, JBoss and OpenShift. What’s OpenShift? It’s Red Hat’s free, auto-scaling platform-as-a-service for Java, Ruby, Perl, PHP and Python apps. Get started for free by signing up at openshift.com with promo code: DEVNEXUS. Special bonus if you love beer, this session is for you!
Web vs. Apps
Apple’s iPhone SDK has been the largest disruption to software development since the Web, sparking the creation in a few short years of the largest medium for consumer engagement in the world, eclipsing the Web, movies, and even television. While some prophesy that in the coming years mobile apps will be replaced by the web, in today’s reality a number of high profile start-ups are bypassing the web entirely to reach their audience exclusively via apps. Join Ben as he discusses the role of the web in the mobile present and explore developer issues as we head into the post-PC era.
Migrating Enterprise Apps to the Cloud: from monolith to modular
The cloud movement is no longer just buzz and hype. Organizations are increasingly planning cloud-based deployments. For greenfield development, the path is relatively clear, but what about existing apps? The monolithic multi-tier architecture so common for enterprise apps is not the best fit for the cloud. For one thing, the presentation layer is typically moving to the client side. With cloud-based messaging and NoSQL datastore options, the data access and integration layers might require renovation as well. Meanwhile the significant investment that a business would most like to salvage is in the service layer sandwiched in the middle. In this session, we’ll explore this space while migrating a hypothetical application to run in the cloud. The starting point will be a fairly standard multi-tier Spring MVC application, and the end result will be a collection of services running in the cloud. We’ll discuss REST, JSON, NoSQL, messaging, polyglot development, and modular architectures designed to run in a dynamic always-on environment.
Launching scalable apps with Google App Engine
Google AppEngine lets you build and host scalable Web applications written in Python or Java on Google’s infrastructure. In this talk, we’ll look at new features in the last year, including the high-replication datastore (HRD), Cloud SQL, the new query planner, and cross-group transactions. In addition, we’ll look at a recipe for load testing and many tips to make your apps more responsive and minimize cost.
What makes JBoss AS 7 tick?
Is it the modular design and infinitely extensible architecture? Is it the elegant administration? Perhaps it’s compliance with the universal language of standards? Maybe the ease of testing your applications? We’ll search the answer together in a journey that will take you from testing the water to the deep dive, and in which you’ll learn the secrets behind the unparalleled speed, incredibly small foot print, and exciting usability features of the next generation application server from JBoss.
Spring MVC 3.1 Walkthrough
Perhaps you’ve already heard of some of the new features like flash attributes, code-based configuration, partial validation with Hibernate Validator 4.2, and many others. This talk aims to be your comprehensive source of all that you can take advantage of in this release. We’ll use code snippets, provide pointers, and highlight the things you need to know without spending too much time on individual topics. At the end we’ll discuss what’s in store for Spring MVC 3.2.
An In-depth Look At Spring MVC 3.1
This presentation is for seasoned Spring MVC developers and for those curious to make the most of the release. Rather than faithfully covering every change, we’ll take a deeper look at the new @MVC infrastructure classes, what has motivated the changes and what possibilities they have created. We’ll discuss pros and cons of the MVC Java config and the MVC namespace and we’ll see how to make advanced customizations with each. We’ll show examples of testing annotated controllers with the new spring-mvc-test project available on github, and more. Last but not least we’ll allow time for questions and discuss what’s planned for Spring MVC 3.2.
Git Going with Distributed Version Control
Many development shops have made the leap from RCS, Perforce, ClearCase, PVCS, CVS, BitKeeper or SourceSafe to the modern 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 (DVCS). Jump ahead of the masses staying on Subversion, and increase your team’s productivity, debugging effectiveness, flexibility in cutting releases, and repository redundancy at $0 cost. Understand how distributed version control systems are game-changers and pick up the lingo that will become standard in the next few years.
In this talk, we discuss the team changes that liberate you from the central server, but still conform to the corporate expectation that there’s a central master repository. You’ll get a cheat sheet for Git, and a trail-map from someone who’s actually experienced the Subversion to Git transition.
Per request, the presentation slides won’t be made available.
Building CDI extensions using DeltaSpike
You’ve heard about the extensibility of Java EE 6, and heard about CDI (Contexts and Dependency Injection). You may have also looked at Seam 3 or MyFaces CODI. You’ve seen enough to pique your curiosity. This session will sate that curiosity and give you enough information to build great extensions for your application and business.
In this session, Jason Porter, Senior Software Engineer at Red Hat and Apache DeltaSpike contributor, will cover creating extensions in Java EE 6 and show how using Apache DeltaSpike will ease some of the work.
The presentation sources are available at:
RESTful web services have become the preferred approach to synchronously integrating heterogeneous systems. The architectural style’s success is due in large part to its simplicity. Furthermore, REST is based on a small set of widely accepted standards, such as HTTP and XML and requires far fewer development steps, toolkits and execution engines than conventional SOAP web services.
This session covers the core concepts of REST and then walks through how to design and implement RESTful web services using three leading RESTful web service framewokrs, RESTlet, Spring MVC and NetKernel.
JSR107: The new Java Caching Standard
In this session Greg Luck, founder of Ehcache and spec lead for JSR107 will walk you through this important new caching standard, which will form part of Java EE 7. You will learn:
NoSQL Smackdown 2012
Alternative databases continue to establish their role in the technology stack of the future—and for many, the technology stack of the present. Making mature engineering decisions about when to adopt new products is not easy, and requires that we learn about them both from an abstract perspective and from a very concrete one as well. If you are going to recommend a NoSQL database for a new project, you’re going to have to look at code.
In this talk, we’ll examine three important contenders in the NoSQL space: Cassandra, MongoDB, and Neo4J. We’ll review their data models, scaling paradigms, and query idioms. Most importantly, we’ll work through the exercise of modeling a real-world problem with each database, and look at the code and queries we’d use to implement real product features. Come to this session for a thorough and thoroughly practical smackdown between three important NoSQL products.
Per request, the presentation slides won’t be made available.
Joda Time and a Brief History of the World
JodaTime is Java Date/Time and Calendering done right. There are many problems with the original Date/Time API that came prepackaged in the early Java days. There are even more problems with the subsequent Calendar API.
One of the obvious issues is that Calendar is mutable and can unintentionally be changed. Another issue is that constructing Calendars in Java involves setting certain fields at certain times during coding, but not always getting the expected result. Joda Time repairs those issues and offers a robust and immutable date, time, and duration API. In Joda Time and a Brief History of the World, I provide a quick rundown of calendaring throughout the centuries, describe UTC, compare UTC to GMT, discuss how time is calculated, and then dive into Joda Time in every popular JVM language. The end result provides the audience with compelling proof that Joda Time should always be their Date Time API of choice.
Using Factories of various abstractions, facades, and other patterns are not the only way to decouple dependencies and isolate code. A more idiomatic approach is events. All applications revolve around message passing. Passing bits to info within and outside of objects is the biggest job in any application. Message passing is typically accomplished using function and method calls. I send you a bit of information, you churn on it and send me something back and round and round we go.
Tight coupling happens because the code needs to have a live instantiation of another object so it can send it a message and maybe get a reply. These locally instantiated objects cause problems for coupling, modularity, and testability.
Emitting events instead of making function calls obviously works best with global objects like utilizing AOP like logging, debugging, and code statistics that have no return values. However events can be used more deeply throughout a web application and we will see how events can play a much more centralized role in any web application.
How We Got Here, And What To Do About It
If you are developing software and getting paid for it, software process is part of your life. Even the absence of a defined process is a process of sorts. For over forty years the world of software development has been churning through forms of process, with each successor disclaiming the validity of its forebears to the cheers of those liberated from the oppressive chains of process past.
But if the latest acclaimed process is the answer, why do so many groups slough off what seemed to be working well a scant few years ago in favor of yet another choice? Furthermore, the time between process changes gets shorter and shorter. Waterfall reigned for ages, then RUP, then Scrum and XP, and now Lean/Kanban, each enjoying successively shorter seasons of favor as the de facto choice.
Process is but a framework to facilitate the collaboration of a group of people to produce a desired outcome. It is not a substitute for culture, technical excellence, discipline, and product strategy.
In this keynote, Barry emphasizes the need to continue thinking critically about the processes and practices we embrace, accounting for the context in which they exist, and the importance of reflection and refinement at both the organizational and personal levels.
Mind-blowing apps with HTML5 Canvas
Before the web, software developers implemented what we now refer to as desktop applications, using powerful graphics APIs that gave them the ability to program pretty much anything they could imagine. Then along came browsers with virtually no standard graphics support at all. Enter boring web applications, and dull work for developers.
But now, with HTML5 Canvas, developers have a powerful graphics API that lets them develop mind-blowing applications. Now you can implement desktop-like applications that run in a browser. In this session, you?ll see how.
This talk is a demo-fueled, fast-paced introduction to HTML5 Canvas. You?ll get an overview of the Canvas API, and see how you can use it to draw, manipulate images, and implement sprite-based animation. You will get a feel for what you can do with this powerful API, and you?ll get a basic understanding of how to harness that power.
Agile, Lean, and the Space Between
In early 2001, “Agile” was coined as the umbrella term for Scrum, XP, ASD, Crystal, and a few other methodologies. In 2003, Mary and Tom Poppendieck published the book “Lean Software Development: An Agile Toolkit”, and the term Lean Software Development became known among a subset of the larger Agile community.
For years, one could assume that any development group trying to improve its approach to software was applying some form of Agile Software Development methodology. In the last couple of years, Lean Software Development has seen a surge in popularity. Some groups adopting Lean perceive it as an alternative to Agile processes like Scrum, and express a sense of elitism and superiority, having “moved beyond Agile”.
While Agile Software Development and Lean Software Development originate from different sources, they are actually closely related and share a great deal of overlap. In this talk attendees will discover where each came from, and just how much of Agile and Lean are shared in the space between.
This presentation did not take place and consequently the presentation slides are not available
What's new in Android
Android 4.0 is a new world for Android, and for many developers who did not track with the changes to Honeycomb, represents a new UI metaphor. In this session we will look at the new UI metaphor and the APIs to work with it, including the ActionBar and Fragments, which allow you to recompose your UI for multiple screen profiles. We will also review the new Android human interface guide to see how these should be used.
Additionally, we will look at other new APIs that can be used to enhance the functionality of your application, including interactive Notifications, Drag and Drop, NFC and WiFi Direct.
Spring and Cloud Foundry, a Marriage Made in Heaven
The talk will include demos of the Spring app development lifecycle with Cloud Foundry: local development with STS, local deployment to Micro Cloud Foundry for testing, deployment to CloudFoundry.com.