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.
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.
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.
In a microservices architecture, it's pretty common to want to build up a response based on a number of responses from downstream services. For performance reasons, you may not want to use threads that do blocking waits on the responses from those services. This type of code gets pretty hard to write using vanilla Java, and this talk would cover some tools and libraries that can help you write it, as well as best practices regarding how to do testing, error handling, etc. 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: 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
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.
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!
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: 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).
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
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.
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!
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.
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
Jfokus VM Language Summit is an open technical collaboration among language designers, compiler writers, tool builders, runtime engineers, and VM architects. We are sharing our experiences as creators of programming languages. We also welcome non-JVM developers on similar technologies to attend or speak on their runtime, VM, or language of choice. We are dividing the schedule equally between traditional presentations 45 minutes and "workshops". Workshops are informal, facilitated discussion groups among smaller, self-selected participants. They enable "deeper dives" into the subject matter.
Space is limited: This summit is organized around a single classroom-style room, to support direct communication between participants.
Jfokus VM Language Summit is an open technical collaboration among language designers, compiler writers, tool builders, runtime engineers, and VM architects. We are sharing our experiences as creators of programming languages. We also welcome non-JVM developers on similar technologies to attend or speak on their runtime, VM, or language of choice. We are dividing the schedule equally between traditional presentations 45 minutes and "workshops". Workshops are informal, facilitated discussion groups among smaller, self-selected participants. They enable "deeper dives" into the subject matter. Space is limited: This summit is organized around a single classroom-style room, to support direct communication between participants.
Presentation: Lessons Learned from Real-World Deployments of Java EE 7
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
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
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.
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.
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.
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.
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.
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".