Home
Videos uploaded by user “Devoxx UK”
WildFly Swarm in 15 minutes by Antonio Goncalves
 
16:59
If you don't know WildFly Swarm, you should come. If you know WildFly but have never heard of WildFly Swarm, you should come. If you know Spring Boot, you should come. If you feel ashamed telling your friends that you do Java EE, you should come too. I will show you how to have executable Jars, use standard Java EE APIs and write Micro, Nano and even Pico services using WildFly Swarm.
Views: 5812 Devoxx UK
Kubernetes in production - blue-green deployment, auto scaling and deployment automation
 
53:10
by Paul Bakker Kubernetes is a great tool to run (Docker) containers in a clustered production environment. There are also a few things that Kubernetes doesn't solve though. When deploying often to a production environment we need fully automated blue-green deployments, which makes it possible to deploy without any downtime. We also need to handle external HTTP requests and SSL offloading. This requires integration with a load balancer like Ha-Proxy. Another concern is (semi) auto scaling of the Kubernetes cluster itself when running in a cloud environment. E.g. partially scale down the cluster at night. Although Kubernetes doesn't provide these things out of the box, it does provide an API that can be used to make all of this happen. Tools for automated blue-green deployments and scaling a Kubernetes cluster were developed as part of the Cloud RTI project which is developed in open source. In this technical deep dive you will learn how to setup Kubernetes together with other open source components to achieve a production ready environment that takes code from git commit to production without downtime.
Views: 62249 Devoxx UK
Building microservices with Vert.x by Bert Jan Schrijver
 
52:23
Vert.x is a toolkit for building reactive applications on the JVM. It was awarded for "Most Innovative Java Technology" at the JAX Innovation awards. Vert.x is event driven, non blocking and polyglot, which makes it an excellent platform for building microservices. In this talk, I'll share experiences and real-world use cases from a Dutch company that started building reactive web applications with Vert.x about 3 years ago. You'll learn the concepts behind Vert.x, why we chose Vert.x, how we're using it and the challenges we faced. Topics include the anatomy of our projects, (micro)services architecture, deployment model and DevOps, scalability, the upgrade from Vert.x 2 to Vert.x 3 and cooperation with the team behind Vert.x. At the end of this session, you'll know enough about Vert.x to get started yourself right away!
Views: 12922 Devoxx UK
Fun never stops. Introduction to Haskell Programming language by Paul Szulc
 
51:26
What is functional programming? No assignment statements, no variables, once given a value never change, no side-effects at all. “The functional programmer sounds rather like a mediæval monk, denying himself the pleasures of life in the hope that it will make him virtuous.”. But there must be something to it, as there are languages which allow only this kind of approach to software design. Can something useful can really be done in this paradigm? I will show you a language develop in the late 80s called Haskell. We will explore its syntax as well as philosophy behind its creation. Why would you want to learn Haskell? Some say it will make you a better developer, triggering ability to look at software problems with different approach. Is it true? You have to see it for yourself.
Views: 27342 Devoxx UK
Where’s my free lunch? by Hadi Hariri
 
20:46
Have you ever thought about how many amazing things we get in this day and age that are free? Think about it, whether it’s articles in daily newspapers, social media, your code repository, your continuous integration server as a service. And that’s not even mentioning all the amazing open source libraries, frameworks that’s all out there. It’s all free, and it’s awesomesauce! Reality though is someone is paying for all this. Sometimes it’s being paid in cash, other times in the form of data and many times in the form of liabilities, in which we’re also paying. But many of us choose to ignore this and glaze at the wonder of it all. One day however, we’ll wake up and ask, hey, where the hell did my free lunch go, and watch how a lot of things come crumbling down.
Views: 1499 Devoxx UK
Java 8 best practices by Stephen Colebourne
 
44:40
The Java 8 release takes Java to a whole new level. Learning the new features is just the first step. The real question is how to make best use of them. There won’t be too much time in this session to introduce the new features, so you’ll need to know what lambdas and method references are in advance. Instead, the focus will be on how coding in Java 8 differs to previous Java versions, and how to avoid going too far with the new goodies. Join me for an opinionated session of best practices.
Views: 28538 Devoxx UK
Just enough app server by Antonio Goncalves
 
51:29
Are Websphere or Weblogic appropriate for your project? Too big" ? Do Jetty or Tomcat actually meet your needs? Too "small"? Neither too big nor too small. What you need is "just enough app server" to support only the subset of APIs and services your application needs. In this session I will make an inventory of Java EE application servers (Weblogic, Websphere, JBoss, GlassFish), Profile Web (Tomee, Payara, Siwpass) and Servlets (Tomcat, Jetty, Undertow). If Microservices is want you want, I will introduce other modular solutions such as WildFly Swarm, KumuluzEE, Spring Boot or Dropwizard. I will talk about performance, war, executable jar, monitoring, management, optimization, use cases and some personal feedback... all this by showing code and executing several types of applications (from the simplest to more complex) in several kinds of containers ... and maybe even on a Raspberry Pi.
Views: 3306 Devoxx UK
Extreme Profiling: Digging Into Hotspots by Nitsan Wakart
 
52:22
Diving down the rabbit hole we will explore a host of advanced tools for analysing performance hotspots in Java code: The Code is a Lie: why the line of code indicator is broken JMH perfasm: looking at microbenchmarks under the microscope JITWatch: digging into compilation process and stages Solaris Studio: Not just for Solaris! performance counters and more!
Views: 2602 Devoxx UK
Adventures with concurrent programming in Java: A quest for predictable latency by Martin Thompson
 
51:35
Concurrent programming with locks is hard. Concurrent programming without using locks can be really hard. Concurrent programming with relaxed memory ordering and predictable latency semantics is said to be only for wizards. This talk focuses on a decade long quest to discover algorithms that provide very high throughput while keeping latency low and predictable. Additionally, they need to provide real-time telemetry on how a system is performing via non-blocking operations. We will cover some fundamental theory of concurrency and then compare various approaches to the same problem so that we can measure the impact on latency. We'll also show how some of these algorithm implementations get more interesting given the new features in Java 8. This talk is aimed at programmers interested in advanced concurrency who want to develop algorithms with predictable response times at all levels of throughput which push our modern CPUs to the limit.
Views: 5703 Devoxx UK
Managers are from Mars, Developers are from Venus by Ted Neward
 
56:38
You're a manager. You've been hired to run a small (or large) development team, and for the life of you, you can't understand these people. Every time you try to motivate them, they balk and resist. You try to hire them, you can't figure out what they want and they walk away. Then, without any sort of action on your part, suddenly they put in 16-hour days, and they pull off some amazing work, but when you try to ask them to do it again for a critical update, they get angry and quit. What the heck? Where did these bizarre alien creatures come from, and how in the world are you supposed to work with them? You're a developer. You work for what has to be the most clueless manager in history. For the life of you, you can't understand this guy. He keeps trying to "motivate" you when all you want is for him to get out of the way. He's ready to drop thousands (or millions) of dollars on a release party, but getting him to pony up some cash for a conference or training class is like wringing blood from a rock. What the heck? Where did this bizarre alien creatre come from, and how in the world are you supposed to work with him?
Views: 950 Devoxx UK
Building multiplayer game using Reactive Streams by Michał Płachta
 
45:25
This talk introduces streams and reactive streams. You will learn how stream-based programming can be used to implement web frontend and multiplayer backend of the classic game: Snake. Building dynamic applications using imperative approach tends to create lots of unmaintainable code. Stream-based programming tries to solve this problem by introducing fully declarative way of defining application logic. While using streams, you will focus on WHAT needs to be done, not HOW and WHEN. The talk is divided into 3 parts. In the first part you will learn how to create a frontend of the Snake web game using streams as building blocks. Then, we will move to the server side and use Scala and Akka Stream library to create backend service that will allow the game to be played by multiple players. In the third part, we will discuss reactive streams and how they make asynchronous communication safe.
Views: 1546 Devoxx UK
The JVM and Docker, a good idea? by Christopher Batey
 
51:05
Containers are the latest hype. It goes without saying that Docker for the development environment is a good thing but what about running our production Java applications inside a container? One of the well known benefits of containers is that they provide a self-contained way to package and ship applications. However, it is already common practice to build fat executable jars that require only a JRE so what advantages would containers actually offer a pure Java shop? At Sky our motivation is efficient utilisation of hardware. We used to run single purpose VMs, which makes sense for production but for our countless test environments it is prohibitively expensive. Even IaaS is still too slow to provision new environments and bootstrap new applications. This talk will be focusing on the downsides and lessons learned from running JVMs inside containers. We will cover the following topics: The benefits, downsides and complexities of running a Java application inside a container. Tuning memory limits taking into account Heap, Native memory, Metaspace, Stacks to avoid being OOM killed Tracking native memory with jcmd
Views: 3053 Devoxx UK
Refactoring to Java 8 by Trisha Gee
 
51:04
While we’re drawing ever closer to Java 9, and even hearing about features in Java 10, it’s also true that many of us are still working with an older version. Even if your project has technically adopted Java 8, and even if you’re using it when coding new features, it’s likely the majority of your code base is still not making the most of what’s available in Java 8 - features like Lambda Expressions, the Streams API, and new Date/Time. In this presentation, Trisha will: Highlight some of the benefits of using Java 8 - after all, you’ll probably have to persuade The Management that tampering with existing code is worthwhile Demonstrate how to identify areas of code that can be updated to use Java 8 features Show how to automatically refactor your code to make use of features like lambdas and streams. Cover some of the pros and cons of using the new features - including suggestions of when refactoring may NOT be the best idea.
Views: 2633 Devoxx UK
Java on Mobile is a thing... and it's really good! by Johan Vos
 
54:54
Today, the idea behind "Write Once, Run Anywhere" applies to Mobile. Developers can write Java applications, and deploy them to the AppStore and the PlayStore. This has been made possible because of * JavaFX, which provides the cross-platform toolkit for creating user interfaces. JavaFX is part of JDK 8 and is widely available * JVM implementations on mobile devices. In this session, we show how to use your favourite IDE to write a Java Client application, and how to use that same IDE to create native applications that can be uploaded to the different appstores. These native applications use exactly the same code as a Java desktop application. We talk about the status of JavaFX on Mobile, and about the options for running Java code on mobile devices (e.g. Dalvik/ART, RoboVM AOT, OpenJDK with the Mobile OpenJDK project).
Views: 3266 Devoxx UK
Docker and Kubernetes Recipes for Java Developers by Arun Gupta
 
02:43:08
Containers are enabling developers to package their applications in new ways that are portable and work consistently everywhere. Docker has become the de facto standard for those portable containers in the cloud. Kubernetes provides an open source orchestration of Docker containers. This tutorial will provide an introduction to Docker and Kubernetes. The talk will explain several recipes on how to create and publish Docker images that package Java EE applications. Design patterns and anti-patterns that show how to create cluster of such applications will be shown. Replicating your environments using Docker images will be shown. Attendees will learn how Kubernetes’s self-healing mechanism can be used to create cluster of these containers.
Views: 3459 Devoxx UK
Java 9 Modularity in Action by Sander Mak & Paul Bakker
 
50:50
With Java 9, modularity comes to your doorstep (whether you ordered it or not). This isn't your average language feature: making the most out of it may involve rewiring your brain. In this session we explore the benefits of a modular codebase using Java 9 modules. Because who doesn’t like more reliable and secure applications, meanwhile killing the dreaded classpath? After reviewing the basic concepts of modules, we'll explore modularity patterns that enhance your design and development skills. We all have existing software, so migration of codebases to a modular world is an important topic as well. Automatic modules, the 'unnamed' module and other new concepts are added to your toolbox to this end. Want examples? We've got plenty in this practical and code-driven talk. Even if you intend to use Java 9 without modules, this talk helps you prevent common issues. You'll be ready for Java 9 before you know it.
Views: 1950 Devoxx UK
Busy Java Developer's Guide to Hacking in Java by Ted Neward
 
51:34
Ever since its 1.1 release, the Java Virtual Machine steadily becomes a more and more "hackable" (configurable, pluggable, customizable, choose your own adjective here) platform for Java developers, yet few, if any, Java developers take advantage of it. Time to take the kid gloves off, crack open the platform, and see what's there. Time to play. In this presentation, we'll examine several of the "hackable" customization points inside the JVM: the boot classpath, allowing us to add or modify existing JDK classes without violating the license agreement; the JNI Invocation API, allowing us to create custom Java launchers to establish an environment for the JVM that corresponds to exactly the way we want it. Innocents beware--we're a long way from "Hello world"!
Views: 3556 Devoxx UK
Building Cognitive Applications with Watson by Jonathan Kaufman
 
50:24
The more we interact with “smart apps,” the more we hear the word “cognitive” being thrown around. But what actually does this imply? What is a cognitive application? Can I make my app smarter? Can I make my app cognitive? In this session we'll be covering what these buzzwords mean and how to enhance your application with Watson services. We'll build an application from scratch and we'll discuss how to integrate Watson into your existing application. We will start with a demo of https://github.com/IBM-Bluemix/election-insights which uses Alchemy for sentiment analysis and entity extraction along with visual recognition. That app is hosted here: http://electioninsights.mybluemix.net/#/. From there we will use Node-Red to quickly build an app that uses Watson Tone Analysis and translates tone into color.
Views: 1505 Devoxx UK
10 Building Blocks for Enterprise JavaScript Applications by Geertjan Wielenga
 
38:17
JavaScript in the enterprise? Does that even make sense? After years of developing Java applications in the enterprise, many developers have become curious about what JavaScript can do for them. But how can you translate concepts like 'modularity' and 'loose coupling' to JavaScript applications? Do JavaScript applications have these kinds of concepts? AngularJS is a popular solution in the JavaScript world, though there are many other solutions, too. In this session, you will be introduced to RequireJS, responsive JavaScript, mobile development with JavaScript, as well as JavaScript transpilers such as GWT, Vaadin, and DukeScript. By the end of this session, you will have a thorough understanding of whether JavaScript is a sensible solution for you in developing enterprise JavaScript applications, today.
Views: 819 Devoxx UK
From object oriented to functional domain modelling by Mario Fusco
 
56:27
The main consequence of the introduction of lambda expressions in Java 8 is the possibility of conveniently mixing the object oriented and the functional paradigms. Nevertheless the biggest part of Java developers is not used yet to employ functional idioms and then they are not ready to fully leverage the new functional capabilities of Java. In particular it is still uncommon to see functions used together with data in business domain model. The purpose of this talk is not doing a comparison between object oriented and functional programming, but showing how these two styles can be combined in order to take advantage of the good parts of both. For example it's usual to pass a list of data to a function that processes them, but there are cases when you may want to create a list of functions and pass a single data through all of them. Immutable objects leads to a inherently thread-safe domain model. Functions often compose better than objects. Side-effect free code allows better reusability. This talk will demonstrate the validity of these statements with practical examples till to distill the essence of functional programming: data and behaviors are two aspects of the same thing.
Views: 1572 Devoxx UK
Testing Apache Cassandra with Jepsen: How to Understand and Produce Safe Distributed Systems
 
47:25
by Joel Knighton In this talk, I'll offer a brief introduction to Kyle Kingsbury's Jepsen, a Clojure testing framework for distributed systems. After explaining the motivation for Jepsen and its strengths, I'll show how to develop and run Jepsen tests for Cassandra. The value of these tests will be demonstrated in the form of multiple real-world Cassandra issues discovered through Jepsen tests I wrote. I'll then explain how we run Jepsen tests in CI at DataStax and offer a glimpse at some Jepsen-inspired testing tools we're developing.
Views: 1242 Devoxx UK
Reactor 2.5, a JVM foundation for Java 8 and Reactive Streams by Stephane Maldini
 
50:49
The apparent simplicity of the publisher/subscriber model as exposed in Reactive-Streams can be deceiving. The relatively fast release cycle for libraries in that space is not a myth, concurrency is hard. To keep out undesired side-effect, most Reactive projects have adopted a vertical approach potentially excluding developers from decision-making around execution model or sometimes language. What if we were able to leave the developer in control, positioning as a robust foundation and making the most of the now industrial standard Java 8 ? What if we hardened this foundation through open-source and research collaboration, with a direct feedback loop from Pivotal engineering ? In essence, that's what we aim to achieve with Reactor 2.5. This session is an invitation to explore how the new Reactor design, structure and features can progressively help you going Reactive and how does it play out in your today and tomorrow applications.
Views: 1156 Devoxx UK
Maven - Taming the Beast by Roberto Cortez
 
15:37
Love it or hate it (and a lot of people seem to hate it), Maven is a widely used tool. We can consider that Maven has been the de-facto standard build tool for Java over the last 10 years. Most experienced developers already got their share of Maven headaches. Unfortunately, new developers are going through the same hard learning process, because they don't know how to deal with Maven particularities. "Why is this jar in my build?", "I can’t see my changes!", "The jar is not included in the distribution!", "The artifact was not found!" are common problems. Learn to tame the Maven Beast and be in complete control of your build to save you countless hours of pain and frustration.
Views: 601 Devoxx UK
Double Trouble : Interview with a pair of Pepper Robots at Devoxx UK
 
07:13
We met with Pepper & Pepper during day 1 of Devoxx UK 2016 and caught up on developments at SoftBank Robotics, talked about (not yet) meeting the Queen and whether there's a need for contingency plans if robots replace a vast swathe of the human workforce. Oh, and there's dancing too.
Views: 3976 Devoxx UK
Building a unikernel Java Application by Ray Tsang
 
16:32
I thought it's all about containers now - what are unikernels? Join this session to learn a bit about unikernels, what it's good at, and how to run a Java application with it! With unikernel, you no longer need to wait for that long OS boot and initialization time, and get better-than-container level of security isolation, and resource isolation. In this session, you'll learn about the different types of unikernels. We'll pick one, OSv unikernel, and: - Use its tool to build a Tomcat unikernel image - Use its tool to build a Spring Boot unikernel image - Running the unikernel application inside of KVM - Deploying the unikernel application to the cloud - Deploying and managing a cluster of them.
Views: 945 Devoxx UK
Faster Java By Adding Structs (Sort Of) by Simon Ritter
 
52:12
The ObjectLayout package provides a set of data structure classes designed with optimised memory layout in mind. In languages like C and C++, the use of structs and explicit pointers can deliver high performance for data access through hardware optimisations for caching and pre-fetching. Java's use of implicit pointers, mutable arrays and general inheritance forces the use of reference lookups whenever an object needs to be accessed. This session will look at the ObjectLayout package (www.objectlayout.org), which provides a new set of APIs that are aimed at matching the natural speed benefits similar data structure constructs enable in most C-style languages while maintaining an idiomatic Java feel and a natural fit with existing code and libraries. The session will talk through the need for these APIs then describe how they work in practice. We'll also look at how the JVM can further optimise the implementation of the API by making this intrinsic.
Views: 656 Devoxx UK
Get Hip with JHipster: Spring Boot + AngularJS + Bootstrap by Matt Raible
 
48:09
Building a modern web (or mobile) application requires a lot of tools, frameworks and techniques. This session shows how JHipster unites popular frameworks like AngularJS, Spring Boot and Bootstrap. Using Yeoman, a scaffolding tool for modern webapps, JHipster will generate a project for you and allow you to use Java 7 or 8, SQL or NoSQL databases, Spring profiles, Maven or Gradle, Grunt or Gulp.js, WebSockets and Browsersync. It also supports a number of different authentication mechanisms: classic session-based auth, OAuth 2.0, or token-based authentication. For cloud deployments, JHipster includes out-of-the-box support for Cloud Foundry, Heroku and Openshift.
Views: 878 Devoxx UK
A Hackers Guide to Disco Calculating by Samantha Headleand
 
14:45
As a data analyst and mathematics nerd, Sam deals with numbers all day long. Beyond monotony of your average calculator, Sam happened across the Disco calculator. With some assistance from a developer, Sam set about constructing her own out of a Raspberry Pi, some LEDs, buttons and a bunch of cabling, and much hilarity then ensued. It’s not quite Numberwang, but it’ll be close!
Views: 103 Devoxx UK
The Silver Bullet Syndrome by Hadi Hariri
 
46:48
We love our silver bullets don’t we? Constantly chasing the dream that the next big thing will solve all our past problems. It doesn’t matter if it’s a language, framework, platform or library, we’re out there chasing it. Why? Well because it’s going to solve our needs, it’s going to solve the business needs. Well supposedly it will. And how much is it going to cost? Not that much, especially if we’re not the ones paying the bills. It’s about time we look at the hard facts and ask those difficult questions. Are we really looking for a silver bullet? Why are we constantly riding the technology bandwagon? Where is the churn going to take us? And at what cost?
Views: 555 Devoxx UK
The Myth of the Magical Messaging Fabric by Jakub Korab
 
50:52
Messaging systems underpin architectures ranging from stream processing, through to event sourcing and communication between loosely-coupled microservices. To most developers the technology is tangential to the business they work in, and is often disregarded with much hand waving as “just a pipe” for message distribution. Without a clear understanding of their capabilities and underlying design decisions, we imagine myths about how these systems “should” work and are frustrated in production by behaviours emerging from their design trade-offs. In this session you will learn how to think about messaging as we compare and contrast the approaches taken by two similar but fundamentally different messaging platforms – Apache ActiveMQ and Apache Kafka. We will discuss how their underlying philosophies impact message distribution, reliability, scalability, and performance. Along the way we will dip into how IOPS, latency and bandwidth affect throughput, why messaging systems do not play nicely with containers, and the unicorn of once-and-only-once delivery in distributed systems.
Views: 747 Devoxx UK
Modular monoliths by Simon Brown
 
45:46
If you want evidence that the software development industry is susceptible to fashion, just go and take a look at all of the hype around microservices. It's everywhere! For some people microservices is "the next big thing", whereas for others it's simply a lightweight evolution of the big service-oriented architectures that we saw 10 years ago "done right". Microservices is by no means a silver bullet though, and the design thinking required to create a good microservices architecture is the same as that needed to create a well structured monolith. And this begs the question that if you can’t build a well-structured monolith, what makes you think microservices is the answer?
Views: 1150 Devoxx UK
Knowledge is Power: Getting out of trouble by understanding Git by Steve Smith
 
51:11
Git is rapidly taking over the development workplace, and nowadays it is integrated with many development, testing and deployment platforms. But one of the downsides of high-level tools is that they can hide the details of what is happening under the hood. So when things go wrong or just get complicated it can be hard to understand why git behaves the way it does. But at its core Git consists of a few simple concepts that, when understood, make it a much more intuitive tool and enables powerful workflows. This talk introduces these core Git concepts and uses them to clarify some examples of seemingly counterintuitive behaviour. It also introduces some of Git's less-known features and tricks that are useful to have in your arsenal. This is an intermediate-to-advanced talk for developers who are already using or investigating Git and want to gain a greater understanding of how it works.
Views: 1024 Devoxx UK
Taking the friction out of microservice frameworks with Lagom by Markus Eisele
 
44:34
Lagom is a new framework for Java designed with microservices in mind. It aims to simplify the process of building microservice-based systems that communicate asynchronously, self-heal, scale elastically and remain responsive under load and under failure. Many of the challenges of microservices are caused by the fact we use tools designed without them in mind. So, how can a framework made to build systems composed of microservices from the start offer us a better solution? Because Lagom is a tool that is highly opinionated and explicitly designed to make development and production with microservices easy, it brings back all the fun and productivity into programming while still enabling you to build a reactive, distributed, highly scalable and rock solid application. By the end of this presentation, you'll have experienced first hand how creating systems of microservices on the JVM using Lagom is dead-simple, intuitive, frictionless and a lot of fun! And we’ll ask whether reactive microservices are potentially so much better than, for example, Java EE?
Views: 1529 Devoxx UK
Caching 101: Caching on the JVM (and beyond) by Louis Jacomet & Aurelien Broszniowski
 
02:45:40
After numerous presentations on the JSR107, this in-depth 3-hour university session will twist the problem upside down. Instead of leading you through every aspect of the new Caching API for Java, we'll start from a real Java application, looking at its architecture, measure contention points and slowly start adding different caching patterns to it. We'll look beyond the specification as well, not in terms of proprietary APIs, but in terms of different cache topologies (onheap, off-heap, distributed, ...) and what to consider when introducing caching to both an existing application or architecting a new one. Finally, we shall look at how different application containers and frameworks may affect decisions we've made during the session.
Views: 841 Devoxx UK
Migrating 25K lines of Ant scripting to Gradle by Hanno Embregts
 
16:24
Most developers prefer to spend their time writing code instead of performing build script maintenance. Build scripting may be an essential part of the software development process, but it often lacks maintainability which makes applying and deploying changes a tedious job. So it’s important to make sure your build system encourages simplicity and that changes can be made in a fast and straightforward way. Industry standards Ant and Maven are not quite up to the task; Gradle is a better alternative. This presentation introduces Gradle – a modern build system that supports all JVM Languages – and shares the result of the Ant-to-Gradle migration that was performed at NS (Dutch Railways). The session will focus on the challenges we faced while trying to replace Ant scripting with the Gradle equivalent and how we handled them. After attending this session, you will have a good understanding of Gradle and its pros and cons compared to Ant and Maven. On top of that, you will be able to migrate your own project to Gradle, even if your project has a huge code base or relies on ancient technologies. The lessons we learnt at NS could be very helpful to your own situation.
Views: 295 Devoxx UK
Cognitive Cynefin: How Language and Bias keep us Complicated by Liz Keogh
 
49:49
For millenia, human beings have survived by learning, then applying our learning to different contexts. We’re so good at it that we’re driven to find those patterns, even when they don’t exist. Our desire for the predictable suffuses everything we do; our beliefs, our behaviour and even our identity. From cognitive bias to the metaphors that underlie our language, we create constructs of words and imagination that keep us from innovating… and yet, they’re the same constructs that help us move forward in uncertainty. Without them, we’d be unable to make decisions at all. In this talk we look at how our language and perceptions hold us back, and how changing the things we say and the way we look at the world might help us become more resilient, happy and innovative.
Views: 268 Devoxx UK
DevOps - Microservices, containers, platforms, tooling... Oh yeah, and people
 
47:02
by Daniel Bryant & Steve Poole Two years ago at Devoxx UK we talked about DevOps, what it was, why it was important and how to get started. Boy, was it scary. Now we’re wiser. More battle-scarred. The large scale of the challenge for application writers exploiting cloud and DevOps is clearer, but so is the path forward. Understanding the DevOps approach is important, but equally you must understand specific deployment technologies, security issues, operational reliability, and how to drive organisational transformation. Whether creating simple applications or sophisticated microservice architectures many of the challenges are the same. Join us to learn how you can apply this within your team and company.
Views: 272 Devoxx UK
SQL for JSON: Querying with Performance for NoSQL Databases & Applications by Arun Gupta
 
47:26
In today’s world of agile business, developers and organizations benefit when JSON-based NoSQL databases and SQL-based querying come together. NoSQL provides schema flexibility, high performance, and elastic scaling. SQL provides expressive, independent data access. Developers need to deliver apps that readily evolve, perform, and scale, all to match changing business needs. Organizations need rapid access to their operational data, using standard analytical tools, for insight into their business. In this session, you will learn to build apps that combine NoSQL and SQL for agility, performance, and scalability. This includes: SQL for JSON JSON data modeling Indexing Tool integration You will understand how to effectively use NoSQL, using open-source technologies.
Views: 1279 Devoxx UK
NFR Testing and Tuning - A Scientific Approach by Andrew Harmel-Law & Kevin Rudland
 
52:10
We've spent a large part of our career building large-scale and mission critical systems, and then verifying they meet their non-functional requirements. With the resurgence of distributed computing this is both harder, and more importantly than ever. What is more, we don't think the old way of doing things works any more - and so we'd like to propose something a little different. In this session we'll describe the approach we use, illustrated with some meaty war stories: theories and hypotheses - accept youre not in control, then drive all your tests from your requirements, and your greatest fears methods - the importance of being as prod-like as possible, especially when you're not Netflix. Oh, and some chat about repeatability execution - where request mix, load profile, duration, network flakiness and failure in its myriad forms are key results - measurement, percentiles, and analysis investigation - when things went a bit weird and you have no idea why improvements - how to stay focussed As an added bonus we've done all this with free tools so you'll be able to go away and try all this out for yourselves.
Views: 229 Devoxx UK
Scaling Engineering by Hacking Conway's Law by Aviran Mordo
 
50:59
Working in a fast-growing company that doubles in size every year, maintaining the quality of products and engineers is a very challenging task. In this talk I will describe how Wix corporate structure evolved from functional teams to gangs, cross-functional teams responsible for end-to-end delivery; guilds, professional groups responsible for methodology, best practices, and training; and mini-companies that serve as internal startups to support rapid growth while maintaining velocity. I will also discuss how we poured our culture into a game-like “guild day”, that helps us maintain alignment, keep the high quality of our work and people, share knowledge, recruit and preserve the best developers, and support a quality-based culture of innovation.
Views: 848 Devoxx UK
Arduino And Java With The Intel Galileo by Simon Ritter
 
01:00:00
The Intel Galileo is a single board computer designed for makers and experimenters. Unlike the famous Raspberry Pi, the Galileo uses an Intel Quark processor and provides compatibility with the Arduino R3 from both a software and hardware (with pin compatibility for Arduino shields) perspective. This presentation will look at some of the things that are possible with the Galileo using Java and Arduino hardware. We’ll use the Zulu binary distribution of the OpenJDK project from Azul and explore ways to communicate with the IO capabilities of the board. There will be plenty of fun demos to show the power of combining the Galileo with Java.
Views: 289 Devoxx UK
My Slow Internet vs. Docker by Ray Tsang
 
16:33
Ray lived in a 180-sqft (~18m2) micro-studio near New York. It had no kitchen but it does come with free, but slow Wi-Fi. Ray's a Developer Advocate at Google and he travels a lot, often needs to build Docker images on the airplane, in coffee shops, or in hotels with unpredictable Wi-Fi. Learn how Ray adapted to working with large Docker images over slow Wi-Fi by utilizing Docker Machine, Google Cloud Platform, and a bunch of tips and tricks! This strategy also saved Ray from numerous demos - he once demoed Docker containers and Kubernetes by tethering to his colleagues' phone connection.
Views: 100 Devoxx UK
REST no more, use an actor (and Lego and Raspberry Pi’s…) by Johan Janssen
 
39:53
Last year we started a new Internet of Things project: The Internet of (Lego) Trains. In our normal jobs we use languages like Java and Scala to build applications for large organizations running on big servers. We wanted to find out if we could use the same languages and tools on IoT hardware. We also wanted to investigate whether or not (remote) actors could replace REST endpoints in our applications. We used Lego trains and Raspberry Pi’s as a sample project. The Lego trains are equipped with a Raspberry Pi, camera, wireless dongle, infrared transmitter, speaker, RFID reader and battery pack. Next to that we have automated switch tracks and camera's again with the help of Raspberry Pi's. We also build some lightning effects with LEDs controlled by Particle Photon’s. On top of that we also automated a Lego ferris wheel. To control the trains and other parts we built an remote actor based application with Scala, Akka, Akka HTTP and AngularJS.
Views: 413 Devoxx UK
The rise and rise of dataflow in the Javaverse by Russel Winder
 
51:23
With Java 8, method references, lambda expressions, and Streams, much of the talk (and buzz) is about "functional approaches in Java", and the application of functional programming as Scala, Clojure, and (particularly) Frege had introduced onto the JVM. This however is only part of the story. The other part of it is about a shift from data location orientation, to dataflow orientation. This is not a new message, it is in fact quite an old one. However it is a newly relevant, resurgent, and immensely constructive rethink about software architecture. In this session, we will quickly review the old story, investigate the current situation and the variants, and speculate about how this might pan out in the future.
Views: 441 Devoxx UK
Creating a safe dev environment on a public Cloud with Docker, Jenkins, Rancher and OpenVPN
 
16:35
by Marc-Aurèle Brothier During this presentation we will show how to set up on a public cloud a dev and CI environment with Docker, Jenkins, Rancher & OpenVPN. This allows you to access your enviroment securely from anywhere, (office, home, on the go) and also give access to other people or connect it to your company internal network. We will demonstrate it by deploying an application from github on Tomcat through a Jenkins build.
Views: 910 Devoxx UK
Build a recommender system using Apache Spark and Akka by Willem Meints
 
46:05
Machine Learning to some is still very magical. The truth however is that this magic is actually much easier to use than you'd expect. Come and learn how you can use Apache Spark and Akka together to build a service that recommends items to users. In this session I'm going to show you some of the bits that go into building a recommender system, how to actually implement one in Spark and finally how to integrate the recommender system into your application using Akka HTTP.
Views: 750 Devoxx UK
Arquillian Cube: Production Near Unit Tests Against Docker Images by Andy Gumbrecht
 
47:45
Arquillian driven testing, and the advantages it brings in regards to ensuring application stability, is becoming more widely known. If you are not already using Arquillian then you are likely to be testing yourself rather than your application. Even if you are, then you might be interested in something new - Arquillian meets Docker!
Views: 278 Devoxx UK
Everything you always wanted to know about highly available distributed databases by Javier Ramirez
 
49:51
Can you imagine a database that stands as much traffic as you want, adding and removing nodes automatically, working interruption-free even if a volcano starts spitting lava over your data centres? That's the promise of distributed systems like Cassandra, Voldemort or Riak. But, how do they do it? In this talk I will tell you the basics of distributed databases. Come to my talk if you want to learn about CAP, BASE, incremental scalability, replication or consensus. I will also explain geeky things like gossip, vector clocks, hinted handoff, or entropy. By the end of the session you should understand which is the architecture that allows Amazon to have their shopping cart available 24 hours a day, 365.25 days a year, or Linkedin to be able to spam you non-stop. When was the last time you saw Amazon or Linkedin websites down?
Views: 161 Devoxx UK
Top 10 Ways to be an Ally for Women in Tech by Heather VanCura
 
20:02
In this session we will discuss 10 ways to be an ally for woman in technology. Learn simple ways to support women in the workplace and the Java community - in the office, at conferences, and online. Become more confident in speaking up to support women and be more aware of the challenges facing women after investing 15 minutes in this quickie session.
Views: 146 Devoxx UK
Dials to 11 - Modern Extreme Programming by Benji Weber
 
50:02
Many concepts from Extreme Programming are now widely accepted. It’s no longer unusual to find development teams practising Test Driven Development, Continuous Integration, Collective Ownership, and working in mall iterations. Meanwhile, the Extreme Programming community has moved on. Extreme Programming was described by Kent Beck as “take everything I know to be valuable about software engineering and turn the dials to 10” We’ll look at how some of the practices have evolved as teams turn the dials still further. I’ll give you a flavour of several practices of a modern extreme programming team including Mob Programming, Continuous Deployment, Monitoring-Driven-Development, and Products over Projects. You will see how they have have made us more effective, and also what some of the pitfalls have been.
Views: 209 Devoxx UK