JAX London 2017 Archive

Russ Miles – Better software development through stress

Production hates you. The machines, the networks, the very users you hope to provide a service hate you. This is reality, and it makes production a hostile battle ground. In this talk Russ Miles will talk about how to turn this pain to your advantages. Following on from his popular “Why don’t we learn?” talk it is now the time for the sequel. Through a sequence of case studies, personal stories and code examples Russ will talk about how sociotechnical systems like your development team improve through stress, turning this pain to their advantage through learning loops so that it is no longer about “how do we avoid the pain” but rather “how do I embrace and thrive on more”.

Khanderao Kand – Deep Learning Anomalies with TensorFlow and Apache Spark

TensorFlow and Apache Spark are important open source frameworks with rising adaptation for big data and machine learning. This presentation will cover deep learning in general and TensorFlow and Apache Spark in specific. Apache Spark is widely used for big data and machine learning, while TensorFlow augments it for deep learning.

Heinz Kabutz – Turbo Charge CPU Utilization in Fork/Join

Fork/Join is a framework for parallelizing calculations using recursive decomposition, also called divide and conquer. These algorithms occasionally end up duplicating work, especially at the beginning of the run. In this talk we will demonstrate this issue and offer a solution in the form of the ManagedBlocker. Combined with the Fork/Join, it can keep parallelism at the desired level. In this session, we will explain how you can can reduce wasted CPU cycles by implementing a reserved caching scheme. Before a task starts its calculation, it tries to reserve an entry in the shared map. If it is successful, it immediately begins. If not, it blocks until the other thread has finished its calculation. Unfortunately, this might result in a significant number of blocked threads, decreasing CPU utilization.

Helen Beal – DevOps Driven Development and Delivery

How do you drive development? Via test? Value? Behaviour? How do you drive operations? Are they Agile? And Lean? In this talk Helen will explore the characteristics of DevOps Driven Development and Delivery, the best practices for regulated organisations where security and auditability are key and what this means for the way we manage change, funding, safety, failure and experimentation.

Emily Jiang – Eclipse MicroProfile

While there are likely a dozen or more Java-based microservice / cloud native initiatives in the industry, Eclipse MicroProfile provides a platform for Java developers to collaborate and innovate on areas of common interest. This session will give a short overview of MicroProfile and how it plans to optimize microservices for Enterprise Java, followed by the demonstration of the MicroProfile config and Fault Tolerance specification being prototyped in MicroProfile. While MicroProfile’s first release is founded in Java EE (CDI + JSON-P + JAX-RS), it is not intended to remain a subset of Java EE 7 (or 8). The intent is to collaborate and innovate as a community in the context of a microservices architecture across the 8 (and growing) MicroProfile implementations today. The end goal of MicroProfile is to feed the Java Community Process (JCP) with JSR submissions backed by well-thought-out concepts and even implementations that developers and enterprises can rely on.

Daniel Bryant – Continuous Delivery with Containers

Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications. Topic covered include: the impact of containers on CD; adding metadata to container images; validating NFR changes imposed by executing Java applications within a container; and lessons learned the hard way in production. A supporting O’Reilly report, “Containerizing Continuous Delivery in Java”, will also be available. This contains instructions and code for how to create a Jenkins-based continuous delivery pipeline that takes a series of Java applications and containerizes them, ready for functional and nonfunctional testing, and ultimately, deployment.

Lorenzo Nicora – Scaling Event Sourcing for the IoT and Mobile

Event Sourcing is a popular persistence pattern that allows reconstructing different views of reality from its history. While the commonly accepted approach guarantees consistent events at write-time, it may fall short scaling to big-data magnitudes. This presentation gathers experience, errors and successes from real-world projects. Often, consistency enforced on write doesn’t scale when you have to cope with unreliable clients and transport, as with IoT and mobile, and keep latency low. You have already abandoned ACID transactions, but you have to push BASE (Basic Availability, Soft-state and Eventual consistency) one step further, making compromises between low-latency writes, read delays and read-model consistency. This presentation will cover authentic problems like building consistent read models from late or missing events, and lack of any global time reference until everyone will have an atomic clock in his pocket. It offers an alternative point of view on Event Sourcing described with whiteboard-like drawings and lessons from the trenches.

Graham Charters – Jump-start Your Microservices Development with Java EE

When asked what framework to use when creating Java microservices, people don’t necessarily suggest Java EE first, but many people are seeing the benefits Java EE brings to a microservices architecture. If you have existing Java EE applications or are simply curious about what makes Java EE a good fit in this space, this is the session for you. It covers everything from creating your application to a choice of IDEs for developing your app and deploying it to the cloud. It also demonstrates how to configure Docker to leverage the power of existing lightweight Java runtimes and make use of the OpenAPI spec in your application. Finally the presentation discusses the innovation being carried out by communities such as microprofile.io.

Sarah Saunders – The monster coming over the hill – enterprise coding is dead

Recently within Capgemini, we took part in an exercise to try and understand why the development community is so big on sharing knowledge, compared with other communities. The kudos you get from sharing code has a greater value to your career than the code itself. With sites like Stack Exchange, you can download every snippet of code you’ll ever need. Add this to the Open Source movement, and the growing number of products which generate code from diagrams and GUIs, and there’s a scary conclusion to be drawn: THE CODE WE WRITE HAS NO VALUE. So, what is it that IS of value in what we do? Through a study of “citizen integrator” projects that didn’t require any code to be written at all, I’ll try and distill the skills that underlie our job description as developers.

Ian Partridge – Server-side Swift for Java Developers

This session will give you an introduction to the Swift language, where and when you might use it, and see how it compares when building a real application server application in Swift and Java. The range of languages and frameworks that are available for building server applications has exploded over the last few years, with the most recent of these being the Swift programming language from Apple that was originally designed for iOS devices, which is now being labelled as the fastest growing language. Is Swift the future for server applications, meaning that you should stop developing Java server applications, or is it just a passing fad?

Peter Lawrey – Scaling Blockchain Systems

Blockchains open up a significant number of opportunities to decentralise services. Increasing demand has raised scalability issues. In this talk we will look at some of the problems scaling blockchain and proposed solutions to increase transaction rates.

Maurice Naftalin – Complicating Complexity: Algorithm Performance in the New Machine Age

It’s no simple matter to explain the performance of even a simple Java program, when instruction execution time is often overshadowed by other costs. Even when network and IO have been taken into account, two programs with similar computational complexity—their big-O characteristics—can differ in cache usage, with big resulting differences in performance. For the Java programmer, this means that big-O analysis no longer gives enough guidance in choosing a collection implementation for performance-critical code. In this talk we’ll explore optimization of the memory layout and performance of some simple programs via alternative collection implementations and frameworks, and the open-source ObjectLayout library.

Davide Fiorentino lo Regio – A Practical Guide to Docker and µService Deployments

It takes months to update everything in a software stack and you *never* know when or where something will break (but you *know* it will). Sounds familiar? In this session, we will go over what tools and technologies that I used in order to build a stable and reliable environment of Web and Standalone Applications. Here’s what I learned during that long journey, whether it’s how to talk with all the stakeholders involved or how to split a monolith from an architectural/deployment point of view. I’ll dive into dockerizing applications, managing images, system configurations, experimental features as well as running and scaling those containers. Along the way, I ran into many obstacles. Some people were unaware of existing and future issues, others had superficial or no knowledge at all of those “alien” tools. Other hurdles included vLANs issues, unconnected servers, and even people asking for docker images for everything. I’ll share my solutions to these issues and more, so that others don’t have to suffer like I did! Best for system administrators, developers and DevOps.

Sumanas Sarma and Rob Hinds – Agile Machine Learning