2013

So you think you’ve picked up enough JavaScript to be dangerous, but feel like the whole prototypical language thing is still a mystery. In this session, we’ll go from basic JavaScript to advanced JavaScript. We’ll discuss and code modular JavaScript with CommonJS. We’ll look into the details of a prototype language and discuss things like parasitic inheritance. We’ll also look at JavaScript libraries that will help you get the most out of JavaScript - not jQuery, but a library like UnderscoreJS and SugarJS.

Almost every example of an agile project involves a single team and while many successful projects are delivered that way, most enterprise software requires the interaction of several teams. But how do we scale agile beyond a single team? What practices translate and which ones don’t? In this talk we’ll discuss some of the issues you’ll encounter as you move agile beyond a single group and how you can keep multiple stakeholders happy. While it isn’t as simple as having a “scrum of scrums” it isn’t as hard as replacing every line of COBOL.

Non-blocking, asynchronous, and reactive are all the rage today. This session will explore why the patterns are important in modern apps and how to apply them to event-driven web, mobile, and RESTful apps. To illustrate the concepts, Java, Scala, Akka, and Play Framework will be used as examples.

The Atmosphere Framework allows the creation of portable Comet and WebSocket applications across browsers and servers. In this session we will first introduce the new WebSocket technology and show how easy it is to write such an application using the Atmosphere Framework. Next we will introduce Atmosphere’s Websocket clients’ Java and JavaScript. We will then demonstrate how WebSocket applications can be highly scaled using the Redis data structure server. We will conclude the session by deploying our WebSocket application into environments that doesn’t support the protocol and how Atmosphere can transparently emulate WebSocket support.

Many developers’ experience with Spring began with JDBC-based data access, and while the template design pattern remains prevalent, Spring’s suite of data libraries has continued to evolve (over the past decade!) with the increased popularity of NoSQL data stores. Spring has also evolved to support higher-level patterns, such as ETL (Extract-Transform-Load) and EIP (Enterprise Integration Patterns), with Spring Batch and Spring Integration, respectively. Taken together Spring Data, Batch and Integration provide a comprehensive foundation for working with data and building message-driven applications. In this session, we’ll walk through the libraries and frameworks with an emphasis on introductory demos.

Moving logic to the client unlocks unlimited potential, but is a challenging endeavor. In this talk we’ll be covering the use cases for Backbone, and show real world examples. We’ll be covering the tenets of client side MVC development, and what tools and resources you need on the server to make this possible, especially when deploying to production. We’ll also get to see how development with a framework like Backbone changes your applications’ workflow, and we’ll be diving into some of those approaches typical in day to day development.

You should walk away knowing:

• Backbone’s role, when to use it, and how it works
• Typical challenges you’ll need to overcome
• What server side tools are a necessity
• Where to go from here

Big Data is quickly proving to be more than hype, as organizations face an increasing volume of information and the challenge to react to that information effectively. New tools and techniques are needed to address that challenge. However, Spring Integration and Spring Batch are both flexible enough to support these new tools and techniques upon their proven foundations for messaging and batch-processing.

In this session, we will walk through a couple Big Data use-cases implemented with Spring Integration, Spring Batch, and the Spring for Apache Hadoop project. The underlying theme is that the frameworks can be combined to provide a platform for Big Data processing, both real-time and batch-oriented, while also incorporating new tools and techniques such as HDFS and Map Reduce.

Everyone is awash in the new buzzword, Big Data, and it seems as if you can’t escape it wherever you go. But there are real companies with real use cases creating real value for their businesses by using big data. This talk will discuss some of the more compelling current or recent projects, their architecture & systems used, and successful outcomes.

Just as Big Data sources and distributed systems are more prevalent today; presenting results in meaningful ways is more cumbersome. BIRT – a set of developer tools co-developed and sponsored by Actuate as a top-level project within the Eclipse Foundation – can ease visualization of results in a user friendly way. BIRT provides native support to access Hadoop through Hive queries as well as connectors to other Big Data sources such as Cassandra and MongoDB.

Using BIRT, developers can display their internal or external clients’ data in a stylized tabular or graphical nature, and customize it using the BIRT Designer environment. These reports can include dynamic drill through and interactivity, and can be exported to various formats including PDF, HTML, XLS, and ODT.

The purpose of this discussion is to show how to improve system-wide performance utilizing an EIP application using a distributed cache to share its data with or retrieve shared data from other applications in your framework. Due to the ever increasing amount of real time data and the need for real time analytics, alerting and reporting on this data, new patterns must be implemented to handle these requirements.
In the past data has typically been shared between EIP applications via messaging or database which maybe too slow to meet SLA’s.
In this discussion we will cover how to implement the following patterns/scenarios:

• A Cache-Aside via the detour EIP pattern to retrieve or insert data in the distributed cache.
• The “System of Record” pattern using EIP and distributed caching.
• The Write-Behind pattern to asynchronously update the database using distributed caching.

An Ehcache gateway written using Spring Integration will demonstrate these patterns. In this discussion, a sample application will retrieve data from the FAA Airport Status Restful Service and share its information with other applications via a distributed cache. The ultimate goal of the presentation is to show developers that the data a EIP application processes can be shared real time with other applications in memory improving system wide performance.

Making your way in the world today takes everything you’ve got, taking a break from all of your front-end development worries sure would help a lot. Which is where the Bootstrap front-end web toolkit comes in: learn how to rapidly create attractive, easy to use user interfaces for your web applications.

Topics covered will include:
- An overview of what’s included
- Where to start
- How to customize
- Gotchas
- Tips for rapid prototyping

An overview of how you can use the tools within your browser to diagnose issues with your HTML application. While focused on Chrome Dev Tools, I’ll also briefly go over the tools available in other browsers.

Ever wish you could use your JavaScript-foo to build a NATIVE mobile app? Wish there was an open-source platform that would let you build awesome cross-platform mobile apps? Come to this session and learn about Titanium, an open-source, JavaScript based platform for creating native mobile apps.

It’s no longer enough to wage war in pre-production. That’s where developers have fought their conflicts time and time again–but now they need to cross battle lines and head into Production.

It’s a new kind of battle, one torn apart with operational complexity, agile missions and server warfare. With access to virtual platforms, monitoring weaponry, and automation tools, developers must now fight to ensure the performance and availability of mission-critical business applications. In this session we’ll look at:

• The production battleground of modern mission-critical apps
• An overview of special weapons and agile tactics (SWAT) for DevOps
• Real-life application fatalities and incidents
• Lessons learned from Customers winning the Dev Ops war

Will you heed the call?

This talk is an experience report on using Clojure in production systems, based on Stuart’s Clojure experiences:

• using Clojure as his own primary development language since 2008
• writing the first book on Clojure, now in a second edition
• committing to Clojure
• advising the Clojure/core team at Relevance
• developing Clojure projects for Relevance customers
• training developers on Clojure
• helping to develop Datomic, a database written in Clojure
• collaborating with Rich Hickey, the creator of Clojure, ClojureScript, and Datomic

If you are considering whether, or how, to bring Clojure into your organization, this talk is filled with practical advice, from the high level to the gritty details.

Despite what some developers think, we spend a lot more of our time reading code, code that was often written by someone that isn’t around anymore. How do we deal with this common scenario without resorting to burning our predecessor in effigy? Better, how can we write code in such a way that our successors will heap effusive praise upon us at the mere mention of our name? During this talk, we’ll read actual code discussing ways it could be improved. As we work through real examples, we’ll explore the importance of patterns, principles like SOLID and SLAP and essential practices like unit testing and continuous integration.

Scala is an expressive language, but can be hard to grasp when coming from imperative languages. The key is understanding what expression is in Scala, and how to adapt code to be more expressive. This talk covers the ‘zen’ of Scala development, as well as what changes the new features in Scala 2.10 bring. In particular, the topics covered are:

• Expression oriented programming and basic functional programming
• Simplicity in Design
• Enhancing libraries with Implicit classes and value classes
• Asynchronous programming with Futures and Promises
• Dynamic types for DSLs
• Reflection as a platform to write macros
• Macros and Rainbow Explosion Powers

Saying JavaScript is powerful is an understatement. The problem is it is way too powerful and dangerously flexible. Programmers often have trouble reaping its benefits due to its uncontrolled flexibility and, to a certain extent, lack of structure. One approach is to learn to tame the beast, like the authors of complex JavaScript libraries have done. Fortunately there is an alternative. CoffeeScript is JavaScript created in a humane way. In this session we will learn how, using CoffeeScript, we can reap all the benefits of JavaScript, but without losing our sanity in the process.

The majority of applications built on Java Platform in the past decade have been single-threaded. And the easiest way to address performance issues was to add a faster CPU. However, that option is no longer viable as the hardware industry has shifted from single-core processors to multi-core processors. Traditional concurrent development on the Java Platform requires in depth knowledge of threads, locks, and queues (oh, my!). Fortunately, new languages and frameworks that run on the Java Platform, such as Akka, have made concurrent programming easier.

In this session, I will demonstrate several concurrent processing techniques including Fire and Forget, Fork-Join, and Asynchronous Web Services using the Java Concurrency Library, the Akka Framework and Jersey (JAX-RS).

Source Code: https://github.com/jtdeane

Clojure’s immutable, persistent data structures encourage side-effect free programming that can easily scales across multiple processor cores. In this talk, we will explore the various features Clojure provides for dealing with concurrency:

• Atoms provide for synchronous, uncoordinated updates
• Agents provide a thread-safe mechanism for asynchronous, uncoordinated updates
• Futures are a convenient mechanism for execution on a separate thread
• Delays provide a way to defer work for one-time execution when needed
• Promises provide one-time delivery as a mechanism for coordination
• Software Transactional Memory (STM) provides a mechanism for managing references and updates across threads.
• Dynamic Vars support thread-local state.

Android has powerful libraries for interacting with RESTful resources on the web. This presentation covers how you can consume these services using the Aerogear library and best practices for storing, querying, updating, and syncing data. This talk will cover the Content Provider APIs, the Loader APIs, SQLite Database, network management, and battery conservation on the Android platform.

Basic proficiency with the Android environment as well as an intermediate level of understanding about Java programming and networking is assumed.

Continuous delivery is the current buzz, but let’s take a few minutes to demystify it. 1. Does it work? 2. How would you go about getting towards that mode of operation? 3. Why would you want to have continuous delivery? 4. What tools facilitate this? You’ll leave a transformed developer. The idea of releases being non-stressful and able to be merged in on Friday at 4pm is attractive to the majority of us who have suffered at the hands of the “awful rollback” and the “long weekend.” These travails are partially the result of being on the opposite end of the spectrum from continuous delivery. Come with an open mind to branching strategies, feature toggles, and Readme-driven development.

Today, there are several trends that are forcing application architectures to evolve. Users expect a rich, interactive and dynamic user experience on a wide variety of clients including mobile devices. Applications must be highly scalable, highly available and run on cloud environments. Organizations often want to frequently roll out updates, even multiple times a day. Consequently, it’s no longer adequate to develop simple, monolithic web applications that serve up HTML to desktop browsers.

In this talk we describe the limitations of a monolithic architecture. You will learn how to use the scale cube to decompose your application into a set of narrowly focused, independently deployable back-end services and an HTML 5 client. We will also discuss the role of technologies such as NodeJS and AMQP brokers. You will learn how a modern PaaS such as Cloud Foundry simplifies the development and deployment of this style of application.

Cloud computing isn’t just about application deployment. There are also a growing number of cloud-based web services that you can use to develop your application. One of the most well known is Amazon’s Simple Storage Service. But there are many others including web services for messaging, relational and NoSQL databases, email and telephony. Using these services allows you to build highly scalable applications without the pain and cost of having to develop and operate your own infrastructure.

In this presentation, you will learn about the benefits and drawbacks of these Web services; their typical use cases and how to use them. We will describe a location aware, telephony application that is built using cloud services. You will learn about strategies for building resilient, fault tolerant applications that consume cloud services.

Managing a modern multi-component application in a continuous integration/deployment environment can be very tricky.

In this session we will concentrate on two of the aspects - environment setup, showcasing tools like Vagrant, Chef and Puppet for creating and controlling development, testing, staging, production and other environments and pushing the deliverables through those environments, using tools like Gradle, Jenkins and Artifactory.

Join us and get all the little tips and tricks that will help you rule your development world.

NoSQL databases such as Redis, MongoDB and Cassandra are emerging as a compelling choice for many applications. They can simplify the persistence of complex data models and offer significantly better scalability and performance. However, using a NoSQL database means giving up the benefits of the relational model such as SQL, constraints and ACID transactions. For some applications, the solution is polyglot persistence: using SQL and NoSQL databases together.

In this talk, you will learn about the benefits and drawbacks of polyglot persistence and how to design applications that use this approach. We will explore the architecture and implementation of an example application that uses MySQL as the system of record and Redis as a very high-performance database that handles queries from the front-end. You will learn about mechanisms for maintaining consistency across the various databases.

Even with the recent explosion in alternative languages for the JVM, the vast majority of us are still writing code in “Java the language” in order to put bread on the table. Proper craftsmanship demands that we write the best Java code that we can possibly write. Fortunately we have a guide in Joshua Bloch’s Effective Java.

In his foreword to the first edition, Guy Steele writes about the importance of learning three aspects of any language: grammar, vocabulary, and idioms. Unfortunately many programmers stop learning after mastering the first two. Effective Java is your guide to understanding idiomatic Java programming.

Effective Java is organized into 78 standalone “items,” all of which will be impossible to cover in one session. Instead I’ve chosen a subset of the most important techniques and practices that are commonly missed by today’s Java programmers. You’ll pick from a menu and decide where we’ll head. Regardless of the path we take, you’ll leave this session thoroughly equipped to write better Java code tomorrow!

Is the only way to deal with technical debt is by giving into it and rewriting every two years? What if we took some measures to keep it under control. This talk introduces intentional and un-intentional technical debt and effective ways to keep it under control using both objective metrics and intuitive methods.

Did you know that you can easily build natively installed mobile apps using web technologies with PhoneGap? In this session, we’ll cover strategies for enterprise application development - everything from MVC & distributed development, UI frameworks, performance considerations, data visualization, and dev/debug workflows in PhoneGap, for applications built entirely with HTML, CSS & JavaScript.

Public Web APIs are increasing at an exponential rate resulting in an ever more connected web. This connected contagion is not just relegated to the domain of Web 2.0 but has infected the corporate world. In fact, companies are becoming more reliant on Software as a Service (SAAS) to provide key business functions.

Combating this contagion requires an approach that provides a type of insurance against constant change and lays the foundation for evergreen enterprise solutions. In this session we will explore three popular architectural styles including Message Oriented, Service Oriented, and Resource Oriented Architecture that are used to achieve Enterprise Integration Agility. In addition, I will provide examples of each architectural style using ActiveMQ/Camel, Mule ESB, and NetKernel.

Source Code: https://github.com/jtdeane

Many iOS applications require the use of external data in order to display current information. For example, a weather application would be useless without having recent forecast information to display to the user. These types of apps typically make HTTP requests for data from online services, which often implement a REST based API. In this session we will discuss some of the concepts behind designing a REST based API, then illustrate an implementation using Spring MVC’s powerful REST support. On the client side, we’ll utilize Apple’s iOS SDK to demonstrate how to make RESTful requests and consume data for presentation to the user.

Learning the syntax of a new language is easy, but learning to think under a different paradigm is hard. This session helps you transition from a Java writing imperative programmer to a functional programmer, using Java, Clojure and Scala for examples. This session takes common topics from imperative languages and looks at alternative ways of solving those problems in functional languages. As a Java developer, you know how to achieve code-reuse via mechanisms like inheritance and polymorphism. Code reuse is possible in functional languages as well, using high-order functions, composition, and multi-methods. I take a variety of common practices in OOP languages and show the corresponding mechanisms in functional languages. Expect your mind to be bent, but you’ll leave with a much better understanding of both the syntax and semantics of functional languages.

The garbage collection subsystem is one of the most powerful parts of the Java Virtual Machine. In this talk, we will discuss the main features of it, and how tooling can be used to understand and visualize the dynamics of your application’s memory use.

You’ve heard about this version control system called Git. Maybe some of your colleagues are using it. But is it here to stay, or just a fad?

We can best answer that by looking at what Distributed Version Control Systems (DVCS) like Git bring to the world of programming and authoring. There are a myriad of benefits ranging from the distributed nature of Git without a central point of failure, to its focus on working locally. These benefits are made possible by Git efficiently communicating over the network only when asked and its Unix-like compositional architecture.

We’ll follow that up with a look at what GitHub, a web service focused on amplifying Git for easier collaboration, brings to this rapidly changing domain of software creation tools.

This talk will enable you to sling the basic Git and GitHub lingo around like an old hat when you get back to the office.

When you start building the next great mobile app, do you want to worry about your backend? Do you want to figure out hosting and support servers, or just work on your killer app? Windows Azure Mobile Services allows you to do that. In this session we’ll cover how you can connect your Android and iOS applications to a reliable cloud based backend that gives you super easy data storage, user authentication, push notifications, and more with just a few clicks. You will leave knowing how to get your backend setup so you can focus on the client experience immediately.

Google Apps Script is a cloud based JavaScript environment which allows you to write powerful applications and workflows around Google Apps such as Gmail, Docs, Drive, Sheets and more. The development is entirely within a browser and its free and easy to get started. Come learn all the capabilities of Google Apps Script and walk away being able to write your first script.

Learn the fundamentals of the Grails framework through example applications. Topics will include domain classes, controllers, transactional services, producing XML and JSON data, working with Ajax, unit and integration testing, and as many plugins as time allows.

Use Groovy to access web services, work with both relational and NoSQL databases, write Java applications in a fraction of the code, and more. This talk will present a variety of small but non-trivial examples of Groovy in action, using techniques ranging from closures to parsers and slurpers to metaprogramming and AST transformations.

Creativity is an important aspect of successful software product development and IT projects. Creativity is subject to the mood of the team – it doesn’t exactly ooze from a team that is demoralized. But how do you motivate creative types? It seems that it’s as easier to demotivate knowledge workers than it is to motivate them. Or is it? Programmers, testers, analysts and product managers can be motivated if you just take care. Know what motivates teams in general, find out what motivates each individual, be observant, and use a couple simple “tools”. This talk covers these concepts and includes thoughts from Jurgen Appelo’s Management 3.0 and Dan Pink’s Drive.

It’s an uncomfortable feeling: you read a news article describing clandestine organization cells, distributed networks of small teams which are nearly completely unaffected by each other’s operations yet united in their goals and beliefs. Their flat hierarchies mean the loss of one team member, even a leader, has little effect on the cell. The organization’s recruiting techniques focus on identifying disenfranchised yet influential individuals, sympathetic to the cell’s cause, and incorporating them into the group after a thorough vetting process.

After reading this you say to yourself, “That’s where I work, and it’s awesome.”

Learn how running a 200-person (and growing) Agile/XP software consulting company is much like running a clandestine organization, and how your teams can take techniques often associated with negative actions and use them for the good of your projects.

Most 2D games have many things in common, such as scrolling backgrounds, animated characters, transitions between levels, and collision detection. HTML5 games have a couple added twists, namely integration with social networks and support for mobile devices.

This talk covers all those things and more. You’ll see real-world implementations of 10 common aspects of 2D game development from scrolling backgrounds and sprites to time- and particle-systems.

This session will give you the knowledge to write HTML5 applications in your production code today. We’ll start out with a review of the current browser landscape (iOS, Android, Microsoft, Firefox, Chrome, Dolphin and Opera) and how to support both mobile device and desktop browsers in a production environment. We’ll review core HTML5 and W3C APIs such as Web Storage, Web Sockets, Web Workers, Geolocation, and Device Orientation and examine how these APIs contrast between desktop and mobile environments.
From there, we’ll begin coding an offline capable, HTML5 based demo application using all the latest APIs.

HTML5 is still a relatively new technology, but it’s rapidly maturing. One thing that HTML5 is currently missing is a way to easily build components, such as sliders or image viewers, for example, that you can drop into a webpage or web application.

In this talk you will see how to create your own ad-hoc components with today’s technology, and you’ll learn about an initiative underway to define a bona-fide component system for HTML5 so that you can implement your own components.

Erlang has made popular the notation of asynchronous message passing as means of distribution and Scaling. While the idea of “actors” is fundamentally simple, how do we, the software engineers, make use of this abstraction to develop real life, scalable systems? This talk designs a scalable distributed search service using Akka and Scala using the “zen” of Actor based design. It covers the basics of message passing, designing topologies and handling failure and moves onto a few common patterns in actors system design, including service overload detection and tracking user sessions.

Learn what Kanban is, what it isn’t, and how to apply it to an IT or software development project. Kanban focuses on the flow of work through a system. It’s a useful tool to visualize the work and the problems that impact flow. It supports evolutionary process improvement and helps control the amount of work in process. Being less prescriptive than many SW Dev methods, it can be used more naturally, that is without shocking the system as it is being adopted. This will be an informal and interactive session with lots of time for Q&A. Time permitting, we’ll touch on pull systems, metrics, value stream mapping, the Theory of Constraints and the Scientific Method.

Skill Level: Beginner

Get ready for a crash course in PhoneGap, a tool that enables you to build natively installed apps using 100% web standards technologies – HTML, CSS & JavaScript, complete with access to local device APIs. In this session We’ll cover everything from “what is phonegap” to strategies for building highly performant & interactive applications.

Video: http://www.tricedesigns.com/2013/02/19/video-introduction-to-phonegap/

The Play Framework is a lightweight, stateless web framework for Java and Scala applications. With Play you can build traditional page-based web apps or modern web apps using REST, JavaScript, and HTML5. This session will give you an introduction to building web applications with the Play Framework.

The modern web no longer is limited to desktop browsers. Smart phones and tablets have become an integral part of our daily lives. Web sites that may look good on a 22" monitor usually do not format and display well on a much smaller screen. Additionally, network speeds can limit the performance of a web site on mobile devices. Because of these reasons many developers and organizations are considering how to make their web sites accessible to all the various devices and screen sizes for which people are using. In this session, we will explore the functionality provided within the Spring Mobile project, and how you can use it to extend your Spring MVC application onto mobile and tablet devices.

The WebSockets technology promises to fill a niche in web applications by enabling browsers and servers to exchange messages with high frequency, low latency and low bandwith requirements in full duplex mode. The WebSocket protocol is an IETF standard, the WebSocket API is almost standardized by the W3C, and the JSR-356 will deliver a Java API in Java EE 7. There are already implementations in node.js and in a number of Servlet containers and Java frameworks. The time is as good as ever to start digging into it and there is so much to consider — from getting familiar with the protocol and the API, to sorting through the choices on the browser and on the server side, practical challenges with browser support and network issues, and so on. Furthermore, WebSockets offer a messaging-style architecture that’s in sharp contrast to the RESTful architectures that connect the web today, so learning where to draw the line will be essential.

There is a good amount of excitement about the new version of Java. The big evolution of course is the lambda expressions. In this presentation we will dive into the language features in Java 8, take a look at some of their nuances, and look at ways to put them to good use.

The effort to define the Java EE 7 platform is well underway and the horizons for Java EE 8 are emerging. This session looks into some of the key changes the community can expect. The goal of this session is to foster discussion and participation around these changes.

Some of the changes discussed include cloud support, retiring EJB 2 entity beans and JAX-RPC, greater alignment with CDI, a long-awaited update to the JCache API, WebSocket/HTML 5 support, a standard API for JSON processing, the next version of JAX-RS, an overhaul of JMS, long-awaited concurrency utilities, batch processing in Java EE and much, much more.

Source Code: https://github.com/m-reza-rahman/cdi-nosql-demo

It is a proven fact that developers can’t write more than a dozen lines of CSS without experiencing eye-twitches, general stomach pains and the overwhelming urge to flip their desk over and “Hulk it Out”.

LESS - the CSS preprocessor - is here to help. With its variety of helpful features like variables, mixins, operations and color functions it is now possible to actually program CSS instead of just typing at it.

Topics covered will include:
- Options for LESS compliation
- Converting current projects
- Customizing Bootstrap with LESS
- LESS alternatives

JFrog is handling huge amount of binaries files for all our customers. Since each customer has its own space and domain, using a global Object Store can be tricky.
Also our application cannot work with an “eventually consistent” storage, and cannot deliver customer requirements with current S3 performance.
Learn in this session how we managed fast upload, critical replication and backups, and global download availability of the terabytes of JFrog customer binaries files.

Persistence, Security, Connectivity. All 3 are an important part of an enterprise application. But how does this translate to the mobile environment. With a range a technologies to support and develop with, things can get messy quickly.

In this session you will see how AeroGear tries to solve these concerns and how it allows developers to access server side components, such as REST endpoints, using a common API across multiple mobile platforms such as Javascript and HTML5, Android and iOS.

No application is an island and this is more obvious today than ever as applications extend their reach into people’s pockets, desktops, tablets, TVs, blueray players and cars. What’s a modern developer to do to support these many platforms? In this talk, join Josh Long to learn how Spring can extend your reach through (sometimes Spring Security OAuth-secured) RESTful services exposed through Spring MVC, HTML5 and client specific rendering thanks to Spring Mobile, and powerful, native support for Android with Spring Android.

What can the life & methods of the celebrated physicist, Richard Feynman, teach us about software development? In this keynote, we will explore the idea that many of the characteristics of Feynman’s approach to physics are applicable to us as programmers and we’ll dream of a world where developers are free to follow the beat of a different drum.

Android’s bundled SQLite database is powerful, but requires a lot of hand-coded SQL to get started. Using an ORM can simplify database development for many applications, and the Android ecosystem already has several to choose from. stORM is a lightweight DAO generator written by Android Developer Advocate David Chandler that aims for a streamlined developer experience (only two annotations required) and solid performance (preferring code generation over reflection). stORM is extensible, minimally intrusive, and offers built-in CSV backup / restore capabilities to facilitate database version upgrades. Along with stORM, Chandler will present basic-http-client, a lightweight Java HTTP client with a built-in asynchronous interface.

Remote pair programming is surprisingly simple and inexpensive to implement, but it’s not just about bleeding-edge technology — a good attitude is just as important as good technology. Joe will walk you through how your distributed team can successfully implement remote pair programming, allowing you to realize the same benefits as in-person pairing and address some of the challenges of distributed development. Joe will discuss the important personal and interpersonal skills needed for remote pairing as well as the technology.

Distributed agile teams need not forgo the valuable discipline of pair programming. Thanks to ubiquitous high speed internet service, major advances in online collaboration technologies, and the need to source talent wherever they might be, remote pair programming is becoming more common.

Audience: All members of software development teams who are interested in pair programming and distributed agile will benefit from this session. Developers will learn the nuts-and-bolts of remote pairing, product managers, business experts, etc. will learn how to integrate remote pairing developers seamlessly with the team. Attendees are invited to share their own remote collaboration experiences — good and bad.

This presentation introduces the audience to the power of Gradle through many real-world examples that are demonstrated. By the end of the presentation, you’ll understand how Gradle helps to elegantly solve the challenges that we face in our daily builds. We’ll go through such powerful concepts as: advantages of declarative over imperative build systems, convention over configuration without rigidity, the Gradle plugins, deep multi–project support, performance optimizations through partial builds and incrementalness, harvesting existing functionality through Ant and Maven integration, as well as migration strategies for migrating from these build tools. We will demonstrate many of the innovative goodies that come with Gradle out–of–the–box, like the Gradle Daemon, the Gradle Wrapper, easy administration of your build environment, building Android apps and libraries, Eclipse integration, and other new plugins.

MongoDB has been designed for versatility, but the techniques you might use to build, say, an analytics engine or a hierarchical data store might not be obvious. In this talk, we’ll learn about MongoDB in practice by looking at four hypothetical application designs (based on real-world designs, of course). Topics to be covered include schema design, indexing, transactions (gasp!), trees, what’s fast, and what’s not. Sprinkled with tips, tricks, shoots, ladders, and trap doors, you’re guaranteed to learn something new in this interdisciplinary talk.

Simulation allows a rigorous, scalable, and reproducible approach to testing:

Statistical modeling

Simulation begins with statistical models of the use of your system. This model includes facts such as “we have identified four customer profiles, each with different browsing and purchasing patterns” or “the analytics query for the management report must run every Wednesday afternoon.” Models are versioned and kept in a database.

Activity streams

The statistical models are used to create activity streams. Each agent in the system represents a human user or external process interacting with the system, and has its own timestamped stream of interactions. With a large number of agents, simulations can produce the highly concurrent activity expected in a large production system.

Distributed execution

Agents are scaled across as many machines as are necessary to both handle the simulation load, and give access to the system under test. The simulator coordinates time, playing through the activity streams for all the agents.

Capture results

Every step of the simulation process, including modeling, activity stream generation, execution, and the code itself, is captured and stored in a database for further analysis. You will typically also capture whatever logs and metrics your system produces.

Validation

Since all phases of a simulation are kept in a database, validation can be performed at any time. This differs markedly from many approaches to testing, which require in-the-moment validation against the live system.

Separation of concerns

The separation of concerns above, and the use of a versioned, time-aware database, gives simulation great power. Imagine that you get a bug report from the field, and you realize that the bug corresponds to a corner case that you failed to consider. With a simulation-based approach, you can write a new validation for the corner case, and run that validation against your past simulation results, without ever running your actual system.

This talk will introduce simulation testing, walking through a complete example using an open-source simulation library.

The Spock testing framework is one of the most popular projects in the Groovy ecosystem. Spock tests are cleaner and simpler than their JUnit counterparts, and Spock includes a mock library as well. Spock tests work for Groovy, Java, and mixed systems. Best of all, the framework is very easy to learn – after this presentation you’ll be ready to write Spock tests right away.

Storm is a distributed realtime computation system. Similar to how Hadoop provides a set of general primitives for doing batch processing, Storm provides a set of general primitives for doing realtime computation. Storm is simple, can be used with any programming language, and is a lot of fun to use! We will talk about how Storm is architected, how to interoperate with Hadoop, and a few real-world use-cases.

The cloud has found a home for many uses, with lower costs and ease of administration as the main selling points. Yet there are still untapped possibilities for the cloud, including one overlooked area where the cloud can shine: testing. At Nexidia, we develop a large scale phonetic analytics framework, performing computational intensive operations across a cluster of servers, utilizing a MapReduce like strategy. This cluster can be as small as a single node, or as large as the needs demand. Testing large scale deployments in house has proven a real challenge; even with an unlimited budget, we cannot possibly anticipate all our future hardware requirements. The cloud has proven to be an excellent answer to this problem. With AWS (Amazon Web Services), we have developed a full automated testing harness in the cloud. This tool utilizes several of the AWS offerings:

• EC2 provides the server instances to create deployments of (almost) any cluster size and server
  instance type.
• Custom AMI images, from which the instances are spawned, contain the bootstrap app
  responsible for application installation and configuration upon instance initialization.
• S3 storage hosts the test data.
• Notifications are passed from and to the cluster via SQS.
• VPC offers a private cloud, thus securing the cluster deployment.

Costs are kept in check, as the server instances are terminated as soon as the test case is complete. Testing in the cloud allows us to explore corner cases, find bottlenecks in the application framework and helps us form recommendations and best practices for our clients. Along the way, we have learnt many lessons about the cloud, AWS, and testing in general. This presentation aims to educate and inform anyone looking to the cloud for testing possibilities.

Today’s front end developer’s have an endless buffet of JavaScript frameworks and development tools that supposedly allow you to do your job better and be more efficient. This talk wades through all the noise to discuss best practices for client-side user agent detection, code compression, GZIP, minification and build processes. We’ll review frameworks like grunt.js, HTML5boilerplate, and many others to see how these new techniques might fit into our current build processes with tools like maven or ant.

Isn’t life hard enough without deployment troubles? Isn’t life hard enough as a new engineer on a team without reproducible builds and environments? Join Josh Long as he introduces Cloud Foundry, the open source PaaS from VMWare. Learn why Cloud Foundry makes life easier for everybody - operations people and developers-alike - in this Cloud Found Bootcamp.

With the increasing popularity of Functional Programming (FP) it is easy to get caught up in the theory, syntax, and language features and forget about why FP is so useful. In this talk we will be looking at common coding problems and discover how FP provides solutions that are simpler, more efficient, and more flexible than those offered by imperative programming techniques. Each solution will introduce a FP feature or approach that is either commonly overlooked or not easily expressed in imperative languages.

In its 3.2 and 3.3 generations, the Spring Framework focuses on core features for asynchronous processing and message-oriented architectures, as well as enhancements to its caching support and its language support. The Spring Framework project also comes with a new Gradle-based build and a new GitHub-based contribution model. In this session, we’ll discuss key features of Spring 3.2 and the upcoming Spring 3.3, including support for upcoming standards such as JCache, JMS 2.0, and not least of all Java 8’s language features. We’ll also explain how we’re tracking Java EE 7.

Opting for a shorter release cycle, Spring Framework 3.2 was released in December 2012, with Spring Framework 3.3 to follow in Q4 2013. This session presents the current plan for both generations and discusses the motivations behind them.

An introduction to the IndexedDB API and how developers can make use of it within their web applications. IndexedDB allows developers to store large amounts of ad hoc data on their client’s machine. This can be useful both for performance reasons and for handling offline use. I’ll discuss support for the technology and alternatives for times when it can’t be used.

This session explores how NoSQL solutions like MongoDB, Cassandra, Neo4j, HBase and CouchDB can be used with JPA and Java EE. Although the primary focus is on EclipseLink NoSQL, we will also cover Hibernate OGM, EasyCassandra, Morphia, etc as well as seeing how NoSQL can be used natively via basic CDI injection without JPA. As part of the talk, we will briefly discuss the changes in JPA 2.1, the latest JPA revision slated for inclusion into Java EE 7.

Source Code: https://github.com/m-reza-rahman/jpa-nosql-demo

Have you ever wished that your local development sandbox could look exactly like production, but you’ve got a mismatch between your local OS and your production OS? And what about the age old “it works on my machine” excuse that quite often stems from differences between developer sandboxes? Many have turned to virtualization, creating a machine image that can be passed around the team. But who manages the template? How do you keep things in sync?

In this session, we’ll explore Vagrant (http://www.vagrantup.com), an open source tool that allows you to easily create and manage virtual development environments that can be provisioned on demand and “thrown away” when no longer needed.

Our agenda will include:

• Creating new base OS templates using the Vagrant Veewee plugin
• Creating a new development box using Vagrant
• Provisioning the box using Puppet
• Provisioning the box using Chef
• Deploying a simple web application to a multi-box development environment
• Packaging and distributing the box within your team

Note: This session is co-presented with Adam Koch.

The world of Android development is constantly evolving. The past few months have seen the release of new tools, frameworks, and other resources that have drastically improved the Android developer (and user experience). In this session, two members of the Android team at Google will demonstrate some of these recent resources that have allowed developers to more efficiently make beautiful, deeply-integrated, and device-independent apps.

Why is the relationship between the hippie counter culture of the 1960’s and the existence of spam email? How did a bunch of math geeks almost destroy the financial world? How can you build simpler architectures that scale? How are types of presentations like software designs? This keynote delves into these unexpected relationships and explores what they tell us about the intersection of the real world with software. Software is eating the world, and the geeks who write the code cook the buffet.