Data Ethics as the New Competitive Advantage

Speaker: Pernille Tranberg

Privacy and the individual’s right to control own data is becoming a competitive advantage. Just as it is being green today, privacy and data ethics is turning into a social and strategic responsibility as it can enhance digital trust. The talk will give an overview of consumer trends when it comes to personal data and describe a range of concrete examples of best practices within data ethics to inspire developers in their work with new products and services. The talk will also zoom in on the new data protection law from the EU, and how it can be used constructively in stead of being regarded as a hindrance to growth and innovation. The talk is based on her latest book (http://dataethics.eu/book/).

Pernille Tranberg is an advisor in data ethics for companies and public institutiones, she’s teaches kids and teens about the data era and digital selfdefense and she’s the co-founder of the think-do-tank Dataethics (http://dataethics.eu).

Fantastic Java contracts - and where to define them?

SpeakerMilen Dyankov

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. Yet it's far from perfect as it is still developer's responsibility to know and configure proper dependencies. This easily becomes nightmare with transitive and provided dependencies. So may be it's time to challenge that approach too? What if we move from hardcoded artifacts to artifact discovery based on well defined contracts? This talk will demonstrate how that can be done today, what are the issues and draft a potential roadmap to fully automated dependency management! 

Not Your Father's Complexity

SpeakerMaurice Naftalin

The traditional measure of an algorithm’s performance was its asymptotic time complexity – the Big-O function that provides an upper bound to the number of instructions it needs to execute. But in modern computers the instruction count is now only one of the requirements that we need to consider: in particular, the importance of caching in modern processor architectures means that a program that is sympathetic to caching requirements, for example by respecting data locality and minimising false sharing, will outperform another that may execute many fewer instructions, if the second one uses cache less efficiently.

What does this mean for the Java programmer? The Java Collections Framework, used daily by every working Java programmer, is interface-based: its design assumes that you will choose an interface—Set, List, or Map—according to the functional requirements of your application, and an implementation of that interface guided by the expected usage scenarios. But we can't any longer use the Big-O as the only, or sometimes even the main, way of choosing between collection implementations. In this talk we'll look at some common Java collections in the light of this new way of judging efficiency, and explore the practical implications for the working Java programmer.

Like the Winter in some famous TV show, CDI 2.0 has been Coming for nearly 2 years

SpeakerAntoine Sabot-Durand

Like the Winter in some famous TV show, CDI 2.0 has been Coming for nearly 2 years. But now CDI 2.0 is Here (like the same Winter) and all the new stuff it brings will deeply change your Java EE, MicroProfile and Java SE experience. In this session I will review the major features introduced in CDI 2.0 and I'll demonstrate how it can be used in various environment like Java EE 7 application server, MicroProfile platform or even Java SE. If you still think that CDI is a simple Dependency Injection solution bound to Java EE or think that there's only one platform to bootstrap advanced service on Java SE, come and see that the CDI "Winter" can compete with "Spring". 

Java EE 8 : Java EE Security API

SpeakerRudy De Busscher

The presentation gives an overview of the current status of the Java EE Security API work, part of the upcoming Java EE 8 specification.

By starting why there is a need for such a new specification, we will cover the main concepts related to security. Soteria is the reference implementation of the specification. Although the spec is targetted to Java EE8, we can use it in several Application servers already. Various common use cases will be presented in a demo.

Developers feedback is important to reach a good specification which can please the developers. At the end, there will be room for questions, remarks, feedback, etc... 

Designing a DSL in Kotlin

SpeakerNicolas Fränkel

Kotlin is one of those “new” JVM languages that are currently rocking the boat. Although it’s made a great impact on Android, it’s equally good on the server side. As Domain-Specific Languages are constrained by the language they run on, Kotlin frees developers from Java fluent builders to propose something better. Taking the example of a Vaadin UI DSL, I’ll demo how one could design its own DSL with Kotlin."

10 tips and tricks to get super-productive with Spring Boot: 100% live coding as well, requires some basic Spring Boot knowledge

Speaker: Stéphane Nicoll

Introduction to Spring Boot: that's not a newbie thing (it's a 100% live coding session, showcasing the concept of Boot using the latest features). If your audience hasn't used Spring Boot so far, that could be a great fit.

Microservices Testing In the Docker Era

SpeakerAsaf Mesika

"To mock or not to mock" that is the question which has been dividing the developer community for quite a while. The discussion climaxed after the heated debate between DHH, Kent Beck and Martin Fowler - “Is TDD Dead?”. The developers siding with mocks do it primarily due to the difficulty of launching third party components. Some are written in Java - like Kafka or Elasticsearch - which makes it easier to use the real thing - but some are not, which leaves you only with binaries, like MySQL, Redis or Consul. Launching binaries using the shell from Java, being platform agnostic, and taking care of downloading the correct platform binary are just some of the difficulties developers are facing.

In this lecture I will show how the existence of Docker transforms the way tests are written. I will introduce you to the innovative library Testcontainers, which provides a complete toolset for controlling Docker in tests. For example, we will take a look at how it enables starting up Consul or MySQL using three lines of code. We will review what the Testing Dichotomy looks like with this power in your hands. At the end of this lecture the audience will know how to test in a pragmatic way making it productively as a result. I believe this approach is mandatory as the world shifts heavily towards team autonomy which means automating your tests on your own - i.e. No QA team dependency.  

Getting Groovy

Speaker: Søren Glasius

In this presentation I will show some of the advantages of using the Groovy language.

Groovy is a powerful, optionally typed and dynamic language, with static-typing and static compilation capabilities. It runs on the Java platform (JVM) and is in many ways a superset of Java. The learning curve for the average Java is described as a "small speed bump" while the powers are described as "Java on Steroids". 

Reactive data marshalling for Java and Scala: XML, JSON and CSV made fun again

SpeakerJan Ypma

In traditional information systems, XML and JSON marshalling is considered a solved problem. You pick a framework of choice, slap some annotations onto your classes, and get going. But most frameworks have 2 big disadvantages: they require the full object graph to be in memory, and by using annotations, you can't use your IDE to help you customize marshalling. In this presentation, a new approach to both reading and writing XML, JSON and CSV will be presented, which leverages lambdas and reactive streams to allow bounded, streaming processing of that data.

Easy Bean Mappings with MapStruct 1.2

Speaker: Thomas Much

Those who have survived the DTO hell of former J2EE versions, where we had to copy data between all the layers of our enterprise applications, appreciate the ease that Spring and Java EE have brought us more than one decade ago.

But if we look closely at our current architectures and design styles like Hexagonal Architecture and DDD, we're in need again for adapters and transfer objects, for example in the anticorruption layer of a DDD bounded context. In other words: We still need to map data between different entity structures.

Often, BeanUtils or Dozer are used to map data between entities, DTOs and similar structures. But those mappings can be slow and are error-prone due to missing type safety... Say hello to MapStruct, the fast and type-safe bean mapper, which - as an annotation processor - generates mapping code at compile time and goes without reflection!

This presentation will show you the basics of MapStruct and its flexible mapping options. We'll have a look at the generated, readable code, and discuss common mapping challenges from real world projects. If you happen to use Project Lombok or Java 8 streams - we'll have a look at them, too.

We'll see some slides and live coding!

Enabling Googley microservices with gRPC

SpeakerAlex Borysov

Software engineer / technical leader with solid experience in large scale software development. Passionate about software development process and technologies. Developed microservices architecture for World leading social games; built core infrastructure backend services for a unicorn startup in Silicon Valley with 300+ million users. Currently working on IoT platform at Google. Clean coder, test-driven developer.

Keeping your data sane with Bean Validation 2

SpeakerGunnar Morling 

Rich UIs, schemaless datastores, microservices communicating with each other - the need for powerful and easy-to-use data validation services has never been bigger.

The Bean Validation standard is here to help, providing Java developers with a rich validation API based on annotations. Bean Validation 2.0 (JSR 380) makes validation even more powerful and expressive by leveraging Java 8 features such as additional annotation locations, repeatable annotations and default methods. This opens up exciting opportunities for Bean Validation - e.g. List<@Email String>. There is also support for java.util.Optional, the new java.time API, JavaFX and more.

In this code-centric talk we’ll explore many Bean Validation features right in the IDE. You’ll learn how constraint validation is triggered via JAX-RS, JPA and even on the client side via AngularJS. You’ll find out how to adjust the validation system to your own requirements, ensuring your data is sane at all times.

Introduction to Spring Boot: that's not a newbie thing

SpeakerStéphane Nicoll

Introduction to Spring Boot: that's not a newbie thing (it's a 100% live coding session, showcasing the concept of Boot using the latest features). If your audience hasn't used Spring Boot so far, that could be a great fit.

OSGI, Java9 - do we need modularity in the age of microservices?

SpeakerMaciek Próchniak

Microservices architecture is one of the most trendy topics in IT these days. Everyone looks at Netflix, LinkedIn or Zalando and tries to be like them. It’s all very good. But at heart of this revolution lie some well known ideas on modularity and decoupling.

And guess what? Idea of modular Java applications is also not new. Even term “microservice” has been in use on JVM since many, many years. However, the main technology for modular Java - OSGi - was always struggling to gain proper attention and we’re still waiting for modules in JDK itself.

In this talk I’d like to explain (and show during quick demo) why you shouldn’t too easily dismiss both OSGi and Java 9 - in many use cases, with little effort they can give you important benefits, without having to spin hundreds of VMs or containers. 

Preparing for Java 9 Modules

Speaker: Ryan Cuprak

Java 9 ships in July, are you ready for Java 9 modules? Java 9 modules (aka Project Jigsaw) is the biggest fundamental change to the Java runtime. Code that use Oracle/Sun private APIs will break. This session will cover the basics of Java 9 modules and also the current state of tooling. The ramifications to existing and legacy applications will be covered along with the steps you’ll need to take to harness the power of modules and write more maintainable systems.

Implementing workflows and rules using Open Source

SpeakerNiall Deehan

Implementing workflows and rules using Open Source Business logic typically involves a lot of long running interactions which might take days or weeks to complete (you may call this workflow). Or (micro-)services have to collaborate in order to fulfill business goals (you might refer to this as orchestration). Also important decisions have to be made based on rules which are changing very often (you might call this business rules management). We know all these requirements must be addressed! In the past shiny vendors promised "zero-code" suites or magic ESBs where "the business" can implement workflows without any developer involved but of course this is nonsense. Instead, I will demonstrate a "developer-friendly" approach which is about business readable models that are enriched with technical attributes and accompanied by code, executed by lightweight engines. I will give an introduction to BPMN (a standard for process modeling and workflow automation) and DMN (for business rules and decision automation). With real world examples, a fun little hack-session and in-depth discussions I will illustrate the variety of possible architectures (ranging from "old-school 3-tier" to "hyped reactive microservices") and point out benefits for the developer. I will use the open source Camunda platform with code examples available on GitHub.  

Oracle Internals for Java Developers

Speaker: Lasse Jenssen

There is no such thing as database independence. If you choose to treat an Oracle database as a black box, you most probably have bugs in your code. This presentation covers some Oracle internals developers need to know about, to avoid bugs and make their applications perform. When your applications fire a query towards the database, what really goes on inside of the Oracle database? Let’s find out! 

Java, JCP, Adopt-a-JSR & You - A Winning Combination

SpeakerHeather VanCura

Learn how to take part in Java technology evolution through the Java Community Process (JCP) program. You can participate as an individual, corporation, or nonprofit such as a Java user group (JUG). This session outlines why and how to participate in the JCP Program. You will also learn about the global Adoption programs and how you can participate in the programs. We will discuss details such as how to run hack days, collaborate with other JUG leads on Adopt-a-JSR activities, and review use cases from other JUGs around the world contributing to the Java EE 7 and Java SE 8 JSRs. Currently there are new JSRs being submitted and developed for the Java EE 8 and Java SE 9 platforms. Find out how you have contribute to the future editions of the Java Standard and Java Enterprise Editions.

One ORM to rule them all

SpeakerSanne Grinovero 

The Hibernate project is no longer tied exclusively to relational databases. Over the past ten years the Hibernate community has been forging Hibernate Search and then more recently Hibernate OGM.

These new components are deeply integrated with the world famous Hibernate ORM layer, and allow you to easily bridge the chasm between your Domain Model and NoSQL databases and high performance full-text indexes.

I’ll give an overview of these projects, their architectures, and finally show a demo of how you could adapt any JPA based application to store data in a MongoDB database, run queries on Elasticsearch, use a distributed real time cache like Infinispan, while actually not changing much code at all.

Java EE 8 - What's new

SpeakerDavid Delabassee

Java EE 8 is right around the corner and quite a few things have changed since the original Java EE 8 proposal. This session will describe in details what Java EE 8 will be. We will discuss the new capabilities that are slated for inclusion in the Java EE platform, e.g. - JAX-RS 2.1’s new Reactive client API - Servlet 4.0 HTTP/2 support - Bean Validation 2.0 improvements - CDI 2.0 Asynchronous events - The addition of a new JSON Binding API, i.e. JSON-B 1.0 - A new cross-platform security context - Etc. Come to this session to understand what's coming.

Advanced search for your legacy application

SpeakerDavid Pilato

How do you mix SQL and NoSQL worlds without starting a messy revolution?

This live coding talk will show you how to add Elasticsearch to your legacy application without changing all your current development habits. Your application will have suddenly have advanced search features, all without the need to write complex SQL code!

David will start from a RestX, Hibernate and Postgresql/MySQL based application and will add a complete integration of Elasticsearch, all live from the stage during his presentation.

Java Annotations Are a Bad Idea

SpeakerYegor Bugayenko

Annotations were introduced in Java 5, and we all got excited. Such a great instrument to make code shorter! No more Hibernate/Spring XML configuration files! Just annotations, right there in the code where we need them. No more marker interfaces, just a runtime-retained reflection-discoverable annotation! I was excited too. Moreover, I've made a few open source libraries which use annotations heavily. Take jcabi-aspects, for example. However, I'm not excited any more. Moreover, I believe that annotations are a big mistake in Java design.

Java EE 8: What HTTP/2 and Servlet 4.0 mean to you

SpeakerAlex Theedom

The goal of HTTP/2 is to increase the perceived performance of the web browsing experience. This is achieved by multiplexing over TCP and Server Push among other techniques. What implications does this have for developers? How does Servlet 4.0 embrace HTTP/2? We will see, with code examples, what the future of developing with HTTP/2 might look like.

Program

Comming soon.

Clouds with trenches and sharp edges

SpeakerFilip Van Laenen

So you're going to run your project in a public cloud. That should be easy, because everything is taken care of, “as a Service”, right? Well, think again, because it turns out clouds have trenches too. And sharp, bleeding edges.

Sure enough, you don't have to set up any hardware. But you still have to set up virtual machines, nodes, containers, or whatever it is you'll be deploying your software to. This will have to be configured in a development environment. And a test environment. A staging environment. A production environment. And a couple of environments more, because it’s easy and cheap to create more environments, right? You better think that through from the start of your project.

Then there’s security. Not just the firewalls that have to be configured, but authentication and authorization. Your data isn’t just sitting around on a local server in an internal zone protected by your corporation’s firewall. It’s in the cloud! Uploading data to the development environment is suddenly the same thing as running a production system.

Performance becomes a new challenge in the cloud. You probably won’t be able to outscale Google, Microsoft or Amazon, but they can pretty easy outscale you with a large bill.

And finally, the joy of beta versions, or if you’re a privileged partner, alpha versions! Are you sure you want to touch them? Or can’t you afford to not touch them? You’ll be bleeding anyway.

Developing software in and for the cloud is a lot of fun, but don’t expect to always be on cloud nine!

Subcategories