Java in the Internet of Things. Smart, Small, Connected

Terrence Barr, Oracle

The Internet of Things is rapidly happening around us. By 2016, intelligent connected systems are predicted to outnumber mobile phones and personal computers combined and generate the majority of Internet traffic. Intelligent systems are the next frontier for reaching into the world to build new solutions, drive efficiencies, and create business opportunities on a huge scale across a wide range of markets such as healthcare, industrial automation, logistics, security, power distribution and consumption, environmental sensing, and much more.

But this new wave presents a host of challenges. Java technology, with it's cross-platform, productive, and secure design, is already present in almost 10 billion devices around the globe. In this talk, learn about Oracle's "Device to Datacenter" vision and the products we are building to help developers build better embedded solutions, faster. This talk includes demos.

Introduction to Vaadin 7

Joonas Lehtinen, Vaadin Ltd

Vaadin Framework version 7 is the first new major version of the popular rich web framework in over three years of iterative evolution. It includes Google Web Toolkit (GWT) to provide best of the Java based UI development - both of the server and client-side. The presentation describes the new features and design decisions and explains the implications of including GWT.

The first goal for Vaadin 7 is to give more freedom to use underlying technologies with ease. We'll show through examples on how to utilize new API:s. The second goal is to embrace the extensibility of the framework with new APIs for adding features. Final goal of the release is to clean up the API. We show what have been changed, how the changes may break your application and give advice on how to upgrade to Vaadin 7.

What is expected of a PaaS in 2013?

Matt Stephenson, Google

The PaaS landscape is only getting better with time. With configuration becoming simpler, the best possible availability expectations, polyglot runtimes, datacenter distribution choices, choice of persistence layers, a richer set of APIs and features (Full Text Search, Map Reduce, PageSpeed,...) all the time. Come and taste the 2013 Grand Cru! There will also be a good deal of discussion on some features and tools that are in the works right now, but will be out by the time you hear us talk.

Making smart meters even smarter with embedded Java technology

David Vonasek, Elvaco AB

David gives a talk on Elvaco's Java-based smart meters and communication infrastructure, Elvaco has for 15 years used an embedded system on chip and GSM, GPRS wireless technology. With Java - on memory constrained hardware - we have been able to develop an application with complete Internet connectivity including support for HTTP/S SNMP SMTP FTP IPv4 and metering protocols such as M-bus. The application has very high demands for uptime, availability and support for remote management.

Coding all this in Java has been a real success for Elvaco. The usage of The Java platform has dramatically lowered the development cost and the time to market. New customer demands have been easily implemented and new features are constantly added on existing products in the field using Java OTAP, which gives new business opportunities and increased addon sales.

Continuous Delivery Patterns for Large Software Stacks

Hans Dockter, Gradleware

We will look at common patterns for building larger software stacks and discuss their advantages and disadvantages. We will also present a new build and promotion patterns that scales even with very large software stacks and allows you to integrate as early as possible but at the same time keep the delivery pipeline for new features flowing. This is a critical problem for many teams. The presenter will share many stories of real life projects, how they were affected by a dysfunctional pipeline and what it took to improve their situation. There are quite a few larger projects for which a naive practice of early integration between their components lead to constant breakages and a defect delivery pipeline. Thus they were not capable to successfully build a new version of the software stack for days or even weeks. Obviously the problem of that is dramatic as no regular manual testing and capacity testing is taking place. Not only is this a massive waste of testing resources, it also leads to very long and therefore expensive feedback cycles that severely affect your time-to-market of new features. It also a likely source of conflict between the CI team and software development, as with no other means at hand, there is a desire to create stability by not adding new features or doing important refactorings.

How to participate in the future of Java

Heather VanCura, Java Community Process

The Java Community Process (JCP) is key to the evolution of Java. This session emphasizes the value of transparency and participation in the JCP program, Java user groups (JUGs), and the Adopt-a-JSR program. You will also hear about some upcoming changes to the Java Specification Request (JSR) process through the JCP.next effort, and learn how you can get involved. Come with your questions/suggestions and leave with the motivation and information you need to become an active participant in advancing the Java platform.

The web performance testing toolbox

Tobias Järlund, Aftonbladet

So, your web application is slow. You read all the books, follow all advices, but users are still complaining. What now? It turns out that there are really good tools out there to help you, whether your problem is slow loading third party widgets, badly performing javascript or heavy paint times for DOM elements. But which one is right for you?
This hands on session will give guide help you assemble your own toolbox with the the different (mostly free) tools available for analyzing and troubleshooting web performance. You'll learn what you can expect from high level tools that measure page load time through synthetic or real user monitoring, down to low level javascript profiling and graphic rendering. We'll dive straight into the advanced parts of WebPagetest, Chrome Dev Tools, Dynatrace Ajax Edition and others, and you'll also get to know how to do most of this on actual mobile devices.

Effective Scala

Henrik Engström, Typesafe

Everything you always wanted to know about Scala but were afraid to ask. If you want to be able to optimize your use of the Scala programming language to solve real world problems without explosions, broken thumbs or bullet wounds then this is the session for you.
During the presentation there will be a lot of do's and don't's in order to guide you into how to become a better Scala developer. The target audience is intermediate to advanced Scala developers.

Lisp is beautiful!

Alf Kristian Støyle, Knowit

Clojure is a fantastic programming language, but it is a Lisp. Lisp languages have a very different syntactic background than C-inspired languages, like Java. Many Java developers dislike the Lisp syntax, mainly because of "all of those pesky parenthesis".

This lightning talk will show you that the Lisp syntax really is extremely simple, and also very powerful. It is even possible to argue that Lisp does not have a syntax!

Mongo for Hibernate/JPA Developers

Justin Lee, Squarespace.com

NoSQL is all the rage these days but sometimes it's hard to figure out where to start when considering all the options. This talk will begin with a basic introduction to mongo and how data is organized. We'll cover at least 3 options (native driver, Morhpia, and jongo) for getting data in and out of mongo. Then we'll walk through an example JPA application and see how it looks using one or 2 mapping options in mongo.

Scala your Android

Konrad Malawski, SoftwareMill

Many of us are aware that it's possible, and quite easy, to use some other language than Java on Android's DVM, but still not many have actually tried it. As it turns out, one of the best languages fit to do Android development is... Scala. Remember how you had to override methods to create menus, and sharing those was quite hard due to Java's inheritance model? Well, Scala's traits solve that problem for you. Or how much boilerplate (with explicit type casting) you had to write to find a view by id? Say hello to Typed Resource! And there's even more pain to be relieved by using some of Scala's features - which, oddly enough, seem to be a perfect `match` for `lazy` Android development... And I assume you're already on the Scala Collections drug? If not - be prepared to get addicted. During this session we'll explore those, and some more techniques that you can use to Develop your Android apps with Scala as well as problems you might encounter.

Rocket Propelled Java

Andres Almiray, Canoo Engineering AG

It's a well known fact that the Java language is verbose, probably more verbose than what it should be. In the past, developers have relied on external tools such as IDEs to cope with the verbosity level. But what if we were able to workaround the problem with the language itself? Come learn about AST transformations and how they can be applied to the Java language.

Will It Float [in Java]?

Stephen Chin, Oracle

In this session we will undertake a rigorous, empirical methodology to find out the current state of Java on devices of all sizes and shapes. Using the time-tested technique of technology immersion, the capabilities of running different devices in Java will be physically demonstrated. We will uncover some surprising developments in Java on mobile, embedded, and consumer devices with a look into the future of Java machine-to-machine (M2M) applications. This session will be run by an expert in the field of device buoyancy, so audience members are strongly cautioned against trying these experiments on their own!

Do you like coffee with your dessert? Java and the Raspberry Pi

Simon Ritter, Oracle

The Raspberry Pi has caused a huge wave of interest amongst developers, providing an ARM powered single board computer running a full Linux distro off an SD card and all for only $35! This session will look at how Java can be used on a device like this. Using Java SE for embedded devices and a port of JavaFX we will show a variety of demonstrations of what the Raspberry Pi is capable of. The Raspberry Pi also provides GPIO line access and we?ll cover how these can be used from Java applications. Prepare to be amazed at what this tiny board can do.

Invokedynamic in 45 Minutes

Charles Nutter, Red Hat

You've heard about it. Maybe you're even using a language like JRuby that uses it. But what exactly is invokedynamic and how can it help you as a Java developer? In this talk, we'll cover the basics of what invokedynamic is and how you can use it. We'll do step through some simple examples to show the mechanics of the invokedynamic bytecode, the bootstrap method, call sites, and method handles. And finally we'll build a toy language to show how it all fits together

Java and the Machine

Martijn Verburg, jClarity

In Terminator 3 - Rise of the Machines, bare metal comes back to haunt humanity, ruthlessly crushing all resistance. This keynote is here to warn you that the same thing is happening to Java and the JVM! Java was designed in a world where there were a wide range of hardware platforms to support. It's premise of Write Once Run Anywhere (WORA) proved to be one of the compelling reasons behind Java's dominance (even if the reality didn't quite meet the marketing hype). However, this WORA property means that Java and the JVM struggled to utilise specialist hardware and operating system features that could make a massive difference in the performance of your application. This problem has recently gotten much, much worse. Due to the rise of multi-core processors, massive increases in main memory and enhancements to other major hardware components (e.g. SSD) means that the JVM is now distant from utilising that hardware, causing some major performance and scalability issues! Martijn Verburg will take you through the complexities of where Java meets the machine and loses. He'll give up some of his hard won insights on how to work around these issues so that you can plan to avoid termination, unlike some of the poor souls that ran into the T-800...

Adding HTML5 to your Native Android Application

Martin Gunnarsson, Axis Communications and Pär Sikö, Jayway

There are many reasons for integrating web content into your native Android applications, for example formatting and styling text or reusing content between platforms. Either way, a thorough understanding of how the web component works, and what you can and can't do with it, is the key to successfully implementing a hybrid application.

In this presentation the different techniques used to integrate HTML5 content into an native Android application will be demonstrated.

The audience will learn how to communicate between Android and the web component, customizing the web component, taking care of resource loading, handling errors, and making the web view blend into the native application.

Delivering high performance Internet of Things and M2M services

Lars Ramfelt, Yanzi Networks AB

Yanzi delivers a horizontal platform that brings simplicity and performance to a new level. The advanced JAVA architecture allows software to be moved between the cloud servers and the gateways. All sensors are kept low cost and stateless, while all intelligent decision making and state is left for the JAVA platform.
Based on the Internet Protocol (IP) suite, the platform addresses the challenges of running multiple applications and devices on a common networking infrastructure, dramatically improving efficiency, lowering costs and ensuring reliable delivery of services.
Currently, Yanzi provides services for remote monitoring with streaming video, temperature, energy flow and several other sensors. This talk will present the platform and the technical challenges and solutions selected to become a world class IoT platform.

AirCasting - Crowdsourcing Environment Data

Andrzej Grzesik, LunarLogicPolska

I'd like to introduce you to AirCasting, a platform for recording, mapping, and sharing health and environmental data using your smartphone. Measure humidity, temperature, gases (NO2, CO), noise and your own heart rate. With an Android, and Bluetooth-powered sensors. Plus a few Arduino-powered devices, LEDs, all tangible.. Except for the few hiccups Android served us along the way.

An app is not enough

Joakim Kemeny, Callista Enterprise

Native or web? That seems to be one of the biggest questions on the market right now. But what do you do when an app is not enough? How can you create something that works great on a 4" phone as well as on a 60" television? Responsive web design can be the answer for you and it's one of the hottest trend in web design right now. Joakim will use this technique to give you an understanding of how to design and code web applications for 2013 and beyond. The result will be shown in a demo that will possibly change the way you think about the web.

Project Lambda: Functional Programming Constructs and Simpler Concurrency in Java SE 8

Simon Ritter, Oracle

The big language features for Java SE 8 are lambda expressions (closures) and default methods (formerly called defender methods or virtual extension methods). Adding lambda expressions to the language opens up a host of new expressive opportunities for applications and libraries. You might assume that lambda expressions are simply a more syntactically compact form of inner classes, but, in fact, the implementation of lambda expressions is substantially different and builds on the invokedynamic feature added in Java SE 7. This session will explain the ideas behind lambda expressions, how they will be used in Java SE 8 and look at some of the details of their implementation.

The Wearable Application Server and Other Adventures in Software Engineering

Holly Cummins, IBM

Mobile technology has so far mostly been confined to the client side, for fairly obvious reasons - traditionally, clients are mobile, and servers are not. However, not only is hardware getting smaller, servers are too. When your application server can run on pocket-sized £25 hardware it opens up some pretty cool possibilities - your server is literally lightweight. Not only can you have location-based services, you can have locatable servers. Servers can run on phones, they can run on the Raspberry Pi, and so they can go almost anywhere you can think of. Modularity gives software the flexibility it needs to cram into these tight spaces without sacrificing power. This talk will demonstrate developing and deploying a web application to an application server embedded in a silly hat.

Real-Time Delivery Architecture at Twitter

Raffi Krikorian, Twitter and Attila Szegedi, Oracle Corporation

With hundreds of millions of users, Twitter operates one of the world's largest real-time delivery systems, large enough and pervasive enough to exert noticeable "pressure" on the overall internet itself. At steady state, Twitter receives thousands of tweets a second that it needs to deliver to disks, in-memory timelines, email, and mobile devices. The name of the game for Twitter is "now", so those deliveries, which multiply according to the graph of who follows whom, need to occur in real-time. In this session, we will dive into both the "write path" and "read path" of Twitter to understand the architecture which supports those tweets, and also how Twitter serves them through one of the world's largest web sites.

Technologies for the Internet of Things

John Fornehed, Ericsson AB

Networked Society Our findings and experiences, 4 top areas in m2m SDK findings Business Lab Future

Scaling Agile with Tribes, Squads, Chapters & Guilds

Anders Ivarsson, Spotify and Henrik Kniberg, Crisp

Dealing with multiple teams in a product development organization is always a challenge! One of the most impressive examples we've seen is Spotify, a fascinating company that is transforming the music industry. Spotify has kept an agile mindset despite having scaled to over 30 teams across 4 cities and 3 timezones.

So how is this managed? How do handle dependencies? How do we avoid technical debt? How do we synchronize multiple teams? How do share knowledge across the organization? How do we get stuff into production?
And what the heck are tribes, squads, chapters, and guilds anyway?

Netflix OSS Cloud Architecture

Carl Quinn, Netflix

This talk presents a general overview of the Netflix cloud architecture built upon the Amazon Web Services (AWS) foundation. It covers how we use existing AWS features to improve the manageability of our cloud objects, and how we add a few abstractions to tie the AWS objects neatly together. It also covers some of the Netflix OSS tools (and a few non-OSS), and how they fit into this picture to help run the show.

Building Rich Web Applications with Ext JS

Mats Bryntse, Bryntum

Ext JS is a powerful JavaScript platform which allows you to create great cross-browser web applications. The library includes everything from an advanced class system, to all the widgets you need such as data bound grids, trees and forms. Its greatest strength however, is perhaps its component model and clean extensibility. This makes it very easy to customize, extend and create your own widgets. We?ll be looking at what Ext JS offers out of the box and I will also demonstrate how easy it is to write a custom component.

Stop doing Retrospective and start your Toyota Kata

Håkan Forss, Avega Group

You have been doing agile for a few years now. With a regular cadence you have retrospectives and a lot of problems and great improvement opportunities are raised but nothing seems to really improve. Stop doing retrospectives! You should shift your focus form collecting problems and start improving! It is time to take your improvement work to a whole new level!
It is time to create the habits of continuous improvement. It is time to start using Toyota Kata!
Toyota Kata is two behavior patterns, or Kata?s, that is the foundation in Toyota?s continuous improvement work. In this session you will get a practical introduction to Toyota Kata. You will see how a team goes through the two Kata's and improves its way of working.

Busy Developer's Guide to HTML5 Development

Geertjan Wielenga, Oracle

HTML5 has suddenly become a hot item, even in the Java ecosystem. How do the 'old' technologies of HTML, JavaScript, and CSS relate to Java developers and can Java developers really be productive in this new/old world? In this session, you'll learn everything you need to know and see a hands on demo illustrating the relevance of HTML5 in the Java world, using simple and intuitive tools that have been especially created for this purpose!

What's new in Android Jelly Bean

Cyril Mottier, Google Developer Expert

A tour of what has happened with the Android platform and ecosystem in the last past year. This presentation focuses on what's new from both a user and developer point of view.

Building Scalable, Highly Concurrent and Fault-Tolerant Systems: Lessons Learned

Jonas Bonér, Typesafe Inc.

The skills of building Scalable, Highly Concurrent and Fault-Tolerant Systems are becoming increasingly important in our new world of Cloud Computing, multi-core processors, Big Data and Real-Time Web. Unfortunately, many people are still doing it wrong; using the wrong tools, techniques, habits and ideas. In this talk we will look at some of the most common (and some not so common but superior) practices; what works - what doesn't work - and why.

Simplicity: the Way of the Unusual Architect

Dan North, Dan North & Associates Ltd

It is often said that the difference between architecture and design is one of scale. Architects are concerned with "big" design and "big" integration. As developers become architects and architects become enterprise architects, the systems they build grow ever bigger and more complex. But does big necessarily need to mean complicated?

In this talk Dan argues for a new appreciation of simplicity, using examples from systems design, enterprise integration, build and deployment, and provides strategies to help you extract the simple essence from complex situations and problems, and to distinguish the simple from the simplistic.

"I would not give a fig for the simplicity this side of complexity, but I would give my life for the simplicity on the other side of complexity." - Oliver Wendell Holmes

Rocking the Gradle

Hans Dockter, Gradleware

This presentation introduces the audience to the power of Gradle through many real-world examples that are demonstrated live. By the end of the presentation, you'll understand how Gradle helps to elegantly solve the challenges that we face in our daily builds.

The Java EE 7 Platform: Productivity & HTML5

Arun Gupta, Oracle

This talk introduces the Java EE 7 platform, the latest revision of the Java platform for the enterprise. Java EE 7 continues the ease of development push that characterized prior releases by bringing further simplification to enterprise development. It also adds new, important APIs such as the REST client API in JAX-RS 2.0 and the long awaited Batch Processing API. Expression Language 3.0 and Java Message Service 2.0 will under go extreme makeover to align with the improvements in the Java language. There are plenty of improvements to several other components. Newer web standards like HTML 5 and Web Sockets will be embraced to build modern web applications.

This talk will provide a complete introduction to the Java EE 7 platform, including different components, and provide a roadmap.

Patterns for key-value stores

Ole-Martin Mørk, Bekk Consulting AS

As nosql gathers more and more momentum I have discovered that there is a need for good patterns. You want to organize the data as well as possible. With good organising it will be easier to find the data again.This can be a real challenge when you have little or no experience dealing with key-value stores. If you use good patterns, your database scheme will make sense, you will get better performance and hopefully your code will look better as well. My presentation with look at patterns for all key-value stores, and patterns for Redis, Riak and end with a peek into what good patterns + Redis + Riak can give you.

Are Your GC Logs Speaking to You

Kirk Pepperdine, Kodewerk Ltd

Getting GC logs is cheap and easy. Just set a couple of switches on the command line and you'll be given the insight into what this performance critical piece of the JVM is up to. For example, many applications are starved for memory in at least one of their internal memory pools. A simple check of the GC logs will tell you if your suffering from starvation. That same data can then be used to calculate a configuration that can result in huge differences in the performance of your application. But it's not only starvation that can be a problem. Having too much memory or an unbalanced configuration can be equally problematic. Or your problem may be as simple as your application's calling System.gc(). All these conditions can be, and in some cases, can only be, diagnosed by listening to what the logs are telling you. In this session we will look some interesting GC logs as well as tools that can be helpful in identifying anti-performance conditions.

Scala Tricks

Venkat Subramaniam, Agile Developer, Inc.

Scala is a very powerful hybrid functional pure object oriented language on the JVM. Scala is known for its conciseness and expressiveness. In this presentation we will look at some common tasks you do everyday in developing applications and see how they manifest in Scala. We will look at the strengths of Scala from application development point of view. Rather than focusing on the syntax of Scala, we will focus here on Scala idioms and powerful Scala libraries to perform routine tasks

WebSocket and Java EE: A State of the Union

Justin Lee, Squarespace.com

Java EE is beginning its climb into the cloud. In addition to updates to existing technologies such as JPA and EJB, Java EE 7 is introducing new technologies such as WebSocket that aim to provide bidirectional, asynchronous communication between a client and a server. This session introduces the protocol itself, discussing the various ways it differs from HTTP. It also touches briefly on how it differs from existing asynchronous approaches. From there the presentation moves to examples of existing APIs that provide support for the protocol and then discusses the current state of the JSR and what remains to be done before final delivery of Java EE 7 in the first half of 2013.