Schibsted is a global media conglomerate with about 200 million unique users per month. The company is currently being transformed into a unified global media giant. To do this, Schibsted needs to collect data about user behaviour, and process that data with machine learning.
This presentation is about we built Schibsted's infrastructure for receiving and processing this behaviour data, which at the moment comes to 700 million events per day, or 2 terabytes per day. The presentation covers the architecture, design of individual services, monitoring, and challenges in scaling and reliability. It also goes into the interaction between legal privacy requirements and overall architecture.
Key technologies used ae Amazon Web Services, Scala, Datadog, Kinesis/S3, Docker, Mesos, and Spark.
Presentation: A Test-Driven Approach to Documenting RESTful APIs
Documentation generated from source code is very popular. Solutions such as Swagger are available for many different languages and frameworks. However, limitations of annotation based tools are becoming apparent. An overwhelming number of documentation annotations make for great docs but muddy the source code. Then, something changes and the docs are out of date again.
Test-driven documentation solutions, such as Spring Rest Docs, generate example snippets for requests and responses from tests ensuring both code coverage and accurate documentation. It can even fail the build when documentation becomes out of date. This session will walk through how to implement test-driven documentation solutions for groovy ecosystem technologies like Spring Boot, Grails, and Ratpack.
Presentation: Adventures in SEO and single-page web apps
Search Engine Optimization (SEO) and Single-Page Apps (SPA) are by nature incompatible since the latter serve all the content under the same URL.
In many cases, its even not desirable to index - e.g., the checkout page of an e-commerce application. And yet, some use-cases mandate for indexing: products from the catalog of the same application should be indexed by Google so that they appear in search results.
How can such different approaches can be reconciled? Come to this talk to learn about the answer!
Akka Distributed Data builds on Akka Clustering to provide an easy way of sharing data across a cluster of nodes. It uses a special data representation called Conflict Free Replicated Data Types (CRDTs) to allow sharing the values across the cluster without central coordination. This session will give an overview of CRDTs and then dive into the details of how they are used in Akka Distributed Data. Through Scala code examples you will learn how to use CRDTs in your own Akka applications.
In this university session we are going to cover some less known areas of Angular 2.
These are:
- Advanced Component techniques. Creating a Structural Directive (ngFor, ngIf)
- Angular 2 Animations. Creating an animation sequence.
- Angular 2 and Redux. How to use ngrx/store and ngrx/effects.
- Angular 2 in Production. Ahead of Time Compilation.
Be prepared for a few bumps. We are going off-track!
Akka Streams is an implementation of Reactive Streams (http://www.reactive-streams.org) for the JVM providing asynchronous processing with non blocking back pressure of potentially infinite streams of data. In this talk we'll cover what Reactive Streams is, why you shouldn't implement it yourself and how Akka Streams makes it easy to define and compose streaming pipelines of back-pressured asynchronous processing stages.
Angular 2 is a framework which eases the development of modern JavaScript applications.
This talk will present the framework, its concepts (component approach, services, dependency injection, forms, routing, validation, tests, etc.) and foremost what is behind the Angular magic. All JavaScript frameworks work roughly the same way: they help the developer to react to application events, to update the application state, and to refresh the DOM accordingly. But they dont all use the same way to achieve that goal. Angular 2 comes with its great solution: the change detection mechanism with the concept of Zones.
Everyone is talking about microservices, but there is more confusion than ever about what the promise of microservices really means and how to deliver on it. In this talk we will explore microservices from first principles, distilling their essence and putting them in their true context: distributed systems.
Hands-on Lab: Build a Time Series Application with Spark Streaming, Kafka and HBase
More and more applications have to store and process time series data, a very good example of this are all the Internet of Things IoT applications.
This hands on tutorial will help you get a jump-start on scaling distributed computing by taking an example time series application and coding through different aspects of working with such a dataset.
We will cover building an end to end distributed processing pipeline using various distributed stream input sources, Apache Spark, Kafka API and Apache HBase, to rapidly ingest, process and store large volumes of high speed data.
You will learn the key features of Spark Streaming for processing live data streams ingested from sources like Apache Kafka, sockets or files, and storing the processed data in HBase.
Presentation: Building a PWA with Ionic, Angular and Spring Boot
In this session, you'll learn how to build a Progressive Web App (PWA) using Ionic, Angular and Spring Boot. PWAs are being hyped as the next big thing in mobile development. This talk will cut through the hype and get down to the nitty-gritty. Are they really better than native applications? Can you develop PWAs and easily target mobile and desktop with the same application?
Presentation: Building cross-platform mobile apps with React Native
There's nothing more expensive than building the same thing twice. Yet that is what a lot of companies do when they publish a mobile app: they build one for Android and one for iOS. But wait, you don't have to! Using React Native, you can build one mobile app for both platforms from one code base using a language you're probably already familiar with - JavaScript.
In this session, we'll discuss building a simple word game app for both iOS and Android. First, we'll dive into how React Native works and how to build a basic application. Then, we'll dive into the Redux framework, which helps us building predictable state and allows for great testability of our application. Finally, we look at how the two integrate and how the game is built.
Presentation: Building Progressive Web Apps with Polymer
Learn all about the future of web applications through Progressive Web Apps: what they are, who has made them, and how to build one yourself. We will touch on how to add a Service worker, enable Add to home screen, build a sleek, responsive design with Polymer, and more!
Quickie: Case Study: What can IoT do in a Facility Management situation?
Microsoft, together with Yanzi Networks, Intel and Coor have created an IoT solution that tracks different assets in real-time in an office environment to get insights in how it is used and take actions on this to make the environment better.
This session is a behind the scene presentation of that solution, both on an architecture and a technical level.
The whole solution is open sourced on https://github.com/buzzfrog/annero-demo. (It uses services in Microsoft Azure.)
Presentation: Comparison of Open Source Frameworks for Integrating the Internet of Things
This session shows and compares open source frameworks built to develop very lightweight applications or microservices, which can be deployed on small devices with very low resources and wire together all different kinds of hardware devices, APIs and online services.
The focus of this session is the comparison of open source projects such as Node-RED or Flogo, which offer a zero-code environment with web IDE for building and deploying integration and data processing directly onto connected devices using IoT standards such as MQTT, WebSockets or CoaP, but also other interfaces such as Twitter feeds or REST services.
The end of the session compares these open source projects to other options such as SaaS offerings like AWS IoT or more powerful streaming analytics platforms.
Presentation: Continuous Delivery of Microservices
Today, mature development teams can push code to production as frequently as they like, with fully automated delivery pipelines. Meanwhile more and more organizations are transitioning their systems into a microservice style architecture. But how do you create new microservices efficiently without a lot of time consuming and error-prone manual work so you that you can focus on delivering business value as soon as possible? In this talk I share my experiences from working with continuous delivery and microservices. Well take a look at how to automate the setup of new microservices and how to painlessly delivery them to production in no time.
I gave my first IoT presentation over a decade ago. The response was overwhelming, and I've been waiting for the IoT tidal wave to land ever since. Strangely, it has not. Why not? Fast-forward through those ten years, and I have learned countless lessons. Join me as I review the strengths and weakness of hardware platforms designed to get you to market, examine how Big Data may just hold the key to IoT success, and glimpse at an AI-powered future.
The web is a hostile place. Browser variance, invasive plugins, unstable networks, evolving languages and tools, and complex systems--our JavaScript apps will inevitably break. When they do, we need to be ready to debug the problem and fix it fast. We'll debug errors live in a demonstration of debugging techniques and tools.
Come along, and let's build a better web.
What is the main metric you monitor to judge the health of your system? Average CPU load? The slowest query in DB?
We have talked with many teams, both developers and operations, about what they monitor and what metric they collect to assess the health of their product. Too many times we heard about CPU monitoring, log aggregation, average response times etc. Only in rare cases end-user satisfaction and its impact to business was measured.
From this talk attendees will learn:
* why you should invite business people to help define important monitoring metrics
* why monitoring only technical gauges is not enough
* the most misleading metric: the average value and the power of percentiles
Machine learning has seen a flurry of recent progress thanks to the growth of big data, fast hardware and clever algorithms. And Java is uniquely well suited to harness this technology, with new Spark-based tools like h20 and dl4j. With these open source libraries, developers can harness recent advances in deep learning to discover new and untapped patterns in images, sound and text. Join us and learn how to train your own machine learning models using open source data and tools. We'll demonstrate how to train a simple model for recognizing handwritten digits using the MNIST dataset, and illustrate a number of common mistakes when doing so. Attendees can clone https://github.com/breandan/deep-learning-samples to get an early look.
Machine learning has recently made enormous progress in a variety of real-world applications, such as computer vision, speech recognition and language processing. And now, Java has the libraries to help you apply these techniques to large data sets, with new Spark-based tools like deeplearning4java (DL4J).
In this workshop, you will learn the basic building blocks for deep learning: gradient descent, backpropogation, model training and evaluation. We'll cover how to build and train supervised machine learning models, give you an overview of deep learning and show you how to recognize handwritten digits. You will gain an intuition for how to develop custom models to discover new insights and untapped patterns big data.
No prior experience in machine learning is required.
Hands-on Lab: Developing microservices using Spring Cloud, Netflix OSS and Docker
In this hands-on lab you will build a set of collaborating microservices from ground up using Spring Boot, Spring Cloud, Netflix OSS and Docker. We will provide a virtual machine (based on VirtualBox) for you to download. The virtual machine will contain all tooling required for the workshop.
The hands-on lab is based on the blog series: http://goo.gl/HLIX7q
Presentation: Device-to-Device Sensor Communication in Home Healthcare
My grandmother the cyborg , has titanic screws in her right foot, shoulder joint replacement in both hear shoulders, spinal fusion, a quintuple bypass and she is a competitive fisher
The talk is about IoT's roll and possibility for working AAL(ambient assisted living) in general. And in detailed how to make a Smartphone-Centric Device-to-Device Sensor Communication for User Mobility in AAL. That could provide a mobility , flexibility and reliability system in order to avoid the risk of losing critical data. Data that may be safe life.
How can we built a system will let my grandmother be able to have the same safety and direct access to her healthcare provider when she is fishing, new trophy put on her shelf , as would she be at home watching fishes on discovery channel.
Dockerizing Java applications may seem simple, but it meets several challenges
related to configuration management, service discovery, licensing, dependency
management and scaling. This workshop will cover some practical aspects of running
Java inside containers:
- Choosing base image: be aware of the license and size DOES matter
- Simple use cases: creating Docker containers for Tomcat, Spring Boot, WebLogic
- Planning Docker image hierarchy:
- Docker containers for Application servers
- Fat JAR vs. thin JAR
- Performance considerations: mapping JVM settings to container limits
- Multi-container setups and service discovery
Presentation: Does JavaScript Make Sense in the Enterprise?
JavaScript in the enterprise? Does that even make sense? After years of developing Java applications in the enterprise, many developers have become curious about what JavaScript can do for them. But how can you translate concepts like 'modularity' and 'loose coupling' to JavaScript applications? Do JavaScript applications have these kinds of concepts? AngularJS is a popular solution in the JavaScript world, though there are many other solutions, too. In this session, you will be introduced to RequireJS, responsive JavaScript, mobile development with JavaScript, as well as JavaScript transpilers such as GWT, Vaadin, and DukeScript.
By the end of this session, you will have a thorough understanding of whether JavaScript is a good solution for you in developing enterprise JavaScript apps.
They say it is a multi-core world. Really? You may have to fight to get more than one VPU at customer sites. Even when on an actual physical multi-core, keeping all cores busy usually isn't the hardest problem you face. You may see all your cores working all out, but it may be a lie. Even if they seem busy, your cores might be "bored". They may be stalled for memory access, or at least not use their instruction-level parallelism to the fullest. We will look at some small code examples that might surprise you, even if you think you know of the importance of cache locality, pre-fetching, and branch prediction. There is no general magic solution, but we will get you started thinking the right way, give you some tips, and perhaps make you question some of the accepted "truths" of performance.
Presentation: Effective and Clean Java Code? Tips and Tricks from the Real World
Java has turned 20, but we still havent figured out how to create great Java code. Of course, we have examples of great developers and great code, but shouldnt it be something common rather than unusual? Weve seen Domain-Driven Design, Effective Java, Clean Code, Refactoring, Design Patterns.... But sometimes its still hard to apply all these great concepts in our projects. And we want to make proper use of encapsulation, immutability, the Law of Demeter, and lambdas. What we need is a proven set of tools, tips, and tricks gathered from successful real-world projects. We want to know how we can stop using basic types such as String, BigDecimal, List, and Map and how we can encapsulate information to craft great code. Attend this session to see code directly from the trenches.
gRPC is a high performance, open source, general RPC framework that puts mobile and HTTP/2 first. gRPC is based on many years of Google's experience in building distributed systems - it is designed to be low latency, bandwidth and CPU efficient, to create massively distributed systems that span data centers, as well as power mobile apps, real-time communications, IoT devices and APIs. It's also interoperable between multiple languages.
But beyond that fact that it's more efficient than REST, we'll look into how to use gRPC's streaming API, where you can establish server-side streaming, client-side streaming, and bidirectional streaming! This allows developers to build sophisticated real-time applications with ease.
Presentation: Event sourcing in practise - lessons learned.
We have all heard how great event sourcing and CQRS is. We have read about how they solve all the problems and how easy it is. We put the first part of our event sourced system in production almost two years ago. Since then it has gotten many friends. Within our team we have multiple services consuming and producing events, splitting the workload. Multiple other teams are also consuming events and there are ideas to create many more event sourced services. But it is not always easy, both the code and business is hard to convince sometimes. In this talk i will present what we have done, how we did it and what we have learned.
Quickie: Expect the Unexpected: How to Deal with Errors in Large Web Applications
Dealing with unexpected exceptions on the server side is something we've all done for ages. Now it's time to apply the same quality goals and monitoring to our javascript codebase. This is especially important for large web applications where the front-end usually contains 100k+ lines of code. I'll demonstrate various powerful monitoring techniques and logging tricks that we are using ourselves at Bryntum. You'll never have to read a callstack again!
Quickie: Experiences from using discovery services in a microservice landscape
One of the most important components in a microservice landscape is the discovery service. During the last few years a large number of alternatives for service discovery have evolved, specifically in the area of container infrastructures.
This presentation will, based on my experiences, go through some of the alternatives. The presentation will cover discovery service components in Netflix OSS, Docker Swarm, Amazon ECS and Google Kubernetes. We will also cover how to write microservices that are independent of the selected discovery service, i.e. that can be used with any of the alternatives without requiring modifications of the code.
By now Java 8's features are well understood.
But best practices are still forming.
Did you ever wonder ...
* ... how to create a "lambda-enabled" API?
* ... whether your methods should return or even accept streams and how that might impact your design?
* ... how to write readable stream pipelines, especially when exceptions are involved?
* ... how to estimate and examine stream performance?
* ... about the details of and opinions on Optional?
* ... how to use default methods to evolve interfaces without breaking client code?
This talk will discuss these and other advanced topics of Java 8, so you can get the best out of its awesome features.
Presentation: Fast Cars, Big Data - How Streaming Can Help Formula 1
Modern cars produce data. Lots of data. And Formula 1 cars produce more than their share. I will present a working demonstration of how modern data streaming can be applied to the data acquisition and analysis problem posed by modern motorsports.
Instead of bringing multiple Formula 1 cars to the talk, I will show how we instrumented a high fidelity physics-based automotive simulator to produce realistic data from simulated cars running on the Spa-Francorchamps track. We move data from the cars, to the pits, to the engineers back at HQ.
The result is near real-time visualization and comparison of performance and a great exposition of how to move data using messaging systems like Kafka, and process data in real time with Apache Spark, then analyse data using SQL with Apache Drill.
Presentation: From mess to masterpiece? Leagacy code transformation
How a migration to MicroServices could change the team, architecture and coding culture.
What you could you do and how you could transform a "Jurassic Park" into a lightweight environment.
In this talk we will explore the strategy, techniques, pattern and tools I used to
transform a team and the architecture that was grown over 15yrs.
This will be a mix of pattern, tools and techniques that was able to migrate
old systems, used inside insurance and banks.
We had to migrate fat systems with a few million lines of code...
Java 8 provides us with new APIs to support a functional programming style. While the standard provides us with a good basis, we sometimes wish for even shorter or powerful ways to write clean code for complex tasks.
In this talk I will show you some additional libraries for Java 8 (and beyond) which give you this little extras here and there. I will cover a wide variety of use cases like filter/map/reduce, stream API add-ons, lambdas with unit testing, SQL query support.
Have you ever wondered how your Java code turns into byte codes?
Lets have a look under the hood of the OpenJDK java compiler! You will find that it is surprisingly easy to understand and even modify. Several pieces that may puzzle you in your everyday work, such as synthetic methods will fall into place once you have seen the the compilation process from the inside. As an exercise we will add support for goto statements in Java: we will show you how to write, compile and debug Java code with goto statements! We will also see demonstrate how a small modification would allow you to compile lambda statements for older JVMs and how compiler plugins and annotation processors easily allow you to hook into the compilation process.
For the daring: goto presentation;
HotSpot's optimizing Just-In-Time compiler C2 is reaching its end-of-life and it's time to look for alternatives. One very promising replacement candidate is Graal. Graal is a Java JIT compiler written in Java. It is being developed by Oracle Labs for a couple years now and has reached a state where it's viable to be that replacement. Twitter's huge distributed system tickles every corner of the JVM and is the perfect testing ground for a new JIT compiler technology like Graal. This presentation will talk about Twitter's experiences with Graal, good and bad, the bugs we found and also the wins.
HotSpot's optimizing Just-In-Time compiler C2 is reaching its end-of-life and it's time to look for alternatives. One very promising replacement candidate is Graal. Graal is a Java JIT compiler written in Java. It is being developed by Oracle Labs for a couple years now and has reached a state where it's viable to be that replacement. Twitter's huge distributed system tickles every corner of the JVM and is the perfect testing ground for a new JIT compiler technology like Graal. This presentation will talk about Twitter's experiences with Graal, good and bad, the bugs we found and also the wins.
This session is about the latest major Gradle release and what it has to offer for building authors and developers. The talk will be started with a short overview of Gradle build system, then some new functionalities will be explored like: Latest dependency management improvements and Composite builds, Functional testing of build logic, Distributed Cache and Gradle Build Scan.
The talk will be finished up with an outlook of what the Gradle team is working on next and what you can expect beyond Gradle 3.0.
Identity theft is perhaps the most concerning kind of Cybercrime nowadays. The most concerning aspect of identity theft is that once you are a victim it is hard to get rid of the consequences. Although as developers we are probably well aware of the risks towards cybercrime and identity theft in particular, in many parts we as developers play a big role in making identity theft happen.
It is not only about how secure is your program, but how aware are you? Or better said how naive are we in practice as developers in this big bad world.
Hands-on Lab: Instant IoT - Open Source Standard Based IoT Device Development
Develop your own IoT device and control it via a variety of smart home platforms. During this IoT tutorial session we will show how to develop a low-cost IoT device that use standard protocols to communicate with smart home environments (such as Apple HomeKit). 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 after the tutorial have a device that you bring home. We will provide basic IR sensor for developing a electricity meter sensor, but other types of devices can also be developed.
Presentation: Internet of Things and Business Models
How can you use Internet of Things to reinvent your business model? To answer the question you need to fully understand the changes that IoT will bring to your business. In this session we'll examine businesses that have successfully adopted IoT and reflect on what made them successful.
This session includes several examples of successful IoT transformations and maturity model. We will also compare traditional and IoT business models and explanin where the business value is in IoT.
At the end of the presentation a generic suggestion for how to transform your business, to take advantage of IoT, is presented.
A quick introduction to the Rust Language. Code comparisons between Java and Rust, compiler features, type system, environment and integrating the two languages.
Topics
- Brief History of Rust - how did the project get started, main goals, first stable releases.
- Main types and Functions - writing a very basic code and a deep comparison between Java style and Rust style. The level of verbosity is similar; however, the way you explicit the types may be different.
- Structs and Traits, contrasting them with Interfaces and Abstract Classes in Java.
- Lifetime vs GC - how can we remove objects from the memory without a GC? An interesting alternative approach from Rust to Java's GC. We will show the good and the complicated parts.
- Notes about the compiler
Machine Learning is all the rage today with many different options and paradigms. This session will walk through the basics of Machine Learning and show how to get started with the open source Spark ML framework. Through Scala code examples you will learn how to build and deploy learning systems like recommendation engines.
Hands-on Lab: IoT interaction Create an Energy and IoT mobile app in an afternoon
Visualisations, Interactions and feedback are core technologies to retain a sustainable future. Interaction between users and IoT data and devices can make big behavioural changes.
During the hands-on session we will combine the Evothings development environment with open energy http://op-en.se tools. You will be using MQTT, socket.io, animation.js and XMPP. You will create your own mobile app that you can deploy in appstore.
If you take part in the pre-noon session you will be able to take your IoT device data into your private mobile app.
Evothings http://evothings.com and Sustainable Innovation http://sust.se
The future Internet will be an IPv6 network interconnecting traditional computers and a large number of smart objects or networks. This Internet of Things (IoT) will be the foundation of many services and our daily life will depend on its availability and reliable operations. Therefore, among many other issues, the challenge of implementing secure communication in the IoT must be addressed. Providing security is challenging in the Internet and in tradition resource-constrained Wireless Sensor Networks (WSNs). It is even more challenging to enable security services in the IoT. This talk will discuss these challenges and address solutions to overcome these challenges.
At JavaOne keynote this year, Mark Reinhold talked about how Java 9 was much bigger than Jigsaw. To put that in numbers - 80+ JEPs bigger! Yes, we see more presentations on Jigsaw since it brings about modularity to the once monolithic JDK. But what about those other JEPs?!
One of those "other" JEPs, is JEP 143 - 'Improve Contended Locking'. Monica will apply her performance engineering approach and talk about JEP 143 and Oracle's Studio Analyzer Performance Tool. The crux of the presentation will entail comparing performance of contended locks in JDK 9 to JDK 8.
Java 9 will introduce a standard module system to simplify the development and maintenance of large applications, modularize the platform itself, and improve both security and performance. This has been an enormous undertaking, similar in scope to the introduction of generic types yet fundamentally different in its impact. It will take time to adopt but, in the long run, will bring significant benefits to all developers.
In this hands-on-lab, we will solve a number of concurrency challanges, starting with relatively easy and ending with, um, shall we say "sporty"?
The first two labs involve solving simple "deadly embrace" deadlocks using lock ordering and tryLock(). Our third and fourth labs look at slightly more complex scenarios that do not appear as obviously in the thread dumps. Our last lab consists of multiple sections where we first have to implement Dijkstra's "Sum of Squares" using BigInteger followed by parallelize our algorithm using the Fork/Join framework. In the last section, we change our cache to use the ManagedBlocker in order to maximize our CPU utilization at the beginning of the calculation.
Warning: This is not a beginner's hands-on-lab.
New paradigms such as microservices architecture, cloud-native development, reactive programming, serverless computing suggest enhancements to Java EE going forward.
The goal of this session is to describe proposals to better position Java EE for use in the cloud, with the goal of supporting users who need to more efficiently build and configure distributed applications based on cloud-native and microservices-style architectures.We will discuss some key investigation works around Java EE 8
A more reactive approach
Eventing
State management
Configuration
Service resiliency and health check
Services grouping and versioning
Security improvements
HTTP/2, ...
The goals of the session are to present potential improvements but also to gather feedback!
Presentation: Java libraries you can't afford to miss
The Java language has crossed it's 20th anniversary and with it comes an incredible range of tools libraries to choose from; sometimes there are too many choices for the same task. In this talk we'll cover those libraries that have risen to the top by proving themselves to be worthy of a place in every developer's toolbox, both for production and testing code. We'll also cover some fairly new libraries that are bound to make a big impact in the ecosystem.
The Java 8 release takes Java to a whole new level. Learning the new features is just the first step. The real question is how to make best use of them. There wont be too much time in this session to introduce the new features, so youll need to know what lambdas and method references are in advance. Instead, the focus will be on how coding in Java 8 differs to previous Java versions, and how to avoid going too far with the new goodies. Join me for an opinionated session of best practices.
Something terrible has happened. Errors litter the floor; memory leaking from cracks in the ceiling. Someone lost their object context in the corner. Everything reeks of jank. The web is overrun. In this session, a JavaScript error tracking expert tracks down some of the most common and most dangerous outlaws of web applications. Youll leave the session armed with track down and capture the problems in your own JavaScript web applications. Bring your bugs and lets fix up our web.
JEP 276 Dynalink is now integrated into JDK 9 and available under the jdk.dynalink package. The API was streamlined and polished and it's a great and easy way to add handling of dynamically typed expressions to your language. With this presentation we want to show you how can you use Dynalink in your language implementation and what can you achieve with it. We'll cover topics of creating linkers, handling type conversions, and interoperability between languages (with a demo). We'll show how does the API provide a foundation for implementing advanced language and runtime features such as the deoptimizing recompilation in Nashorn, customizing behavior for missing methods on POJOs, or even linking null values - all the kinds of details that you never thought you need.
Tutorial: Large Scale Data Pipelines with Kafka, Spark Streaming and Cassandra
In this University session we will walk through building this type of large scale, mission critical data pipeline using Kafka, Spark Streaming and Cassandra. We will start by looking at the individual technologies that make up the data pipeline. Then we will discuss the overall architecture of the data pipeline and how to address these core principles. We will walk through each of the pieces of the architecture.
The event flow in financial markets is getting higher and higher. Modern Market Surveillance applications needs to be able to handle millions of events per second. All events are analysed in real-time and suspected trading patterns results in system Alerts. In this presentation we'll show how open source machine learning libraries in Java can be used find false positives. We'll also discuss potential usage to find anomalies and walk through some code examples in Java.
Tutorial: Managing Cloud Native Applications with Kubernetes - End-to-End
This university session will teach you everything you need to know about running and managing applications and microservices in containers at scale using Kubernetes. This university session is composed of several topics, including:
1. Importance of orchestration and cluster management and how it helps you improve cluster utilization
2. Introduction to basic DevOps tasks using Kubernetes, including deployment, rolling update, rollback, provisioning stateful workload and batch jobs
3. Advanced usages such as Configuration Management, Secrets, and Cluster Federation
4. Automated CI/CD pipeline with Jenkins and Fabric8
Presentation: Microservice communication and integration: what are my options?
I've heard it said that the American and English are one nation, separated by a common language. This quote can apply nicely to microservices too; you are all speaking in the same language, or, in the case of microservices, using language agnostic protocols, but everyone has their own way of doing things. As a result, having stable and resilient communication is a big challenge in microservices. Common hurdles you will have to overcome are how to find services and what communication methods to use. This talk will cover some of the choices you have including service location and using rest protocol vs an event-like websocket protocol. I will include lessons learned while creating the open source text-based adventure Game On! about the world of microservice communication and integration.
The introductory session, Modules in One Lesson, assumed an ideal world in which applications are constructed solely from modules, but that is not the world in which we live today. How do we get there from here? In this session well live-code a simple Java 8 application that uses some popular libraries and then modularize it with Java 9. Well see how Project Jigsaw and the Java Platform Module System give you the ability to migrate to modules at your own pace, even if the libraries upon which you depend have not yet been modularized.
Presentation: Migrating to serverless -- an experience report
The new generation of cloud services such as AWS Lambda, Google Cloud Functions and Azure functions lower the bar for deploying responsive event-driven micro-services, auto-scaling web APIs, and high-performance web sites to the cloud. But with a major impact on architecture, these services also require teams to re-think how to approach sessions, storage, authorization and testing.
This talk provides an experience report of moving a large collaboration platform from Heroku to AWS Lambda, leading to a huge improvement in scalability and performance, and a significant decrease in cost. You'll find out what worked well, where we got stuck, and how we made it work well at the end.
Presentation: Mission to Mars: Exploring new worlds with AWS IoT
Would you like to explore new worlds with your connected devices? In this presentation we will build a simple robot and connect to it remotely, receiving data and sending instructions over the internet. Just like the Pathfinder spacecraft and its Sojourner Mars rover, our little robot will boldly travel into uncharted territory.
In a live demo, our robot will explore the session room and transmit all kinds of sensor data. We will visualise that data in a web UI.
With the Mars robot use case, we explore the capabilities of the Amazon IoT platform. AWS IoT comes with easy to use APIs and arranges secure communication with our robot.
Are you curious about how to connect your devices to the cloud? Take this journey and find out if this mission will lead to new discoveries.
A practical introduction, with live coding, to Project Jigsaw and the Java Platform Module System in Java 9. Well construct and hack on a simple modular application to explore the essential aspects of the module system. Well see how the module system ensures reliable configuration and strong encapsulation, how it improves security, and how it makes the JDK itself configurable.
Containers are quickly gaining popularity as the preferred tools for deploying and running services. While being easier to deploy and isolate, containerized applications are creating new challenges for the logging and monitoring systems.
During this talk we will look into the details about how the Elastic Stack, and in particular Beats lightweight shippers are gathering data from containers.
The session shows our way to:
* fetch logs from a container
* collect different measurements from cgroups
* collect metrics using the Docker API
* enhance the data with the metadata of the containers
* monitor the network traffic exchanged between the containers
* get metrics from the host system
One important subject to be analysed on languages is its type system. Having a general overview of a type system can provide us information about syntax performance, optimisations and may help us to understand how statements are evaluated. And those are topics that we shall consider for language evolution and development. This talk will provide a gentle introduction to type theory, how it helps us with IDE's and type inference and how can we apply some of its concepts in Java and other languages build on the top of JVM, such as Scala and Clojure, providing a comparison between the type system of such languages.
Topics: - Why Type Theory? - Quick introduction to logic and Lambda Calculus
- Where are those concepts used? - An analysis of Java Type System - Clojure Type System, - Scala ty
Starting 2014, all Dutch households will receive a smart meter to replace their old meter systems for electricity and gas. Theyre called smart, but are they really? Most meters just send their data to a central point using GPRS. Using third party services, consumers can get an insight in their energy usage.
But were technicians, we can build something better ourselves. All it takes is a prefab cable (or some soldering), code, patience and a beer. Using Scala plus Akka for the backend, ES6 plus React for the frontend and Websockets for communication you can build your own energy dashboard. In this session well discover how to outsmart the Smart Meter!
Presentation: Programming your body with chip implants
Would you put a chip in your body if it meant a longer and healthier life? Would you put a chip in your body in order to open doors, withdraw money from an ATM, and to safely store sensitive data? This session will introduce you to connected bodies, look at the possibilities available today and end by discussing a few important things we can expect in the future:
* Medical reasons - what if we could implant thousands of chips and let them monitor vital parts of the body?
* Identification - what if we could use chip implants as identification.
* Tracking - what if we could publish our "body status" and whereabouts as a service?
The speaker has been wearing a chip implant for a year.
Everybody is doing REST -- at least everybody claims they are. But mostly web APIs are built without Hypermedia, what would allow the client to follow related resources and autonomously navigate through the API without prior implicit logic of the application.
This sessions shows the concept and benefits of a Hypermedia driven REST API and how to implement this using JavaEE 7 with JAX-RS.
This presentation is designed to help you use your Java programming skills to create hobby projects using the Raspberry Pi as an inexpensive (35 USD) interface to the physical world. We will teach the concepts by demonstrating examples with working projects and source code. Coming out of this session you will have the knowledge you need to start building your own embedded projects for your home or office, and can leverage your Java programming skills to connect it to the Internet of Things. Start building the future now with Java 9 Embedded technology.
At JavaOne 2016 Oracle announced their plan for Java EE8. One of the key points was to improve support of the 'reactive programming model'. But until Java EE8; are we cut short on building reactive applications?
In this hands-on presentation we'll go through the concepts of reactive programming and proceed to how we actually implement it. Using the current APIs, we'll cover areas such as asynchronous programming, WebSocket and message- and event-driven architecture. When you leave this session, you will have the utilities to build responsive applications with higher throughput, better use of your hardware, and especially a nicer user experience.
Everybody is talking about microservices and reactive programming these days. And theres a reason for that: the high-demand and high-scale distributed world that we have today, reacting to events in an asynchronous and non-blocking fashion seems the right approach to deal with scalability. And to achieve microservices you need a lightweight, fast, modular and high-performance engine. Meet Vert.x: a toolkit for building reactive applications on the JVM.
Come to this session to see how you can use Vert.x to create reactive apps using Java, Groovy, JavaScript or other JVM languages. Well demonstrate how to build Vert.x-based systems leveraging the unique Vert.x eventbus for creating apps with real-time communications from the modern web browser to the cloud and back again.
Tutorial: Reactive Programming, Systems and Microservices
Reactive Programming is a subset of functional programming where your logic is designed around streams while Reactive Systems, defined by the Reactive Manifesto, focuses on distributed applications that are highly responsive, resilient, elastic and message driven. In this session, we are going to quickly explore reactive asynchronous programming models, dive into reactive systems infrastructure and then distributed microservices principles, where every component can be independently deployed, scaled and updated.
Presentation: Revolutionizing the IoT with Bluetooth 5
With 4x range, 2x speed, and 8x data broadcasting capacity, Bluetooth 5 is revolutionizing how people will experience the Internet of Things (IoT).
In this talk we will give a detailed insight into the core enhancements made in Bluetooth 5. We will focus on explaining how these enhancements offer IoT
application developers the flexibility to build reliable and efficient IoT solutions adjusted for a variety of wireless environments and end products.
We will also discuss how Bluetooth 5 can influence the design of IoT large-scale network topologies, bringing large home and enterprise IoT networks one step
closer to reality.
Java 8 introduced the Stream API as a modern, functional, and very powerful tool for processing collections of data. One of the main benefits of the Stream API is that it hides the details of iteration over the underlying data set, allowing for parallel processing within a single JVM, using a fork/join framework.
I will talk about a Stream API implementation that enables parallel processing across many machines and many JVMs.
With an explanation of internals of the implementation, I will give an introduction to the general design behind stream processing using DAG (directed acyclic graph) engines and how an actor-based implementation can provide in-memory performance while still leveraging industry-wide known frameworks as Java Streams API.
Presentation: Scaling the Data Infrastructure @Spotify
Over the last years Spotify has had an enormous growth. This has lead to some interesting challenges for our data infrastructure. In this talk we will share some of these experiences such as our move to Google Cloud and how we have solved some of our challenges.
Presentation: Scaling with Kubernetes, Automatically! Learn Kubernetes API through writing a visualizer to an autoscaler
Kubernetes is a powerful, open source, container orchestration / cluster management tool created by Google. It drew upon all the lessons learned from a near-decade of using containers at Google. In this session, we'll look beyond container orchestration with Kubernetes, but also taking a deep dive into more advanced feature such as autoscaling. But its most powerful feature is its versatile REST API which you can use to tailor Kubernetes to your needs.
In addition to the Kubernetes Autoscaler, We'll look at:
- How to access the Kubernetes API securely
- The different Kubernetes resources, such as Pod, Replication Controller, Service, etc.
- How to update/manage your entire cluster using the API
We'll demonstrate all of the concepts via a custom autoscaler that scales a state
Spring Framework 5.0/5.1, scheduled for release in early/late 2017, focuses on several key themes: reactive web applications based on Reactive Streams, comprehensive support for JDK 9 and HTTP/2, as well as the latest API generations in the Enterprise Java ecosystem. This talk presents the overall story in the context of wider industry trends, highlighting Spring's unique programming model strategy.
The best reason for writing tests is to automate your testing. Without tests, you'll likely be testing manually. This manual testing will take longer and longer as your codebase grows. In this session, youll learn how to test an Angular 2 application. You'll learn how to use Jasmine to unit testing components and Protractor for integration testing. Well also take a look at code coverage options and explore continuous integration tools.
Almost any business application implement business processes and rules in some form. Agility in this area is essential for companies to survive. But neither workflow nor business rules seem to be sexy or hip amongst Java developers. But more and more companies (like e.g. Sparebank, Duni, Zalando, AT&T or Warner Music) start doing things differently - because they understood the 7 sins. In this talk I will introduce the 7 sins and walk you through one of them in detail. As part of this I will discuss a developer friendly approach using lightweight open source frameworks and useful standards like BPMN and DMN as a potential remedy. Expect to see some code.
Angular 2 comes with a new router. We will review its main features and show how we can use navigation gards, secure sections, use nested routes and do lazy load while quickly building a fully working prototype!
The Angular 2 Router is one of the most fundamental pieces in any Angular 2 Application. We will cover it's main features. Possibly the most interesting one is the ability to Lazy Load Components on-demand. We will go through all the steps to cover the common scenarios and some more advanced ones.
Auxiliary routes allow totally independent navigations so you can handle complex scenarios with ease. We will show common pitfalls and best practices to take advantage of them.
Content will be updated accordingly to use latest Angular 2 release available.
Presentation: The DevOps disaster: 15 ways to fail at DevOps
Getting DevOps right isn't easy. It's downright hard. In this talk, I'm not going to explain how to 'do' DevOps in your organisation, since there is not just one 'right' way to do it. What I can show you however, is how NOT to do DevOps.
This session shares 15 common misconceptions, call them anti-patterns, of DevOps. I'll talk from my own experiences in getting things wrong, explain why they are wrong and prevent you from making the same mistakes. You'll leave this session with a basic understanding of how (not) to fail at DevOps and hopefully, a smile on your face ;-)
Quickie: The joy and misery of connecting a car to the internet
Modern cars are sometimes described as computers on wheels. With close to a hundred computation units and equally numerous sensors and output devices they are actually more of a computer network one wheels. Each car manufacturer has their way of putting it all together, and the hardware configuration varies from model to model and from year to year.
Connecting a car to the internet promises a lot of interesting features, but connecting a random car poses a non trivial problem.
I will give a short introduction to the mess of communicating with a modern car, the standards that tries to adress the mess and hopefully a glimpse of what one could achieve when successful.
With so many AR/MR/VR devices out there, and the price range dropping, we are all able to take a leap into the virtual world with our apps. This also means there are new ways to interact with your application, controllers, hands or even voice. But how do you design your apps and games? Do you look at movies like Minority report or Iron Man, to get ideas? What are the design pitfalls of Virtual, Augmented and Mixed realities and what do you need to think about? VR - Vommit Reality? In this space a bad user experience can actually make you nauseous. I will go through the differences in AR/MR/VR, where we can go wrong, how to fix it and a few pointers to keep in mind.
Presentation: Throughput, latency and footprint - pick two
This talk will focus on the fundamental trade-offs when designing a memory management algorithm - throughput, latency and footprint. When designing an memory management algorithm, you can only optimize for two out these three features. However, an algorithm is always made up of smaller parts and this talk will show how various design choices, small and large, all shape a memory management algorithm. Examples of optimization being presented are:
- Dense prefix for Parallel and Serial (latency over footprint)
- Concurrent refinement of remembered sets (latency over throughput)
- Using cards instead of references (footprint over latency)
Presentation: To serve Odin, adventures in project Valhalla prototyping
Over the last year or so, a number of prototyping efforts have taken place within the JVM and JDK order to implement various ideas from the Valhalla project. Not all of the prototypes have been pretty, but we've learnt a few things along the way. Listen to an overview of what's been going on in terms of prototype implementation of generic specialization and value types, and where we are likely going from here. Includes discussing: value type byte code evolution, evolution of specialization, prototyping via byte code transforms, exotic type changes like "trait" injection, and various feature feasibility studies
Presentation: Turbo Charge CPU Utilization in Fork/Join Using the ManagedBlocker
Fork/Join is a framework for parallelizing calculations using recursive decomposition, also called divide and conquer. These algorithms occasionally end up duplicating work, especially at the beginning of the run. We can reduce wasted CPU cycles by implementing a reserved caching scheme. Before a task starts its calculation, it tries to reserve an entry in the shared map. If it is successful, it immediately begins. If not, it blocks until the other thread has finished its calculation. Unfortunately this might result in a significant number of blocked threads, decreasing CPU utilization. In this talk we will demonstrate this issue and offer a solution in the form of the ManagedBlocker. Combined with the Fork/Join, it can keep parallelism at the desired level.
Presentation: Typed JavaScript with TypeScript, Flow and Elm
JavaScript is the natural choice when developing for the browser. For larger projects, however, there are issues concerning type safety and refactoring.
TypeScript, Flow, and Elm are different approaches to compensate for that shortcoming by each introducing a type system of their own. Flow is a static type checker that has been developed and used by Facebook to find errors in JavaScript. TypeScript is an extension to JavaScript that compiles back to ES5 or ES6. It is actively developed by Microsoft and used as primary language for Googles Angular 2 framework. Elm is the most radical approach, which abstracts quite a bit from JavaScript.
Based on a set of real world examples that can benefit from type annotations we will discuss how the three approaches compare to each other.
Presentation: Using jPDM, a performance diagnostic model
Java Performance Diagnostic Model (jPDM) is the key to a performance tuning methodology that I have been using in my engagements to help me quickly get to the (sometimes surprising) root cause of performance bottlenecks in many applications across many different domains. In this demo driven talk, you, the audience, will use jPDM to reason through a couple of commonly seen but often unidentified performance bottlenecks in a sample application.
Presentation: Value types - The Next Big Thing for Java
Brian Goetz from Oracle has announced: after lambdas in Java 8, the next big thing for Java will be the support for value types directly in the programming language. With this Java is getting a feature that other languages have already had for some time.
In this talk we will look at:
* what's behind the motto "Codes like a class - works like an int"
* why value types make your code at the same time better readable and more efficient
* the difference between refence and value types
* the new syntax to support value types in Java
* how value types are implemented in other languages
* what inheritance means for value types
* the advantages of storing data on the stack versus storing data on the heap
Code lines are added at high speed? Too many developers? How do you see the big picture?
What processes are going on with your large code base? This presentation will show how to
leverage existing code analysis tools (Cloc, Structure101, SonarQube) and combine them
with data storage (ElasticSearch, Neo4j) and visualization tools (Gource, D3, Inkscape, Kibana) to at least make some sense out of millions of code lines and their history. During his consulting work, author often meets unfamiliar and at the same time large Java code bases that need quick analysis and input for decision making. That's where visualizations come to into play by helping mining important knowledge directly from the code statistics.
9.00-9.45 To serve Odin, adventures in project Valhalla prototyping
Over the last year or so, a number of prototyping efforts have taken place within the JVM and JDK order to implement various ideas from the Valhalla project. Not all of the prototypes have been pretty, but we've learnt a few things along the way. Listen to an overview of what's been going on in terms of prototype implementation of generic specialization and value types, and where we are likely going from here. Includes discussing: value type byte code evolution, evolution of specialization, prototyping via byte code transforms, exotic type changes like "trait" injection, and various feature feasibility studies
10.00-10.45 What I learned from LuaJIT
You might have heard about LuaJIT - an implementation of the Lua programing language sporting a fast interpreter and a sophisticated tracing JIT - all hidden within 100KLOC of a filigree C code. This talk summarizes my experience from digging into LuaJIT sources while working as a compiler engineer for Google DeepMind. We will walk through the whole pipeline starting at the bytecode format and value representation and finishing in the trace compiler. This is not a deep insight into LuaJIT inner design but rather a collection of choices made by the original LuaJIT implementor which I found interesting, elegant and educational.
11.15-12.30 Graal @ Twitter
HotSpot's optimizing Just-In-Time compiler C2 is reaching its end-of-life and it's time to look for alternatives. One very promising replacement candidate is Graal. Graal is a Java JIT compiler written in Java. It is being developed by Oracle Labs for a couple years now and has reached a state where it's viable to be that replacement. Twitter's huge distributed system tickles every corner of the JVM and is the perfect testing ground for a new JIT compiler technology like Graal. This presentation will talk about Twitter's experiences with Graal, good and bad, the bugs we found and also the wins.
13.30-14.15
Write Barriers in Garbage First Garbage Collector
Garbage First Garbage Collector (G1 GC) is HotSpot VMs latest addition to the GC family. G1 GC has remembered sets (RSets) and regions. Also, G1 GC implements a new marking algorithm called snapshot-at-the-beginning (SATB). With the advanced structures and the new marking algorithm comes the maintenance cost of post-write and pre-write barriers. During this talk, Monica will cover the SATB algorithm and also discuss the reason for pre-write barriers. Monica will also talk about RSet maintenance costs and discuss post-write barriers then.
14.30-15.15
Throughput, latency and footprint - pick two
his talk will focus on the fundamental trade-offs when designing a memory management algorithm - throughput, latency and footprint. When designing an memory management algorithm, you can only optimize for two out these three features. However, an algorithm is always made up of smaller parts and this talk will show how various design choices, small and large, all shape a memory management algorithm. Examples of optimization being presented are: - Dense prefix for Parallel and Serial (latency over footprint) - Concurrent refinement of remembered sets (latency over throughput) - Using cards instead of references (footprint over latency)
15.45-16.30
Ajdk.dynalink is here
JEP 276 Dynalink is now integrated into JDK 9 and available under the jdk.dynalink package. The API was streamlined and polished and it's a great and easy way to add handling of dynamically typed expressions to your language. With this presentation we want to show you how can you use Dynalink in your language implementation and what can you achieve with it. We'll cover topics of creating linkers, handling type conversions, and interoperability between languages (with a demo). We'll show how does the API provide a foundation for implementing advanced language and runtime features such as the deoptimizing recompilation in Nashorn, customizing behavior for missing methods on POJOs, or even linking null values - all the kinds of details that you never thought you need.
Presentation: What I learned from analyzing 750 billion GitHub events and 42 TB of code
"Data gives us insights into how people build software, and the activities of open source communities on GitHub represent one of the richest datasets ever created of people working together at scale." --GitHub Universe 2016
We are going to analyze - live on stage - 5 years of GitHub metadata and 42 TB code stored in it to answer questions like:
- How coding patterns have changed through time.
- Guiding your project design decisions based on actual usage of your APIs.
- How to request features based on data.
- The most effective phrasing to request changes.
- Effects of social media on a project's popularity.
- Who starred your project - and what other projects interest them.
- Measuring community health.
- Running static code analysis at scale.
- Tabs or spaces?
You might have heard about LuaJIT - an implementation of the Lua programing language sporting a fast interpreter and a sophisticated tracing JIT - all hidden within 100KLOC of a filigree C code.
This talk summarizes my experience from digging into LuaJIT sources while working as a compiler engineer for Google DeepMind.
We will walk through the whole pipeline starting at the bytecode format and value representation and finishing in the trace compiler.
This is not a deep insight into LuaJIT inner design but rather a collection of choices made by the original LuaJIT implementor which I found interesting, elegant and educational.
Presentation: Write Barriers in Garbage First Garbage Collector
Garbage First Garbage Collector (G1 GC) is HotSpot VMs latest addition to the GC family. G1 GC has remembered sets (RSets) and regions. Also, G1 GC implements a new marking algorithm called snapshot-at-the-beginning (SATB). With the advanced structures and the new marking algorithm comes the maintenance cost of post-write and pre-write barriers.
During this talk, Monica will cover the SATB algorithm and also discuss the reason for pre-write barriers. Monica will also talk about RSet maintenance costs and discuss post-write barriers then.
Schibsted is a global media conglomerate with about 200 million unique users per month. The company is currently being transformed into a unified global media giant. To do this, Schibsted needs to collect data about user behaviour, and process that data with machine learning.
This presentation is about we built Schibsted's infrastructure for receiving and processing this behaviour data, which at the moment comes to 700 million events per day, or 2 terabytes per day. The presentation covers the architecture, design of individual services, monitoring, and challenges in scaling and reliability. It also goes into the interaction between legal privacy requirements and overall architecture.
Key technologies used ae Amazon Web Services, Scala, Datadog, Kinesis/S3, Docker, Mesos, and Spark.
.jpg)
