Physics in Android games

Realistic physics can add a new dimension to many traditional games, and enable a lot of new and creative game concepts. In this presentation we'll show how to integrate a physics engine into Android games and applications. We'll show features like gravity, collisions and joints, and explain how to use them. We'll finish off by showing a simple game incorporating all the topics we've covered, and sharing some valuable tips and tricks.

HTML5 is the Future of Mobile, But PhoneGap Takes You There Today

HTML5 promises to pave the way for easy, device-neutral mobile app development. But, until HTML5 supports sophisticated cross-platform apps, developers are stuck building native apps for various mobile devices. Or are they? In this session you'll learn how combining HTML5 with the open source PhoneGap (www.phonegap.com) framework bridges the gap between what's possible with HTML5 today and the engaging mobile apps developers want to build. See how HTML5 and PhoneGap work together and learn how to expose device features outside of the existing HTML5 spec, such as camera. By by learning to combine PhoneGap with HTML5, developers no longer have to commit to native development, nor do they need to wait for a mature HTML5 spec to build full-featured, cross-platform apps in HTML, CSS and JavaScript.

Building mobile applications with Flex

With the rise of a wide range of Internet connected devices, a new class of application is emerging to work across multiple kinds of devices. Developers are now faced with new challenges to provide the most engaging user experiences on any screen. New device input methods like touch and gestures require developers to rethink interaction models. Screen size constraints also require developers to optimize real estate usage. With so many different mediums for delivering rich Internet applications code, reuse becomes incredibly important. This session will help developers get up-to-speed on how they can use Flash Player and Adobe AIR to deploy a consistent runtime environment for Web content and applications across devices, both within and outside the browser. The last version of the open source Flex SDK lets you building this new generation of mobile apps.

Free your data with the Open Data Protocol

There is a vast amount of data available today and data is now being collected and stored at a rate never seen before. Much, if not most, of this data however is locked into specific applications or formats and difficult to access or to integrate into new uses. Public data is often unfortunately held private or needlessly buried behind random, inefficient, and cumbersome interfaces. The Open Data Protocol (OData) is an open REST based protocol for sharing data. It provides a way to break down data silos and increase the shared value of data by creating an ecosystem in which data consumers can interoperate with data producers in a powerful way, enabling more applications to make sense of a broader set of data. In this session we will examine the Why, What and How?s of the protocol and look into detail how to produce OData services and how to consume these services using different server and client platforms such as Java, PHP and .NET.

NoSQL consistency models and transactional semantics

NoSQL technologies often use different models for failover, high availability, and multi-data center support than traditional databases. In this session we will review approaches for different products such as Dynamo, BigTable, Yahoo PNUTS, CouchDB, and MongoDB. Discussion will include topics such as eventual consistency and CAP theorem. The CAP Theorem states that we cannot achieve consistency, availability, and tolerance to network partitions in a distributed data system.

In this session we will review how traditional database deployments have traded off these items, and how NoSQL sometimes offers a different approach to the problem. Different non-relational database products take different approaches: for this reason we will examine how different products deal with replication, multiple copies of information, consistency, failover, high availability. We will examine the implications of different approaches when working with multiple data centers and also in terms of performance.

Overview of NOSQL

It seems like everywhere we look there's talk about next-gen databases. Under the rallying cry of "NoSQL," several close-kept secret databases have gone open-source recently, giving everyone many exciting and confusing new opportunities. Some perform like crazy, some scale out to football field size, some just keep going no matter what, but none can do it all.

In these days, databases for huge, rich internet sites is all about making the right trade-off in the CAP theorem, not trying to cling to ACID semantics. Instead of trying to be another one-RDBMS-fits-all, these NoSQL databases typically address one or a few particular scenarios in the best way.

This talk is an overview of the four main categories of NoSQL databases: Key-Value Stores, ColumnFamily implementations, Document and Graph databases. We'll compare and contrast the major players of each type. You will take a way a better understanding of what your choices are, and what scenarios each database type is meant to solve.

To be relational, or not to be relational? That's NOT the question!

With distributed computing being a reality, whether between clouds or within data center walls, programmers and architects are facing new challenges. In traditional enterprise development, we?ve been relying on the database to be the keeper of our data and constraints, but since the pattern didn't scale, NoSQL recently came to our rescue. Now what does all that mean? And more importantly, what does it mean to you and your application? This session aims at guiding you on the journey from using a single relational database server, to making it as scalable as possible and choosing proper alternative solutions: explaining pros and cons of tools available depending on your needs, their impact on your architecture, the concepts and algorithms under the hood, and when NoSQL should really be Not Only SQL. This session should be attended by developers and architects that plan on delivering applications in the next couple of years, as the future is now and you can't get struggled with hamletic questions!

Top SOA Tips - A Road to a Successful SOA Implementation

You have been handed the keys and a blank slate to build a new services-based architecture. Are you up for the task? Do you have the knowledge, judgment, and combination of hard and soft skills needed to plan, design, and execute a significant SOA project?

Implementing a strong and flexible SOA can be a difficult challenge for an experienced architect, let alone someone with less experience. Many complex architecture projects end in failure, or are scaled back so that something can be achieved in a reasonable amount of time.

In this session Jeff Genender, CTO with Savoir Technologies, explores the key characteristics of successful SOA projects. He covers some of the patterns, and anti-patterns, tool sets, and strategies that he himself learned the hard way – through his own trial and error experiences as an architect. Last, he provides a strategy and blueprint for achieving a high likelihood of success in your SOA project Key session topics include: How to apply SOA patterns to different classes of problems. The common failures of a SOA project and how to prevent them. Architectural strategies that offer the best chance of achieving project success. And more.

Architects and development teams embarking on an SOA strategy will find this session especially beneficial, as this kind of expert advice is required in order to avoid making the same mistakes that have been made many times in the past. This type of advice can save you months of lost design and development time, and hundreds of thousands of dollars in poorly conceived and executed projects.

Meet the Vaadin team BOF

Meet and great Vaadin meet-up

Women in IT

Duchess is a global network for women in Java technology. We provide a platform through which women can connect and get involved in technology.

JDuchess organize this BOF at Jfokus. We will have a discussion about the role of women within both Java and IT in general. We think that these are important topics that need special attention. Everyone will be welcome to join this discussion, men as well as women. We have previous experience with organizing similar sessions, for instance at Devoxx, JavaOne, and others. Duchess: http://jduchess.org/

A new dimension for Android

With the new year we have a new version of Android available. There is also new hardware coming on the new devices that will enable developers to do some really exciting things. Come listen to what Sony Ericsson is doing with Android and see what makes the most entertaining smartphone to date.

The JavaEE BOF

Informal gathering with JavaEE experts.

It's All About ME (Mobile and Embedded)

Devices are now equipped with sensors such as 3G accelerometers, full GPS tracking units, along with Bluetooth and Zigby type communication protocols that allow mobile and embedded devices to be much more than an phone and device to play games. The talk is meant to show how one developer has used these system enhancement to make one of his favorite hobbies more enjoyable, but the overlying purpose is to encourage the attendees to develop programs that will benefit their lives and make mobile phones, and to a lesser extend embedded devices, much more than just a phone, text, and game player. The presenter in this talk is the Java Mobile & Embedded Community Leader and a golfer. This talk will present a number of free open source programs that have been created to make his golfing life easier and to play better. Devices used in the presentation will include a cell phone, SunSPOT, and Trackbot. Software used build the programs will include the Java ME Platform, SunSPOT software, Light Weight UI Toolkit, the Java SE platofrm (possibly with Java FX). The programs written will help the golfer to fully analyze his swing, including such key features as swing path, angle of attack, speed, and face angle; on course caddy information including distance to green, club selection, and club distance; and on green information including slope and green mapping.

Top reasons why you should switch to Maven 3

The just released latest and greatest version of Apache Maven 3.0, is an almost fully backwards compatible drop-in replacement for your old Apache Maven 2 build environment. Rewritten from the ground, it is the result of several years of work by the Apache Maven team. Changes include a new modular design to facilitate for embedded use, as well as a switch to Google Guice. This session will be a countdown of the top ten reasons why you should switch to Apache Maven 3.0, as well as pointers to a few changes that could break your project and how to deal with them.

Domain Driven Design BOF

Infomal Domain Driven Design unconference.

JRuby + Rails = Awesome Java Web Framework!

When looking for a productive, innovative web framework for a Java environment, who says it has to use Java the language? Rails is the framework that sparked a new wave of innovation in web development, and it's available on the Java Virtual Machine, via JRuby. And now, Rails 3, the latest release, allows you to mix and match components, making it easier to use existing Java code in numerous ways. Use Rails with EJB 3/JPA or Spring if it suits your environment! We'll give background on Rails as a framework and what makes it great, and show working demonstrations of Rails in a Java environment using traditionally Java-oriented components such as Servlets, JSP, JPA, Hibernate, etc.

Introduction to Mirah

Welcome to an introduction to one of the latest additions to the JVM family of languages. Mirah is a language created by JRuby co-lead Charles Nutter. It is a compiled language which makes no assumptions on the compiler or backends. This makes it an extremely "pluggable" language, which can output source code of another language, bytecode for the JVM, CLR, Dalvik, or whatever you may like. Mirah compiled for the JVM runs at the same speed as Java, and unlike most alternative JVM languages needs no runtime libraries. This makes it an interesting alternative for, for instance, Android development, Google App Engine or GUIs using the newly released JavaFX libraries. It has a pleasant uncluttered syntax very similar to Ruby.

No more loops with lambdaj

Lambdaj is an open source library that makes easier to manipulate collections in a pseudofunctional and statically typed way. To iterate over collection, especially in nested loops, is often error-prone and makes the code less readable. Lambdaj alleviates these problems by employing some functional programming techniques, without losing the static typing of Java in order to make refactoring easier and safer. Lambdaj partially eliminates the burden to write poorly readable loops while iterating over collections by allowing to filter, convert, group, aggregate, and sort their items without a single explicit loop. Beginning with its 2.0 release, lambdaj also makes it possible to define and use pseudoclosure in the same DSL style.

Web development in clojure

Rapid web development with clojure. Clojure is a strong upcomming language for the jvm, but how is it for web development? This talk will give you an overview on how to do webbdevelopment with clojure. Begining at hello world and simple forms, and going further with using templates to separate design from logic, and how to create a restfull interface to your application.

Gaelyk, a lightweight Groovy toolkit for Google App Engine

Gaelyk is a lightweight framework for developing applications using the Groovy dynamic language, and deploying them on Google App Engine. After a brief introduction to Google's cloud solution, we'll deep dive into the toolkit, discovering how Groovy makes using the App Engine SDK a breathe: querying the datastore, caching data in memcache, manipulating images with a DSL, sending email and Jabber messages, and more. We'll also see how easy it is to develop "groovlet" controllers and templates for the views, to define REST-friendly URLs, and be productive thanks to the seamless reloading making you productive in no time.

Visualizations for Code Metrics

Judicious use of metrics improves the quality of your code. But interpreting metrics presents a challenge. You have a list of numbers for a project - what does it mean? And what does it tell me about the health of the project overall? This sessions shows how to produce visualizations for software metrics, making them easier to understand and more valuable. It covers metrics at the individual method level all the way up to the overall architecture of the application. This isn't just a talk about how some tools produce visualizations: this session shows you how to generate your own visualizations, allowing you to customize it to the level in information density that shows real value on your project. I show how to produce projected graphs from dependencies, heat-maps for cyclomatic complexity and code coverage, using XSLT to extract visual information from XML configuration documents, and others. Metrics can't help you if you can't understand them. By creating visualizations, it helps leverage metrics to make your code better.

Binary patching of Java classes for fun (and profit).

The what/why/how of runtime binary patching of JAVA applications, frameworks and application servers to provide custom integration. We will follow the JRebel integration story from dirty bytecode insertions to readable Java code patches. The session is intended for advanced Java developers interested in patching or integrating with binary java applications. We will look at the different problems that arise when doing runtime binary patching of different Java applications and frameworks. * What and why is a binary patching? * Tools, methods and tips. * Sample use-cases of binary patching different systems * Pros/cons

Folding Together DDD and Agile

After a decade of heavy process, the Agile revolution of the late '90s threw off the dead hand of big upfront design. The bloody purge that followed was needed!

There were unintended consequences. Too many teams interpret "Agile" as a permit to not think about design. But if they have ambitious goals, Agile teams need more than standup meetings and iterations. Many teams get off to a quick start, building lots of features in early iterations, but end up with a "Big Ball of Mud". Without clear and well–structured code, they cannot sustain their pace and also put themselves at risk of, one day, encountering a critical feature they simply cannot deliver.
Without the common understanding between developers and stakeholders that is forged in domain analysis, one of the greatest benefits of iteration, the deepening communication about what the software should do and how it should do it, is never realized.

We must not return to the "Analysis Paralysis" that we used to endure (and that many teams still do), but interpreting "Do the Simplest Thing"
as "Do the Easiest Thing" doesn't work either.

This talk will consider ways of incorporating modeling and design into the iterative process in a lightweight way that increases communication with stakeholders and decreases the likelihood of painting ourselves into corners, without returning to the dead–hand of the analysis phase.
As a concrete example of how such techniques can be incorporated into the Agile framework, we'll have an overview of a simple process Domain Language has used with its clients for the last six years.

The right kind of modeling and design, far from bogging down a project, leads to a livelier and more sustainable development pace.

DDD Repository pattern with Spring Data JPA

Domain Driven Design has become a ubiquitous approach to tackle complex problem domains and build a rich object model. A crucial DDD concept to access entities is the repository. Besides that, JPA has become the standard and widely accepted way of object persistence in the Java world.

This talk starts with a brief analysis of a plain JPA based repository implementation and outline pain points esp. regarding the domain driven approach (lack of abstraction, tediousness of executing queries, pagination and so on). The main part of the talk then takes a step by step walkthrough the issues and see how the Spring Data JPA project (formerly know as Hades) can help solving these issues.

The presentation is 80% hands on - less slides, more code :)

Hitchhiker's Guide to the NetBeans RCP

Defence forces, banks, oil/gas companies, bioinformatics, public transportation organizations... why are so many large applications across all software industries based on the NetBeans RCP? In this session, you will learn to understand the world's only Swing-based modular rich-client platform. At the end of the session, you will have all the knowledge you need to get started leveraging this platform for your own corporate applications for the desktop.

Architecture remakes with DDD, true stories from the wild

Applications have a tendency of becoming harder and harder to maintain over time. That affects the cost as well as the possibility of incomes thanks to meeting new business opportunities. For some applications, it’s considered valuable to give them a remake to make them more maintainable and such remakes have a tendency of affecting the overall architecture. In my experience, DDD is often used for describing the new target architecture, but it’s also a very infuential and valuable tool and philosophy for taking on such a task.

In this presentation we have distilled a set of common key possibilities in such situations, both how they can be achieved and what benefit they will give. You will also learn what to watch out for from our lessons learned.

Ubiquitous Language

Apart from being hard to say, ubiquitous language seem to be the hardest part of Domain Driven Design to grasp. We dive into what is meant with a "language" in this context, and how it is linked to domain modeling. Of course there will be philosophy, but the focus will be on how to make the practice valuable to our development effort. Therefore we will talk about practical issues, like who will need to be involved, how to handle synonyms, and discuss traps that can trip the effort.

Domain Driven Security Code Kata

The top two risks for applications where Injection Flaws and Cross-Site Scripting (XSS) according to OWASP as well 2007 as 2010. Time to do something about it. In this code kata we address both Injection Flaw as well as XSS by applying techniques from Domain Driven Design - thus Domain Driven Security. In specific we use DDD value objects to shape up our module APIs to make these vulnerabilities go away by enforcing indata validation and outdata encoding in a way that feels natural for the developers.

Git Going with DVCS

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. Jump ahead of the masses staying on Subversion, and increase your team's productivity, debugging effectiveness, flexibility in cutting releases, and repository and connectivity redundancy (at $0 cost).

Understand how distributed version control systems (DVCSes) are game-changers and pick up the lingo that will become standard in the next few years.

The Java EE 6 Programming Model Explained

The Java EE 6 platform contains a wealth of APIs: some were just introduced (CDI, JAX-RS and Bean Validation); others have been around for a long time with little or no change (JMS); and still others have a long history, but have also seen leaps in usability (EJBs). When writing an application, we often fall back on old habits. As a result, we overlook some new, often simpler, features that would let us solve the problem much faster. In this session, we'll look at the Java EE 6 programming model as a whole, then dive into the different layers of a typical Java EE Web application and show how to implement them using the latest Java EE features with the help of a modern IDE.

Vaadin, Rich Web Apps in Server-Side Java without Plug-ins or JavaScript

Get introduced to the Vaadin Web Framework by one of its core developers, Joonas Lehtinen. The Vaadin framework provides a desktop-like programming model on the server for creating Rich Internet Applications (RIAs) in plain Java - without the need for HTML, XML, plug-ins or JavaScript. In this session, Joonas lays out the key concepts of the server-side RIA development model and compares it to client-side RIA. To demonstrate the use of framework, an example application is developed during the session step-by-step. The presentation is concluded with pointers on how to start developing your own applications with Apache-licensed Vaadin-framework.

What a crazy year it has been

On January 27 2010, the EU green-lighted Oracles acquisition of Sun Microsystems. The 12 months following this have arguably been among the most eventful, at least in the public eye, in the history of Java. We will do a year in review, comparing press coverage with actual events and tell you what has happened in 2010 to make the Java ecosystem stronger than ever. In what direction is Java heading? What are Oracles plans? What can you do to influence the future of Java?

The Secrets of Concurrency

From the first version of Java, we have been able to create multiple threads. Initially, this was mostly used for making our GUIs more responsive. For example, we would read a file using a separate thread from the main Swing thread, updating the GUI as to the progress. Running many active threads on one CPU seldom made the program faster, on the contrary, the swapping overhead frequently bogged down the machine. However, in the last few years, the speed increase of CPUs has not been the clock speed, but the number of cores on each chip. We are in a position now where we can get a job done much faster by splitting it between multiple threads. Unfortunately there is still a lack of understanding of the mysteries surrounding threading. This has caused programmers to write code that is fundamentally incorrect, not taking into account best practices for threading. Here is an example of such incorrect code, seen today on a web forum: synchronized (namedQueues) { try { namedQueues.wait(5000); } catch (InterruptedException ie) { // Can safely ignore this } } if (isInterrupted() || isStopped()) break; In this talk, we look at ten laws that can help us to write more correct threaded code.

The talk does have something for everybody, but is mainly aimed at the intermediate to advanced developer. There are code samples and a short demonstration. What you will get out of the talk: You will learn several tips that will help you in writing correct threaded code in Java.

Java EE 6 Toolshow

The Java EE 6 platform improves on the Java EE 5 developer productivity features. The true potential of this platform can be unleashed using tools and IDEs to quickly create Java EE 6 compliant applications. Syntax coloring, code completion, javadocs, debugging, profiling, and refactoring are some of the features that are important during a development cycle. Using a live coding session, this mostly slides-free session will demonstrate the different tooling options available for Java EE 6 developers. It will demonstrate how NetBeans, Eclipse, IntelliJ, JDeveloper, and Maven makes developers life easy in creating Java EE 6 applications. The attendees will learn several tips & tricks for each IDE to boost their productivity.

Terrastore: document database for developers.

This is a rundown on the Terrastore "NOSQL" store, providing a quick introduction to its most important features and how it will boost your productivity in developing data-centric applications.