Jim McLaughlin

Transports & Logistics

functional programming Java Spring

Kansas City, Missouri, United States

Jim McLaughlin

Lead Technical Architect @ YRC Worldwide

Jim is the Lead Technical Architect at YRC Worldwide, HQ'd in Overland Park, KS. He started his professional software development career the Kansas City area in 1988 after graduating from Graceland University (IA) with a degree in Computer Science. Jim has worked with a wide range of technologies over the years including C++, JavaScript, Java, and C#/VB.net. His current interests include Java Spring, JavaScript, PowerShell, Python, Serverless Cloud Computing, and Functional Programming.

Current sessions

Functional Programming with Java's Stream API

This workshop expands on the basics of Java Lambdas and the Stream API. In this workshop, we will go beyond the introduction and basic mechanics of Lambdas and dive deeper into the variety of intermediate and terminal operations and how each of them have multiple overridden implementations within the API (and why).

During this workshop, we will build a functional Spring MVC Restful web service to demonstrate how to apply the different operations, such as:

* filter
* map
* flatMap
* reduce
* sorted
* forEach
* collect
* allMatch
* anyMatch
* count
* findAny
* findFirst
* distinct
* limit
* skip
* toArray

The review of these operations will focus on the following:

* the difference between intermediate operations and terminal operations
* which operations are short-circuiting operations
* why some operations are stateful
* what it means for some terminal operations to return an Optional

Asynchronous Java Without Tying Yourself in Threads

This session will explore the Java CompletableFuture class within the Java Concurrency API introduced in Java 8 and how the CompletableFuture class allows developers the freedom of creating asynchonous code without having to resort to a complicated and advanced approach of directly implementing threads.

Starting with a brief discussion of Java's Future and CompletionStage interfaces which are used by the CompletableFuture class, introduce the concept of asynchronous computation. This will also compare how Java now has a concrete implementation similar to other platform's implementations (Promises in JavaScript and Async/Await in C#, Python, and also in JS, etc...).

This session will assume some basic understanding of Lambdas, Functional Interfaces, and Functional Programming in Java, as the CompletableFuture API leverages these concepts.

We will also discuss some use cases for when to use the CompletableFuture class and show some basic live code examples.