Following on from the popular 55 New Features in Java SE 8 we bring you the eagerly-awaited sequel, 55 New Features in JDK 9.
Obviously, the big new feature in JDK 9 is modularity and project Jigsaw, but theres lots more to tempt developers. Well divide things into five categories:
1. Features
2. Standards
3. Inside the JVM
4. Specialised
5. Housekeeping
Join us on a whirlwind tour of whats in (and whats out) in JDK 9 so youre ready to get started with the latest version of the most popular programming platform on the planet.
Presentation: Advanced search for your legacy application
How do you mix SQL and NoSQL worlds without starting a messy revolution? This live coding talk will show you how to add Elasticsearch to your legacy application without changing all your current development habits. Your application will have suddenly have advanced search features, all without the need to write complex SQL code!
David will start from a RestX, Hibernate and Postgresql/MySQL based application and will add a complete integration of Elasticsearch, all live from the stage during his presentation.
Keynote: AI and the future of computing, are we all cyborgs now?
Calm technology describes a state of technological maturity where a users primary task is not computing, but being human. The idea behind Calm Technology is to have smarter people, not things. Technology shouldnt require all of our attention, just some of it, and only when necessary. How can our devices take advantage of location, proximity and haptics to help improve our lives instead of getting in the way? How can designers can make apps ambient while respecting privacy and security? This talk will cover how to use principles of Calm Technology to design the next generation of connected devices. Well look at notification styles, compressing information into other senses, and designing for the least amount of cognitive overhead. Well also look at the rise of Artificial Intelligence.
Presentation: Angular with NGRX - there is a reducer in my soup
How to handle state management is a problem as old as time. You think about things such as how should the data flow, where does my state live. Sadly you tend to end up with a mess, more times than not. With the arrival of the new Angular suddenly data was no longer two-way binded and it made sense to start to look at patterns such as Redux.
It is of course possible to write your own implementation of Redux but what if you were to use what's already there in what Angular gives you. I'm talking about RxJS. If you combine Redux with RxJS sweet music will be created. This talk aims to give you a good understanding of the Redux concepts, a little bit of RxJS but most of all a good foundation on how to use NGRX for your next Angular app.
This talk will show you how to use provisioning tools in order to automate server setup. Starting from a basic Debian image, we will launch a server on DigitalOcean using Terraform and provision it using Ansible.
Presentation: Awesome native apps with NativeScript and Angular!
Developing native iOS (and Android apps) can be very time consuming and expensive. What if you could build native apps with one code base and web techniques? Well, you can with NativeScript!
In this introduction, Ill explain what NativeScript is and how it compares to other platforms. And in a live demo, I will show you how easy it is to get started and to make use of native capabilities.
Presentation: Benefits of Functional Programming beyond map/filter/reduce
Since Java 8 we have grown to exploit the benefits of Lambdas and Streams together with high-order functions to map, filter, and reduce our data. But this is only the beginning. With purely functional programming we can explore new territory where we can go safely parallel, ensure through the type system that we never call from the wrong thread, and expand our solution space with new mental tools.
Any new trick that you learn this way is immediately applicable to a growing number of functional languages: Frege for the JVM, Elm and Purescript for the web, and Haskell and Idris for native code.
Presentation: Beyond JavaScript Frameworks: Writing Reliable Web Apps With Elm
In times where a jungle of JavaScript frameworks wants to solve every conceivable problem in web app development, creating headaches and javascript fatigue in the process, Elm offers a different approach.
Elm is a functional programming language that you can use instead of JavaScript. It builds on the concepts of virtual dom and one-way dataflow popularized by React and Redux, but with a great typesystem, built-in immutability, and an amazing compiler that catches errors before you even run your code. Simply put, Elm is a great language that will make your backend team jealous!
In this talk you'll see how Elm works and how to build apps with it. Pros and cons of using Elm over a traditional JS stack will be highlighted. No prior experience with functional programming is required.
Presentation: Broken Promises; How data destroys relationships in microservice systems and what you can do to win back trust.
Data-centric, even-driven, stateless these terms are often tossed about when people speak on microservices or distributed systems. But how often do these things work together to deliver the promise of a resilient and trustworthy environment? If youve struggled to build a distributed system that can deliver on all the promises of a Reactive, it could be due to poor architectural practices, especially around handling uncertainty that is part and parcel to distribution. But it doesnt have to remain this way; you can learn to trust and rebuild trust in your systems.
In this talk, we will drill into key concepts around Promise Theory and a framework designed to embrace this theory as a principle to building highly resilient, responsive and elastic systems.
Presentation: Building Desktop Applications with Electron
Developing cross-platform desktop applications has been always a problem, each operating system has its own tools and API, thus the idea of a single code base that works across was a myth for a long time. To help with this, Electron allows people to use their web development skills to create desktop applications without needing to worry too much about the specificity of each operating system. It is a framework, developed by GitHub, since 2013, that lets users create packaged HTML, CSS and JavaScript applications that run on cross-platform systems, by combining the features of Chromium and Node.js. The talk will be focused how you can create your first app. We will look at what components and features Electron offer and the benefits and downsides of the framework.
Tutorial: Building e-health IoT solutions with AWS
During this workshop we will show different technologies applied to e-health including voice assistant, serverless architecture, IoT sensor gateways resilient to Internet fail, massive deployment over-the-air and machine learning. We will bring many different sensors and devices including Libelium / MySignals e-health kit with 15 different biometric sensors, Raspberry Pi, Alexa and Amazon Dash.
Agenda:
-Introduction to e-health and AWS technologies
-Hands-on #1: Using Alexa as voice input for health data
-Hands-on #2: Using Raspberry Pi + Lambdas + Greengrass
-Hands-on #3: Integrating legacy e-health devices with AWS
-Hands-on #4: Applying machine learning to e-health data
We will also publish the components list for anyone that want to buy!
Presentation: Building Interactive, AI-powered IoT Applications on AWS
IoT is about connecting Internet-enabled devices that relay information back to us, to cloud-based applications and to each other (device to device). In this talk, I will discuss best practices and show how to efficiently build IoT apps on AWS, including the use of voice interfaces. I will also showcase the latest AWS IoT Device called DeepLens (https://aws.amazon.com/deeplens/) and build a machine learning project using Amazon SageMaker to build and train model and deploy it at the edge on the AWS DeepLens device.
React.js is a view library from Facecbook for building performant user-interfaces in JavaScript. In this session, we'll explore React.js and understand why it's a great step forward for building complex UI's that run fast. We'll code up an example web application using React.js and step through the basics of using the library while discussing concepts like the virtual DOM and components.
It is not necessary to change. Survival is not mandatory. -W. Edwards Deming
Software - for many organizations and industries - is a competitive advantage. Organizations break their larger software ambitions into smaller, independently deployable, feature -centric batches of work - microservices to optimize for velocity. Velocity, for velocitys sake, is dangerous. Microservices invite architectural complexity that few are prepared to address. In this talk, well look at how high performance organizations like Ticketmaster, Alibaba, and Netflix make short work of that complexity with Spring Boot and Spring Cloud.
In this workshop we'll look at how to build cloud-native Java systems that are elastic, agile, observable and robust.
The Collections Framework was introduced in JDK 1.2 back in 1998 and is still in heavy use today. Although its fundamentals remain unchanged, it has evolved considerably since its introduction, and it continues to evolve. This session describes some of the recent enhancements made to Collections, with a focus on the enhancements added to Java 9. Of particular note is JEP 269, Convenience Factory Methods, a library-based API that serves the purpose of collection literals. Finally, the session provides a glimpse at some possible future enhancements for the Collections Framework.
Quickie: Contiki-NG - The Next Generation OS for IoT devices
Contiki-NG is an effort to modernize Contiki - one of the most used open-source IoT OS:es. Contiki-NG comes with support for many of the latest IoT protocols defined by IETF and OMA including IPv6/6LoWPAN, MQTT and LWM2M. This presentation will introduce Contiki-NG's main features and show a few commercial devices and dev-kits that use it.
Presentation: Cracking the Code to Secure Software
What is it that makes writing secure software so difficult? Why do we keep making the same mistakes? One challenge is that developers are busy delivering features, another is that security seems scary and complex.
In this talk, we'll address this by combining tools and mindsets from Domain Driven Design along with a pinch of security. This way, we'll teach you how to create secure code while still focusing on delivering business features. We'll also present the basic principles of Secure by Design and show how security weaknesses can be addressed using good design principles and why you shouldn't fear security as a field. Finally, the ideas and patterns presented are directly applicable in your daily work regardless if you're working with legacy code or brand new state of the art software
Presentation: Crash Coaching - Fast development in a risky environment
Do you ever feel anxious when you are about to push to the Git repository? What is the worst thing that can happen? What if your or someone else lives would be at risk? Would you still push it?
In this talk, I will show you how the Swedish Motorcycle organization uses Agile principles to create a safe environment for their members to educate and develop their driving skills. I will draw an analogy with the sort of environment that I try to set up for our development teams to enable them to develop at 300 km/h.
Presentation: DDD and Microservices, our experience
At Ping Pong, after 20 years in the edTech industry we recently realized that our product can't solve all our customers needs. It just tried to do to much. We realized we needed a new product for new markets. From the beginning we knew that we have a lot of unknowns in our product requirements, so we knew it would be important to be able to iterate and build small features that are very isolated from each other. With this in mind we decided from the start that we will be build it with a strong DDD mindset and separate concerns as clusters of microservices. I will share some of our experiences and thoughts we have gone through while building the system so far. And how it made us change our domain and think in new ways.
What's a Site Reliability Engineer and how's that role different from the DevOps engineer my boss wants to hire? I really don't want to be on call, should I? Is Docker the right place for my code or am I better of just going straight to Serverless? And why should I care about any of it?
I'll try to answer some of these questions while looking at what DevOps really is about and how commodisation of servers through "the cloud" ties into it all.
This session will be an opinionated piece from a developer who's been on-call for the past 6 years and would like to convince you to do the same, at least once.
It's half a century since the NATO Software Engineering conference in Garmisch. How are we doing? Are we nearly there yet? Or is there no 'there' there?
We are excited by new language releases, microservices, machine learning, agile development, testing all the things... but what is genuinely new in our practices, our programming languages, our understanding of software architecture? What could we have learned and what have we still to learn?
In this talk we'll try to understand what 'engineering' means for software and its development, what is helping us go forward and what is holding us back, which ideas are old and which are genuinely new. We can learn from our experience, but the future doesn't necessarily have to look like our experience.
Turbofan is V8's new optimizing Javascript compiler, which uses an unscheduled sea-of-nodes intermediate representation. After a short introduction to Turbofan's design, we explore the challenges encountered when implementing Escape Analysis for Turbofan. Escape Analysis is a compiler optimization that allows to remove or postpone the allocation of temporary objects, potentially storing the object fields in registers instead. This reduces load on the garbage collector and removes memory access instructions. To make the analysis phase fast enough while keeping the implementation readable, we used of a purely functional data structure to share data when storing the state of all objects at all points in the code.
Hands-on Lab: Event stream processing using Kafka Streams
This workshop will give you hands-on experience using Kafka Streams to solve a variety of event stream processing problems. The examples and exercises are based on real-world usage from our stream processing platform in Schibsted, used to process over 800 million incoming events daily from users across the globe. We will cover topics ranging from the basics like filtering and transforming events, to how you can use Kafka Streams for data routing, aggregating events, and enriching and joining event streams. To solve the exercises we'll be using Java 8 and/or Scala.
Presentation: Falcon a new JIT compiler in Zing JVM
Falcon is the new JIT compiler for Zing JVM, which has replaced our C2 compiler. The new compiler is based on the LLVM infrastructure and focuses on improving peak throughput performance.
LLVM had originally been used as a static compiler for C/C++. It has taken us a lot of work upstream to teach LLVM how to compile Java code efficiently. In this talk we will discuss the difference between a static compiler for C/C++ and a JIT compiler for Java and will cover GC support, deoptimizations, and Java specific optimizations.
Building a new compiler is no small feat. In the talk you will find out why we decided to write a new compiler and will see examples of how Falcon speeds up execution.
Presentation: From Beaglebone to Boiler room kernel issues and electrical noise
Taking our product, a smart heating control system, from a prototype and getting it into the hands of consumers has proved to be a non-trivial task.
We chose software stacks, development tools and communication protocols. We figured out monitoring, maintenance and upgrades. We worked with our production partners on provisioning, producing systems and CE certification. Hear the benefits of and problems with the choices we
made in our quest.
Hands-on Lab: Getting your hands dirty with the Java Module System
The days to study the Java 9 module system from a distance, just by reading about it, is over - time to gets your hands dirty! This half-day workshop...
* starts with the basics
* why is there even a module system and what does it solve?
* what's a module and how is one defined?
* what do readability and accessibility mean and why are these terms so important?
* teaches you refined techniques beyond the basics
* how to model optional and transitive dependencies
* how to use services to decouple modules
* how to make sure reflection is working
* how to create runtime images for or even with your application
Presentation: Gluing the IoT world with Java and LoRaWAN
One of the reasons for the rapid ascension of IoT is the advancement in the communication protocols. In this field, LoRaWAN opened up a broad new spectrum of possibilities, allowing low powered devices to communicate at great distances. The entire infrastructure is non-invasive, runs on open frequencies and is completely end-to-end secure.
TheThingsNetwork provides a complete LoRaWAN infrastructure which handles the entire communication, security and data delivery. Its core principles are that it's open, free and community driven, meaning that everyone can extend it and everyone can use it.
This talk will explain how to utilize TheThingsNetwork and some well known frameworks like Spring Boot and Eclipse Paho in order to create robust, scalable and secure IoT solutions of your own.
Presentation: Hops, the world's fastest Hadoop distribution
Hops is the world's fastest and most scalable distribution of Hadoop and it has been developed by KTH, RISE SICS, and Logical Clocks AB in Stockholm. Java has been a central part of the Hops journey, not just on the backend, where JVM languages rule the Hadoop ecosystem, but also on our Gateway to Hadoop, Hopsworks provides UI-driven access to Spark, Flink, TensorFlow, and other Big Data services. We recount our journey with Java and how it enabled us to build the world's only multi-tenant Hadoop platform. We will also show you the Hopsworks platform in action from the Rise ICE Data Center at www.hops.site, where SICS North are providing reseachers and companies in Sweden with access to managed Spark, Flink, Hive, and Tensorflow services on the Hops platform.
Presentation: How to Properly Blame Things for Causing Latency: An Introduction to Distributed Tracing and Zipkin
This presentation reviews concepts, data model and architecture. It also talks about the difference between logging, metrics and tracing. The demo will have code in javascript and java (maybe also a surprise language!), but code expertise isn't required. When you leave, you'll at least know something about distributed tracing, and hopefully be on your way to blaming things for causing latency!
Presentation: Humans vs Computers: five key challenges for software quality tomorrow
With the advances in our industry we can build software faster and operate it cheaper while serving more platforms and solving more problems than ever before. This is not without it's complications though, this new landscape requires teams to change their approach to reduce risk and ensure quality in their software.
In this presentation, based on the research for the book Humans vs Computers, Gojko will look at five important software quality challenges facing delivery teams due to these shifting roles. He will also present some emerging ideas that will help address these challenges and inspire you to rethink your approach to testing.
Husqvarna Group understood early on that data from products are of value to the customer, the business, to R&D and product development. But also, that data, IoT and digitization has the potential of connecting products and services into future comprehensive solution offerings in different internal and external ecosystems, but also, that it will come to challenge all functions and disciplines of the company in how they are organized, and in how they work. Husqvarna Group is though off to a good start, having got both Husqvarna Fleet Services and Gardena SMART already on the market, and during passed year, the Group has also tested a new concept within the field of sharing economy. Hear Petra Sundström tell us what went well and what challenges they continue to face.
Presentation: I didnt know the browser could do that!
The times when a browser simply had to parse and show some markup are long gone. These days they are full of interesting apis exposing various information and behaviour to web developers. This talk will walk you through a few of these apis (speech, speech recognition, battery, location, ...), some of which you might know, some maybe not. I will show a quick example of what some of these apis can do, and how to use them.
Presentation: IoT for Smart Buildings: from Sensor to Cloud
Can IoT can be both secure, scalable and easy to install? The answer is YES and this session will tell you how!
Yanzi has developed a world class scalable and secure IoT platform where ease of installation has been in focus from day one.
This session will share some of our Smart Building customer stories and will also walk you through the technology behind the scenes. You will get a full platform overview including Sensor, IoT Network, Gateway, Cloud and API technologies.
Getting the most of your Java applications can be an interesting challenge. Understanding some of the optimizations the latest crop of JVMs are able to apply when running on the latest servers may help with that. This talk will discuss some of those features and optimizations. Along with discussing JIT compiler capabilities, we will dive into how such optimizations interplay with warmup, startup, rare executions, and dynamic JIT adaptations. We will also discuss the issues that these techniques can introduce when speed "right out of the gate" or "at rare but critical times" is an important consideration. We'll even throw in some fun examples of micro-benchmarking pitfalls that often come in the way of understanding what reality looks like in such environments.
In this informal BOF session, learn how leaders from the community working on Java standards Spec Leads, Expert Group members, Adoption Group leads, and JCP members work together to evolve Java technology. Meet people working to gain more developer involvement in Java standards as well as the language and the platform itself. All levels of experience are welcome. You are sure to get your questions answered and will come away with some concrete activities you can get started on to help change the future of Java.
The goal of this session is two-fold, i.e. explain what Java EE 8 brings today and understand where Java EE is going tomorrow with the recently announced move of Java EE to the Eclipse Foundation.
We will start by covering in details the new capabilities added in Java EE 8:
- JAX-RS 2.1s new Reactive client API
- Bean Validation 2.0 improvements
- CDI 2.0 Asynchronous events
- Servlet 4.0 HTTP/2 support
- The addition of a new JSON Binding API
- A new Security API...
We will then conclude by discussing the move of Java EE to the Eclipse Foundation and what it exactly means for the platform and its relation with the MicroProfile.IO project.
Attend this session to understand what Java EE 8 brings today and where Java EE is going tomorrow!
In this session we'll explore the major new features of JDK 9, in detail, providing developers with enough information to be able to put them to use effectively. The session will cover topics like. The Java Platform Module System (JPMS). What is it and what does it mean for existing applications. Using Java modules in applicaiton development. How to mix existing jar files with modules. JPMS beyond the basics. How to use services and layers and how abour backwards compatibility? And some of the core JDK 9 Library improvements:.
The Kotlin programming language is developed by JetBrains and now is an officially-supported language for Android development. This half-day workshop aims to share with you the power and the beauty of the language. We imply that you consider using Kotlin in your every-day work and want to feel more confident with the language first. Well have a basic overview of the language, as well as a discussion of some corner cases, especially concerning Java interoperability. The workshop is based on your Java experience; it shows the similarities between two languages and focuses on whats going to be different.
Well cover:
* Basic syntax
* Nullability
* Object-oriented programming with Kotlin
* Functional programming with Kotlin
* Java interoperability
Kubernetes makes a orchestrating containers easy, but any technology that changes the way you workflow may impact security. This talk provides an overview of security concerns that come up as you move to containers and Kubernetes. It will go over relevant security features and common pitfalls. Then it will show these features in action as they mitigate the impact of vulnerabilities in a demo web application.
Interested in trying out Lambda and Streams features of Java 8? If so, this "higher-order lab" is for you. Participants will use JDK 8 and NetBeans to work on exercises intended to teach them about the Lambda feature of the Java programming language and the new Streams Library API. The exercises start off very simply, so that beginners can learn the fundamentals. Additional exercises covering grouping and parallel reduction aim to challenge more-advanced participants. Participants need not have any prior knowledge of Java's Lambda feature, although having attended a prior JavaOne Lambda session or tutorial will be helpful. The laboratory exercises have been updated to cover recently added Java 9 features.
Presentation: Looking for the Holy Grail of Mobile Web Performance
Theres a long-standing myth in the mobile world that only native apps are able to provide a decent performance for the mobile user. With the emergence of Progressive Web Apps that suppose to mimic all the native goodness, the push for performance in the mobile web is now stronger than ever before.
Is the Web Platform ready to keep up with these expectations? This talk is a wide overview of the many practices and strategies we can employ to satisfy our mobile users needs - from the HTTP-level tweaks via load and render time optimization to smooth scrolling and animations tricks.
Presentation: Lost in transaction? Strategies to deal with (in-)consistency in modern architectures
You probably work on a distributed system. Even if you don't yet face a serverless microservice architecture using a NoSQL database, you might "just" call some remote services via REST or SOAP. Welcome to a world without ACID transactions which leaves you in charge of dealing with difficult problems yourself e.g. eventual consistency, distributed transactions, compensation or message delivery semantics like "exactly-once"? In this talk, Ill briefly describe why this will become the new normal and which challenges arise for us as developers. I will discuss strategies to deal with it and present real-life experiences, including recipes, patterns, but also frameworks. Expect fun little live hacking sessions with Open Source components like Spring, Hystrix, Kafka and Camunda.
Plain Old Java Developer? Entranced by the magic of buzzwords like "Deep Learning", "Artificial Neural Networks", "Chat Bots", anything with the prefix "neuro", and "The AI Apocalypse Where They Come For Us All"?
There is a world out there of other Machine Learning techniques, unfairly cast aside in the tide of trends. They are tried and tested, sad, minor characters in the AI hype stage. But do you know what? You don't need to reach for the complicated allure of Neural Networks to add a bit of intelligence to your application.
Hands-on Lab: Make your own IoT device and service using open standards and open platforms
Develop your own IoT device and/or IoT service using open standards and open source platforms. During this IoT tutorial session we will show how to develop a low-cost, resource constrained, IoT sensor device that use standard protocols such as LWM2M and MQTT to connect to cloud. You will use open-source software and IoT devices that have WiFi and/or 6LoWPAN (802.15.4) for wireless connectivity. Before the hands on part starts up there will be a short introduction to some of the IoT protocols and the open source software that will be used during the session. You will be able to choose to develop in low-level C programming or use high level languages for both device and service software.
Method handles, Java's fast function pointers and functional adapters, were added in Java 7 to support new language features. Since then, they've been leveraged to make not only fast dynamic languages, but a richer set of features for Java itself. In this talk we will explore how you can use handles to improve your apps and libraries. We'll see how they wire up and optimize. And we'll play with the new loop and variable pointer handles in Java 9. If you've ever been curious about java.lang.invoke.*, this is the talk for you.
When the Microprofile initiative was started in 2016, it only took about three months
before version 1.0 was launched. From day one, there were four different implementations
from four different vendors available.
One year later, Microprofile 1.1 is here!
Whereas version 1.0 was a subset of Java EE specifications, version 1.1 brings something
new to the table. The new kid on the block is _MicroProfile Config_.
In this fast-paced, demo-heavy session, MicroProfile will be introduced and demonstrated
using the available implementations in live coding demos.
We will also take a look at the potential candidates for future versions. This will include
technologies such as Fault Tolerance, Security, Health Checks
Presentation: Mission Possible - Near zero overhead profiling
Java Flight Recorder is a low overhead profiling tool built into the Oracle JDK.
It is possible to turn on whenever you wish to investigate the behavior of your Java application, the data is then analyzed in Java Mission Control.
It is designed for production time usage, but it also useful during development.
JDK 9 includes a new supported API for creating your own events, and for controlling the JFR engine. JMC 6 includes a redesign GUI and automated analysis, which can be extended with your own heuristics and executed in JMC or headless.
Both JFR and JMC are currently in the process of being open sourced.
Why should we monitor our system? Why cant we just rely on the operations team anymore? They use to be able to do that. Whats currently changing?
Presentation content:
- Why do we monitor our system
- How did it use to work?
- Whats changing
- Why do we need to shift focus
- Everyone should be on call.
- Resilience is the goal (Best way of having someone care about quality is to make them responsible)
The Java SE Platform and the JDK are moving to a rapid, six-month release cadence, with the next release in March 2018. Well review the motivations for this change and discuss some of its consequences. We'll then take a look ahead at the pipeline of features currently in development in various projects in the OpenJDK Community including Amber, Panama, Valhalla, and Loom.
You pick up the keyboard, and select 'tanh'. 'Play'. The epochs rack up... Something doesn't feel right, things aren't converging, your HP is decreasing. But you've seen people do this before... The FAQ is useless, and the documentation is like boss level 99. You know it's possible - but What The Fowler is 'tanh' anyway? And How The Fortran does this work?
Neural Networks are hard. But don't worry, there is a walkthrough for this, and it has pictures.
Presentation: Offline-first apps with Web Components
We will explore how to boost the usability of web and mobile-web apps by implementing offline-first functionalities, it's the only way to guarantee 100% always on user experience. Low signal or no connectivity should no longer be a blocker for the user, we will discuss the available solutions for caching, in-browser database, and data replication. We will also take a look at how WC help solving those issues out of the box.
There will be a live coding demo to see how it's simple to manipulate a large data, completely offline.
MultiDevice controls are capable of adjusting their appearance according to the device they are running on (desktop, mobile). In addition the idea was to improve the user experience in a way that one can use a mobile device to enter data into your desktop software. You can think of an extension that makes it possible to use the capabilities like touch etc. of your mobile device to set parameters on your desktop software. To give you an idea we prepared a little demo that will show the possibilities of that concept. For the demo we make use of a JavaFX application but the concept could also be implemented in JavaScript etc.
Presentation: Pause-Less GC for Improving Java Responsiveness
The Open J9 Java VM recently introduced a new Pause-Less GC policy. This technology uses a new HW feature on the 390 platform to create a concurrent copying GC. The Pause-less GC policy significantly reduces pause times with minor to no throughput reductions. I will provide an overview of the new hardware feature, a deep dive into the technology, discuss the pause time improvements and future advancements.
Presentation: Polishing the Diamond: Core Library Improvements in Java 9
The Java Core Libraries are mature, well-understood and loved, but dont you always run into corner cases where they dont work so well? In this talk, which is entirely live-coded, you will learn key updates and improvements that youll get to enjoy in the next exciting version of Java: Java 9. You will also get to see the new REPL JShell in action as an educational tool. In this session you will learn about:
Collection factories
Improvements to Streams and Collectors
Improvements to Optional Data Type
If youve already heard a lot about project Jigsaw and want to know about what other Java 9 updates will rock your world, come to this talk!
Privacy and personal integrity has become a focus topic, due to the upcoming GDPR deadline in May
2018. GDPR puts limits on data storage, retention, and access, and also give users rights to have
their data deleted and get information about the data stored. This constraints technical solutions,
and makes it challenging to build systems that efficiently make use of sensitive data.
This talk provides an engineering perspective on privacy. We highlight pitfalls and topics that
require early attention. We describe technical patterns for complying with the "right to be
forgotten" without sacrificing the ability to use data for product features. The content of the talk
is based on real world experience from handling privacy protection in large scale data processing
environments.
Presentation: Processing Data of Any Size with Apache Beam
Rewriting code as you scale is a terrible waste of time. You have perfectly working code, but it doesn't scale. You really need code that works at any size, whether that's a megabyte or a terabyte. Beam allows you to learn a single API and process data as it grows. You don't have to rewrite at every step.
In this session, we will talk about Beam and its API. We'll see how Beam execute on Big Data or small data. We'll touch on some of the advanced features that make Beam an interesting choice.
Live Coding systems encourage us to think extremely differently about programming languages. In addition to considering standard requirements such as reliability, efficiency and correctness we are also forced to deal with issues such as liveness, coordination and synchronization all whilst working in real time. Live Coders not only run and modify our code live they often performing with it live on stage in front of large crowds of people who really don't want the code to miss a beat. In this code and demo-heavy talk, Sam will take a deep technical dive into the internal ideas and innovations of Sonic Pi a system designed specifically for live coding music. The audience will explore Sonic Pi's novel temporal semantics which allows multiple concurrent threads to execute in synchronizatio
Presentation: Project Loom: Fibers and Continuations for the Java Virtual Machine
As concurrent programs grow in scale, so does the disparity between the domain unit of concurrency (session/transaction), and the software unit of concurrency -- the thread. A modern server may support a million concurrent connections but only a few thousand threads. As a result, developers are forced to abandon the thread as a model of domain concurrency and rely on finer-grained constructs. The resulting asynchronous programming style is difficult to write, debug and maintain. Project Loom is a new OpenJDK project aiming to provide an alternative, flexible and lightweight implementation of threads that would allow a good abstraction to meet modern requirements, and enable new and useful programming styles. That implementation will employ continuations, which have other interesting uses.
Quickie: Project Loom: Fibers and Continuations for the JVM
As concurrent programs grow in scale, so does the disparity between the domain unit of concurrency (session/transaction), and the software unit of concurrency -- the thread. A modern server may support a million concurrent connections but only a few thousand threads. As a result, developers are forced to abandon the thread as a model of domain concurrency and rely on finer-grained constructs. The resulting asynchronous programming style is difficult to write, debug and maintain. Project Loom is a new OpenJDK project aiming to provide an alternative, flexible and lightweight implementation of threads that would allow a good abstraction to meet modern requirements, and enable new and useful programming styles. That implementation will employ continuations, which have other interesting uses.
Spring Framework 5 is here! One of the most exciting introductions in this release is support for reactive programming, building on the Pivotal Reactor project to support message-driven, elastic, resilient and responsive services. Spring 5 integrates an MVC-like component model adapted to support reactive processing and a new type of web endpoint, functional reactive endpoints. In this talk, we'll look at the net-new Netty-based web runtime, how existing Servlet code can run on the new world, and how to integrate it with existing Spring-stack technologies.
Ahh, reactive, probably the buzzword of 2017, newer and shinier than good ol' microservices, all asynchronous, non-blocking and I've even heard some event-driven buzz around it.
During this live-coding session we won't focus on the shiny nor on saving the world with dataflows using composable operators.
Instead we'll focus on how the execution of this reactive approach differs from 'classic imperative approaches' and check how it impacts resource consumption.
We'll also see backpressure in action, cover the topic of data marshalling and talk about event loops.
Quickie: Ready for Java 9 - Bridging the Gap Between Database and Stream
Whenever you write code that mixes languages and domains, such as Java and SQL, you are going to get bugs. A solution is to move away from query languages such as SQL and instead write your business logic with the type-safe and object-oriented constructs we have learned to love in Java, such as streams, predicates, and functions. The Stream interface that came in Java 8 and was expanded in Java 9 will be introduced in this session, you will rediscover the power of the Stream interface in a completely new domain: relational databases. You will also learn how nicely it blends in with your existing application, even with no modifications on the database layer. This will not only increase your productivity but also help you build safer and more maintainable Java code.
Dealing with real-time, in-memory, streaming data is a unique challenge and with the advent of the smartphone and IoT (trillions of internet connected devices), we are witnessing an exponential growth in data at scale. Learning how to implement architectures that handle real-time streaming data, where data is flowing constantly, and combine it with analysis and instant search capabilities is key for developing robust and scalable services and applications.
In this deep dive session, we will look at how to implement an architecture like this, using reactive open source frameworks. An architecture based around the Swiss rail transport system will be use throughout the presentation.
Presentation: Renode, an open source simulation framework for developing robust, well rested ARM and RISC-V systems
The open source Renode framework, developed by Antmicro, is a flexible simulation framework meant to revolutionize development of embedded systems by enabling a workflow with Continuous Integration (CI) that is notoriously difficult to perform with physical devices.
Renodes target is to simulate not only CPUs but entire SoCs and development boards including sensors. Hence, unmodified firmware / software, identical with that used on physical hardware, can be run in Renode without the need for using special compilation targets. Renode supports many CPU families such as ARM, x86 and the new RISC-V architecture. The presentation will cover Renode, focusing on the landmark features and the recent development in the RISC-V domain, including a demo of multiple RISC-V based nodes.
Security is a hot topic. But most developers don't like security. Why? Because it's hard and it doesn't matter how much time you spend on it. Sooner or later some white hat hacker does a penetration test and claims you "pwned" so what's the point?
Secure by Design solves this using patterns that implicitly promote security. It allows you to focus on delivering features rather than thinking about security guidelines & policies. In this tutorial, we share several of these patterns using code and discuss how they promote security attributes such as confidentiality, integrity, and availability (CIA). We also relate them to the new edition of OWASP Top 10 2017 and discuss how they apply to your daily work, regardless if you're working with legacy code or brand new state of the art software.
While the Internet of Things (IoT) brings billions of devices online, it was only a matter of time before they become the target for hackers and cybercriminals. Security has become a hot topic; as the majority of IoT devices have been built using low powered, resource constrained micro-controllers that are difficult to secure or have been built on top of operating systems that expose sloppy security practices and vulnerabilities. RIoT Secure has developed a device agnostic secure end-to-end device management solution for the complete lifecycle of IoT devices. This talk will dive into topics on what is required to building such a platform, covering the challenges and compromises that must be made - through to a live demo utilising an Arduino UNO, the achilles heel of IoT devices.
Presentation: Security today and tomorrow : Adapting the rules to suit technological advances
From Hexagonal to Micro Services, from 3 Tier applications to BlockChain, as design patterns and technologies advance, so too must the security recommendations we apply to these systems. What was critical to keep in mind previously may no longer be an issue simply because the constraint that gave rise to it is no longer around.
But as we see time and again in software development, sometimes that which is old becomes new again, and so it's equally important that we look over the security patterns we've successfully used in the past and how they are still relevant even though the buzzwords have changed!
Presentation: Serverless Architecture Patterns and Best Practices
AWS Lambda has changed how developers build and run their applications or services. But what are the best practices for tasks such as deployment, monitoring, and debugging in a serverless world? In this session, well dive into best practices that serverless developers can use for application lifecycle management, CI/CD, monitoring, and diagnostics. Well talk about how you can build CI/CD pipelines that automatically build, test, and deploy your serverless applications using AWS CodePipeline, AWS CodeBuild, and AWS CloudFormation. Well also cover the built-in capabilities of Lambda and API Gateway for creating multiple versions, stages, and environments of your functions and environments of your functions and APIs. Finally, well cover monitoring and diagnostics of your Lambda functions.
In this deep dive w will explore the Serverless paradigm by diving into the Serverless manifesto first and by explaining the differences between Serverless, FaaS, and PaaS. Then we'll look at the different Cloud vendors and what they have to offer in the Serverless space. After the theoretical first part, I'll start developing some functions with AWS Lambda, since it is by far the easiest entry point into the world of Serverless. Then we take a step back and look at how existing architectures (ie modern web applications) will be impacted. Where does it actually make sense to use this kind of technology and where doesn't it. Finally I will end with a number of drawbacks to consider and to make it a balanced story of both pros and cons. Besides AWS Lambda, we'll look at alternatives.
In this session, we'll start with a short introduction to Serverless and what it means to developers, and why it's important to understand this technology. Then we'll survey Serverless options on the Java ecosystem to give you an idea of what is currently available.
Are you still using Docker in production? Get over it! Serverless is the NEW future of the Cloud. But since the Cloud is still someone else's computer, that needs to be managed too. And if it is sitting idle, you probably have to pay for it whether you like it or not. No server can be more easily managed than no server. Therefore: meet Serverless, a new paradigm that truly approaches the Pay-as-You-Go philosophy once promised by the Cloud.
This talk explores Serverless, its impact on existing architectures, and assesses it's usability for Mobile Back-ends as a Service (MBaaS), Functions-as-a-Service (FaaS) and also for Microservices based architectures hosted in the cloud. Internet connectivity permitting, there will be demos too.
The first generation of microservices was primarily shaped by Netflix OSS and leveraged by numerous Spring Cloud annotations all throughout your business logic. The next generation of microservices will leverage sidecars and a service mesh. In this session, we will give you a taste of Envoy and Istio, two open source projects that will change the way you write distributed, cloud native, Java applications on Kubernetes. Traffic shaping, network fault-injection, A/B testing, dark launches and much more. A highly distributed application based on microservices brings a number of additional complexities to your application architecture, increasing the weight/size of each of your components, mixing infrastructure logic within your business logic.
Shenandoah is the ultra-low pause garbage collector for OpenJDK, developed by Red Hat. It adds concurrent compaction to the mix, making all heavy-weight phases in GC cycles concurrent. This talk is about brief status for Shenandoah in 2018 and what changed in past years, the performance
successes it has, the challenges faced by the implementation, the ideas that are being tried.
Developing applications with Spring Boot is already a pretty magical experience, but could it be better? Can the magic get any more powerful than it already is?
In this talk, we'll look at how Kotlin can be used to reduce boilerplate, increase code quality, and elevate your wizardry. The presenter will demonstrate how to begin incorporating Kotlin into your existing Spring applications and, once you start your journey, where it can lead. Come to this session to level up on Spring+Kotlin! (Robes optional)
Presentation: Streaming Data Analysis with Kubernetes
Dealing with real-time, in-memory, streaming data is a unique challenge and with the advent of the smartphone and IoT (trillions of internet connected devices), we are witnessing an exponential growth in data at scale.
To be able to handle potential data growth, you want to process data in a cloud environment that can easily scale. In this space, Kubernetes offers great container orchestration and auto-scaling, and when combined with Infinispan, an in-memory data grid, it empowers you with state of the art distributed data processing capabilities to tackle these challenges.
In this session, we will identify critical patterns and principles that will help you achieve greater scale and response speed, and you will see them in action with live coding examples.
Internet of Things is a hot buzzword these days, but this talk is about the nitty-gritty practicalities of it. How the heck can we remote-administrate and remote-update a bunch of devices that are inside houses and buildings all over the country, stuck behind unstable networks and unknown firewalls? How can we do agile development and continuous delivery under those circumstances?
The past year Ive been neck deep in code, developing and rolling out a smartmeter for solar energy (well, a raspberry Pi in disguise...). We naively thought the icky infrastructure part was solved and all we had to do was build the application. Wrong! 95% of the work was infrastructure, and only 5% application. So what did we build, and what did we learn along the way?
Presentation: The Eclipse OpenJ9 JVM: a deep dive!
Interested in learning how a JVM actually works? Want to understand the design of the Eclipse OpenJ9 JVM, formerly IBM's J9 JVM? IBM open sourced their enterprise production hardened JVM at the Eclipse Foundation as the OpenJ9 JVM. Come to this session to learn the design principles behind the OpenJ9 runtime and the key advantages of this JVM, particularly for Cloud deployments. Follow your application code as its loaded, linked, and excuted on OpenJ9.
Want to learn the shortcuts and see the benefits of a modern programming language that have swept the Android developer community of their feet?
This presentation is packed to the limits with code examples of how Kotlin have made my code more elegant, readable and safer. For all of you that can't move up to the latest JVM versions, or just want to learn something new, here is your chance of using the perks of a modern programming language.
Presentation: The Fn Project, Serverless Everywhere and Anywhere
Serverless computing is one of the hottest trends in computing right now due to its simplicity and cost efficiency. The Fn Project (https://fnproject.io) enables you to run your own serverless infrastructure wherever you want on-premise or in the cloud. Built on Docker, Fn supports writing functions in every popular programming language with excellent support for Java. All you need is Docker and you're ready to go!
1) Look at how to use Fn with a demo.
2) Walk through writing functions in Go, Node.js, and Java and deploy them.
3) Discuss how the platform is implemented including packaging, input and output, the nitty gritty on running short-lived Docker containers and hot functions to increase performance
4) How to operate and scale Fn.
5) Q&A
Hourly prices for electricity is on the rise. With smart controlling of the consumption of electricity we can save both money and the environment. In this speech we take a closer look at a solution for a more intelligent charging of electric vehicles. With the unofficial Tesla API and electricity price forecasts we can charge the vehicle during the most beneficial hours, without user interaction.
Since Gradle 3.0, a Kotlin based DSL that allows better tooling, type-safety, and unprecedented expressiveness, can be used to author Gradle build scripts.This comes with a richer IDE experience, with more precise content assist, quicker access to documentation, better source code navigation, refactoring and more when working on your build.
In this presentation you will learn how you and your team can start taking advantage of the Kotlin DSL in Gradle, the improved IDE support and the faster configuration times.
Reactive Programming, Reactive eXtensions, Reactive Streams, Reactive Systems, Reactive Manifesto, thats a lot of 'reactive' thingies. Just to make it even more confusing, 'reactive' is often associated with asynchronous, scalability, RX libraries (RX Java, RX-JS), back pressure, streams, observables, futures, promises, spreadsheets and so on . That's a lot to digest This session helps you understand what's behind the reactive word. It explores the reactive landscape and explains what all these 'things' are and how they are related. By providing a global overview of the reactive landscape, this session also provides to the attendees a general understanding of the 'reactive' trend, and why it matters.
Presentation: The Three Software Stacks Required for IoT
Whether youre looking at the constrained devices that make for the "things" of the IoT, gateways that connect them to the Internet, or backend servers, theres a lot that one needs to build for creating end-to-end IoT solutions.
In this session, we will look at the typical software features that are specific to IoT, and see whats available in the open source ecosystem to implement them.
We will also dive into the architecture of some real-world solutions that have been built on top of Eclipse IoT technologies, and learn about the software behind them.
Presentation: To JAR Hell And Back - A Live Migration to the Java 9 Module System
I'm sure you've heard about compatibility issues with upgrading to Java 9 and the new module system but did you try it yourself yet? This live coding session starts with a typical Java application and runs up against and eventually overcomes the common hurdles:
* build system configuration
* dependency analysis with `jdeps`
* dependencies on internal APIs and Java EE modules
* split packages
* stepwise modularization with automatic modules
To get the most out of this talk, you should have a good understanding of the module system basics - afterwards you will know how to approach *your* application's migration to Java 9 and the module system.
Everyone knows there isn't just one way of doing things. This is also true for web-administrated Embedded Devices and a lot of different ways to attack the implementation were taken before the combination of Golang and Typescript manifested. Plenty of the tries started by missing knowledge, inability, the hate of some programming languages or just plainly on size requirements.
Over Java and C/C++ to Go+Lua, Go+JavaScript and the final decision on Go and Typescript, we follow the adventure of an embedded framework and the arising problems. Pros and Cons but also the feeling for a Java developer and new horizons are given.
Presentation: Using Developer Testing to Boost the Quality of Your Code
Quality cannot be tested in. It has to be built in. While very true, this phrase is also a true cliché in our industry. What does it actually mean, who is supposed to do what and how? Developer testing is the developers intentional and systematic employment of testing tools and techniques to achieve the highest possible quality of the software that they create and it provides the answers to the above questions.
In this talk, I'll give a short introduction to developer testing based on the nine core competencies, and Ill explain how to use them to improve your development process as well as to identify your teams next step. Obviously a team maintaining a legacy monolith and struggling with quality issues faces a different challenge than the team that starts out afresh doing TDD.
9.00-9.45 Shenandoah GC: What We Know In 2018
Shenandoah is the ultra-low pause garbage collector for OpenJDK, developed by Red Hat. It adds concurrent compaction to the mix, making all heavy-weight phases in GC cycles concurrent. This talk is about brief status for Shenandoah in 2018 and what changed in past years, the performance successes it has, the challenges faced by the implementation, the ideas that are being tried.
10.00-10.45 Escape Analysis in V8
Turbofan is V8's new optimizing Javascript compiler, which uses an unscheduled sea-of-nodes intermediate representation. After a short introduction to Turbofan's design, we explore the challenges encountered when implementing Escape Analysis for Turbofan. Escape Analysis is a compiler optimization that allows to remove or postpone the allocation of temporary objects, potentially storing the object fields in registers instead. This reduces load on the garbage collector and removes memory access instructions. To make the analysis phase fast enough while keeping the implementation readable, we used of a purely functional data structure to share data when storing the state of all objects at all points in the code.
11.45-12.30 Pause-Less GC for Improving Java Responsiveness
The Open J9 Java VM recently introduced a new Pause-Less GC policy. This technology uses a new HW feature on the 390 platform to create a concurrent copying GC. The Pause-less GC policy significantly reduces pause times with minor to no throughput reductions. I will provide an overview of the new hardware feature, a deep dive into the technology, discuss the pause time improvements and future advancements.
13.30-14.15
Project Loom: Fibers and Continuations for the Java Virtual Machine
As concurrent programs grow in scale, so does the disparity between the domain unit of concurrency (session/transaction), and the software unit of concurrency -- the thread. A modern server may support a million concurrent connections but only a few thousand threads. As a result, developers are forced to abandon the thread as a model of domain concurrency and rely on finer-grained constructs. The resulting asynchronous programming style is difficult to write, debug and maintain. Project Loom is a new OpenJDK project aiming to provide an alternative, flexible and lightweight implementation of threads that would allow a good abstraction to meet modern requirements, and enable new and useful programming styles. That implementation will employ continuations, which have other interesting uses.
14.30-15.15
ZGC - Low Latency GC for OpenJDK
ZGC is a new garbage collector for OpenJDK, optimized for low latency and very large heaps. We've developed ZGC internally at Oracle so far, and we're now open-sourcing it so as to broaden the base of both contributors and users. This talk will give an introduction to ZGC, what it is, how it works, where we are and what we plan to do.
15.45-16.30
Falcon new JIT compiler in Zing JVM
Falcon is the new JIT compiler for Zing JVM, which has replaced our C2 compiler. The new compiler is based on the LLVM infrastructure and focuses on improving peak throughput performance. LLVM had originally been used as a static compiler for C/C++. It has taken us a lot of work upstream to teach LLVM how to compile Java code efficiently. In this talk we will discuss the difference between a static compiler for C/C++ and a JIT compiler for Java and will cover GC support, deoptimizations, and Java specific optimizations. Building a new compiler is no small feat. In the talk you will find out why we decided to write a new compiler and will see examples of how Falcon speeds up execution.
Presentation: Vue.js - developer friendly, fast and versatile
Vue.js is a client side JavaScript framework that is developer friendly: a command line interface to create new projects, easy to learn concepts, great online documentation, and top of the league developer tools. All this will get you started in no time working on modular and maintainable apps.
Under the hood there is a fast state of the art rendering engine applying unidirectional data flow and virtual DOM that eliminates manual optimizations. Transitions are already part of the core engine so your apps will look fancy, too!
Join me for this talk to see how simple and advanced applications can look like. I also provide a brief overview of the ecosystem.
Weve started to use Vue.js in early 2016 and this talk is based on our day-to-day experience.
Quickie: We Are All Equifax: Data Behind DevSecOps
In March 2017, hackers took three days to identify and exploit a new vulnerability in Equifaxs web applications. In the post-Equifax world, moving new business requirements (e.g., a non-vulnerable version of Struts2) into production in under three days might just be your new normal. Join this session to better understand how DevSecOps teams are applying lessons from W. Edwards Deming (circa 1982), Malcolm Goldrath (circa 1984) and Gene Kim (circa 2013) to improve their ability to respond to new business requirements and cyber risks.
Web Components may be the future of UI components. Let's try it out in practice by building hello world applications with a couple of different web application frameworks. Through this, we will learn about both the good and the bad parts, and see what the future might hold.
Presentation: When you need to add Deep Learning to raise your next round of funding
We all love working inside the JVM (personally I love Scala), but sometimes the new shiny thing doesnt fit easily into our existing ecosystem.
The rise of Apache Spark brought in lots of Scala developers, but now to keep up with the next shiny thing we need to be able to look at how we can play more nicely with tools (like deep learning) that are created beyond the wonderful JVM land.
There was a time when playing nicely could mean a pipe of strings, but now days the bar is a little higher. We will look at how Apache Spark is using Apache Arrow to integrate more nicely into the world beyond. In addition to Arrow well examine the different approaches taken in Apache BEAM to support a wide ecosystem of client languages. We'll finish with a DL example so you can close your series B*.
Presentation: Winning a Pulitzer Prize with open source software The Panama Papers story
The largest ever known leak of confidential information occurred in 2015 when 2.6TB of data was leaked from a Panamanian law firm. A worldwide team of journalists secretly began work on making sense of this trove of unstructured data. In 2017 the journalists were awarded the Pulitzer Prize.
Making this possible was a team of three developers who built a platform for data processing and analysis, enabling over 400 journalists to mine the data. They used a toolchain of open source software to convert the files to a searchable set of different kinds of entities.
Neo4j was one of the last stages of the platform, powering queries and exploration of the semantic data extracted from the files. Come get a glimpse of how the journalists used Neo4j to make sense of the Panama Papers.
Presentation: You asked for it, you got it: type safe Actors
Akka Typed is the next generation of the actor model APIs in Akka, providing what many have asked for:
Using the type system to guarantee actors are only sent messages they can handle. After three long iterations of trying to formulate an API for typed Actors that makes sense we have finally found the right level of abstraction to build upon.
In this talk we will take a closer look at the new Akka Typed APIs and how they allow you to achieve type safe asynchronous message driven systems, scaling up across many cores and out across many machines.
ZGC is a new garbage collector for OpenJDK, optimized for low latency and very large heaps. We've developed ZGC internally at Oracle so far, and we're now open-sourcing it so as to broaden the base of both contributors and users. This talk will give an introduction to ZGC, what it is, how it works, where we are and what we plan to do.