Spring Boot, the new convention-over-configuration centric framework from the Spring team at Pivotal, marries Spring's flexibility with conventional, common sense defaults to make application development not just fly, but pleasant! Ideal for microservices and for all your distributed systems and devops needs. Join Spring Boot co-lead Dave Syer and Spring committer Stéphane Nicoll for a look at what Spring Boot is, why it's turning heads, why you should consider it for your next application (REST, web, batch, big-data, integration, whatever!) and how to get started.
Ceylon is a new programming language that runs cross-platform on the Java Virtual Machine and JavaScript VMs. Ceylon features a flexible and very readable syntax, a unique and uncommonly elegant static type system, a powerful module architecture, and excellent tooling, including an awesome Eclipse-based IDE.
In this talk, Gavin King will show how its unique static type system enables, and sometimes even requires, a different approach to some kinds of programming problems. In this session, we'll introduce the type system by presenting a series of simple examples, exhibiting common idioms in the language.
For many years software engineering meant delivering software the way we constructed buildings. This turns out to be a wildly inefficient way to create innovative products and services based on software. In this talk I'll discuss what makes software different from buildings, and how we can take advantage of its unique properties to satisfy our customers through continuously delivery of valuable software. I'll also talk about how you can adopt these practices in the safety of your own office, and explore the art of the possible and the patterns and practices used by high performing companies.
So you've heard of this newfangled "Scala" thing and think it might be worth checking out. Good for you! Unfortunately, it's also daunting. Your first search for Scala is likely to pitch it as a "statically-typed hybrid object-oriented and functional language", which is technically true but doesn't really help much.
Instead, this talk will provide an overview of the language, focusing on five highly practical advantages Scala has over Java without a brain hemorrhage-inducing paradigm shift, followed by some tips and recommendations on Scala adoption in the real world and (as time allows) open-ended Q&A.
Java 8 is of course the release of lambda expressions, the Stream API and the Collectors class. These major language features and API shadow everything. But Java 8 has many more gems in many fields: a new API for dates, a new ConcurrentHashMap, a new HashMap, new concurrency utilities, and all kinds of little things that will make our lives easier, and that we present here.
The goal of this talk is to present all the new things in Java 8 that are left once we have removed the lambdas, the streams, the collectors, JavaFX and Nashorn.
Presentation: A Field Guide to DSL Design in Scala
Scala's powerful type system and flexible syntax enable the design of internal DSLs, e.g. for test specifications in Specs²/ScalaTest, routing in Spray and query construction in Squeryl. While immensely useful, the budding DSL designer will quickly realize that there are precious few resources on how to approach DSL construction in Scala; the techniques, limitations and workarounds are not well understood or documented. In this talk I'll attempt to summarize lessons learned from reading, extending and designing Scala DSLs in the hopes of saving future Scala library designers a world of pain.
Quickie: Adding social login to a website using Spring Social
Handling user registration and authentication on a website is hard, both for the users required to remember yet another pair of username/password and for developers implementing a secure handling of the user credentials. With requirements of more sophisticated login-methods such as two-factor authentication and single sign-on it gets even worse. A few years ago websites started to use social login, i.e. delegating the sign in process to social network services such as Facebook, Twitter and Google+.
Initially social login was rather complex to setup and a number of commercial offerings evolved to simplify the setup. Today a free and open source based alternative exists, the Spring Social project.
This presentation will describe how Spring Social can be used to setup social login.
Presentation: Advanced Java Unit Testing with Spock
The Spock unit testing framework is on the verge of a 1.0 release and has already proven to be the next-generation thinking on how to test Java production code. Using Spock is hands-down the best way for developers to mock and test Java applications. One of Spock?s great features is the ability to write your own custom extensions. This session is a fast-paced (not for beginners), code-centric overview of how to use the advanced features in Spock, including custom extensions and interceptors.
Presentation: Asynchronous Java in a Microservices World
One of the ways that microservices architectures differ from monolithic architectures, is that they add latency to request processing. This has consequences for what techniques you need to use when writing highly performant code. In particular, you need to do more things asynchronously. This talk covers some of my learnings from six years of working with asynchronous microservices and gives you some advice about how to choose a the right tool for the job. Tools and libraries covered: Guava, RxJava and Spotify's Trickle (which I am one of the authors of).
Presentation: Be a better developer with Docker: tricks of the trade
The talk will teach developers how to approach their development environment setups using Docker, covering awesome tricks to make the experience smooth, fast, powerful and repeatable. The talk is logically divided in three parts. Why Docker makes developers happier, Workflows and techniques and tips and tricks.
The topics covered will be a selection amongst. Dockerfile caching concepts, Sharing folders into containers, Transparent tunnels, dynamic ports for your apps, Tiny Core Linux (the secret horse to super fast container automation) and heap orchestration tricks.
Presentation: Be Agile, Code, & Do DevOps--Completely in the Cloud!
Software development teams are looking for faster, easier ways to get their jobs done. They don't want to worry with infrastructure or installing software--they just want to code!
In this presentation, Lauren will explain (and demo!) how you can leverage Software as a Service (SaaS) and Platforms as a Service (PaaS) to develop applications in the cloud without having to install any software on your devices. She'll demonstrate how you can use Agile planning tools, code in the cloud, and set up automatic deployments (DevOps!) to collaborate with your teammates completely in the cloud.
You know beautiful code when you see it. But what about lots and lots of beautiful code; is it still beautiful at a distance? "Structure" is how all the snippets of code are organised into containers (methods, classes, packages, jars, etc.) and how the containers relate to each other. The same code can be organised into anything from a hopelessly tangled mess, to a Beautiful Structure.
This talk will explore how "locality of relationship" affects coupling, cohesion, and the width of interfaces. It will show how some structural patterns dramatically increase complexity, and how alternative patterns can massively decouple and simplify. The structure of open-source Java projects (such as the beautifully-structured Spring framework) will be used to illustrate the principles.
In difference from all success stories spoken at conferences, this is the true story from a developer's life. The life where projects goes wrong, where budget runs out, where deadlines are missed and where suppliers get kicked out the door. In the past years I have been in several failing projects and this session will point out the similarities between the projects, sum up what mistakes we did, what we should have done different and not the least how we could fail even though we used Java, scrumboards, planning poker and demos.
Is there life after Java 9? Most definitely! This session will offer a highly-speculative sneak preview of advanced features currently in development for the Java language and virtual machine.
One area that had always caught my attention in technology is how people interact with software applications. Using hand gestures is the most basic of all forms, but it has been missing for so many years. Finally we have a very cool technology available: the MYO wristband from Thalmic Labs. Join this session and learn how I'm incorporating Java into the MYO paradigm and how I'm using it to control a diverse type of applications, from wearable solutions to desktop apps.
From 2015 and onward, everyone wants their product to be connected. But building a connected product involves deep technical challenges in many areas: from electrical engineering, firmware development, wireless connectivity, to cloud partitioning, server software, and smartphone app development. We're going to look at how fight these challenges to get your product connected.
Presentation: Building Amazing HTML5 Apps with Sencha GXT
Sencha GXT (Ext GWT) is an open source, enterprise-class UI framework based on GWT for building amazing HTML5 apps using Java. Sencha GXT provides out-of-the-box support for high-performance widgets, feature-rich templates, layouts, advanced charting, data loaders, stores, and much more, for building the most complex user interfaces with ease. The core advantage of using Sencha GXT is development time savings, allowing you to concentrate on building the desired functionality as opposed to underlying framework complexities.
This session provides an overview of the Sencha GXT framework and explains how to get started with Sencha GXT in Eclipse or IntelliJ. In addition, we'll take a quick peek at super dev mode support in GWT 2.7.0.
Presentation: Building Microservices with Spring Cloud and Netflix OSS
Microservices? A thing? Or hype? What does it mean in practice? The answer, like so many Facebook statuses, is complicated. In broad strokes, microservice offer a refreshed approach to application architecture. Microservices are a new way to describe many of the patterns that have fallen out of large-scale applications in practice over the recent years. There is no doubt that the approach works. The question is: how does one build a microservice architecture? Join Dave Syer for this session introducing Spring's support for building microservice architectures, including both Spring Boot, and the new Spring Cloud project incorporating Neflix OSS.
Presentation: Building responsive Web apps with Go, Polymer and Google Cloud Platform
The Go programming Language continues to gain momentum amongst developers and is becoming extremely popular on Google App Engine. In this session will show how you can use the App Engine Go Cloud endpoints library to build from scratch, a service that exposes backend application functionality via a RESTful API running on the Google API infrastructure used to run Google's own APIs. We'll then look at how you can design and build a responsive frontend application that consumes this newly created API using Polymer and Web Components. We will also demonstrate how we used Web Components to build an interactive frontend for an existing Go application, the Kubernetes Container Cluster scheduler
Software engineers everywhere are looking for faster, easier ways to get their jobs done. They don't want to worry with infrastructure or installing software--they just want to code!
In this hands-on lab, attendees will learn how they can leverage Software as a Service (SaaS) and Platforms as a Service (PaaS) to develop applications in the cloud without having to install any software on their devices.
Bring your laptop or tablet and get ready to code! Attendees will improve an existing application as they track their work, file defects, update the application's code, and see their application running live. They will also have the option of setting up automatic deployments, so they can see DevOps in action!
Traditional concurrent development on the Java Platform requires in depth knowledge of threads, locks, and queues. Fortunately, new languages and frameworks that run on the Java Platform 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 the Spring Framework.
Creating automated end-to-end functional acceptance tests is hard. Maintaining them over time is harder. Some agilistas even claim that the cost outweighs the benefit. In this lecture we present five principles for creating valuable, maintainable acceptance test suites. We discuss practices such as layering acceptance tests to reduce coupling between the test harness, and talk about how teams should be organized in order to efficiently manage acceptance test driven development. The core of the talk discusses how to manage the evolution of acceptance tests by organizing them as scenarios rather than as suites of story tests. Finally we show how to manage data for acceptance tests.
Presentation: Creating Our Robot Overlords: Autonomous Drone Development
Who wants a mindless drone? Teach it to "think", and it can do so much more. But how do you take it from Toy Story to Terminator? This session's speaker discusses a new open source library, Autonomous4j, for autonomous drone development. Combining this library and some components from their mad science toolkit, they demonstrate how to get your Internet of Things off the ground and do some real cloud computing. In the session, you'll learn how to write an autonomous drone program with Java 8; deploy it to the drone's "positronic brain," an onboard Raspberry Pi; have the Pi guide an AR.Drone to accomplish a task; monitor it via a JavaFX console; and create your own robot overlord. Demos are included: you've been warned!
Quickie: Debugging the hell out of your HTML5 App with NetBeans
NetBeans has silently converted to a top notch HTML5 / JavaScript IDE. Live debugging in Chrome, responsive previews, live CSS and DOM Inspectors make web development an immersive experience. Join this session to learn how NetBeans can simplify your life as a developer.
Does your application deployment rely on an unhealthy amount of shell scripting glue code? Start encapsulating your application and its runtime environment in Docker containers. This talk will give you a brief introduction to the concepts behind Docker and a handful of tips to get you started on the exciting journey towards a more robust and reliable application deployment. By the end of the talk you will have learned how to build and deploy Docker images, how to let your containers talk to each other and why the JVM and Docker are a perfect match.
There is no doubt that Docker has made containers a dev shop topic of conversation. The challenges is after learning how to use docker on your local machine, everyone asks the same question. "How do I scale this into production?".
This tutorial will walk through the development steps of using docker using your favorite web application platform. The tutorial will continue with either a local virutal machine or a cloud setup on EC2 or Google Cloud Platform provisioned with Apache Mesos. Techniques covered in the tutorial will include:
- Building a Docker container
- Setting up a private Docker Repository
- Setting up an Apache Mesos Cluster
- Deploying Docker into a Docker
- Scaling to multiple instances
- Load balancing behind HAProxy
- Service Discovery
Presentation: Dukescript, put Java into JavaScript
HTML5 has won the race for the most interesting rendering technology, but with JavaScript it?s hard to write maintainable applications. DukeScript solves this problem by simply replacing JavaScript with Java. In this session, you?ll learn how you can program in Java, render in HTML5, and deploy to any device, from a desktop to an iPhone or Android Device. You can either use our existing APIs enabling modern architectural UI patterns such as MVVM via the Knockout API, or immediate mode rendering via the Canvas API, but you can also create your own APIs very easily and utilize existing JavaScript libraries hidden behind a type-safe Java API.
Presentation: End-to-end IoT solutions with Java and Eclipse IoT technology
The Internet of Things market is poised for exponential growth, but there are still lots of barriers that prevent building a real open Internet of Things.
Over the last few years, Eclipse has been growing an ecosystem of open source projects for the Internet of Things that are used in real-world solutions, from smart gateways bridging sensors to the cloud to device management infrastructures or home automation systems.
Java is a key enabler for the Internet of Things, and this session provides you with a concrete example of how to build an end-to-end solutions with the Eclipse IoT Java stack and projects such as Kura, Paho (MQTT), Californium (CoAP) and Concierge (lightweight OSGi implementation).
Presentation: Event-sourced Architectures with Akka
Different JVM languages lead to different architectural styles. We all know the typical three-tiered architecture and its limitations. Akka and Scala offer event-sourcing. Event-sourced apps model all state changes explicitly and store them immutably. The actor model makes this horizontally scalable. Even better are the functional benefits: a provably correct auditlog and creating new views on past data.
This session introduces the event-sourcing concepts. You?ll see how well they map onto actors. To prove this, we show an event-sourced application using Akka. The new Akka Persistence module provides excellent building blocks. Want to learn about the next generation of scalable architectures on the JVM? Check out event-sourcing with Akka!
Presentation: Everything you wanted to know about writing async, high-concurrency HTTP applications in Java, but were afraid to ask
Facing tens of millions of clients continuously downloading binaries from our repositories, we decided to offer an OSS client that natively supports these downloads.
In this talk we will share the main challenges in developing a highly-concurrent, resumable, async download library on top of Apache HTTP client. We will cover other libraries we tested and why we decided to reinvent the wheel. We will see important pitfalls we came across when working with HTTP and how using the right combination of techniques can improve performance by a magnitude. We will also see why your initial assumptions may completely change when faced with other players on the network.
Consider yourself forewarned: lots of HTTP internals, NIO and concurrency ahead!
The functional programming style fits the event based development paradigm of Vaadin very well. This presentation explores how the functional features of modern JVM languages combine with Vaadin to allow you to write more clear UI code. After introducing the tools and concepts we start with a short Vaadin UI written in Java 7. Next, we evolve it step by step using the capabilities of Java 8 and Scala to demonstrate the benefits of each. We will also see how Vaadin makes it easy to utilize the functional reactive approach in your user interface logic.
No prior experience of Java 8, Scala or Vaadin is needed to follow the presentation. A basic understanding of Java and interest in the functional approach are sufficient.
Hands-on Lab: Go With The Flow: Streams and Lambdas Power Lab
Java SE 8 introduced the biggest changes to the Java platform since its launch nearly 20 years ago. The two main features are Lambda expressions and the Streams API. When combined these features provide a more functional style of programming that will be unfamiliar to many experienced Java developers and requires a different way of thinking when designing solutions to problems.
This lab provides a range of exercises intended to get attendees thinking differently about the approach they take to common bulk operations on collections. The exercises will start with simple introductory type problems and work up to complex, more real-world scenarios. An introduction will be given at the start of the lab to set the scene in terms of the features used and will conclude with the solutions
Hands-on Lab: Going Wearable: Java, Raspberry Pi, and Cool Peripherals
This session's presenters say, "In the last couple of years, we have been running the Java and Raspberry Pi hands-on lab. Due to the popularity this lab has always showed, we have decided to continue with it, improving and bringing new challenges for our developers. Given the big interest in the Internet of Things, we have decided to move it even further...vto wearable technology. For this lab, we are bringing an intelligent "glove" the attendees of the lab can program and play with. The glove includes some bend sensors, gyroscopes, accelerometers, and other interesting sensors, already attached to the Raspberry Pi. Come join us in this trip, where only your imagination is required!?
This workshop will cover everything from messaging basics to advanced messaging techniques leveraging Enterprise Integration Patterns. In addition, the workshop will include a demo that can be turned in to a hands-on exercises using Apache ActiveMQ and Camel. Get the Messaging Workshop Materials
Terrifying and fun both describe our head-on rapid transformation towards a microservice architecture. We will give you a live report from the trenches with our main choices, mistakes and takeaways concerning design principles, orchestration, ownership etc.
SVT interactive is expanding rapidly which increases the complexity rapidly and increase the demands on modularisation. How do you at the same time keep a culture of freedom, experimentation and innovation.
HTML5 is a tricky subject. When we started with it, it was heralded as the solution to everything and the new amazing thing. When we started using it, we realised very soon that not every browser and
environment was ready for it yet. Thus we started relying on abstractions which now are in the way of fast, memory-efficient and above all, good looking apps.
In this talk Chris Heilmann will get us up to speed as to what can be safely used across browsers, how to decide what cool new technology to support and which one to maybe wait for a bit until they are supported by browsers without us as developers having to jump through hoops.
If you are frustrated by HTML5, this is a good talk to get you happy again. You'll learn how to use some of HTML5's features in ways you don't expect
Husqvarna Group, with its Brand Management structure holding Gardena, Construction, Husqvarna and the Consumer Brands, has set the Connectivity Hub in place to care for synergies, strategies, innovation and planning when now collecting already ongoing initiatives, and as a Group heading into a field of IoT and connectivity.
As for any product producer this is of course a challenge in terms of having little previous experience of digital materials, and few IT systems of the kind needed, but also in terms of at all engaging an IT organization with product development processes. However Husqvarna is now fast moving towards providing both consumers and professionals with interesting and intelligent outdoor services, products and tools.
I will present a fairly simple web application, written using standard Java frameworks and libraries. What makes this application special is that it contains 8 different Permanent Generation memory leaks. They all are pretty standard, nothing obscure or weird. Each of them has a high chance to exist in your application as well. In fact the chances are so high I can bet a beer on the outcome.
I will describe each of these leaks explaining why this particular code leaks class loaders. I will also reason, if this was a deliberate technical decision and/or the implementation was just sloppy. I will also show how to fix it.
Presentation: Immutable Infrastructure generation: the new App Deployment
App deployment and server setup are complex, error-prone and time-consuming. They require OS installers, package managers, configuration recipes, install scripts, server hardening and more. But... Is this really necessary?
What if we could start over and radically simplify all this? What if, within seconds, we could wrap our app into the smallest machine required to run it and transfer this machine unchanged from our laptop to the cloud? How do the various platforms and tools like AWS, Docker and Boxfuse fit into this picture? When should you use them?
This talk is for developers and architects wishing to radically improve and simplify how they deploy their applications. It takes Continuous Delivery to a whole new level. Welcome to Immutable Infrastructure. This is the new black.
Hands-on Lab: Infrastructure Automation with Gradle and Puppet
Infrastructure-as-code is becoming a mandatory part of any successful project.
During this presentation we will show how to use Gradle plugins and Puppet manifests
to provision and maintain consistent infrastructure configuration. We will
also touch tools like Jenkins, Vagrant, Packer, VirtualBox and AWS.
It is advised to have laptops with at least 8GB for this workshop.
During last years we accumulated a lot of experience helping our clients
automating their JVM projects starting from automated deployments and ending
with fully automated production infrastructure configuration.
I would like to share this experience in a workshop.
AngularJS is one of the most popular frontend frameworks out there right now. If you haven't tried it yet, prepare to be amazed! Here's what we'll cover:
1. Templates/Expressions - Your View
2. Module - Your app's namespace
3. Directives - DOM Interface
4. Filters - Display utils
5. Scope - What on earth is this thing!?
6. Controllers - The View Model
7. Services - Common utilities
8. Working with third-party modules
9. Routing - Single Page App with state in the URL
10. Firebase & AngularFire - A full web application with no server setup required!
We'll be following through a repository hosted on GitHub. There's a branch for each concept, so you can play around with the code and then catch right back up with the next branch. So come on, and let's learn AngularJS!
Bluetooth Low Energy or BLE (not to be confused with Classic or High Speed Bluetooth) is a relatively new technology. It has already gained considerable adoption in the last few years. BLE was designed from the ground up to be small in size, cheap, low power and compatible with a large installed base of mobile phones. These days BLE is finding its way into everyday things like light bulbs, door locks, watches and even tooth brushes.
This session will introduce BLE to people who are new to this technology. Focus will be on core concepts and tools which will help mobile developers and hardware hackers to build and test BLE enabled apps and devices.
Presentation: InvokeBinder: Fluent Programming for Method Handles
The MethodHandle API provides a powerful way to build optimized function pointers that do a wide variety of call-path adaptations. Unfortunately, the API as designed requires mental contortions to write anything more than trivial handle chains by hand. Adaptations must be made backwards from the target, argument-list modifications are done by index and length, and debugging failed adaptations can be a terrific challenge. InvokeBinder seeks to make method handles fun and easy to use by providing a fluent API, building adaptations from the call forward, allowing argument-list manipulation by name and wildcard, and much more. We'll explore everything InvokeBinder does today and talk about improvements for the future.
What do magicians and programmers have in common? They are good at juggling, have very nimble fingertips, often make things vanish, and have lovely assistants! Ok, so maybe not all of those describe your average hacker (unless your pair programmer partner happens to be Penny), but we are going to try to put on the most spectacular magic show that has ever been seen on the stage at a tech conference! [geeks only]
As proper geeks, we are going to make heavy use of embedded wearable and internet connected devices to make up for our lack of dexterity and supernatural powers. Also, all tricks will be revealed with the designs available to reproduce in the spirit of open source and creative commons. Come join us to see for yourself what real [hacker] magic looks like!
Presentation: Is it possible to secure micro-controllers used within IoT?
With the introduction of micro controllers such as the Arduino, Raspberry Pi and BeagleBone ? it has become easy to connect sensors to gather information and utilise network connections to build an IoT ecosystem. Strong encryption schemes like RSA/AES/SHA and ecliptic curves cryptography (ECC) have been difficult to introduce due to limited performance and memory capabilities of the micro controllers used and using standard libraries just isn?t feasible - we find that designated and optimised software is the only feasible way forward.
Come hear about how IBM's J9 JVM approaches MethodHandle compilation. The MethodHandle architecture and the transitions from interpreted to compiled and finally to customized will be described. Recent performance optimizations will be touched on along with hints on how to aid the JVM to optimize your MethodHandle code.
Everyone is talking about Lambdas and as they maybe the bee's knees but they're not the only new thing in Java 8. This talk will look at the *other* new features such as the replacement of Permspace with Metaspace, the restructuring HashMap, @Contended and shiny new tools that can give you better insight when troubleshooting your application.
Java 8 is here! Now the honeymoon period is over larger companies and innovators are starting to use the new features. However, Java 8 isn't just another version of Java, it fundamentally changes how you are able to approach problems. This tutorial session will help bootstrap your learning of two of the fundamental changes, lambada and streams. That is the introduction of functional programming and how we freely switch between OO and functional style of programming. The session will introduce each of the libraries building on practical applications from two bestselling Java 8 authors.
Java 9 will introduce a standard module system to the platform in order to modularize the platform itself, improve performance and security, and simplify the development and maintenance of large applications. This session will explain how these changes will impact all developers, and also bring significant benefits.
Quickie: Java EE 7 Batch Processing in the Real World
This talk will explore one of the newest API for Java EE 7, the JSR 352, Batch Applications for the Java Platform. Batch is found in nearly every industry when you need to execute a non-interactive, bulk-oriented and long running operation task. A few examples are: financial transactions, billing, inventory management and so on. The JSR 352 specifies a common set of requirements that every batch application usually needs like: checkpointing, parallelization, splitting and logging. It also provides you with a job specification language and several interfaces that allow you to implement your business logic and interact with the batch container. We are going to live code a real life example batch application, starting with a simple task and then evolve it using the advanced API's.
Java EE 8 is going to be the next major release of the Enterprise Java platform. This is going to add support for latest web standards, further simplification of programming model, and add support for cloud infrastructure. JSR 371 has been filed to add support for action-based Model-View-Controller. JSR 367 will provide standard binding between JSON and Java objects. CDI 2 is proposing to split the specification into two parts, one for core CDI and other for Java EE integrations. Servlets will go through a major revision in JSR 369 and add support for HTTP/2. JAX-RS 2.1 will add support for HTML5 Server-sent Events. Several improvements from Java SE 8 platform such as repeating annotations and Date/Time API will be leveraged. This session will provide an overview and status of Java EE 8.
In this lab the attendees will learn how to use the Java Mission Control tool and especially Java Flight Recorder. We will look at how to create flight recordings and how to analyze them to find potential performance problems. Problem areas include Excessive GC, Synchronization problems and finding execution hotspots
Presentation: JCache is here. Say Goodbye to proprietary Caching APIs!
JCache API (JSR-107) has been released in March 2014. For the first time since initial release of Java we have a standardized vendor-neutral API for caching. What does it mean for developers and why we should care? Isn't this yet another bloated & hard-to-use abstraction? This talk will introduce concepts and structures JCache is based on. I will show how to deal with differences in underlying implementations, how migrate from existing proprietary caching APIs to JCache and how to avoid common pitfalls.
Learn how to take part in Java technology evolution through the Java Community Process (JCP) program. You can participate as an individual, corporation, or nonprofit such as a Java user group (JUG). This session gives you step-by-step instructions on how to participate in the JCP Program, the Adopt-a-JSR program and provides tools for running JUG events as part of the Adopt-a-JSR program. We will discuss details such as how to run hack days, translate content into local languages, and collaborate with other JUG leads on Adopt-a-JSR activities. In addition, highlights of use cases from JUG hack days and events leading up to and contributing to Java EE and Java SE JSRs will be shared.
9.00-9.45
JVM implementation challenges: Why the future is hard but worth it
In this session, John Rose (Oracle's JVM architect) will offer a peek into the OpenJDK projects, including Valhalla and Panama, which are experimenting with new "superpowers" for future versions of the JVM. These include value types and new arrays, plus new optimizations of existing features, such as invokedynamic and lambda streams. Specific emphasis will be placed on deep technical challenges confronting JVM implementors, and the implications of overcoming those challenges. Despite a frank look at some prickly problems, John hopes to leave you excited about using a JVM technology that has never been more vibrant, and will continue to power the renaissance of polyglot programming.
10.00-10.45
InvokeBinder: Fluent Programming for Method Handles
The MethodHandle API provides a powerful way to build optimized function pointers that do a wide variety of call-path adaptations. Unfortunately, the API as designed requires mental contortions to write anything more than trivial handle chains by hand. Adaptations must be made backwards from the target, argument-list modifications are done by index and length, and debugging failed adaptations can be a terrific challenge. InvokeBinder seeks to make method handles fun and easy to use by providing a fluent API, building adaptations from the call forward, allowing argument-list manipulation by name and wildcard, and much more. We'll explore everything InvokeBinder does today and talk about improvements for the future.
11.15-12.30
Proxy 2.0 - Behind The Scenes
One problem people that implement dynamic languages on the JVM have is the integration between their dynamic language and Java. This problem can be decomposed in several sub problems, some are easy like how to call a Java method from the dynamic language, some are harder like calling a function/method of a dynamic language inside Java or how to inherit/implement a Java class/interface inside the code of a dynamic language. Proxy 2.0 is a small library that aims to give a simple answer to these problems freeing people that implement dynamic languages from these problems thus lowering the bar to implement a dynamic language on top of the JVM. The code is freely available here: https://github.com/forax/proxy2
13.30-14.15
Patterns of VM design
The popularity of dynamically typed programming languages has been skyrocketing in the past years. This success can be partially attributed to the advances in VM engineering enabling efficient execution of those languages. Just like boilerplate of any enterprise application can be decomposed into infamous patterns of object oriented design, efficient virtual machines running dynamically typed languages seem to consist of reimplementations of common patterns of "VM design". These patterns often tread the thin line between efficiency, development time and maintainability. This talk discusses the trade offs we encountered while building virtual machines for JavaScript and Dart programming languages.
14.30-15.15
J9's MethodHandle compilation pipeline
Come hear about how IBM's J9 JVM approaches MethodHandle compilation. The MethodHandle architecture and the transitions from interpreted to compiled and finally to customized will be described. Recent performance optimizations will be touched on along with hints on how to aid the JVM to optimize your MethodHandle code.top of the JVM. The code is freely available here: https://github.com/forax/proxy2
15.45-16.30
Nashorn: Implementing a dynamic language runtime on JVM in 2015
Oracle's Nashorn JavaScript runtime has served as the proving ground for new approaches for implementing dynamic languages on top of the JVM. Our challenges included static type inference over a dynamic language program, liveness analysis, cutting up methods too large to fit into a single JVM method, on-demand compilation of multiple type-specialized function variants, and the most exciting: generating code with optimistic type assumptions and gradual stabilizing deoptimizing recompilation, with on-stack-replacement of code, all with the goal of approaching native runtime performance. I'll talk about details of these achievements, as well as our future plans. We want to distill these into a reusable dynamic language implementer's toolkit to put this into the hands of the developer public.
Presentation: JVM implementation challenges: Why the future is hard but worth it
In this session, John Rose (Oracle's JVM architect) will offer a peek into the OpenJDK projects, including Valhalla and Panama, which are experimenting with new "superpowers" for future versions of the JVM. These include value types and new arrays, plus new optimizations of existing features, such as invokedynamic and lambda streams. Specific emphasis will be placed on deep technical challenges confronting JVM implementors, and the implications of overcoming those challenges. Despite a frank look at some prickly problems, John hopes to leave you excited about using a JVM technology that has never been more vibrant, and will continue to power the renaissance of polyglot programming.
Presentation: Lessons Learned from Real-World Deployments of Java EE 7
Java EE 7, released over a year ago, introduced several new technologies such as WebSocket, Batch, and JSON. There are already three compliant application servers: WildFly, GlassFish, and Tmaxsoft. NetBeans, Eclipse, and IntelliJ provide extensive tooling support for the APIs. What are the best practices for building and deploying Java EE 7 applications? What to do and not to do? This session takes three Java EE 7 applications running in production and shares lessons learned from each one. It attempts to answer questions such as Is WebSocket ready for production? How do we migrate from Spring Batch to JSR 352 batch? Any change in DevOps? Are additional libraries still needed? Which is more prominent, EJB/JSF or REST/JavaScript?
Quickie: Making The News, One Small Microservice At A Time
News websites used to be big monolithic systems, tightly coupled to a big monolithic CMS. But as the world of online news has gotten more complex, that's just no longer enough. This is the story about how Aftonbladet, one of the world's leading news sites, is transforming the architecture from a few big Java monoliths into a network of microservices.
You'll get a quick history of Aftonbladet's architecture, and the reasons why microservices is the way forward. We'll touch on the key components that enables a microservice mindset, the importance of an asychronous flow, life in a polyglot environment, testing, the challenges and hard lessons learned, and the (mostly open source) tools used.
Oracle's Nashorn JavaScript runtime has served as the proving ground for new approaches for implementing dynamic languages on top of the JVM. Our challenges included static type inference over a dynamic language program, liveness analysis, cutting up methods too large to fit into a single JVM method, on-demand compilation of multiple type-specialized function variants, and the most exciting: generating code with optimistic type assumptions and gradual stabilizing deoptimizing recompilation, with on-stack-replacement of code, all with the goal of approaching native runtime performance. I'll talk about details of these achievements, as well as our future plans. We want to distill these into a reusable dynamic language implementer's toolkit to put this into the hands of the developer public.
Presentation: Ninja Tricks for Groovy System Scripting
Do you write Bash, BAT, Python, Ruby, Perl, Lua scripts for system administration and scripting purposes? Stop! You don't have too. Since JVM ecosystem has a perfect answer - Groovy. With the release of version 2.3, Groovy is a mature and stable language that can be employed to deploy small scripts or to build large, mission-critical applications. This talk focuses on some less-known features of the language that are going to make the life of a Java/Groovy developer more fun than ever. In particular, this presentation will cover system administrator scripting toolkit that developers can take full advantage of: I/O operations, mini-DSLs, comparison to other languages like Python and Bash.
WebSocket provides a rich and powerful communication channel where client and server cancommunicate with each other in a standard way.
Would you like to learn how to build WebSocket applications in Java ?
How and where do you deploy these applications ?
What are the concerns around firewall, DNS and routers ?
How do you debug message exchanges ?
What to do if WebSocket is not supported in the browser or app server ?
Debugging and Production tips ?
Learn about phantom WebSockets.
This uinversity session is for you! Here is what we'll cover:
- Introduction to WebSocket
- WebSocket using JSR 356
- WebSocket using Undertow/WildFly
- WebSocket using Atmosphere
- Surviving Firewall and Proxy
- WebSocket Debugging
Have you ever used an open source project? Of course you have, but have you made any contributions yourself? Filed a bug report? Submitted a patch? Have you ever started your own OSS project, or taken a closed/private project public? What licenses should you use? How do you manage contributions? How do you encourage contributors and get work done? In this talk we'll go over the basics of OSS: how to get involved, how to start a project, how to manage contributions. We'll discuss project lifecycles, legal CYA tips, and how to keep projects moving. You'll see the inner workings of real OSS projects, and learn how to be a better OSS user and producer.
The popularity of dynamically typed programming languages has been skyrocketing in the past years. This success can be partially attributed to the advances in VM engineering enabling efficient execution of those languages. Just like boilerplate of any enterprise application can be decomposed into infamous patterns of object oriented design, efficient virtual machines running dynamically typed languages seem to consist of reimplementations of common patterns of "VM design". These patterns often tread the thin line between efficiency, development time and maintainability. This talk discusses the trade offs we encountered while building virtual machines for JavaScript and Dart programming languages.
Presentation: Pipes Were a Great Idea, But What Comes Next?
This talk is about how we connect programs together. I'll talk about composing complex systems from simple parts. Simple things are easy to make, but complex things made by composing simple things are very difficult to build. It talk about why this is so, and what we can do about it.
In this talk, I'll visit monads, pipes, protocols and contracts. Finally I'll suggest some ways to glue things together that provide stronger guarantees of consistency than many of the methods we use today.
Presentation: Pragmatic Functional Refactoring with Java 8
You may be hearing a lot of buzz around functional programming. For example, Java 8 recently introduced new features (lambda expressions and method references) and APIs (Streams, Optional and CompletableFutures) inspired from functional ideas such as first-class functions, composition and immutability. However, what does this mean for my existing codebase?
In this talk we show how you can refactor your traditional object-oriented Java to using FP features and APIs from Java 8 in a beneficial manner.
We will discuss things like: How to adapt to requirement changes using first-class functions. How you can enhance code reusability using currying. How you can make your code more robust by favouring immutability over mutability. How you can reduce null pointer exceptions with Optional
We live in an uncertain world and we deal with this by considering possibilities and probabilities; from what movies you might be interested in to what diseases you might have given your symptoms. But what is probability, how to we measure and work with it? Given the wealth of big data collected how can we use that to predict the future? What if there is noise in the data? What if the data changes over time?
We start with the fundamentals of probability theory before looking Bayesian systems (frequently a key part of recommendation and expert systems), Markov chains (useful in predicting human behaviour), and dynamic Bayesian networks (such as Kalman filters and hidden Markov chains which are often used in real-time systems like auto-pilot navigation).
Keynote: Programmers are way cooler than musicians
Programmers are the wizards of our age. We weave the fabric of the modern society, tell the stories and bring dreams to life. Geeks are ruling the world of today and programmers make it all happen. The uninitiated marvel at what we accomplish without an inkling about how everything comes to fruition. Many centuries ago, musicians held a similar role in society but today they have lost that grasp on the world. Programmers are in an unprecedented position in which we can not only make a good living, but fuel our work with passion, creativity, collaboration, innovation, and forward thinking. Programmers can make a significant difference in a world that is truly our oyster, and that is worth celebrating.
How do we get our software out on the Internet of Things? Many assumptions in current deployment practices don't hold up. Devices can be occasionally connected, through low-bandwidth networks and are generally outside of direct control. Manually shuffling around binaries is not an option.
Apache ACE is an open-source Java provisioning tool tackling such challenges.You can manage Java apps and configs in a modular fashion. The foundations of ACE are OSGi, semantic versioning and reliable communication. Pushing out incremental updates and managing numerous devices becomes possible.
We'll show an example where a fictional car-entertainment system is updated and extended using ACE. Although the talk focusses on IoT, the mechanisms demonstrated applies to environments like the cloud too.
One problem people that implement dynamic languages on the JVM have is the integration between their dynamic language and Java. This problem can be decomposed in several sub problems, some are easy like how to call a Java method from the dynamic language, some are harder like calling a function/method of a dynamic language inside Java or how to inherit/implement a Java class/interface inside the code of a dynamic language.
Proxy 2.0 is a small library that aims to give a simple answer to these problems freeing people that implement dynamic languages from these problems thus lowering the bar to implement a dynamic language on top of the JVM.
The code is freely available here: https://github.com/forax/proxy2
Go reactive with me as I'll get you up to speed on react.js and go through the process of getting started with reactive programming. Learn how to "think in React". This means throwing out the classic MVC pattern, and start re-rendering your entire application everytime your data changes. This a radical approach that requires a new way of thinking when you're developing apps.
In this talk I'll walk you through a demo app which will show you how React components are built, how they operate and how they communicate with each other.
Geared towards providing and consuming REST APIs in high-performance systems, akka-http enhances the increasingly popular Akka toolkit (akka.io) with its own client- & server-side HTTP stack:
- Fully async & non-blocking
- Reactive-Streams "all the way through (reactive-streams.org)
- Flexible and concise, yet powerful and type-safe high-level APIs
- Entirely written in Scala, no external deps
- Deeply typed, immutable HTTP model
- Successor of spray.io
Akka-http delivers an excellent tool for connecting your applications to the world.
In this session we'll look into what akka-http brings to the table, how it is used and how it improves upon previous solutions. You'll learn about best practices, who'll benefit most from its features as well as the roadmap forward.
Presentation: Scalable real-time data processing with Apache Samza
High-volume event streams are becoming widespread: IoT sensor data, activity events on social media, and monitoring events for fraud detection, to mention just a few. Hadoop is great for analysing data after the fact, but it's often too slow to respond to things happening right now. Traditional event processing frameworks are not scalable enough to handle the onslaught of data.
Apache Samza and Apache Kafka, two open source projects that originated at LinkedIn, have set out to solve this problem. They are designed to go together: Kafka is a fault-tolerant message broker, and Samza provides a scalable and powerful processing model on top of it.
This talk will introduce those projects, and explain how you can use them to solve your real-time big data problems.
Presentation: Scalable, Available and Reliable Cloud Applications with PaaS and Microservices
Attendees at this session will discover how a combination of Platform-as-a-Service and a microservices architecture can provide the basis for a scalable, highly available and reliable web application running in the cloud. We'll show how simple it is to take a Java web application and scale it with a Platform-as-a-Service offering such as the open source Cloud Foundry. We will then see how breaking an application down in to microservices can increase the reliability of the application. Specifically, we'll look at using the Netflix OSS projects to isolate and monitor service interactions.
Presentation: Scalaz Stream: Reactive Without the Buzzwords
Scalaz Stream provides a framework for purely functional, non-blocking and IO-heavy applications operating at scale. The underlying principles are profoundly simple and yet scale remarkably well to hard problems, complex applications and high volume. This talk will provide a gentle introduction to Scalaz Stream, covering the fundamentals you need to get started with this powerful tool and also some advanced tricks and techniques derived from extensive use in a complex production application. We will also sneak a little vanilla Scalaz in the backdoor and maybe even see how it doesn't need to be quite so scary!
Presentation: Selfish Purity: How Functional Programming Makes Every-Day Jobs Easier
Functional programming is too-often viewed as an academic discipline. And why not? After all, FP imposes constraints that seem to be more aesthetic and pedantic than practical, and almost all motivating examples for FP involve one-liners mapping over a list while hand-waving about endomorphisms rather than something more "down to earth". This talk takes a different approach.
Functional programming makes things easier. It makes it easier to write code, test code, design components and abstractions. It makes turnaround times faster, bugs rarer and even improves application throughput. This talk explains how all of this is possible and why it is precisely that I will *never* work on a serious application without FP again.
Hands-on Lab: Sensor Networks with Contiki and Java/Eclipse IoT
Join us for an extensive tutorial on sensor networks, involving Contiki on the embedded side, and Java/Eclipse IoT technologies on the server side.
We will introduce the core technologies of sensor networks such as 6LoWPAN, RPL, CoAP, and we will jump on very hands-on examples to get you started with Contiki, an operating systems for the "things" of the Internet of Things, and how to hook your sensors to your backend infrastructure using CoAP and Java.
We will cover many aspects of the development of an end-to-end IoT solution including:
* Setup a Contiki development environment,
* Contiki core APIs,
* Simulation of sensor networks,
* Exposing sensor data using CoAP,
* Bridging CoAP to good ol' HTTP,
* Intro to LwM2M and Device Management.
Sensor networks are the way to go if you have to monitor environmental data such as temperature in a wide area. Usually you need some infrastructure, including servers for communication, data storage, and the like and to manage the network and make the sensor data available. This session shows how you could build a sensor network, including the infrastructure, based on embedded devices only. It uses several embedded devices such as a Raspberry Pi, a BeagleBone Black, a Cubieboard2, and an i.MX6-based Cubox-i. The idea is to use cheap standard devices in combination with Java technology to realize a sensor network. In addition, it shows mobile clients, such as a smartwatch, for visualizing the sensor network data.
Despite the buzz around the Internet of Things (IoT) there are still many devices, systems and protocols for home automation that cannot be directly hooked up to your wifi and used through IP. To enable smartphone apps to access them and to integrate them with other devices, a home gateway is required.
Eclipse SmartHome is a flexible software framework for such home gateways. It was initiated by the popular open-source project openHAB, which connects to a multitude of different systems and comes with powerful automation rules and nice UIs. Its modular architecture guarantees simple extensibility.
This session includes live hacking and you will of course see a smart home live demo that goes way beyond the standard use cases.
Presentation: The Adventurous Developer's guide to Application Servers
There are many application servers on the market today, but which are right for you as a developer? This session looks at the popular application servers?including Tomcat, TomEE, GlassFish, Jetty, IBM WebSphere, Oracle WebLogic Server, Liberty Profile, and JBoss/WildFly?and analyzes them from the point of view of a developer. It focuses on performance, config management, open source compliance, feature richness, tooling, and developer productivity, among others. Come to this session to learn about the main differences between the application servers on the market today and understand which might be best for your needs.
Presentation: The Adventurous Developer's guide to JVM Languages
Today there are over 50 actively worked JVM languages in existence today. Some have been ported to the JVM while others have been written specifically for the JVM. This hands on session with take an introductory (but non hello, world) look at a number of JVM languages including, Java 8, Scala, Groovy, Kotlin, Ceylon and Xtend as well as the tooling support, discussing how and why they came about along with the evolution of the languages and distinguish the innovative languages versus those which consolidate existing features from other languages. We'll cover our initial experiences including what rocked and sucked learning each one with example code snippets of a sample HTTP Server from each language.
You don't need any prior knowledge in these languages to attend the session.
The Internet of Things is here, and its just as big and disruptive as the Web was in the 1990s. Hear what is really happening in the IoT industry, how not to be another American Online, why the Cloud is just as important as Things, the birth of the IoT software ecosystem, and the role that Java is going to play in this space.
We are rapidly entering a world of agents: microservices, internet enabled devices (IoT), bots, and robotics. However, even when acting on simple rules, unexpected, and sometimes disastrous, behaviours can occur. By looking at examples such as the algorithmic trading on stock markets and SmartHomes we will seek to understand "emergent behaviour", how complexity and choas theory can predict the behaviour of these systems, and the practical and pragmatic ways of preventing and limiting the negative effects. The aim is to get developers thinking in a "multi-agent" paradigm, which in a way is the next abstraction level up from multi-threaded design considerations, whether the system comprises fully autonomous or semi-autonomous agents, controlled by a "central AI", or a hybrid of all of these.
Contrary to our intuitions, the execution of our software is far from the continuous and sequential mental model we use when reading and writing code. In this talk we will discuss the gap between this model and the reality of the average Java application:
* Placing the Java process in the stack: HW (real/virtual)/OS/Process
* The other threads in your process
* When the JVM stops (and the promise of a "pause free JVM")
* Open to interpretation: from your code to assembly
* The pause button: Safepoints in your code
* Pointer accounting: store barriers and load barriers in your code
Presentation: The return of Java on the Mobile Client
While the Java Platform was initially targeting clients and embedded devices, the majority of the Java developers today are working on back-end systems. The lack of standardization in the mobile area, and the difficulties to run cross-platform Java applications made it very hard to create a successful Java client business. Today, this is changing. The popularity of the AppStore (for iOS devices) and the PlayStore (for Android devices) and the availability of Java and JavaFX SDK's for those devices allows Java developers to create real cross-platform Java applications. Join this session and learn how the work done by RoboVM and LodgON allows every Java developer to create native applications for iOS and Android.
A BOF for all fans of Spring to talk about the latest and greatest tech, including Spring Boot, the convention-over-configuration centric framework built on top of Spring.
Presentation: Thinking Fast and Slow in Software Development
In the international bestseller 'Thinking, Fast and Slow', Daniel Kahneman explains how we as human beings think and reason, and perhaps surprisingly how our thought processes are often fundamentally flawed and biased. This talk explores the ideas presented in the book in the context of professional software development. As software developers we all like to think that we are highly logical, and make only rational choices, but after reading the book I'm not so sure. Here I'll share my thinking on thinking.
Topics that will be discussed include; the 'Availability Heuristic', which can lead developers to choose the 'latest and greatest' technology without proper evaluation; 'Optimistic Bias' which can blind architects from the 'unknown unknowns' within a project; and more!
Presentation: Unlocking the Magic of Monads in Java 8
This session demystifies what monads are and outlines reasons why you would even want to introduce them into your code. It takes a look at the traditional definition of monads and offers a corresponding type definition in Java. You'll see a sample Java 8 implementation of a 'Promise' monad, which represents the result of async computation, to help answer practical questions about monads. Also, the presentation goes over the laws of monads and shows that you can have a proper monad in Java if you are brave enough to allow the underlying platform to change the rules a bit.
PS: You won't be penalized or ridiculed during this session for your (lack of) Haskell knowledge!
Presentation: Using ReactJS with existing AngularJS codebase
ReactJS is an amazing View library that promises (and delivers) high performance, composability, and maintainability. AngularJS is an amazing MV* framework.
Tons of shops have adopted and totally bought into AngularJS for their entire frontend application. They're loving it, but some are finding that as these applications get bigger, they can become unwieldy, unperformant, and difficult to reason about. Many of these problems can be solved by doing things better with angular, but not all of them.
In this talk, we'll go over why you don't need to re-write your whole application to get some of the wins of React and that it actually is quite easy to integrate the two. We'll talk about where it makes sense to bring in React to an existing Angular codebase and how it works well.
The upcoming web components standard promises encapsulation and isolation between web UI components so that they can be reused. The standard is built on shadow DOM, customer HTML elements, HTML import and CSS sandboxing. While each of these is interesting by its own right, the combination of these tools has a potential to simplify web platform and empower developers building larger applications.
The value proposition is really close to that of component based frameworks like Vaadin: Make building good quality user interfaces easy with a powerful encapsulation.
Let me present you Vaadin X - a new research project that answers what Vaadin has to do with web components. Is Polymer related? How GWT fits in? Which is the right way to go - Java or JavaScript for the user interface layer?
Up until now it was almost impossible to create reusable components for the Web in a reasonable way. In large applications, CSS rules and JavaScript variables would always get in their way. Luckily there is an initiative now to unify techniques to define custom Web Components.
With the help of many examples we will show how you can build your own components. We will explain what the Shadow DOM is and will present tools like Polymer and X-Tag. This talk will give an overview of the current state of technology and a forecast of future development.
Quickie: Welcome and introduction to Jfokus 2015
Quickie: Welcome and introduction to Jfokus IoT 2015
Presentation: What's next for JavaScript? - ECMAScript6 and beyond
The modern web needs a better programming language and at the same time, there is no way the current one could break existing code on the web. The ECMAScript 6 / harmony project solves this problem and specifies compatible, major updates to JavaScript -- the language of the web. A ratified standard of the already feature-frozen ES6 will be published in mid 2015. All modern engines are working on implementing it. This talk looks at what features are coming for JavaScript with ES6 and what is in the makes after that.
Testing JavaScript is hard. When my team first started writing JavaScript tests we almost gave up several times. We struggled with topics such as the DOM, Ajax requests and asynchronicity. After months of practice we had written hundreds of unit and end-to-end tests. The problem was that we were slowing down. Our tests had become a burden. They were complex, difficult to understand and a chore to maintain.
Gradually, through experimentation and trial-and-error we got better. The same way we need to learn how to build large-scale JavaScript applications, we need to learn how to write maintainable, beautiful tests for them.
In this talk I'll share my experience with JavaScript tests, and show the most important patterns we rely on to write simple, beautiful and maintainable tests.
Presentation: Writing for wearables, an introduction to the Android Wear platform
Android Wear is a version of Google's Android operating system designed for smartwatches and other wearables. By pairing with mobile phones, Android Wear integrates Google Now functionality and mobile notificationsinto a smartwatch form factor. It also adds the ability to download apps from Google's Play Store.
The presentation will cover
- What is Android Wear?
- Features, Design Principles, Types of Applications
- Developer Tools, how to get started
- How to extending your existing application to the smart watch
In the presentation I will use one of my published applications, "Food Facts" to show how Android Wear can extend the usability of an existing app. I will go through all tools, setup, code and configuration needed to get you started with wearable development.
Keynote: You don't need another hero app - you need one that survives the Thunderdome
Technical marketing and advertising always tells us about a soon-to-come future where everything is connected at high speed and all our wishes are fulfilled with the swipe of a hand, the wink of an eye or by typing lots of green text on a black screen maniacally. The reality very much lies in the middle of the two. Connectivity will always be an issue and our users are never the parachuting, yacht-owning superheroes we want them to be.
In this keynote Chris Heilmann will show some of the trends in the app space, some of the honest truths we have to face when developing software and how to build for the future of the now rather than the one we'd love to have. Our job as software creators is to build things that work like magic. If our magic fails, our users move on.
Surviving as a zombie is tough... with the constant risks of sunlight, fire, and pesky mobs, doing your job of infecting the local villagers can be deadly. Fortunately, with the new JavaFX ZombieTime app, powered by the JSR 310 Date and Time API, you can rest easy. With built-in time zone and DST support you no longer have to worry about roaming around under the scorching hot sun. Accurately calculate out how long you have to infect the villagers before you decompose using Durations. And coordinate global attacks on the humans by syncing with your undead brethren on Instants. This presentation is designed to teach Java Date and Time APIs to the undead, but the living are welcome to be our "guests".
Spring Boot, the new convention-over-configuration centric framework from the Spring team at Pivotal, marries Spring's flexibility with conventional, common sense defaults to make application development not just fly, but pleasant! Ideal for microservices and for all your distributed systems and devops needs. Join Spring Boot co-lead Dave Syer and Spring committer Stéphane Nicoll for a look at what Spring Boot is, why it's turning heads, why you should consider it for your next application (REST, web, batch, big-data, integration, whatever!) and how to get started.
