Online conference for developers

Java EE 8 has been the most community opinion driven release in the history of the platform. Java EE 8 solidly enables HTTP/2, Server-Sent Events (SSE), JSON and aligning all parts of the platform with Java SE 8. It includes a much awaited security API overhaul as well as a slew of critical updates to APIs like JSF, JPA, JAX-RS and CDI.

In this talk we will look at a solution that combines real-time data streams with machine learning to analyze and visualize popular Uber trip locations in New York City. You will see the end-to-end process required to build this application using Apache APIs for Kafka, Spark, and HBase.

With microservices architectures, we’re making more network calls and need to do more integration to get our system to work; this creates more ways for our applications to break and cause failures to propagate much faster. We need a way to call our microservices and be resilient to distributed systems failures — as a first-class implementation.

What if someone told you that you could use the full capacity of your server? That you could have the same performance on the backend as your react frontend? Don't you believe it? That you could choose the best language/tool for the task and you were not limited by what you already know? In this talk, I'll show you that you can use the full power of React on the frontend and Vert.x on the backend. You will see a fast full stack development workflow with Rollup/Webpack + Babel + React. How you can mix JavaScript with any other language. Build microservice applications in minutes.

Vert.x is a "toolkit" for developing reactive applications on the JVM. Vert.x provides the flexibility to integrate with all of your existing Java technologies while providing powerful features to enable reactive application development. In this session attendees will learn the basics of Vert.x development on a Kubernetes PaaS with CI/CD/DevOps practices.

Is software a field just for twenty­somethings? In our fast­-paced industry, it can often feel that way. In this talk, Don Denoncourt will explore how to stay relevant in the tech industry. Don has over three decades experience with numerous tech stacks. He is currently a coder at SimpleThread.com and intends to be a programmer until he dies.

Development of the open source Axon Framework started about 7 years ago. From its inception, Axon's primary focus has been to support CQRS and Event Sourcing for Java, founded on Domain-Driven Design (DDD) principles. Over the last 2 years, adoption of Axon Framework is rapidly increasing: the Maven download numbers grow exponentially (currently at +500k), and several high-profile companies like Barclays and Société Générale have done presentations about their adoption. 

Are you Spring Framework user? Have you ever had troubles with Reactive System? Have you ever gotten rid your whole existed codebase to make the high-throughput system? Have you ever feel the pain during migration? If yes, I have a good news for us, with Spring 5 and Reactor, development of Reactive System is a dream. 

Integrating microservices and taming distributed systems is hard. In this talk I will present three challenges we observed in real-life projects and discuss how to avoid them.

1. Communication is complex. With everything being distributed failures are normal so you need sophisticated failure handling strategies (e.g. stateful retry).

2. Asynchronicity requires you to handle timeouts. This is not only about milliseconds, systems get much more resilient when you can wait for minutes, hours or even longer.

3. Distributed transactions cannot simply be delegated to protocols like XA. So you need to solve the requirement to retain consistency in case of failures.

Most developers are aware about design patterns. The difficulty is not in understanding them but in getting an intuitive understanding of when and how to apply them. In this session, we'll go through a case study of how a compiler codebase - of course written in Java - may implement different design patterns. (Note: No prior exposure to compilers needed for attending this session.)

Are you tired of java.lang.OutOfMemoryError: Metaspace/PermGen space? Then this talk is for you! We'll begin with a crash course in the Java memory layout in order to understand what the error message actually means. Then we'll look at different causes of the error and how to avoid them. We'll look at using Eclipse Memory Analyzer to track down memory leaks. We will glance at a few interesting mistakes from the Open Source world. Last but not least you'll learn how you can get rid of java.lang.OutOfMemoryError: Metaspace/PermGen space once and for all, using the presenters ClassLoader Leak Prevention library.

In this talk we will explore two of the foundations of Functional Programming: functor and monad. We will look at Functional Programming from a theoretical perspective, but we won't get lost in mathematical details. Using simple diagrams and practical examples we will build a clear understanding of monads. This is the perfect talk for anyone that feels baffled by functional programming!

Relational databases are great! They are well proven powerhouses in persisting state, but are they always the best solution to your problems? Join me as we explore a more functional approach to how we deal with state in our systems. We'll start by covering the basis of EventSourcing and continue to take a hands-on look on the Lagom framework and Akka. You will hopefully leave with a stepping stone to start to implement EventSourced systems on the JVM.

Based on our experience in the complex banking domain, we present to the public a detailed experience report on the adoption of Event Sourcing based Microservices. We describe the practical implementation of the architecture as wells as the most important components, like the Event Store, Event Listeners, Command Handlers, Aggregates, etc. Additionally, we talk about how we go about the different levels of testing in this architecture and the most relevant challenges we faced. In the end, we present a live demo as well as some external references on the topic.

I’ll demonstrate the easiest ways for Java developers to deliver their Java code to the cloud by using Spring Music as an example (https://github.com/cloudfoundry-samples/spring-music). I’ll show deployment using Linux command line tools, open source tools such as Jenkins, and other free SDKs and tools available on GitHub. The examples, tools and demos that I show will be applicable to any cloud platform, and all are available on GitHub. I will show Microsoft Azure running the samples but will not be selling azure - this is a technical talk that will focus on the code. 

In this talk you'll learn how the Spring Framework team made sense of this present day landscape, about the range of new choices available in Spring Framework 5 and Spring Boot 2 for web applications, and of course how applications can make sense and make decisions for themselves.

The session will first provide background information on the support for TLS in JDK 8 and use that knowledge to demonstrate the new security enhancements by building separate modules for a simple banking application server used as a showcase - namely a simple XMPP module that demonstrates how to leverage ALPN for protocol negotiation and a simple SIP module that demonstrates how to get started with DTLS.

Machine learning is both a highly overloaded and hyped topic. This talk covers one specific area in this space — anomaly detection of time-series data. It sounds very narrow, but is widely applicable in IT security and operations.

With the rise of microservices, REST communication is more popular than ever. But the communication between the different parts must also be performed in a secure way. Besides the concepts, the presentation will use various code examples to show the theory in action.

This talk is about Java 8 concurrency applied to a real case scenario of Big Data ingestion using the Streamsets Data Collector Open Source tool and its powerful Java SDK. 

A fast, yet comprehensive, introduction to Kubernetes. With Gradle, a few Java based containers are published on Kubernetes. We will unpack it all together.

In Java 8 functional style programming was introduced in Java. Java 9 extended this with some nice new features. For many people it is hard to grasp the idea of functional style programming after so many years of purely working in the imperative OOP style. The opportunities Java gives us out of the box are massive on the other hand with great power comes great responsibility.

Andrej Karpathy, the director of AI at Tesla has referred to neural networks as "software 2.0" and believes neural networks will take over increasingly large portions of what Software 1.0 is responsible for today. Even if he's overstating the case for neural networks, it's still a good signal that software engineers should get an understanding of what neural networks are and how they work since they are only likely to become more prevalent.

What is software architecture? Is it the decision to adopt microservices? Is it the document that describes the layers in your Java EE application? No, every line of code you commit is part of your evolving architecture.

This session will focus on use of machine learning to make IoT device smarter and give them cognitive ability. For this talk I can consider a raspberry pi device connected to Ibm Watson cloud and the device call call Ibm Watson cognitive service based on the requirements. The Watson service can be speech to text, text to speech or visual recognition. For this session I will show how the IoT device integrate with cloud and use node.js to make Watson api calls form the IoT device.

Today our world is full of things that are “as a service” - infrastructure, containers, platforms, software…and of course functions. With developers just now wrapping their heads around application platforms and containers, what are they to make of functions as a service? How does a busy developer cut through the hype and make sense of the world of serverless, Kubernetes, Spring Cloud Function and all the rest?

Functions, and the so called serverless computing have freed developers from worrying about infrastructure, and even upper platform layers, as well some steps in the software development lifecycle. But once you have functions deployed, how do they interact with each other? How message navigates between them? Maybe, just maybe, it’s time to look back again at EIPs - Enterprise Integration Patterns, and their use in this new way of deploying code to the Cloud. 

Java EE is productive and easy to learn and runs smoothly on containers such as Docker and rkt. It has become the perfect microservices platform. Unfortunately, no one in the enterprise is interested in managing thousands of nanoservices “just for fun.” In this session, the presenter hacks on stage a couple of Java EE 7/8 “rightsized” services, links them together, runs them on Docker, and explains the architectural decisions and best practices in real time.

A big change is happening in software development. Docker is transforming the way we build applications, while Kubernetes has grown into a full-featured microservice platform. Java-based applications always had their own packaging format (jars, wars, ears) and runtimes in the form of applications servers of different sophistication. What can the world of containers offer for developing and running Java applications?

This isn't a talk about microservices, NO-SQL, Container solutions or hip new frameworks. This talk will show some of the standard Java APIs that are part of Java since version 5, 6, 7 or 8. All this features are very helpful to create maintainable and future-proof applications, regardless of whether JavaEE, Spring, JavaFX or any other framework is used. The talk will give an overview of some important standard concepts and APIs of Java like annotations, null values and concurrency

JVM is a complex machine that drives our systems. Every day in the sweat of the forehead transfers terabytes of objects between successive generations in GC, generates streams of the optimal code compiled by one of the JIT compilers in the meantime, trying to get along with the operating system.

Vaadin announced about the developer preview of its next major framework: Vaadin 10. The biggest change in this version is a bigger focus on PWA and the usage of Web Components instead of GWT for the UI elements.

The Eclipse MicroProfile initiative is probably one of the main motivations that gave Oracle a nudge towards donating Java EE to Jakarta EE. Apache TomEE and Tomitribe are amongst the initial contributors. Listen to our take on this fantastic development, and how we feel it will affect future development of the platform.

You are writing integration tests, aren’t you? Have you ever needed to stub the HTTP or a messaging call? Have your tests passed? That’s awesome, but it doesn’t mean that your application is working fine or that your system will not break on end to end tests.

Ahh, reactive, probably the buzzword of 2018, 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.

The rapidly expanding world of stream processing can be daunting, with new concepts such as various types of time semantics, windowed aggregates, changelogs, and programming frameworks to master. 

KSQL is an open-source, Apache 2.0 licensed streaming SQL engine on top of Apache Kafka which aims to simplify all this and make stream processing available to everyone. Benefits of using KSQL include: No coding required; no additional analytics cluster needed; streams and tables as first-class constructs; access to the rich Kafka ecosystem.

Cryptography is often shrouded like it is a black art. While you should stay away from implementing your own crypto, there’s plenty of components available in the Java ecosystem that can help you. But, what are they, and what to all those terms mean?

Microservices are hot! A lot of companies are experimenting with this architectural pattern that greatly benefits the software development process. When adopting new patterns we always encounter that moment where we think ‘if only I knew this three months ago’. 

Everyone wants to use MicroServices these days, but are they reliable? This talk covers Miranda: a system for making very reliable (6 9s) MicroServices. The talk goes over the need for Miranda, how it works, why it's reliable and why it's secure.

What does GraphQL and Traditional REST API have in common? Shouldn't the GraphQL be connected to some graphs or similar? What is actually GraphQL all about?

Opentracing is an open standard for distributed tracing and can be used to debug, profile and tune microservices based software. This session will provide an overview about Opentracing fundamentals, Java libraries and use case examples. 

JNoSQL is a framework and collection of tools that make integration between Java applications and NoSQL quick and easy—for developers as well as vendors. The API is easy to implement, so NoSQL vendors can quickly implement, test, and become compliant by themselves. 

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.

JSON handling in a Java EE application is now simpler than ever before, thanks to the new JSON Binding API and uplift to the JSON Processing API. Handling JSON in Java EE applications used to require a third party API but now that is not necessary. In fact, it is easier to use these APIs because they are so well integrated. 

One of the more interesting features of the latest release of Java is undoubtedly JShell, Java’s Read-Eval-Print-Loop implementation, which makes exploration of new APIs faster and easier. The release, however, packs many other smaller and less-known features and APIs, which are often overlooked, but can have a huge impact on application development.

We will take a look what actually a GPU is. In the beginning we will have a small introduction on how it has evolved through the years. We will see how it can be utilized in the Java world. There will be a small intro to the world of OpenGL. And then we are going to move to CUDA and OpenCL technologies for general purpose massive computations on regular desktops or cloud machines. We will see what are the advantages and what are the main drawbacks, how can we ease the use from java and utilize GPUs in the clouds.

Creating objects in Java using `new` keyword was a no brainer for many years! Then IoC / DI questioned the approach and component containers changed the way we think about it! Managing dependencies between artifacts is yet another topic we still tend to think we have sorted out. Maven central has become the de facto standard artifact repository.

In this session I’ll share best practices and practical architectural patterns for building a cloud foundry infrastructure that is secure, robust and scales well. We’ll use a demo of Spring code running microservices on web apps and explore special considerations for both Virtual Machines and Docker containers. 

In JavaScript applications (Web, Mobile, Node.js), JavaScript clients often need to invoke Java servers through REST Web Services. Testing such invocations to ensure that they are following the API contract and that evolutions will not break the code can be complicated and time consuming. This talk will demonstrate how the clients and the servers can safely interoperate in a typed way, such enabling easier and more robust application development. We will illustrate our talk with a Data Visualization example using some D3.js components on the client side, invoking a standard JAX-RS backend powered by Jetty and Jersey.

Manual development of data-centric, form-based UIs is tedious. Existing UI technologies, such as JavaFX or HTML, are powerful, but not focused on developing forms. Developers struggle with the development, maintenance, and testability of forms, especially if the underlying data model is complex and subject to frequent change. Finally, the UI must be redeveloped for all target client platforms -- from desktop over web to mobile or embedded.

Have you ever had a NoClassDefFound error caused by two different versions of the same library on the classpath? Java only allows unique classes on the classpath, so it can break when multiple versions of the same class are used. It worked fine on your machine, but somehow when the libraries are loaded in different order, errors start popping up.

Welcome to Maven Dependency Hell.

I will show you what can go wrong when you (transitively) depend on different versions of a dependency. And I’ll show you ways that seem to lead you out of the dependency hell. But don’t be deceived! Some of these ways will actually bring you deeper and deeper into the abyss.

Let me be your guide through the realms of the Maven Dependency Hell and together, we’ll make Dante proud!

Have you ever wondered how an ideal deployment workflow of your Java Application(s) should look like? In this session I will provide insights into how patterns for build infrastructures could look like! Based on Containers as a Service (CaaS) the show cases span from simple apps to complex distributed systems with build pipelines as Infrastructure as Code. In particular we will see CircleCi Jobs, a multi-staged Jenkins 2.0 pipeline, custom Gradle tasks based on the OpenSource Docker Plugin, Best-Practices for Dockerfiles/Cloud stack files including the usage of the JDK 9 module system and for Kubernetes (K8s) manifests and services, GCE deployments and many more things. Let's learn how to bring your app into production and into the hands of your customers in minutes!

Local communities are maybe the easiest way and a great opportunity for tech people to learn, socialize, share knowledge or just hang out with some friends. However, we've seen many communities starting with a couple of great meetups but then eventually lose pace and at some point, they are abandoned by their organizers. In this talk, I will share my experience on leading and organizing two active communities for more than 4 years. I will present what I tried, what worked well, where I failed, how much time I spend and other interesting bits.

As regular day to day programmers we usually think that revolutionary and innovative technology comes from great minds who receive ideas from almost divine inspiration. Usually is not the case on the strict sense. Most of the tech gurus and leaders found great solutions because they worked hard and joined other individuals with similar ideas pursuing a common goal. We call this group of people a community and there are thousands around the globe. Being part of a tech community lets you share time with like minded people, allows you to keep track of the state of the art technology, and can even let you guide the path to follow of your favorite framework/language/tool. During this talk we will discuss how to start being an active member or fund your own tech community.

We'll cover the highlights from Get a Better Developer Job!, my career course for developers. It leverages my 20 years as a developer, hiring manager, and technical recruiter. The course is based on reality, not opinions or conjecture, focused on the current job market and hiring process. The bad news is that the system is far from perfect. The good news is that you can hack it like a Raspberry Pi.

Gone are the days where we build applications and just think about graphical user interfaces, look and feel etc., There is a new interface that is gaining popularity. As Amazon, Google and Apple are bringing in voice assistants, it has become extremely important for us to learn how to build voice-activated applications. Voice based commands are much more complex than a GUI, user actions on our application are limited to button clicks, combo box selections, typing in text fields comprise of the majority of instructions. With touchscreen, we can see some more actions users can perform like swipe, pinch, zoom, rotate etc., However, with voice a single user may ask our application to do specific tasks in wide variety of ways, to increase the complexity even further different people may use and each have their own way of speaking. Alexa provides a simple framework to build these skills. In this presentation we will how you can build your own Alexa Skills.

Gain access to the conference platform where you can watch all of the talks live, schedule one-to-one sessions with the speakers, and replay your favorite talks for up to 2 months after the conference!

(c) 2018 - all rights reserved.

Terms & Conditions / Privacy Policy