List of videos

Spring I/O 2017 - 18 -19 May, Barcelona For many companies, the data they collect and the dataset they build is their most valuable asset. As these datasets grow it becomes increasingly important that these organizations analyze and find meaning in their data, and typically they’ll reach for well-known tools like Hadoop. However, over the past few years a new generation of data analysis tools have become available... most notably Apache Spark. Spark is a cluster-computing framework that allows users to perform calculations against resilient in-memory datasets, distributed across multiple machines, using a functional programming interface. It has won world records for quickly processing large data sets and is currently one of the Apache Foundation’s most active projects. Spark supports a variety of technologies that can be used as its persistence mechanism; one of the most interesting is Apache Cassandra. Cassandra is a linearly scalable, fault tolerant, decentralized datastore that is useful if you need highly available and scalable storage. It is used heavily by some of the largest firms in tech, like Apple, Facebook, and Netflix. These two technologies are complicated, but integrate well and provide such a level of utility that whole companies have formed around these two technologies offering consultancy and development services. In this talk we’ll learn how Spark and Cassandra can be leveraged within your Spring Application, and how to get started with the Spring XD and Data integrations. We’ll talk about Spark and Cassandra from a high level and walk through code examples showing what it’s like to programmatically work with them. We’ll discuss some of the pitfalls you will run into when working with these technologies - like modeling your data appropriately to ensure even distribution in Cassandra and general packaging woes with Spark - and ways to avoid them. Finally, we’ll explore how we at ThirdChannel are using these technologies in the real world.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://www.slideshare.net/fbenz/introducing-spring-auto-rest-docs This talk introduces Spring Auto REST Docs, an extension to Spring REST Docs that helps you write less and get more. We have been using and evolving our Spring REST Docs extension for over 1.5 years and recently open sourced it: https://github.com/ScaCap/spring-auto-restdocs Spring Auto REST Docs uses tests, introspection and Javadoc to automatically document request and response parameters. We will look at how much work this saved and how it increased the quality of our documentation. Sprint Auto REST Docs proposes a tight coupling of code and documentation. This way we make it easy to add documentation in the first place, and to keep it up to date as your platform evolves. During the presentation, we give instructions on how to use the extension and discuss pros and cons of the proposed approach. We will present our own system as a real-life implementation and highlight the benefits of reusing tests, bean validation and Javadoc together with the freedom of AsciiDoc to generate documentation. For further reading: https://dzone.com/articles/introducing-spring-auto-rest-docs

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://speakerdeck.com/sdeleuze/functional-web-applications-with-spring-and-kotlin In this brand new talk, I will show how you can leverage Kotlin and Spring Framework 5 to build functional web applications efficiently. I will describe gradually how you can transform your Spring Boot 1.0 Java project into a Spring Boot 2.0 Kotlin project running on top of the new WebFlux functional web framework: - Step 1: Use Kotlin instead of Java 8 - Step 2: Upgrade to Spring Framework 5 and Spring Boot 2.0 - Step 3: Switch from Spring MVC to WebFlux and Reactive APIs - Step 4: Use WebFlux functional API This talk will detail the upcoming official Kotlin support introduced in Spring Framework 5 [1], and will also demonstrate a real Spring + Kotlin functional web application [2] that I built for the last 6 months for MiXiT conference. [1] https://spring.io/blog/2017/01/04/introducing-kotlin-support-in-spring-framework-5-0 [2] https://github.com/mixitconf/mixit

Spring I/O 2017 - 18 -19 May, Barcelona Links: https://github.com/rburgst/rancherci-presentation https://github.com/rburgst/rancherci-seedjob https://github.com/rburgst/rancherci-demoapp Rolling your own CI system is not easy. Choosing the right solutions is becoming more and more difficult with the advent of new solutions and technologies such as Gitlab CI, CodeShip, Drone.io, travis, ... However, when you have specific needs there are few solutions that can compare with the flexibility of jenkins. Setting up, configuring and managing a jenkins instance can be a laborious job, especially when you are supporting multiple teams which are using different development environments (Java, Node.js, go, ...). Oftentimes it takes days of hand tuning the system per project and keeping up with updates is a job of its own. In this session we will show how to set up a rancher cluster, run jenkins with jenkins swarm on a number of hosts, all build jobs are configured using code (jenkinsfile) so that every change is accounted for in the git history. Due to the use of dockerized build containers it becomes straightforward to support every possible build environment. As a demo we will use a spring based web application which will be built, tested, dockerized and deployed into a staging environment. Time permitting more in-depth topics such as LDAP authentication, SSH key exchange, automatic DNS updates will be addressed. To get the most out of this session a solid understanding of docker and docker-compose is recommended.

Spring I/O 2017 - 18 -19 May, Barcelona One of Spring Boot's most powerful features is its auto-configuration. This magic is key to the convention-over-configuration approach that has brought a huge boost in productivity to Java developers. But is it really magic? We don't think so. In this session we'll take a look under the covers of Spring Boot. You'll learn about auto-configuration and the conditional configuration model that powers it, helping you to be even more productive when writing Spring Boot applications.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: http://presos.dsyer.com/decks/road-to-serverless.html GitHub repo: https://github.com/dsyer/spring-cloud-function Spring Cloud Function provides a new programming model for Spring Boot applications, abstracting away all of the transport details and infrastructure, allowing the developer to keep all the familiar tools and processes, and focus firmly on business logic. Join this presentation to learn about the features of this new project, and why it is going to change the way that you build applications.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://docs.google.com/presentation/d/1CRjAKdQEvVNi9JzuudEKlnncJffKi5k8Lw0J335IYMk/edit?usp=sharing The bigger a monolithic application, the larger the dependency set. Adding or changing dependencies becomes a tricky task. Similarly, the complexity is in a number of beans and their dependencies in components container. In this talk, we’ll discuss a way to simplify things by splitting component containers into smaller ones. We’ll see how to split a monolithic ApplicationContext into a number of sub-contexts, how to isolate sub-context internal beans, clear their APIs and avoid non-trivial dependencies. Each sub-context can have its own classpath, which tackles the dependency hell problem. After being divided, a monolithic system becomes easier to split into a set of micro-services or processes. From the talk, attendees will learn several practical tips and tricks on how to split component containers into smaller ones

Spring I/O 2017 - 18 -19 May, Barcelona GitHub repo: https://github.com/neilstevenson/springIO2017 The bigger a monolithic application, the larger the dependency set. Adding or changing dependencies becomes a tricky task. Similarly, the complexity is in a number of beans and their dependencies in components container. In this talk, we’ll discuss a way to simplify things by splitting component containers into smaller ones. We’ll see how to split a monolithic ApplicationContext into a number of sub-contexts, how to isolate sub-context internal beans, clear their APIs and avoid non-trivial dependencies. Each sub-context can have its own classpath, which tackles the dependency hell problem. After being divided, a monolithic system becomes easier to split into a set of micro-services or processes. From the talk, attendees will learn several practical tips and tricks on how to split component containers into smaller ones

Spring I/O 2017 - 18 -19 May, Barcelona Ever wonder how to test a hard problem like caching or write an integration test without making an external API call? Or come across a situation where testing something was so hard that it never got tested? A lot of developers today find themselves in situations where they are unsure of how to write light-weight unit tests. In our presentation, we will talk about how to do Test-driven development for a Spring Boot application and how some of the latest Spring Boot annotations and utilities make that easy. We will deep dive into some tricky real world testing scenarios that have baffled us in the past such as: Database queries Caching Configuration files Form validations Message brokers