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).
Speaker: Filip 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!
Speaker: Maurice 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.
Speaker: Milen 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!
Speaker: Rudy 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...
Speaker: Antoine 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".
Speaker: Stéphane Nicoll
Spring Boot DevTools is not the only new feature that boosts your productivity. During this live coding session, we’ll work on 10 common app features and see how Boot is making your life easier.
We’ll cover the following:
- Development cycle with Devtools, the actuator and H2 Web console
- Manage custom error pages
- Managing application Cache
- Supporting OAuth2 in your app
- Using your custom AuthenticationPrincipal
- Using a persistent database in production
- Evolving your database schema with Flyway
- Custom Boot configuration (key hint, metadata)
- Gathering and exporting app Metrics
Speaker: Nicolas 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."
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".
Speaker: Asaf 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.
Speaker: Jesper Wermuth
This is a talk about how and why we codified and automated an entire infrastructure at Danske Spil, including server generation, networking, access, infrastructure building and deployment, code project building and deployment, generation of CI environment and much more. We even codified the workflows of the DevOps department, a very interesting part of the project that I look forward to share. The talk has a technical angle and there will be high level views and code examples and perhaps a demo if I feel lucky that day. Some of the technologies / things involved are: terraform, packer, vagrant, AWS, jenkins, gradle, VPNs, NATs, Virtual Private Clouds, IAM, Java, Artifactory, Docker, Swarm, Registry, … Hope to see you there 8)
Speaker: Jan 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.
Speaker: Ted Neward
Ever wanted to truly explore what it would be like to be a James Gosling, or a Bjarne Stroustrup, or Anders Hejlsberg? Want to see what it's really like, building a language from soup to nuts? This presentation will take you through that process exactly, from deciding whether your language will be compiled or interpreted, or static- or dynamically-typed, through defining a simple grammar, building the parser, constructing the AST, and generating code out the back end. We'll look at tools that can simplify this process, and discover that building a custom language for a particular task isn't quite as hard as it might seem at first. It's domain-specific languages, without the MDA.
Speaker: Alex 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.
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!
Speaker: Stéphane Nicoll
It's ideally suited for building microservices and distributed systems and makes streamlining devops practices simple.
Join Spring Boot committer Stéphane Nicoll for a look at what Spring Boot is, why it's turning heads, why you should consider it for your next application (REST, web, batch, big-data, integration, whatever!) and how to get started.
Speaker: Gunnar 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.
Speaker: Monica Beckwith
Monica Beckwith has worked with the Java Virtual Machine for more than a decade not just optimizing the JVM heuristics, but also improving the Just-in-time (JIT) code quality for various processor architectures as well as working with the garbage collectors and improving garbage collection for server systems.
During this talk, Monica will cover a how the performance trifecta drives innovations in the OpenJDK HotSpot Java Virtual Machine. Monica will talk about these optimizations based on the performance drivers. She will cover 3 of the garbage collectors - Parallel, CMS and G1 and a few JIT and Runtime optimizations.
Speaker: Maciek 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.
Speaker: Niall 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.
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.
Speaker: Heather 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.
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!
Speaker: David 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.
Speaker: Sanne 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.
Speaker: Yegor 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.
Speaker: David 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.
Speaker: Arun Gupta
Serverless applications, aka Function-as-a-Service or FaaS, relies upon services to manage server-side logic and state. These applications run in stateless compute containers that are event-triggered, ephemeral (may only last for one invocation), and fully managed by a 3rd party. These functions can be triggered by a REST API call, scheduled timer, or another function. Static website hosting on Amazon Web Services S3, API Gateway for RESTful APIs, AWS Lambda for functions and Couchbase for persistence provide an ideal combination for deploying, managing and scaling your microservice. This talk will provide a quick introduction to each part of the stack. Then it will explain how a Serverless Application Model can be used to deploy different components of microservice. A path from your favorite IDE to a fully deployed and functional microservice will be shown with live coding.
Speaker: Alex 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.