Henning Schwentner
Jeroen Resoort
Marcus Fihlon
Yegor Bugayenko
The best time to talk with speakers and attendees
Charles Oliver Nutter
Mark West
Maciej Laskowski
Tomasz Michalak
Jacek Kunicki
The best time to talk with speakers and attendees
Nikita Lipsky
Krzysztof Kudryński
Błażej Kubiak
Geertjan Wielenga
Jakub Kubryński
Jakub Marchwicki
Wojciech Burkot
Bruno Bossola
Tomasz Borek
The best time to talk with speakers and attendees
Avishai Ish-Shalom
Kamil Owczarek
Anton Arhipov
Adam Dubiel
The best time to talk with speakers and attendees
Rod Johnson
Since I've been working on distributed systems I always wanted to go back in time and teach myself what I know now, in order to avoid the silly mistakes I did! Things like vector clocks, the CAP theorem, how replication really works (and why it's needed), what BASE means and in general all about how this stuff really works! This is the speech I'd needed when wrote my first distributed system and it's something you need to know if you fancy working in this area. And we will also be coding some very simple examples in NodeJS, with working demos where we will kill processes and freeze networks! It's so easy to understand when you see things in action, we will use powerpoint only for some introductory theory! Yep, I am not a big believer of diagrams... show me code!
Bruno Bossola ,
VP of Engineering at Workshare
Unit testing is nice, but without a proper integration testing you might not know how your application will behave once it's deployed to the real environment. Before the Docker, configuring the environment for integration testing was painful – people were using fake database implementations, mocking servers, usually it wasn't cross-platform as well. But now, we can easily prepare the environment with Docker for our tests. In this talk I would like to spread the word about TestContainers ( https://github.com/testcontainers/testcontainers-java ) – a Java library that supports JUnit tests, providing lightweight, throwaway instances of common databases, Selenium web browsers, or anything else that can run in a Docker container. A year ago we (ZeroTurnaround) decided to join our Docker-based test engine and TestContainers, and now it's open-sourced, available to everyone, so you can test your apps like we do :)
Anton Arhipov ,
Java Champion and Developer Advocate at ZeroTurnaround
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?
Matt Raible ,
Web developer and Java Champion with a passion for skiing, mountain biking, VWs and good beer
With Java 9 and Jigsaw project around the corner (this time apparently for real), we finally need to stop pretending we can simply ignore the concept of modularity in Java! The thing is - modularity is NOT just some new framework! Neither it is a simple set of APIs! It's a complex concept that has been around for almost as long as the industry itself. So in this talk I'd like to take a step back and reason about the fundamental idea of modularity in Java by comparing the concepts of Jigsaw with other Java modularity approaches and implementations that have been around for quite some time.
Milen Dyankov ,
Developer Advocate at Liferay, passionate about Java, OSGi, clean architecture and modular design
A key advantage of the IoT is that it enables you to expand the potential of constrained devices by giving them access to the computational power of The Cloud. In this session I’ll show you how I transformed a lowly Raspberry Pi Zero webcam into a smart security camera (with motion detection, threat detection and alert notifications) by combining open source software with cloud based image analysis. Attendees can expect an introduction on how to set up their own Raspberry Pi Zero webcam, a comparison of some of the image analysis API’s currently available, and finally a demonstration of how I used Node.js and a range of cloud based API’s (including AWS Rekognition, AWS Lambda and AWS Step Functions) to help my smart security camera distinguish between an unwanted guest and the neighbours cat.
Mark West ,
Coding and IoT enthusiast
DDD is often misinterpreted in so many ways. Many teams focus only on the tactical patterns, or even consider repositories as mere glorified DAO's and forget about all the other concepts that really matter: the focus on the business domain, modeling in code, and the concept of Bounded Contexts. In this talk for junior and senior developers alike, we'll clarify the few most important building blocks of DDD. We will also illustrate how practicing DDD actually looks like. This talk is the perfect opportunity to get started on DDD on solid grounds!
Cyrille Martraire ,
Deliberate Designer
In today’s world of software development we deal a lot with integrations, SOA and Microservices pushed this to the next level and IoT will make developers life even more difficult and challenging. There is an approach to tackle integration hell, to decouple service development and to allow API to evolve. The approach is called Consumer-Driven Contracts and in this talk I’m going to deep dive in this topic in order to provide more understanding and application of it. Along with theory there should be a practical part where we’ll take a look at one of existing tools to enable CDC at your project.
Marcin Grzejszczak ,
Author of Mockito books. Making Spring Cloud Contract / Sleuth / Pipelines @Pivotal
Static (ahead-of-time) compilation of code appeared in Oracle JDK 9. We have already discussed why this is necessary, and the scope of the current implementation. Now it makes sense to talk about the technical details. What information is generated by the AOT and how it is generated, how compiled AOT code interacts with Hotspot. What you can do with AOT code by external tools, and how to infiltrate into the compilation process. And of course, what grips to twist, and what will be the performance with AOT.
Dmitry Chuyko ,
Java SE performance engineer at Oracle
Traditionally, Java developers have a strong dislike for JavaScript. Justifiably so, of course. JavaScript lacks a range of features that we all know and love in Java. However, JavaScript has been gradually taking over the frontend landscape. Since JavaScript is the native language of the browser and the browser is available on all devices, the relevance of JavaScript is no longer in question. The only question is how to choose the right tools for the job, since the JavaScript ecosystem is filled with a wide range of technologies, libraries, and tools. In this session, you will learn how the speaker, a Java developer, has bit by bit, over time, come to like JavaScript. Not so much the language, but the ecosystem and the range of possibilities available. By the end of the session, you will have a thorough perspective on everything the JavaScript ecosystem can do for you, as a Java developer, and how you can make sense of the instability/vibrancy of the JavaScript ecosystem, too.
Geertjan Wielenga ,
Open source technology advocate working at Oracle.
The rate of business change is accelerating. Organisations must learn to build the right things better and faster to survive. Continuous delivery and lean product management help deliver “better and faster”. But we need practices to ensure the “right things” flow into these processes. Practices that help experiment and innovate with new business models, products and services before technical solutions are commissioned. This need presents technology departments an opportunity to increase their contribution towards organisational agility. Partnering with business to implement such practices and ensure diverse, cross-functional participation is crucial to ensure building the “right things”. One approach is to introduce GV design sprints into the demand process. Design sprints are a mix of business strategy, innovation, behaviour science and design thinking. They answer critical business questions, focus on greatest impact first, identify new consumer opportunities and lead to smarter allocation of resources. In this talk we explore the use of design sprints in an enterprise environment to:
Gary Crawford ,
Loves to build the right thing better and faster
In this talk we will shortly look at the functionality Docker and Kubernetes (K8S) provides and compare it with the features of a traditional Java EE application server. During the talk we will present a small Java application that reuses traditional Java EE design patterns but will be deployed as Docker containers on Kubernetes. Where possible the application will reuse K8S core features, e.g. for service location, resiliency and scalability. Business logic itself will be implemented based on Vertx.io with a Hazelcast cluster backend and some distributed NoSQL persistent storage. The result is small, lean and fast Java code that fully focuses on the business aspects, but written without any current application server technologies. Winding up I will shorty strive the idea how Kubernetes even be used as a single application runtime container being deployed to your customers environment.
Anatole Tresch ,
Principal Consultant at Trivadis AG and Oracle Star Specification Lead and Apache PPMC member
FlameGraphs offer us a new way to visualize execution profiles, combined with Linux system profiler perf and the recently added -XX:+PreserveFramePointer option in JDK 8u60 we now have for the first time a way to capture a comprehensive profile for the OS, JVM and your Java code. In this session we will be exploring the JVM and Java applications using this new perspective and reflecting on the profiles and the utility of this new method:
Nitsan Wakart ,
A coder/blogger/speaker with a pedantic passion for performance and concurrency
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. Based on an overview of this topics and some samples the talk will answer questions like: How can I create my own annotations? How can I create a plugin structure without using frameworks like OSGI? What's the best way to handle NullPointerExceptions? How can I write concurrent code that is still maintainable?
Hendrik Ebbers ,
Java Champion that loves Java, Star Wars & Rock
New possibilities are opening up for developers with the many innovations of the highly anticipated JDK 9. The module system, in particular, is a driving force for change. The session demonstrates how JDK 9 developers can improve and accelerate their work in a variety of environments, including the cloud.
Dalibor Topic ,
Principal Product Manager for Oracle
Java had been constantly criticized for poor performance ever since its inception, but not so much in recent years. Thanks to optimizing dynamic native code compilers, Java performance today is very close to the performance of low level languages such as C/C++, and is even better on some classes of applications. Along with dynamic compilers, static compilers for Java have been evolving as well, so there is still no clear winner among these two approaches. It should then come as no surprise that an AOT compiler is finally going to appear even in the HotSpot JVM and OpenJDK via JEP-295, which is officially included in Java 9.
Nikita Lipsky ,
Initiator and a product lead of Excelsior JET project – JVM with AOT compiler
Have you ever heard of non blocking web servers? Have you tried it in Java? Curious? Let me show you how to write simple HTTP Rest Server using Ratpack library. Yes library - because it is not another vast framework. Just a small tool for big things! I will show how non blocking architecture works - and yes one thread can handle thousands of simultaneous HTTP connections in Java. We will see why using more threads on server is not the best option every time - and we will try to find the sweet spot for performance. We will deal with topics such as: REST, WebSockets, persistence (with and without SQL databases), asynchronous IO, blocking IO, RxJava 2.0, JavaSlang, immutability and more. And yes - there will be mondas, a lot of them, you are going to love them. They are terrific. All that on a working example of a simple web based multiplayer game.
Jaroslaw Ratajski ,
JVM Developer
Stream processing is a hot topic today and it’s easy to get lost among all the possibilities. In this live coding session we will explore the Reactive Streams approach used by the Akka Streams project. On an almost real-life example we’re going to walk through both the basics and some more advanced usages of the library. And if you thought Akka Streams was a Scala library, come to learn the nice Java API and see how wrong you were.
Jacek Kunicki ,
A passionate software engineer
So that exception I see in the logs 3000 times is a 'normal exception'? sounds legit. Repeat after me: A Normal Exception is Not. Exception raising/handling is a popular and ingrained mechanism for dealing with faults. Unfortunately, this mechanism is not without issues: confusing control flow, performance problems, ignored faults and bugs that are very hard to understand. But moreover, exception handling is abused; Even in languages with checked exceptions, studies consistently find that the majority of exceptions are ignored, swallowed or handled by a default snippet. It's not uncommon to see elaborate machine learning systems crunching terrabytes of logs to filter out hordes of meaningless exception messages thrown from our code. We can do better. This talk introduces a guiding principle for proper exception handling: 'Actionable Excpetions'
Avishai Ish-Shalom ,
Avishai is a veteran operations and software engineer with years of high scale production experience
Android development is hectic area where new technologies and APIs appear at a record pace, applications often require very tight deadlines and agile approach of endless iterations towards perfection, where we are only equipped with old trusted Java language to deal with all this madness. While some say Java is nearing the expiry date and is a problematic choice for modern mobile platform, there are few tricks left in the sleeve that can help poor mobile Java developer to be more productive problem solver in this world of chaos. This talk will focus on Java Annotations and their usage for Android development specifically. We will go through both runtime Annotation handling using reflection and compile time Annotation Processors, see how we can utilize this knowledge to build synoptic, concise code that plays well with the Android platform. We will have quick outline how popular libraries embrace Java Annotations to tackle various real world problems, such as networking calls or persistence. Special consideration will be given to various design and architectural patterns, often thoughtlessly transferred from the Java Enterprise, where they might be poor match for mobile development for Android and how Annotations might help simplify developers life together with making the application more robust. The talk assumes only a basic knowledge of mobile Android development, there will be many easy to understand examples to illustrate the concepts that will be presented.
Pavel Lahoda ,
Develooper
The beautiful thing about software engineering is that it gives you the warm and fuzzy illusion of total understanding: I control this machine because I know how it operates. This is the result of layers upon layers of successful abstractions, which hide immense sophistication and complexity. As with any abstraction, though, these sometimes leak, and that's when a good grounding in what's under the hood pays off. The second talk in this series peels a few layers of abstraction and takes a look under the hood of our 'car engine', the CPU. While hardly anyone codes in assembly language anymore, your C# or JavaScript (or Scala or...) application still ends up executing machine code instructions on a processor; that is why Java has a memory model, why memory layout still matters at scale, and why you're usually free to ignore these considerations and go about your merry way. You'll come away knowing a little bit about a lot of different moving parts under the hood; after all, isn't understanding how the machine operates what this is all about?
Tomer Gabel ,
Oddball extraordinaire
Communication is the cornerstone of distributed systems. Our services often communicate using HTTP protocol and it is difficult to imagine a modern project without a HTTP client. However we often forget how important role they play. Have you ever wondered what hides behind different clients APIs? How does the magic work? What properties and options should be set in HTTP client and why do they matter? During this talk i will show what happens behind the scenes when using popular high-level HTTP APIs: RestTemplate, Jersey and Retrofit. What settings are crucial to make the most out of them, how to detect failures quickly, what are the bottlenecks and how to monitor them. I will also talk about lower level clients hiding behind those APIs: Apache Client and OkHttp. Come and listen if you want to be a conscious user of these fundamental tools. Level: beginner and everyday user
Adam Dubiel ,
Passionate developer and technical team leader
Java is everywhere. According to Oracle it’s on 3 billion devices and counting. We also know that Java is one of the most popular vehicles for delivering malware. But that’s just the plugin right? Well maybe not. Java on the server can be just at risk as the client. In this talk we’ll cover all aspects of Java Vulnerabilities. We’ll explain why Java has this dubious reputation, what’s being done to address the issues and what you have to do to reduce your exposure. You’ll learn about Java vulnerabilities in general: how they are reported, managed and fixed as well as learning about the specifics of attack vectors and just what a ‘vulnerability’ actually is. With the continuing increase in cybercrime it’s time you knew how to defend your code. With examples and code this talk will help you become more effective in tacking security issues in Java.
Steve Poole ,
A long time Java and JVM developer, leader and advocate. Works at an IBM R&D Lab
You’ve heard about data analytics. You’ve even got a little data. but how do you get started with analysing your data and what exactly could you look for? In this talk we will explain how you can easily use your Java or Scala skills to analyse data and get real (and sometimes unexpected) insights. We’ll show you how you do not always need large amounts of money, time or computing resource to get meaningful results . With code and demonstrations we will walk you through the steps needed to deploy and use a complete solution that will run on your laptop. Your first steps on the data analytics path starts here. Who knows what you’ll discover.
Adam Roberts ,
Team lead for Apache Spark runtime at IBM
The rising demands on malware protection systems - ever-changing environment, the need to make good decisions fast and learn quickly from data - all pose significant challenges. Performing rich real-time analysis of large number of samples pouring in from over 400 million users, we'll show how an event-driven microservices architecture is a great fit for our systems. We'll discuss our first-hand experience adopting microservices and container orchestration. We'll cover technical aspects such as communication between services or their monitoring, but also how we benefit from our internal Docker cloud, based on proven open-source technologies, to deploy, manage and scale our services. Most importantly, nothing is all roses, which is why we'll share some of the missteps and difficult trade-offs we had to make during our transition. While having services written in multiple technology stacks enable other teams in our company to participate easily, what are the costs? How do we handle shared libraries and data? Also, what exactly makes a microservice a good citizen in the system? Is running an internal cloud yourself worth the effort? We'll touch on all these tough questions, too.
Petr Krebs ,
Backend developer @ Avast
Alena Varkockova ,
Backend developer @ Avast
JVM technologies such as garbage collection and just in time compilation, have been improved for decades and provide industry tested reliability and performance to the Java ecosystem. Recently, a lot of new languages have been written in Java to leverage this investment in JVMs. We believe it is possible for other languages to leverage the huge investment in JVM technology without necessarily becoming tied to the Java Language or the JVM itself. In March 2016, the Eclipse OMR (https://github.com/eclipse/omr) open source project was created. The Eclipse OMR project consists of a highly integrated set of open source C and C++ components that can be used to build robust language runtimes that will support many different hardware and operating system platforms. The components in Eclipse OMR were donated from the IBM J9 Java VM. I will discuss the different technologies available in OMR and their capabilities. The technologies include garbage collection, compiler (JIT), RAS and diagnostic tools. During this talk I will also discuss the languages consuming OMR and other runtime proof of concepts we have been working on to demonstrate the benefits of shared runtime technologies. The proof points include IBM J9 Java VM (soon to be open sourced as Open J9), Ruby MRI, SOM++, Lua Vermelha, CPython and Rosie Pattern language.
Charlie Gracie ,
Senior Software Developer and Co-Project Lead on Eclipse OMR working on Virtual Machine Technology
Caching is relevant for a wide range of business applications and there is a huge variety of products in the market ranging from easy to adopt local heap based caches to powerful distributed data grids. Most of these caches are being promoted with examples from applications that have the luxury of having 'eventual consistency' as a non-functional requirement. Most business / enterprise applications don't have that luxury. This talks aims at developers and architects that want to adopt a caching solution for their business application. I will present 15 caching patterns and best practices for these kinds of applications that address the typical questions being asked in that context. These questions might be: 'what data can I cache?', 'how to I handle consistency in a distributed environment?', 'which cache provider to choose?' or 'how do I integrate a cache provider in my application?'. This talk comes with many live demos, some of them are run on a distributed cache cluster on Raspberry Pis
Michael Plöd ,
Consultant for Software Architecture / DDD
Everyone is talking about microservices, and there is more confusion than ever about what the promise of microservices really means and how to deliver on it. To address this we will explore microservices from first principles, distilling their essence and putting them in their true context: distributed systems. What many people forget is that microservices are distributed and collaborative by nature and only make sense as systems—one collaborator is no collaborator. It is in between the microservices that the most interesting and rewarding, and also challenging, problems arise—enter the world of distributed systems. Distributed systems are by definition complex, and we system developers have been spoiled by centralized servers for too long to easily understand what this really means. Slicing an existing system into various REST services and wiring them back together again with synchronous protocols and traditional enterprise tools—designed for monolithic architectures—will set us up for failure. As if that wasn’t enough, we can’t just think about systems of microservices. In order to make each microservice resilient and elastic in and of itself, we have to design each individual microservice as a distributed system—a «microsystem»—architected from the ground up using the reactive principles.
Jonas Bonér ,
Founder and CTO of Lightbend, inventor of the Akka project
Lagom is a new microservices framework that helps you to create resilient and highly scalable service based systems on the JVM. It is reactive from the ground up and guides you through CQRS and Event Sourcing to built isolated microservices with ease. In this session, you will get and overview of Lagom's architecture and features. There will be code and live demos to show you in practice how it works and what you can do with it, making you fully equipped to build your next microservices with Lagom. Target audience: Intermediate
Markus Jura ,
Software Engineer at Lightbend
Apache Cassandra is one of the most renowned NoSQL databases. Although it's often associated with great scalability, improper usage might result in shooting yourself in the foot. In this talk I'll present a set of ideas and guidelines - both for developers and administrators - which will help you to make your project an epic failure.
Michał Matłoka ,
Software Wizard @ SoftwareMill
Every idea has the golden age. The DevOps movement is slowly reaching that point in its history. The wave of DevOps adaptions creates new opportunities, but it also arises the hordes of unhappy people badly touched by defective implementations of DevOps. Renaming the team names to 'DevOps team' without transformation of the culture. Expecting the knowledge about the system administration from programmers. Thinking that DevOps is the continuous deployment. This is just a short list of DevOps sins. This distorted picture of DevOps in some of my projects forced me to ask the question: what are the main ingredients of DevOps? Is it our technical knowledge? Maybe it is how we maintain our infrastructure. Is it the way we organise our teams? Is it support from the management of our company? Can we define at all the recipe for DevOps? During this presentation, we will try to find answers to these and other questions raised by 'users' of DevOps.
Robert Firek ,
Software Craftsman
BigData is quite trendy and now you're in a new project with Spark/Cassandra/Hadoop/ to build the DataLake/ of the 21st century. To have a good start with the new world and all its concepts you'll need some foundational knowledge: 1) basics notions in distributed systems: time, topology of failure, latency, replicas... 2) the CAP theorem, or 'pick 2 out of 3, no free lunch' 3) master/slave, multi-master and masterless architecture, advantages and drawbacks
DuyHai Doan ,
Apache Cassandra evangelist at Datastax, committer for Apache Zeppelin
Web Components are a set of standards currently being produced by Google engineers as a W3C specification that allow for the creation of reusable widgets or components in web documents and web applications. The intention behind them is to bring component-based software engineering to the World Wide Web. The components model allows for encapsulation and interoperability of individual HTML elements. (Wikipedia) During this talk I will convey to you the significance of using Web Components and explain why web developers need them. I’ll talk about the state of browser compatibility and how to use Web Components in browsers that are not compatible. I’ll demonstrate to you how to use Web Components and explain how they work. A significant part of this talk is about creating your own Web Components, which I’ll compliment with live coding examples. To fully understand this talk the attendees should have a basic knowledge of HTML, CSS and JavaScript.
Marcus Fihlon ,
Agile Coach, Software Engineer, Lecturer, Author
JPA is the main building block in most Java projects. However, a lot of developers still use it without a deep understanding of the technology, relying mainly on applying the copy-paste methodology from StackOverflow or existing system entities. During this presentation, I will consolidate knowledge about object-relational mapping. We'll see how lazy loading works under the hood and understand the difference between a set, list or bag. We will also talk about common traps leading to significant decreases in performance or improper behavior of the system.
Jakub Kubryński ,
Co-Founder @ Devskiller.com
For those familiar with the teachings of Uncle Bob, Clean Architecture is no stranger. It's a set of architectural guidelines that provide a SOLID set of principes on which to base you architecture in order to have a clean, easy to understand and even easier to maintain foundation. This talk will show you how you can implement such an design, using Java, and will demonstrate the power of such a design. It will also show how you can be pragmatic in implementing Clean Architecture and what the possible implications can be when making pragmatic concessions.
Lieven Doclo ,
Java developer with an appetite for clean architecture
This is a light talk about the fundamental topics of distributed systems theory. It introduces a few theoretical system models, and briefly discusses how they reflect to real world problems. It talks about the concept of time, how we perceive and use it to order things in distributed systems. It also touches on the consensus problem by walking through the famous FLP result, failure detectors and a couple of consensus algorithms. Lastly, it mentions the CAP theorem, which gained a lot of attention recently, thanks to the cloud computing paradigm and NoSQL databases.
Ensar Basri Kahveci ,
Data-intensive distributed systems expert
Probably there is no Java developer in the world who writes tests and haven't heard about Mockito. That most popular mocking framework for Java will be celebrating its 10th birthday soon. However, I don't plan to brood the history. At the end of 2016 the new and shiny Mockito 2 has been released. During the presentation I will show what brand new features have been implemented in Mockito 2 and what improvements you can expect. We will also take a closer look at the places which changed incompatibly and possible migration pitfalls. You will be able to judge if it was worth to wait almost 2 years since Mockito 1.10.19.
Marcin Zajączkowski ,
Software Craftsman at Codearte
Oh Java, my old, lousy and boilerpalted friend. For ages, trying anything new (which luckily wasn't that frequent afterall) required starting a new project, followed by a `Sandbox` class and a `public static void main` method. Alternatively, a simple JUnit test was a nice entrypoint as well - if we were lucky enough to have some dependency management sorted out.Thankfully, things have changed. With the Java9 a REPL has been introduced, everybody can just run an up-to-date Java shell and try out new sytaxt, new APIs, new libraries. Now we can feel like Scala, CLojure, Ruby, JavaScript, PHP, call whatever language developers - finally there.In this talk I'll walk through essential REPL examples, see how we can use JShell to try out new language features (like Java9 Streams enhancements), but foremost, we will use it to build a real-life web application. Expect meat-only talk without theory, diagrams, useless 'javax.swing.*' application examples.
Jakub Marchwicki ,
Developer since ever, architect by accident, manager if required, trainer by <3, JUG leader
For years there have been voices calling out Akka - the most popular implementation of te Actor Model in the JVM world, for having its interctions loosely typed. This has now changed with the final introduction of the new akka-typed module and with typed persistence module, currently under construction. Akka Typed also comes with a new, behavior-driven philosophy that requires developers and architects to re-think their ideas about actors. How to design & implements actors with that new mindset? How to model & type actor interactions? Answers to this & more in this humble presentation. The talk will take around 60 minutes and is aimed at an advanced audience. Solid understanding of Scala and Akka is required to fully understand it. It will include code samples illustating the Akka Typed API as well as the behavior-driven actor design.
Kamil Owczarek ,
Scala / Big Data Developer. 'Data is always more valuable that you recognize it to be'
Basic functional concepts like immutable data, second-order functions, lambdas and function composition can already be found in the modern programmer’s toolkit. During this talk you will learn about more advanced functional concepts and how they can solve real problems. I will talk about pattern matching, algebraic data types, type classes, functional abstractions, folding and type-level programming. I will show you a practical example written using today’s Java functional constructs and build up from there. I will use only JVM-based languages to show you how they can improve the code, make it more maintainable and safe.
Michał Płachta ,
Makes things alive using computers. For fun and for living
When we talk about objects, we think about their behaviors, attributes and interactions. We think about the things they help us achieve. Yet, before any object can participate in any kind of operation or calculation, we first have to create it. Easy? Well, sometimes it is harder than you expect. Unfortunately as developers we tend to tackle even the simplest problem in an over-complicated way. During the talk I will show you the ways of creating objects and I will present you all problems that come with each solution. I will also talk about the problems that become more visible when you create your objects in the right way.
Sebastian Malaca ,
Agile maniac and OOP fanatic
In this talk, we’ll look at what it takes to create a WAN-first distributed stream processing engine for IoT. Assume that you want to battle the traffic of the Mirai botnet of 623Gbps and do real-time analytics of traffic to inform upstream servers of route changes, etc. In this talk, I’ll share the changes and additions made to concord (concord.io) a C++ streaming engine running on top of Apache Mesos to support a multi-tenant workload. We’ll cover the security, debugging, fleet management of tens of thousands of servers while keeping the Akamai platform isolated from accidental or malicious attacks at millisecond latencies.
Alexander Gallego ,
Principal engineer at Akamai. Previously CTO of Concord.io
Event sourced domain naturally leads to messaging infrastructure and CQRS based services. See how we can benefit from getting rid of typical relational database model replaced by events. See how events come along with projections and different read model. In this talk we are going to explore all of this backed by a real Spring Cloud Stream applications. Don't ever lose information in your ORM-based system again. Leverage eventual consistency and event-driven architecture with the usage of pure Spring tools. Let's look into internals of databases and see that ideas like ES and CQRS are not new ones. For the fans of Functional Programming, see how you can model your domain with just functions, pattern matching, left fold and immutability. I would like to focus on several aspects: 1. Where to apply Event Sourcing - which is often wrongly recognized as architectural pattern 2. How Event Sourcing is different than ORM-based system with dirty checking. 3. How to apply Event Sourcing with just relational database and spring tools, which can be a good fit for a majority of projects 4. How we can deal with eventual consistency, blue/green deployments, replication, functional decomposition and scaling when using ES/CQRS
Jakub Pilimon ,
Passionate about DDD, CQRS, Clean code and Event Sourcing
UI - backend developer's nightmare, but nowadays backened developers means fullstack devloper. In this presentation I would like to show how easy is build full working UI with Vaadin 8. Grids, lazy loading, push, complex forms, etc it's all at your fingertips. Only requirement is to be open minded and have will to use right tool for the job.
Lukasz Byczyński ,
Software Developer during day, hAkker at night
Come explore how a production JVM takes your application class files, the compiled Java code you’ve written, and loads them into the managed runtime in a form that can be executed. This session provides anyone interested in hacking on a production managed runtime with the background necessary to understand the design of OpenJ9, the upcoming open source project based on IBM’s production JVM and the Eclipse OMR project. It focuses on the key data structures used in the core JVM because understanding these data structures enables anyone to hack on the JVM and to take better advantage of the JVM features in their applications. Learn how the J9 Java VM operates, why there’s a ROM/RAM class division and the state changes that the data can under go from interpreted to jitted execution.
Dan Heidinga ,
J9 VM Lead, JSR 292 / 335 EG member, Eclipse OMR contributor
Oracle has announced: after lambdas in Java 8 and modules in Java 9, 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:
Henning Schwentner ,
Coder, agilist, domain-driven designer, project carer, listener, speaker, trainer, one of @wps_de
InterruptedException is what most of us catch, but few of us really understand what it's coming from. I will try to explain what's going on under the hood and why it's so important to restore interrupted status in the thread. We will discuss the very idea of interrupted concurrency in Java and how we must use it effectively, on the level of user code. I wrote an article about a few months ago, but at the presentation we will try to go a bit deeper into details and discuss different use cases: www.yegor256.com/2015/10/20/interrupted-exception.html
Yegor Bugayenko ,
Author of 'Elegant Objects'
Hard time to stick with decisions made on Retrospective? Not sure if your dedication to team’s working agreements is bringing fruits you expected? Suspect that your team is barking up the wrong tree? A life of an agile software development team in not easy. Regardless of method of choice a team needs to fulfill many often contradicting needs still retaining place for self-improvement. The Talk describes an experiment of combining elements of Evidence Based Management with Four Disciplines of Execution as a way for a development team to track and improve their own habits. It’s meant to address two common issues that hinder team’s self-improvement: lack of consistency and inability to see long term payoffs of current actions.
Grzegorz Gubiński ,
Agile & Lean trainer, coach and consultant
We often think of performance testing as one of those things we just have to do at the end of a project, often using heavyweight tool sets in dedicated environments. In this talk, James offers an alternative. What decisions would we make differently if we had the ability to rapidly perform experiments using lightweight performance testing as our lens? In this talk james will cover the pre-requisites to allow us to make small bets on performance and explore the strange world of evolutionary design that this technique makes possible.
James Lewis ,
ThoughtWorks Developer
Have you wondered how you can improve the performance of your applications under high load? You probably heard that reactive design can help meet better response time and make your applications more flexible. I will show you that you don’t need to rewrite your Java EE applications from scratch to achieve that. We’ll go through 5 ways how to reuse the knowledge of Java EE and Java 8 to improve your existing applications with a reactive design. We’ll apply them to a big production-like application step by step, walking through the code and demonstrating live. In the end, we’ll compare how much the performance and user experience can be improved. All that without learning a new framework or library, and limiting the amount of changes in the application source code to a bare minimum.
Ondrej Mihályi ,
Developer, lecturer and consultant, exploring new approaches with already proven Java tooling
Home automation has been around for a while, but in the last few years intelligent voice controlled devices have made their appearance on the marketplace. A popular one is Amazon Alexa. Common uses for your assistent at home are controlling lights and music, but let’s start thinking outside the box! In this talk we will explore fun and unusual voice controlled applications for in your home. We will look at how the Alexa Skills kit works and how we can create our own Alexa applications.
Jeroen Resoort ,
Java Consultant @ JDriven
There are 10 kinds of people: the ones who already log stuff and the ones who will. ;-) But what can be fascinating about logging? It's just adding some statements of given level to a file in /var/log, so what's this presentation for in the fist place? Well, ordinary adding lines to /var/log and tracing them with tail -f or searching with grep is so... 1980 and inefficient. Meet Graylog: a centralised and distributed log management system. A tool, which will let you gather, process, analyse logs from many sources: syslog, your application, Apache/ngix, database, firewall, etc. It can alert, search all ways throug, analyse the logs no matter what language/technology sent them. And it makes that good. And is Open Source. This presentation is about some gotchas based on real-life experience, quick Graylog setup, wiring your apps/systems/servers, analysing logs after. Even if the machine which sent them is already gone.
Piotr Przybył ,
Remote Freelance Software Gardener
There's a shortage of people that you can hire. There are problems to find promising, good or even proper candidates when you want to recruit. You are getting more and more certain, that education in the universities are not enough. Or perhaps you would even phrase it harsher. You're not the only one, I talked with boys and girls thinking whether after lycée or tech-school they should go straight to work, 'for studies are useless'. And because you (or your team, or your boss, or your company) have problems with letting people go, you're afraid of saying 'YES' to the candidate, unless you're really convinced (as you should!). Solution: hire and teach them yourself. Last year I prepared and led a Java Academy program. I was hired just to do it. Rules were simple: interview, choose most promising ones, teach them for 3 months interspersed with mock interviews to gauge progress. Program was repeated. Afterwards, I used variation of it to introduce manual testers to Java. During this presentation, you will learn: - what I did, - what worked, - what failed to work, despite seemingly having no reasons to, - what you need to do to have such a program (and why), - how taxing that is. And I'm hoping for a good QnA session!
Tomasz Borek ,
Coder from Poland, thankful to anyone who teaches me while I hop along
You’re going to mess up. Probably really terribly. The site’s going to crash. Or get hacked. Or you’re going to accidentally drop the database. Or enable email delivery on staging servers. Something bad is going to happen, eventually, whether you messed up or not. This talk is a talk about mistakes made by companies like GitHub, GitLab, and others, and how you and your team can address them when they pop up.
Zach Holman ,
Developer and startup advisor
The cure for scurvy is not lemons or limes; it's vitamin C. The cure for your system blues is not functional or object-oriented programming; it's data. We will explore how data helps in modeling your business logic, enforcing contracts, building UIs, testing your systems, and documenting your assumptions. Or, you can just let your teeth fall out.
Norbert Wójtowicz ,
Recovering empty-stack developer
Jarosław Pałka ,
Coder, architect, system thinker 'wannabe', open source contributor, still enjoying the ride
Spring 5 is almost 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.
Josh Long ,
Spring Developer Advocate at Pivotal
The last years have brought Akka the largest changes since the initial 2.x rewrite yet it remained fully compatible across the last years. With the new exciting modules like Akka Streams, Akka HTTP (including the most recent HTTP/2 work) and the new remoting reimplementation codenamed Artery, we've stepped into the era of Akka 2.5 already. Which again, remains backwards compatible as previous releases. What's in there, and what's next for Akka in general? In this talk we'll take a brief look back at the newest stable modules of Akka itself, as well as new projects such as Alpakka. Next, we'll continue with the (then present) 2.5 version and the stable Persistence Query, high-availability CRDT support in Distributed Data and continued work on the Artery remoting. Finally we'll have a sneak peek at what's coming in the next releases, which among other things include Akka Typed and more!
Konrad Malawski ,
Akka hakker @ Lightbend, Reactive Streams TCK author, founder of multiple communities
A crucible allows base metals to be mixed together at high temperatures to form alloys. Medieval alchemists used crucibles to mix an astonishing variety of substances together in the search for new materials. While Alchemy is often derided for its informal approach, early Alchemists paved the wave for modern chemistry, and included Newton and Boyle among their number. Just as the crucible encouraged an experiential and experimental approach to understanding the world, so too the computer can provide a computational crucible. Code can be mixed and brought to great temperature in the search for greater understanding and new discovery. Using his own Extempore programming language Andrew will provide a ``live'' introduction to sound synthesis, building up the core components of a real-time digital synthesizer on-the-fly ``in the computational crucible''.
Andrew Sorensen ,
Artist-programmer, author of impromptu & extempore languages
One of the hardest challenges for Software Engineer is presenting work. I’ve seen people who did amazing work get up in front of a client and lay eggs. I’ve also seen people do alright work and wind clients around their little finger. Optimally, you want to do good work and present it well. It’s much better to be a good developer who can present well than a amazing developer who can’t. In this session we’ll cover the most common mistakes software engineers make when presenting their work, and how to avoid them.
Krzysztof Kaczmarek ,
10 years experiences as JVM developer, 3 lifetimes as fan of brackets
Scrum framework has evolved in last 20 years.it was one of the favourite tool embraced by developers in all industries. What went wrong? Is SCRUM still agile? What is an agile framework? During this presentation, we will uncover why developers stopped using SCRUM framework. It will be a good moment to talk bit more about principles and how we can deliver software without frameworks and why should we care about it.
Matthew Brylka ,
Director of Software Engineering at Guidewire and technologist by heart
Let's imagine an online banking website containing different features like a chat box, exchange rates, stock data and user profile information. The site has a high performance characteristic, despite of its complexity and target publishing channels. All those features come from different providers/vendors having their own teams working in various modes, technologies and release cycles. Knot.x connects all of them in a controlled and isolated way, preventing any undesired interferences. It combines asynchronous programming principles and message-driven architecture providing a scalable platform for modern sites. If you want to see Vert.x, RxJava in action you can not miss this talk. During the talk we will explain the idea behind Knot.x and show how Knot.x impacts systems architectures.
Maciej Laskowski ,
Software Engineer at Cognifide - reactive programming enthusiast
Tomasz Michalak ,
Software Engineer at Cognifide, lead developer of Knot.x open source project
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 there’s lots more to tempt developers. We’ll divide things into five categories:
Simon Ritter ,
Deputy CTO of Azul Systems
Managed runtime performance expert, Monica Beckwith will divulge her survival guide which is essential for any application performance engineer to get to the bottom of a performance issue. The presentation will provide a step-by-step approach to finding the root cause of any performance problem. Monica will walk the attendees through an example that will showcase a few performance tools and the performance process. Following the simple rules highlighted in the presentation and applying performance engineering patterns will make you and your stakeholders happy.
Monica Beckwith ,
Independent performance consultant and instructor
Garbage First (G1) Garbage Collector (GC) is going to be the default in Java 9. G1 GC has incremental compaction and your friendly-neighborhood stop-the-world collections. G1 also has a concurrent marking phase. After having worked with it for many years, Monica will share her performance work in helping customers achieve their SLAs with G1 GC. So you don't want to miss it!
Monica Beckwith ,
Independent performance consultant and instructor
Inside the JVM JIT: Monitoring OpenJDK JITs and learning what they're doing, tweaking how they run. Oldish talk but I keep it up to date.
Charles Oliver Nutter ,
Red Hatter working on JRuby and JVM languages
Java Native Runtime: a walkthrough and short tutorial on using the Java Native Runtime libraries to call C libraries from Java without writing C code.
Charles Oliver Nutter ,
Red Hatter working on JRuby and JVM languages
Flying is exciting and useful, but it is also quite complicated. Especially for the machine which does not have years of experience in understaning what it sees, like we humans do. On the other hand, machines can be more focused on the task. When they sense something through their equipment, they can react much faster than we humans do. In our project we try to make the machine understand its environment as it flies, and use that understanding to fly on its own, smoothly and safely in unfriendly environments. During this talk you will participate in all the stages of this exciting adventure from the first lines of code, through algorithmic struggles up to complete system ready to explore the world.
Krzysztof Kudryński ,
A passionate problem-solver with experience in design and implementation of algorithms
Błażej Kubiak ,
Enthusiast of all aspects of big data processing and all technologies
In this talk I am going to demystify Quantum Computing. I will start with the absolute basics stemming from insights stemming from physics, in turn showing that they are as relevant to the power of quantum computing as they are for classical information processing. From there, I will go to describing the abstraction level not much different than the frameworks of the modern languages, harnessing all the new power to be harnessed if quantum computers are available in sizes, numbers and prices allowing Moore’s Law to continue beyond 2025. In the second part of the talk I will describe QUIL, the practical language allowing for effective use of quantum computing without paying attention to underlying spooky physics.
Wojciech Burkot ,
Co-founder of Beit.tech, developing quantum algorithm designed to solve NP-complete problems
Most software product organization eventually wrestle with the challenge of refactoring and evolving the architecture, design and code of their products and platforms. Over time code size and complexity increase as successive layers of code, features, integrations, are introduced. Systems become more and more brittle and susceptible to failure, product life cycles grow longer as more safety checks are added in an effort to prevent breakages, and the organization becomes increasingly cautious and uncertain when making changes – further slowing and constraining time to market, and ultimately creating an unvirtuous cycle. One of the biggest challenges in large systems is knowing where to start and how to proceed. This talk will describe proven technical and organizational approaches to modernizing extant systems architectures and code.
David Moore ,
Senior Technology and ECommerce Executive. VP at Sabre Corporation
Rod will discuss how developing Java applications has changed and simplified over the past 15 years, and what may come next around automation and collaboration. What comes after convention over configuration?
Rod Johnson ,
Independent investor, author and software developer. Creator of the Spring Framework. CEO of Atomist
Graal/Truffle is a project that aims to build multi-language, multi-tenant, multi-threaded, multi-node, multi-tooling and multi-system environment on top of JVM. Imagine that in order to develop a (dynamic) language implementation all you need is to write its interpreter in Java and immediately you get amazing peek performance, choice of several carefully tuned garbage collectors, tooling support, high speed interoperability with other languages and more. In this talk we'll take a look at how Truffle and Graal can achieve this and demonstrate the results on Ruby, JavaScript and R. Particular attention will be given to FastR the Truffle based R language implementation, its performance compared to GNU R and its support for Java interoperability including graphics.
Štěpán Šindelář ,
Polyglot developer @ Oracle Labs, working on Graal/Truffle project
I want to share my insights on how we created an effective agile team for a new project. We managed to maintain a very vibrant team spirit in addition to following well-known agile methods. Most of the techniques we used have equally proven valuable in my other teams within a corporate environment. To increase the team velocity and make it more than the sum of its parts, it takes more than to motivate people with salaries and bonuses. This is hard to explain to managers, but a vibrant, dynamic and effective team has to be built differently. It can be achieved only when information is effectively shared, barriers are being removed and team members are kept happy and excited!
Ondrej Mihályi ,
Developer, lecturer and consultant, exploring new approaches with already proven Java tooling
Microservies. Everybody is talking about microservices. Everybody says they do microservces (or at least they plan to) . The definition of microservice architecture is quite broad and vague: functional decoupling into discrete services. Therefore a number of approaches, with different flavors and implementations is so great - everybody can do microservices differently. In this talk we aim to categorize and make some things clear. Based on experience from multiple companies, projects and f*ck ups, we would like to propose certain maturity criteria which organizations must embrace to start with microservices approach. Without these, things might work but times might become even harder. We will walk through multiple practices essential for successful microservices rollout, validate them and justify. This won’t be a purely technical talk - no successful change in the organisation happened on purely technical bases. We will correlate the maturity criteria with some business drivers, which help team-up business and technical guys on the same side. If your organisation considers microservices, or you - as an engineer - need some argument to better justify the technical choices, this talk might be for you.
Jakub Marchwicki ,
Developer since ever, architect by accident, manager if required, trainer by <3, JUG leader
Jarosław Pałka ,
Coder, architect, system thinker 'wannabe', open source contributor, still enjoying the ride
Have you ever wondered why great multi-billion dollar software products changing our lives are built in the US, Western Europe or Australia and not in Poland, Ukraine or Bulgaria? Uber, Facebook, Spotify, Tesla (sic!), JIRA - all of them built by software geeks. Are Polish (or other CEE) IT specialists less intelligent or worse than their colleagues from the West? Or maybe it’s about the huge capital those countries have and we don’t. Or maybe the problem is in our approach to IT and our mindset? Regardless of the true reasons, as the effect, tens and hundreds of thousands of relatively low-cost and controllable people in Poland and other CEE countries work on conserving and maintaining software systems envisioned and usually designed elsewhere. Together with other emerging countries, we have become a development plantation for the most modern countries. I’d like to analyse some reasons of this situation and present what mindset change must happen so that Poland and other CEE countries are not anymore colonies providing human resources, but instead have a creational impact on the advancement of the civilisation and modern economy.
Wojciech Seliga ,
Entrepreneur, leader, software developer, devoted agilist, Atlassian advocate, speaker, Spartez co-founder & CEO
Graphic processing units (GPUs) are not just for playing games. They play a huge role in accelerating applications that have a large number of parallelizable tasks such as machine learning, data analysis or similar. Learn how Java can exploit the power of GPUs to optimize high-performance computing applications, through both explicit GPU programming and letting the Java JIT compiler transparently off-load work to the GPU. This presentation covers the principles and considerations for GPU programming from Java and looks at the software stack and developer tools available. From laptops to the cloud GPUs are turning up everywhere. After this talk you will be ready to extract the full power of these GPUs from your own application.
Steve Poole ,
A long time Java and JVM developer, leader and advocate. Works at an IBM R&D Lab
Adam Roberts ,
Team lead for Apache Spark runtime at IBM
We recommend Dolnych Mlynow 10, a recently reclaimed area with a number of pubs.
View presentationTBD
Krzysztof Kudryński ,
A passionate problem-solver with experience in design and implementation of algorithms
Błażej Kubiak ,
Enthusiast of all aspects of big data processing and all technologies
It's easy to do a proof-of-concept but hard to make something 'production-ready'. Maintainability is complex in distributed systems, and become extremely complicated in the microservices. In this talk, we'll take a look at the common traps producing a gap between 'should work' and 'works.' We'll also talk about costs which come with the most famous (at least at the conferences) architecture.
Jakub Kubryński ,
Co-Founder @ Devskiller.com
Build backend UI like a rockstar with Vaadin 8
UI - backend developer's nightmare, but nowadays backened developers means fullstack devloper. In this presentation I would like to show how easy is build full working UI with Vaadin 8. Grids, lazy loading, push, complex forms, etc it's all at your fingertips. Only requirement is to be open minded and have will to use right tool for the job.
7 simple steps to boost your team work
I want to share my insights on how we created an effective agile team for a new project. We managed to maintain a very vibrant team spirit in addition to following well-known agile methods. Most of the techniques we used have equally proven valuable in my other teams within a corporate environment. To increase the team velocity and make it more than the sum of its parts, it takes more than to motivate people with salaries and bonuses. This is hard to explain to managers, but a vibrant, dynamic and effective team has to be built differently. It can be achieved only when information is effectively shared, barriers are being removed and team members are kept happy and excited!
Lukasz Byczyński ,
Software Developer during day, hAkker at night
Ondrej Mihályi ,
Developer, lecturer and consultant, exploring new approaches with already proven Java tooling