Developers shouldn't work faster and more effectively, they should work harder. Too much energy is spent learning how to improve and not enough is spend crushing every hour with manual repetitive tasks to get the job done. This tongue in cheek session takes a look at 10 development tools/projects/products, explaining what they do and how they 'supposedly' help your development practices. Fear not, padawans, I'll uncover what these vendors, and project owners don't want you to know about how they're ruining your development environments and rotting your development projects from the core. We'll cover JIRA, Confluence, Tomcat/TomEE, JRebel, XRebel, Arquillian, JBoss Forge, IntelliJ, Jenkins, and Gradle.
Presentation: A horizontal, open standards based network for the Smart Sustainable City
Connode is dedicated to the idea that the IoT should be modeled after the success of the Internet, using open standards and IP to reach all devices. This presentation will give an insight into how large scale RF mesh networks using 6LoWPAN works in some of the largest IoT projects in the world.
Presentation: A Java Implementer's Guide to Better Apache Spark Performance
Apache Spark has rocked the big data landscape, becoming the largest open source big data community with over 750 contributors from more than 200 organizations. Spark's core tenants of speed, ease of use, and its unified programming model fit neatly with the high performance, scalable, and manageable characteristics of modern Java runtimes. In this talk we introduce the Spark programming model, and describe some of our unique Java 8 capabilities in the JIT, fast networking, serialization techniques, and GPU off-loading that deliver the ultimate big data platform for solving business problems. We will demonstrate how solutions, previously infeasible with regular Java programming, become possible with our high performance Spark core runtime, enabling you to solve problems smarter and faster.
Presentation: A JVMs Journey Into Polyglot Runtimes
Java Virtual Machines (JVMs) are now being used to implement runtimes for many different languages. Building on top of JVMs leverages the mature runtime technology resulting from decades of investment and enables great interoperability with Java applications. JVM based implementations are rarely the primary implementations for languages other than Java, possibly because JVMs are primarily built to run Java. While JVM support for other languages has improved tremendously, JVMs still offer a primarily Java focused execution model. This talk will discuss experiments to unlock the underlying internal mechanisms of a production JVM to provide key technologies for non-JVM based implementations of polyglot runtimes.
Project Valhalla proposes to bring value types and specialized generics to Java. In this talk, Java Language Architect Brian Goetz offers some of the highlights of the progress and pitfalls of adding these features to the Java Language and VM.
Presentation: Adventures with concurrent programming in Java: A quest for predictable latency
Concurrent programming with locks is hard. Concurrent programming without using locks can be really hard. Concurrent programming with relaxed memory ordering and predictable latency semantics is said to be only for wizards. This talk focuses on a decade long quest to discover algorithms that provide very high throughput while keeping latency low and predictable. Additionally, they need to provide real-time telemetry on how a system is performing via non-blocking operations.
We will cover some fundamental theory of concurrency and then compare various approaches to the same problem so that we can measure the impact on latency. We'll also show how some of these algorithm implementations get more interesting given the new features in Java 8.
Presentation: An Arduino, an Application, Server, and me - Adventures In and Out Of the Cloud
Presenting the world's first cuddly, throwable application server! Computers are getting smaller and smaller and cheaper and cheaper. It's possible to sock computers away almost anywhere, and to connect almost anything to the internet. This talk will explore the limits of embeddable hardware and present a getting-started-guide to the internet of things. What's needed? How much does it cost? What's the best way of making an embeddable device talk to the internet? And why would you want a throwable application server?
As well as hints and tips, there will be a show-and-tell session (or "demo" if you're discussing with your boss).
Presentation: Arm yourself with Domain Driven Security. It's time to slay some security trolls?
We all know we have Anonymous, LulzSec, and NSA around. With this in mind, isn't it time to think about the security of our systems? Well, of course. In this talk, we'll show how Domain Driven Design is used to counteract security weaknesses without one thinking "security" all the time. So, if you're interested in learning how to design secure software, then this session is for you.
Business and technical attacks are two kinds of attacks, where the latter is most famous, e g SQL Injection & XSS. But it doesn't mean business attacks are less harmful. On the contrary, they tend to be extremely sophisticated and powerful as they often leave infrastructure intact without firing alarms. Domain Driven Security is the field that counteracts both categories by using tools and mindsets from DDD.
Angular 2 introduces a new Data Architecture based on Reactive Programming. We are really excited to see the new approach using Observable sequences aka Observables. Besides, the new HTTP module was just released! We will cover a basic introduction of Angular 2 followed by streams and the new HTTP API covering some basic use cases.
Presentation: Being productive developer using JPA helper libraries
Standard JPA has proved to do the mapping part really well, but quite many JPA developers spend way too much time writing and debugging JPQL/Criteria queries. What if you could just take the good parts of JPA and somebody else would write your queries? Helper libraries like DeltaSpike Data and QueryDSL will help you get there. Using a practical full stack Java EE example, you'll learn to write less queries, write the remaining ones faster and write them so that they work with the first run. DeltaSpike Data helps to write the first version of your DAO in a snap and automatically writes most queries for you, based on your method names only! QueryDSL lets you build your complex JPA queries with an intuitive and well typed API.
Agile planning has always been a hit-and-miss affair. At one end of the scale is the soul-crushing, multiple day workshops whose output is a list of hundreds of detailed features, many of which will never see the light of day. At the other end is the continual insertion of random demands into the product backlog, with the team constantly on the defensive, never knowing what is coming next and forever switching context.
Maybe features aren't the point of delivery after all. Maybe there are other kinds of work that we could recognise, schedule and track as first class citizens. Maybe this could take some of the uncertainty out of the delivery process, and give us back our sanity. Maybe.
As Java developers we are used to having rich ecosystems of libraries and tools that make our lives easier. As of the release of Java 8, we finally got our hands on building blocks like lambdas, optionals, and streams. All sorts of tools that help us write more concise code. But now, when the honeymoon is over, are there any downsides to Java 8 or is it a silver bullet? Are there any new anti-patterns emerging? Or subtle bugs caused by the new style of programming? Have there been any lessons learned? Are there any best practices?
If you are interested in learning about the challenges encountered when moving over to a functional style of Java programming, what code constructs to avoid, and best practices to use, well then this session is for you.
Presentation: Beyond the basics of SonarQube: improve your Java(Script) code even further
SonarQube is (becoming) more or less the standard tool for managing Java code quality. Unfortunately most developers use it just as a replacement for separate Checkstyle, PMD and code coverage tools. SonarQube is capable of so much more than that, over time SonarQube will even replace the Checkstyle and PMD rulesets with their own ruleset.
This presentation will explain a lot of the more advanced features and plugins SonarQube has to offer. The topics include: measuring coverage of a running Java application in an application server, JavaScript plugin, Pitest plugin, compare, measure, code review, hotspots, architectural constraints, package tangle index, PMD rules for unit test quality, incremental analyses and more.
Presentation: Beyond the buzzword: a reactive web application in practice
In this talk / live-coding session we will have a practical look at how a reactive web application is different from a "normal" one and how resilience, elasticity and responsiveness translate into code. We will start by having a quick theoretical introduction to asynchronous computation and then build, run, deploy and load-test a small reactive web application built with the Play Framework, exploring a few key concepts such as Futures, Actors and Circuit Breakers along the way.
Presentation: Bringing The Performance of Structs To Java (Sort Of)
Java is a powerful language and platform and in many cases can match or even exceed the performance of natively compiled languages like C and C++. However, there is one area where this is not the case, which is the use of structs, where machine level optimisations work very well.
To address this, there is an open source project, ObjectLayout (objectlayout.org), which provides an API where pre-fetching and caching can deliver performance gains. The beauty of this approach is that no changes are required either in the Java language or in the JVM. However, the JVM can be modified to use intrinsics when processing the API to improve performance further.
The design and ideas behind the API will be discussed as well as ideas for how the JVM can be enhanced.
Presentation: Building Fault Tolerant Microservices
Despite all efforts to the contrary, faults will occur in our applications. When building an application we must prepare to minimize the faults' impact. This fact is especially evident in a microservices setting where the failure of one service must not be allowed to cascade to other, possibly more critical, services.
This presentation will introduce you to stability patterns such as Bulkheads and Circuit Breakers. We will talk about how these patterns make your applications resilient to faults and how you implement them in a microservices architecture.
Another important component to making your system resilient is the ability to detect and act on anomalies. Hence, we will also discuss monitoring guidelines for a distributed microservices system.
In this session I will walk you through how to build your own retro handheld console that is powered by Java, runs on a Raspberry Pi, and is printed on a 3D printer. Some of the topics that we will cover along the journey include: hacking Java on the Raspberry Pi, rigging input devices with Pi4J, insane performance tuning on the JVM, and why your boss [or SO] needs to buy you a 3D printer!
And of course your retro gaming mettle will be put to the test, so make sure to dust off your old 8 and 16 bit consoles to prepare.
This presentation is about the most fun you can have while still legitimately calling this conference ?work.? In fact, I will hopefully inspire you to do your own creative ?work? leveraging Java and Raspberry Pi to hack the real world.
Every developer needs a set of tools, especially web developers that bend under the pressure of multiple languages, environments, IDEs and what not. One of the most comprehensive tool out there today is Chrome Developer Tools. It contains so many amazing features other than the common ones, and it?s just a shame most developers don?t know about them!
Come to the session to learn about the known and less-known features of Chrome Developer Tools and see how your everyday web development can become easier by just a few simple steps.
Imagine a culture where the input of the whole organization turns an individual idea into a user story in just a couple of hours, where everybody's goal is to make the customer's job easier and more effective, and where you work on projects you love instead of projects you loathe. A great coding culture concentrates on making developers productive and happy by removing unnecessary overhead, bringing autonomous teams together, helping the individual programmer to innovate, and raising awareness among developers about how to create better code.
I will talk about how to establish and foster a strong engineering-focused culture that scales from a small team to a huge organization with hundreds of developers.
Culture matters!
Presentation: Continuous Delivery with Docker Containers and Java EE
Organizations need a way to make application delivery fast, predictable and secure and the agility provided by containers, such as docker, help developers realize this goal. For Java EE applications, this enables packaging of applications, the application server, and other dependencies in a container that can be replicated in build, test, and production environments. This talk introduces the audience to the various concepts and dives into the different delivery models that can be achieved with Java EE servers running in containers. it introduces several different approaches to packaging, deployment and continuous delivery on a full blown, open source middleware stack.
Presentation: Create Elegant Builds At Scale With Gradle
How can medium and large projects use Gradle to scale their build infrastructure? This session looks at organizations such as Netflix and LinkedIn and how they scale with Gradle across hundreds or thousands of developers. It discusses how to solve the challenges of standardization, dependency management, multi-language builds, and automatic build infrastructure provisioning.
Collect lots of data, do something mysterious, make profit! The big data buzz affects everyone. We all have data, and we all have a hunch that we may be able to get something valuable out of it, but the step in between is somewhat foggy, both in terms of engineering and science.-
This presentation is an attempt do demystify the practice of building reliable data processing pipelines. We will go through the necessary pieces needed to build a stable processing platform: data ingestion, processing engines, workflow management, schemas, and pipeline development processes. The presentation will also include component choice considerations and recommendations, as well as best practices and pitfalls to avoid, most learnt through expensive mistakes.
In the summer of 2015, we released JRuby 9000, representing the largest amount work ever put into a JRuby version. The execution runtime has been completely replaced with a new optimizing IR compiler that we continue to improve. The IO and Process subsystems are now doing direct POSIX calls for better UNIX integration. We are caught up on compatibility with Ruby 2.2. This talk will cover the advances we've made and how other projects can leverage and learn from them.
What does it really mean to design software for high-performance? Performance is such a generic and misunderstood subject. In this talk the subject of software performance will be explored. We will focus on what is means to achieve sufficient response times, throughput, and scalability. We will explore the difference between latency and response time and how our industry confuses both.
Once the theory is out of the way we will dig into how modern hardware works and what we need to know about abstractions mapping to our software designs. These abstractions are the key to the models our code represents. The author has not meet many abstraction layers he did not enjoyed violating. There is a good reason for this. So many of our abstractions are leaky or just plain wrong.
Containers are enabling developers to package their applications in new ways that are portable and work consistently everywhere. Docker has become the de facto standard for those portable containers in the cloud. Kubernetes provides an open source orchestration of Docker containers. This tutorial will provide an introduction to Docker and Kubernetes. The talk will explain several recipes on how to create and publish Docker images that package Java EE applications. Design patterns and anti-patterns that show how to create cluster of such applications will be shown. Replicating your environments using Docker images will be shown. Attendees will learn how Kubernetes?s self-healing mechanism can be used to create cluster of these containers.
Presentation: Docker Container Lifecycles, problem or opportunity?
Docker is hot. However, as Docker container use spreads into more mature production pipelines, there can be issues about control of Docker images to ensure they are production-ready. Is a promotion-based model appropriate to control and track the flow of Docker images from development to production?
We will demonstrate how to implement a promotion model for docker images, and then show how to distribute them to any kind of consumer, being it a customer or a data center.
Here is the IoT market, and it's on fire. Here is the App Store and it's hot. Appstore is about software delivery to the customer, and IoT devices need software (and firmware).
So, do we need an App Store for the IoT? There are things that exist in Appstore that IoT doesn't need, and there are requirements of the IoT that App Store doesn't have.
So, will it blend?
Presentation: Easy does it; Simpler IoT app development using JavaScript and Bluetooth
IoT is a sweet-spot for cross-platform JavaScript mobile development. Leveraging open-source projects like cordova-ble and cordova-eddystone, we will show how to easily build cross-platform apps which interact with BLE IoT devices
Presentation: Emul8 - path to continuous integration for IoT systems
The IoT systems of today are not thoroughly tested due to the impracticality of setting up large, distributed device networks physically. Instead, typically work focuses on single nodes or small networks, and testing (if any) is done on a one-off basis, with little repeatability and not including the aspect of scalability.
If we are to practically arrive at many billions of nodes constituting the Internet of Things ecosystem, tools are needed to allow continuous, repeatable, scalable testing methods for embedded IoT nodes on a PC.
The Emul8 open source emulation framework lets you run unmodified binaries of nodes such like ARM Cortex-M on your PC, opening the way to doing continuous integration on a scale previously unknown to embedded systems software development.
Presentation: ES2015: Using tomorrow's JavaScript today!
You don't have to wait to use the next generation JavaScript language until all browsers support it - using transpilation you can start using it today and future proof your code and make it more elegant NOW! See the details for the topics covered.
In this rapid fire, live-coding session, we'll look at the features in ES2015:
arrows
classes
enhanced object literals
template strings
destructuring
default + rest + spread
let + const
iterators + for..of
generators
unicode
modules
module loaders
map + set + weakmap + weakset
proxies
symbols
subclassable built-ins
promises
math + number + string + array + object APIs
binary and octal literals
reflect api
tail calls
Presentation: Events on the outside, on the inside and at the core
This presentation looks at the importance of events and the role that they play in applications. We describe how events are a key application integration mechanism and how they are used by applications to communicate with the outside world. You will learn how the microservices inside a system can use events to maintain data consistency. We discuss how easy it is to implement both of these mechanisms by developing your core business logic using an event-centric approach known as event sourcing.
Presentation: Experiences from integrating 100 things
Internet of Things is changing many aspects of how companies do business and engage with customers. This includes being able to introduce new types of products and services as well as increasing efficiency. But developing professional IoT solutions and integrating all the things often prove to be difficult. There are many obstacles and factors that you need to consider. Connecting a thing means you need to master the skills of hardware, software and networking as well as business processes and user interaction.
In this session Hans will share his experiences from integrating and operating more than 100 different types of device/things/machines such as vending machines, electrical vehicle charging, bus stop displays, sensors, smart homes, RFID/NFC, GPS-tracking and more.
Presentation: Frege: purely functional programming for the JVM
Frege is a Haskell for the JVM. It is the only purely functional JVM language and has a lot of interesting features in that regard. Most of all, it interoperates with Java in a very special manner that doesn't try to mix but combines with the object-oriented world without sacrificing any of its language guarantees in terms of purity. Pure functions cannot possibly have mutable state or any other side effects and are thus the ultimate tool for concurrent and parallel programming. If you ever wanted to see how functional programming looks in its pure form, this session is for you.
As core counts continue to increase, how we exploit hardware parallelism in practice shifts from concurrency - using more cores to handle a bigger workload - to parallelism - using more cores to solve data-intensive problems faster. This talk will explore the different goals, tools, and techniques involved between these various approaches, and how to analyze a computation for potential parallelism, with specific attention to using the parallel stream library in Java SE 8.
Presentation: From JavaScript to ES6 - how ChakraCore changes the game
2015 was a year of massive JavaScript innovation and changes. Lots of great features were added to language, but using them was harder than before as not all features are backwards compatible with older browsers. Now browsers caught on and with the open sourcing of ChakraCore you have a JavaScript runtime to embed in your products and reliable have ECMAScript support. Chris Heilmann of Microsoft tells the story of the language and the evolution of the engine and leaves you with a lot of tips and tricks how to benefit from the new language features in a simple way
JUnit is a well-known tool for java developers in the area of TDD. Here it has become accepted, that CodeCoverage can be measured. In this case we distinguish between coverage on the level of classes, methods and rows. The goal is to get the CodeCoverage as high as possible on the row level, but not higher than necessary.
What exactly does it mean? A CodeCoverage of appr. 75% on the row level is very good and can already provide a basis. But what does this figure say?
In this talk we will deal with the term Mutation Testing and show the practical ways of use. How can the coverage be defined and what can be achieved?
How can it be integrated into an existing project and what should be considered while running a test?
We don't know when Angular 2 will be released but we know it's going to be *AWESOME*. In this hands-on session we are going to build a basic application while looking into different Angular 2 features like: bootstrapping, components, services, new template syntax and component routing
Writing documentation is often seen as no fun, but it does not have to be that way! Asciidoc is a member of the microformat markup languages family; like Markdown but with more pizzaz and power. Asciidoctor revolutionizes source doc processing in the JVM by leveraging well-known tools such as Maven and Gradle, you can even call it from the command line as is. Come learn why teams around the world are getting excited about Asciidoctor.
So you've gotten a handle on Git and know how to use it for everyday development tasks like committing code and pushing and pulling changes with the rest of the team. But do you really know how it works under the covers? In this brief demonstration, we'll commit a file to a brand new repository without ever touching the git add or git commit commands, and in the process learn some critical Git internals that every power user should know.
We'll also take a look at some advanced history and undo commands like reflog and reset, and how to rewrite past mistakes with interactive rebase. Come for 45 minutes of advanced Git fun!
Presentation: Healthcare for the elderly using the IoT
The Healthcare situation in cities might be good but for the elderly population on the country side it is often problematic.
In this session it will be shown how one can use a mobile phone and a smart watch in combination with a Java based gateway, iBeacons and other sensors to monitor the activity of elderly people. With the help of an IoT Cloud Service this data can be analyzed to detect situations that might be critical (illness, bone fracture etc.). If such a case was detected the Cloud Service can trigger Enterprise applications. With this approach it might be possible to connect such a system to existing Healthcare Applications. This session will give you an idea on how you can combine existing technologies to do something useful and help elderly people in case of an emergency.
Feature gluttony is a common sin among IT projects. Customers deliver never ending wish list of features they want. However, the key is not to build everything, but only things that are really needed. Learn how to defeat feature gluttony by... saying NO ;)
What will you learn? First of all how to maintain product road map in non-linear way (so no one assign the deadlines to it ;)), how to create mystical MVP and how to reduce the scope :) Final, and the most surprising element is... learning how to talk about removing features for the application with business people. All those 'cunning' techniques allow you SAY NO to excessive features!
Remember, there is always a way to make your application lean!
Presentation: How to speed up your application using JCache
In this talk we will delve deep into JCache, the new caching standard for Java. There are six implementations of JCache, most of them open source.
In this talk we will introduce you to the theory of caching, to such things as Pareto distributions and cache efficiency, N Times problem and so on. How to get the benefits out of it such as microsecond data access and offload of processing from expensive mainframe systems and databases. We also show you how to use this technology in a complementary way with NoSQL for performance speedup.
We will show you how you can use JCache directly or with Spring. When and why to use distributed versus in-process caching and when to consider leaving caching and moving to In-Memory Data Grid techniques.
Hands-on Lab: Industrial Prototyping with TinkerForge
TinkerForge is a very simple, easy-to-handle modular electronic system. Depending on the application, a system of sensor, wireless and motor control elements can be built in a modular way and programmed with a few lines of code. No soldering iron is needed. Both the hardware and the software are open source.
After a brief overview of the available sensors and actuators, we will quickly start with the actual programming. Together, we will explore different applications, architectures, and the combination of TinkerForge with Java. Using sensors, actuators and some other elements, we will take the first steps and delve into the practical world of IoT with Java 8 and TinkerForge.
Quickie: Introducing Pepper, the new robot by Aldebaran
A monolithic architecture is a great choice for small applications. However, a better approach for large, complex applications is to use a microservice architecture, which structures the application as a set of services. Each service can be developed, deployed and scaled independently. The microservice architecture enables teams that develop large, complex applications to be agile.
In this tutorial, you will learn about the motivations for using microservice architecture. We discuss the benefits and drawbacks of microservices. You will learn how to solve some of the key technical challenges with using the microservice architecture, including inter-service communication and distributed data management. We will discuss strategies for refactoring a monolithic application to microservices.
Keynote: IoT - an evolution from Internet of Screens to Internet of Things
Internet of Things is a big buzz word in the tech communities nowadays, but how different it is to an Internet of predominantly Screens that has been forming since 80/90s? Should we make a clear distinction between Internet of Screens and Internet of Things? What are the commonalities and what are the differences? What does IoT mean to the skillset in the web app developer communities? What is the importance of standardization in IoT?
This workshop will be using our own board called IoT Surfboard that agregates:
- Temperature, humidity, light, alcohol and infra-red sensor
- Relay, transistors
- WIFI / Bluetooth or Zigbee connector (we will be using WIFI)
- LED RGB
- Real-time clock
We will wok with the following labs:
1. Creating home-automaton system controlling lights
2. Reading traffic information and changing LED color based on that
3. Create a breathliser integrated with Twitter
4. Read all the sensors and publish on MQTT
5. Using IBM Bluemix to make ANY IoT implementation
We will provide the boards and the attend need to bring your own laptop. In the end we will let the attendes to play with IoT Surfboard and the boards will be available for selling!
Presentation: IOT, Timeseries and prediction with Android, Cassandra and Spark
IOT has a massive potential and its impact in our daily life is important. Here is an exemple of using a connected object and analysing its data: we'll see how to collect data using the accelerometer sensor of your smartphone. Then, we'll store it in Cassandra as a Timeseries model. Finally, we'll analyse those data and predict the activity with Spark. We will see a live demo on stage to show this solution working in realtime.
Isomorphic (greek: "isos" = equal, "morph" = shape) JavaScript apps are JavaScript applications that can run both client-side and server-side. Isomorphism describes that if you look at the same entity in two different contexts, you should get the same thing. Here the contexts are server and client. Although the term has been mostly used in mathematics until now, it's an apt term to describe a web programing pattern where the code is shared by the front-end and back-end. Just take an MVC-based Java framework, integrate it with Nashorn and use a famous JavaScript templating engine like React - that's it. Now you can render templates on the server- as also on the client side - or start rendering serverside, send them to the client and finish there! Nothing is impossible - even Netflix uses it
Lambda expressions and the streams API add a more functional style of programming to Java; something developers have not really had in the past. The session will start with a short summary of the key features of both Lambda expressions and streams before moving on to some real world examples of how to use them effectively, including some pitfalls that should be avoided.
We'll finish off with a quick look at some of the ideas for improvements to streams in JDK 9.
Presentation: Java-based microservices, containers, Kubernetes - How To
Join this session to learn how to create a microservice using Spring Boot, containerize it using Maven plugins, and subsequently deploy a fleet of microservices and dependent components such as Redis using Kubernetes.
Spring Boot makes creating microservices fast and easy when it comes to running a single instance. Like most Java applications, the harder part is usually the clustering and fail-over configurations.
First, we'll go over how to get started with Spring Boot, and, subsequently, using Maven plugins to generate and create Docker images during the build process.
Next, we'll go over some basic architecture and configurations, such as configuring session, and container linking. Finally, with the images, we'll deploy the microservice into Kubernetes!
JavaScript is amazing. You can manipulate the language so much which really makes it the land of endless possibilities. However, most JS developers usually run into a few troubles. And by "a few" I mean "a lot". In this session we will go through these funny yet irritating gotchas, understand them and figure out how to write our code so we never come across them again!
Presentation: JavaScript Immutability - "Don't Go Changing"
Many functional programming languages emphasize the use of immutable data. This makes it easier to reason about the code.
Immutability is a builtin feature of some languages, including Clojure, Haskell, and Scala. However, this is not the case for JavaScript. While it is possible to manually achieve immutability in JavaScript without resorting to a library, there are good ones that make this easier and more efficient.
This talk discusses several JavaScript libraries for immutability. The primary focus is on the Immutable library from Facebook which provides persistent data structures. These enable efficient creation of new data structures that share memory with others. This library is commonly used in conjuction with the React web framework, but it can be used in any JS application.
Hands-on Lab: JHipster, the best way to breed a new webapp
In this hands-on-lab you will learn to leverage and love the JHipster stack, combining best of breed java backend with a modern SPA JavaScript frontend (single-page application) and the tooling to get you and your team productive.
JHipster is a Yeoman generator used to create a Spring Boot + AngularJS project to create Responsive Web Design with HTML5 Boilerplate, Twitter Bootstrap, AngularJS and Spring Boot.
We will develop a full stack application, from scratch, and deploy it in the cloud.
You need a laptop with the following tools preinstalled.
- Java 8 (http://www.oracle.com/technetwork/java/javase/downloads/index.html)
- Maven (http://maven.apache.org)
- Git (http://git-scm.com)
- NodeJs (http://nodejs.org/)
Quickie: JHipster, the best way to breed a new webapp
In this presentation we will demonstrate the JHipster stack. JHipster brings the best of breed java backend with a modern SPA JavaScript frontend (single-page application) and the tooling to get you and your team productive. JHipster is a Yeoman generator used to create a Spring Boot + AngularJS project to create Responsive Web Design with HTML5 Boilerplate, Twitter Bootstrap, AngularJS and Spring Boot.
We will demonstrate how to build a full stack application, from scratch.
Kotlin comes to us from Jetbrains the same people that make the IntelliJ IDEA IDE. Designed to run on the JVM and interop cleanly with exisiting Java classes, Kotlin provides a number of upgrades from standard Java development. More than just another language tour with and ceaseless parade of tidbits and nuggets, this talk is a walkthrough of an actively developed project. Converted from existing Java code, this dropwizard and angularjs based application offers a glimpse of a number of Kotlin features in context. We'll walk through each layer from the Jersey resources all the way through the testing code showing how Kotlin works and can be used in conjunction with exising Java libraries.
java.lang.String is pervasively and perversely used in most Java applications. Not surprisingly, we are looking into optimizing it both on small and large scale. In this talk, we will take a deeper look into two interesting String-related features coming in JDK 9:
a) Compact Strings, that saves memory for Strings representable with single-byte chars, with little or none performance regressions, and in many cases, significant performance improvements;
b) Indify String Concat, that uses the magic of invokedynamic to concatenate Strings, to free runtime implementors for optimizing string concatenation without pushing users to recompile their programs;
We will talk about the rationale, pitfalls and caveats of implementing the intrusive core library/runtime changes.
Presentation: Making Darwin Proud: Coding Evolutionary Algorithms in Java
Java Developers sometimes face programming challenges, such as creating a school roster or determining a salesperson's optimal route, that are extremely difficult to crack using conventional approaches. Discover how Evolutionary Algorithms can be applied to solve these complex puzzles. The session starts with a success story from the NASA space archives to explain the concepts. Once the stage is set, it's puzzle solving time! Learn to code Evolutionary Algorithms using plain Java - although existing Java frameworks such as JGAP are also addressed. The session concludes with a checklist that can be used to determine whether Evolutionary Algorithms are a good fit to the problem. With this checklist, the decision has never been easier!
While Java's strict type system is a great help for avoiding programming errors, it also takes away some of the flexibility that developers appreciate when using dynamic languages. By using runtime code generation, it is possible to bring back some flexibility back to the Java virtual machine. For this reason, runtime code generation is used by many state-of-the-art Java frameworks for implementing POJO-centric APIs but it also opens the door for assembling more modular applications. This presentation gives an overview on the various ways code generation and manipulation is currently used on the Java platform, both by library developers and end users. Furthermore, it discusses the up- and downsides of several code geeration libraries such as ASM, Javassist, cglib and Byte Buddy.
Love it or hate it (and a lot of people seem to hate it), Maven is a widely used tool. We can consider that Maven has been the de-facto standard build tool for Java over the last 10 years. Most experienced developers already got their share of Maven headaches. Unfortunately, new developers are going through the same hard learning process, because they don?t know how to deal with Maven particularities. "Why is this jar in my build?", "I can't see my changes!", "The jar is not included in the distribution!", "The artifact was not found!" are common problems. Learn to tame the Maven Beast and be in complete control of your build to save you countless hours of pain and frustration.
Microservices is the new popular kid on the block. Crowd pleaser at many conferences. With popular poster children such as Netflix and Amazon it seems to be the killer approach to 21st century architectures, right? But is this stuff only for Hollywood Coders pioneering on the bleeding edge of our profession? Or is this stuff ready to be used for your projects and your customers? This presentation is a warning. Microservices don't fix broken organizations and distributed computing is still hard. I will go over the benefits, but more so the pitfalls, of using a Microservices based architecture. What impact does it have on your applications, on dealing with scale and failures, and how do you prevent your systems landscape from becoming an unmaintainable nightmare.
Presentation: Microservices: From dream to reality in forty five minutes
Are microservices a wonder-pattern for rescuing intractably complex applications? Or are they just a restatement of the software engineering best practices we all should be following anyway? Or something in between?
How do they work? How should they be written? What are the pitfalls? What are the underpinning technologies?
Using a pile of tiny computers, cables, and code, I'll demonstrate writing, deploying - and managing - a polyglot microservices application. Since there are limits on how much traffic the data-centre-in-a-handbag server topology can handle, I'll also demonstrate scaling up, out, and away to the cloud.
In this fun workshop, we'll do a series of exercises to convert "old school" JavaScript code to ES2015, or ECMAScript 2015 code. ES2015 just got finalized, but you don't have to wait to use it. Using transpilation as part of your build process, you can quickly start using it TODAY.
We'll do exercises to convert legacy JavaScript code to ES2015 to help you understand how to migrate existing code and write new code in the new version of the language. This is a hands-on lab, attendees will require a laptop.
All the brilliant people working on the same thing, at the same time, in the same place, and on the same computer.
Mob Programming is a cost-effective, collaborative and fun way to get work done together. It's a whole-team approach to development, where coding, designing, testing, and working with the "customer" (Partner, Product Owner, User, etc.) is all done as a team.
Participants in this workshop experience Mob Programming hands-on while learning the mechanics of how to work together as a Mob and the techniques that make this form of development so effective.
Learn how a mob performs sample project work, including user stories, prioritization, test-driven development, refactoring, and retrospectives.
Designed and facilitated by Mob Programming pioneer Woody Zuill.
Presentation: Mob Programming, A Whole Team Approach
Mob Programming is a development practice where the whole team works on the same thing, at the same time, in the same space, and on the same computer. It is a whole-team approach to doing all the work the team does including designing, coding, testing, and working with the customers, users and other stakeholders.
This is an evolutionary step beyond pair programming, and accentuates face-to-face communication, team alignment, collaboration, and self-organizing team concepts of the Agile approach to software development.
Mob Programming can be a highly effective approach to software development.
Please join me as I share how the concept got started, the benefits, techniques we use, and some of the problems we've faced.
One of the challenges with a microservices architecture is understanding it. How do you figure out what connects to what, where things are deployed, what capabilities the total system of services has? This is a talk about System-Z, the microservice-based microservices modelling system we use at Spotify to understand our set of services. We use a combination of runtime collection of data and mostly-static service metadata. The system currently tracks about 1000 components deployed to about 8000 machines, and we're looking at extending it to also tracking our data collection and analysis pipelines, as well as possible client-side features.
First part will be a a gentle introduction, with examples, to the forthcoming Java Platform Module System. Learn how to create a module from scratch, compile it, test it, and run it. This session will also show basic techniques for modularizing existing libraries and applications.
Second part : Modularizing an existing library or application, or creating new modules from scratch, can raise many difficult and subtle design issues. This session will present a set of principles for modular development, with examples taken from the JDK itself.
Keynote: Move Deliberately and Don't Break Anything
Programming language design is not just about type theory and grammars. For evolving a mature programming language like Java, it is about finding ways to add capabilities while maintaining compatibility, both with existing code and with the expectations and mental models of 9 million or so Java developers. In this talk, Java Language Architect Brian Goetz looks at some of the challenges and lessons of steering Java through major evolutionary changes, and a sneak peek at where the Java platform is headed.
Presentation: Moving Renewable Energy Embedded Systems Into the Cloud
Learn how to build scalable, self-sustaining Embedded Ecosystems powered by small-scale Renewable Energy (solar, wind) systems and connect those systems to cloud services.
Using low-cost, off-the-shelf hardware, see how to build self-sustaining sensor meshes and access them from anywhere in the world using cloud services for deployment, management, & data/trend analysis. Hardware components include Raspberry Pis, Arduinos, weather/environmental sensors, & physical control devices; software includes Java Embedded, Cloud services, & JavaScript.
This session introduces you to IoT & Cloud concepts and demonstrates how one necessitates the other. The driver of the "Internet of Things" is not the Things, but the INTERNET; a cloud connection is key to unlocking full value from your system.
So, you have heard about NoSQL but did not have time to deep dive into it nor had a chance to use it in a commercial project? NoSQL movement has been around for a while now. It's worth to have a gist of what it can do for you.
This session will be a practical walk-through showing the most popular NoSQL databases, outlining their features and surprise, surprise drawbacks. Marketing hype aside, we will try to understand the differences between these databases, their programming models and learn how to properly use them in our daily work.
No prior knowledge is required. Come by to learn more about Cassandra, MongoDB, Hazelcast, HBase and others!
You already have heard about RxJava but wish for a practical and concrete approach? You want to discover Functional Reactive Programming (FRP)? This hands-on-lab is made for you.
We'll discover ReactiveX by developing a client application that composes with multiple (not always reliable) services. We'll see which best practices to put in place so as to make it production-ready (retry, backpressure, exponential backoff...).
RxJava is an awesome library for async data streams, both expressive and powerful. But the learning curve can be quite steep at first, so we want to quickstart you into the world of Reactive eXtensions, go beyond a mere presentation of the operator, let you code!
The hands-on-lab needs a laptop with Maven, JDK 8, an IDE (preferably IntelliJ)
The modularization of the Java SE Platform in JDK 9 will bring many benefits, but also many changes. Existing code that uses only official Java SE Platform APIs and supported JDK-specific APIs should continue to work without change. Code that uses certain deprecated features, however, or any JDK-internal APIs, is likely to break. This session will show you how to prepare existing libraries and applications for JDK 9, and how to get old code working on JDK 9 even when you can't update it.
Presentation: Providing eyes, ears and mouth to your IoT Project using MQTT, Android and Intel Real Sense
This session discusses how you can integrate different technology to provide amazing user experiences with gestures, text-to-speech voice recognition and sensors (like alcohol) to provide environment and physical information to your IoT project.
We will be presenting different hardware technologies including Raspberry Pi, Arduino, Gemalto EHS6 with JavaME, Intel Edision as IoT gateway, Intel Real Sense to gesture recognition everything using MQTT + REST and MANY amazing live demos. In the end you will have a nice resume around Internet of Things possibilibites and many nice technologies!
Tutorial: Purely functional programming on the JVM - the red pill
It takes some experience to learn functional thinking. The smooth route is to do a bit of stream processing with higher-order functions and leave it at that. The tough route is to learn purely functional programming: no loops, no side effects, no assignments, no variables, no nulls, no mutable state whatsoever. It is hard to believe that such an approach can be useful at all. But it is. It is even more. It is cool. We force ourselves into purely functional programming, by using the Frege language, which is a Haskell for the JVM. We will learn how to program with that approach and draw conclusions on how that experience also helps us with functional programming in Java. If you are an adventurous programmer, this tutorial is for you.
React is a web framework from Facebook that focuses on the view portion. It emphasizes building UIs from components, most of which only use data that is directly passed to them. This results in components that are easy to understand, reuse, and test.
React applications naturally divide into code that addresses two concerns. The first is what a component should render when given certain data. The second is how events should modify the state of the application. React handles determining the minimum set of DOM changes that are required to update the UI based on changes to the state. This is done efficiently through use of a "virtual DOM". Changes to this can be quickly "diffed" against the previous version.
This talk covers everything you need to know to get started using React.
This tutorial will give you a thorough introduction into Web Components. We start by explaining the standards that form the foundation of WebComponents: Template tag, custom elements, Shadow DOM, and HTML imports. Next we will do a live coding session showing you how you can rapidly build a web application with existing Web Components from Polymer Elements and other sources and connect the application to a server. In the last section, we are going to explain how you can build your own custom components and integrate them into your application. Also we will share our experience gained while building an application with Web Components and talk about pitfalls that should be avoided when using Web Components in a real world project.
A common pattern when building systems based on distributed services is Service Discovery. And that is where Snoop comes in. It is a 100% Java EE alternative to solutions like Spring Cloud Eureka. Just as simple and at least as powerful. And no need for 3rd party frameworks.
Apache Cassandra is a leading open-source distributed database capable of amazing feats of scale, but its data model requires a bit of planning for it to perform well. Of course, the nature of ad-hoc data exploration and analysis requires that we be able to ask questions we hadn?t planned on asking?and get an answer fast. Enter Apache Spark.
Spark is a distributed computation framework optimized to work in-memory, and heavily influenced by concepts from functional programming languages. It?s exactly what a Cassandra cluster needs to deliver real-time, ad-hoc querying of operational data at scale.
In this talk, we?ll explore Spark and see how it works together with Cassandra to deliver a powerful open-source big data analytic solution.
Presentation: Speed, scale, query: can NoSQL give us all three?
The NoSQL movement promised availability, redundancy, speed and more but query was always the poor relation. Now, non-relational databases are increasingly attempting to fix the problem of query. In this talk, we?ll survey the non-relational landscape to understand where different NoSQL databases have strengths and which use cases each type suits best. Then we?ll look at the
different strategies the leading NoSQL databases are taking to solve them problem of rich query in a world that previously saw poor query as a necessary trade-off. You?ll get an overview of how the data model of NoSQL databases shapes what is possible in terms of query and what trade-offs the architecture of those databases brings out. Can we really have scale, speed and queryability all from one database?
The microservice architecture has been growing momentum over the past few years, but once you've started down the microservice path how do you make sure that your applications are still fully tested? This session will give an overview of the trials and tribulations when testing microservices. It will cover the different testing types that are required, using a sample java-based microservice to highlight the reasons for the requirements. It will also reference this sample microservice as an example of some of the testing techniques that can be used. These techniques will include testing microservices with a Gradle or Maven build system and using testing tools such as JUnit.
One of the big challenges in building an API is predicting how it's going to evolve. How will we handle big breaking changes? And how do we share a model layer without code duplication? How can we let the server predict which content will be needed on the client? And how do we fokus on the important problems in our API design, and don't reinvent the wheel? This talk will demonstrate the JSON API approach (http://jsonapi.org). JSON API is not only the missing specification you can rely on to settle endless arguments in how the JSON API should be structured. It's also a specification for creating self explaining JSON APIs, also called hypermedia APIs. This will be demonstrated through a JavaScript library we've created at Confetti called YAYSON (https://github.com/confetti/yayson).
Alright, so maybe "bootiful" won't ever work, but I tried, and it was worth it too because you're reading this. 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! Spring Boot aims to make address the common functional and non-functional requirements that gate quickly moving to production.
Join Spring developer advocate Josh Long for a look at what Spring Boot is, why it's turning heads, why you should consider it for your next application (REST, micro services, web, batch, big data, integration, whatever!) and how to get started.
Presentation: The Epic Groovy Puzzlers S02: The revenge of the parentheses
More strange, more bizarre, more fun! The Groovy Puzzlers hits with its second season in which we implemented the lesson learned from the first one - do more of the same (always as a duet)! Expect even more ?NO WAY!?, ?WHOA!?, ?WTF!?, O_o and prizes flying around, and expect to learn more about Groovy?s darkest secrets! As usual, the traps we fell into here in JFrog and contributions from top-notch Groovy authors and users!
Presentation: The image problem of the web and how to solve it with AI
One of the biggest culprits of bloat on the web is images. Maintainers upload them in the wrong format, scale large images down and instead of delaying the loading until the page displays make users wait. Using EXIF data in JavaScript and openly available machine learning APIs you can unearth hidden data in images and give a great pre-rendering experience that does not only look good, but also helps making image content accessible for non-sighted users.
We wanted to find out if we could use the same languages and tools on IoT hardware. We used Lego trains and Raspberry Pi?s as a sample project.
The Lego trains are equipped with a Raspberry Pi, camera, wireless dongle, infrared transmitter, speaker, RFID reader and battery pack. Next to that we have automated switch tracks and camera's again with the help of Raspberry Pi's. We also build some lightning effects with LEDs controlled by Particle Photon?s. On top of that we also automated a Lego ferris wheel. To control the trains and other parts we built a Java application based on Jersey and Tomcat together with an AngularJS application.
Pragmatic Java EE are efficient, fast and lots of fun. In this session I would like to share with you a set of idioms of successful vanilla Java EE projects. Slides would only obscure the beauty of Java EE 7, so I will spend all the time in the IDE
In the past years we have been overwhelmed by agile coaches bombarding us with important stuff like the optimal length of a sprint, how to rip off a Post-It and why we should use CAPITAL letters on story cards.
The question is, will that help us write better code? Will it make our programs more maintainable?
Probably not. Nevertheless, organizations spend barrows of money on agile coaches, but not a single dime on technical coaching. This lunatic must come to an end and now is the time for us developers to fight back and protect our right to grow in the art of creating code.
Taking its starting-point in the XP-principles this session will explain what technical coaching is, why you should do it and how it could be done through mob programming sessions.
I have some scary examples for you, gathered throughout many years on maintenance and on large modernization projects. Examples of code so indescribably bad that it's difficult to understand how it came to ever exist.
These (anonymized) examples have been analyzed in order to determine how they came to be. Participate in this presentation so that you can avoid making the same mistakes in your next development project.
...or live with the misconception that only bad developers make bad code.
Presentation: Top 10 Key Performance Techniques for Hybrid mobile Apps
It is an easy task to develop, and deploy your hybrid mobile apps to your favorite stores, and get it ready for your client. But what about your application performance, is it fine tweaked for your audience devices.
Writing HTML5, CSS3, and JavaScript code is an easy task for web and desktop developers. But very different when we talk about mobile devices.
Is your application consume customer battery?, is it a data hungry application to consuming customer bandwidth?, Takes too much memory? , is it slow or even too slow?, is it , is it ?. etc. questions about performance.
You?ll learn how to enhance your mobile applications performance, by implementing those top 10 performance concepts and more.
9.00-9.45
Adventures on the road to Valhalla
Project Valhalla proposes to bring value types and specialized generics to Java. In this talk, Java Language Architect Brian Goetz offers some of the highlights of the progress and pitfalls of adding these features to the Java Language and VM.
10.00-10.45
A JVMs Journey Into Polyglot Runtimes
Java Virtual Machines (JVMs) are now being used to implement runtimes for many different languages. Building on top of JVMs leverages the mature runtime technology resulting from decades of investment and enables great interoperability with Java applications. JVM based implementations are rarely the primary implementations for languages other than Java, possibly because JVMs are primarily built to run Java. While JVM support for other languages has improved tremendously, JVMs still offer a primarily Java focused execution model. This talk will discuss experiments to unlock the underlying internal mechanisms of a production JVM to provide key technologies for non-JVM based implementations of polyglot runtimes.
11.15-12.30
Lord of the Strings: Two Scours
java.lang.String is pervasively and perversely used in most Java applications. Not surprisingly, we are looking into optimizing it both on small and large scale. In this talk, we will take a deeper look into two interesting String-related features coming in JDK 9: a) Compact Strings, that saves memory for Strings representable with single-byte chars, with little or none performance regressions, and in many cases, significant performance improvements; b) Indify String Concat, that uses the magic of invokedynamic to concatenate Strings, to free runtime implementors for optimizing string concatenation without pushing users to recompile their programs; We will talk about the rationale, pitfalls and caveats of implementing the intrusive core library/runtime changes.
13.30-14.15
Deep Diving into JRuby 9000
In the summer of 2015, we released JRuby 9000, representing the largest amount work ever put into a JRuby version. The execution runtime has been completely replaced with a new optimizing IR compiler that we continue to improve. The IO and Process subsystems are now doing direct POSIX calls for better UNIX integration. We are caught up on compatibility with Ruby 2.2. This talk will cover the advances we've made and how other projects can leverage and learn from them.
14.30-15.15
Bringing The Performance of Structs To Java (Sort Of)
Java is a powerful language and platform and in many cases can match or even exceed the performance of natively compiled languages like C and C++. However, there is one area where this is not the case, which is the use of structs, where machine level optimisations work very well.
To address this, there is an open source project, ObjectLayout (objectlayout.org), which provides an API where pre-fetching and caching can deliver performance gains. The beauty of this approach is that no changes are required either in the Java language or in the JVM. However, the JVM can be modified to use intrinsics when processing the API to improve performance further.
The design and ideas behind the API will be discussed as well as ideas for how the JVM can be enhanced.
15.45-16.30
Adventures with concurrent programming in Java: A quest for predictable latency
Concurrent programming with locks is hard. Concurrent programming without using locks can be really hard. Concurrent programming with relaxed memory ordering and predictable latency semantics is said to be only for wizards. This talk focuses on a decade long quest to discover algorithms that provide very high throughput while keeping latency low and predictable. Additionally, they need to provide real-time telemetry on how a system is performing via non-blocking operations.
We will cover some fundamental theory of concurrency and then compare various approaches to the same problem so that we can measure the impact on latency. We'll also show how some of these algorithm implementations get more interesting given the new features in Java 8.
With Java 9 and Jigsaw project around the corner (this time apparently for real), we finally need to stop pretending we can simply ignore the concept of modularity in Java! The thing is - modularity is NOT just some new framework! Neither it is a simple set of APIs! It's a complex concept that has been around for almost as long as the industry itself. So in this talk I'd like to take a step back and reason about the fundamental idea of modularity in Java by comparing the concepts of Jigsaw with other Java modularity approaches and implementations that have been around for quite some time.
At JavaOne/OpenWorld 2015, Oracle announced that its own internal developers have been using JavaScript for several years to develop Cloud applications and that a toolkit built up out of open source solutions is being made available for general use.
Data in the Cloud needs to be visualized in interesting and understandable ways, which is the key reason for the existence of Oracle JET (Oracle JavaScript Extension Toolkit). It provides JQuery UI components that make available graphs, charts, and similar components, on top of Require.js for modularity, Knockout.js for data binding, and more. The entire toolkit will be open sourced.
Come to this code-driven session to find out what Oracle is doing with JavaScript and how you can leverage these solutions too!
Developers shouldn't work faster and more effectively, they should work harder. Too much energy is spent learning how to improve and not enough is spend crushing every hour with manual repetitive tasks to get the job done. This tongue in cheek session takes a look at 10 development tools/projects/products, explaining what they do and how they 'supposedly' help your development practices. Fear not, padawans, I'll uncover what these vendors, and project owners don't want you to know about how they're ruining your development environments and rotting your development projects from the core. We'll cover JIRA, Confluence, Tomcat/TomEE, JRebel, XRebel, Arquillian, JBoss Forge, IntelliJ, Jenkins, and Gradle.
