Intro to Kotlin for Java Developers

This session introduces Kotlin to people familiar with Java, but not Kotlin. It covers just the basics, but with a focus on the language features of Kotlin which solve specific pain points which will be familiar to Java developers such as nullability, optional parameters, collection operations, and data classes.

Building a Great Developer Experience with Platform Engineering

If you want to onboard developers quickly, and retain them by providing a frustration-free environment, you need a great developer experience (DX). This goes beyond just providing CI/CD. It requires runtime libraries, build tooling, local environments, data collection, an internal developer portal (IDP), and migration automation. All of these work together to create a constant two-way stream of information between the platform engineers and their client development teams.

This talk does not dive deep into technical details, but is more of a conceptual overview of the various pieces of a platform DX solution. It does not propose a specific DX solution, but does suggest some tools that are useful to have in your toolbox. This talk is most relevant to developers in the platform engineering, developer experience, and developer productivity spaces, but developers of all stripes will be able to take away some ideas they can implement in their own teams.
I have not yet delivered this talk publicly.

Trimming the Fat with jlink

Learn how to use javafx with jlink and jpackage to distribute smaller and faster desktop applications that don't depend on an installed JDK.

Audience should have very basic familiarity of javafx and the JDK. Very little technical knowledge is needed though, as the session will use pre-built applications and just demo how jlink can decrease start up times, memory usage, and file size, which will be easily apparent.
This would be the first public presentation of this material, but I have presented it internally at my company. It is also based on an actual implementation at my company.

Why Does Agile Fail?

If you work in software development, you have likely heard of Agile or Scrum. You might have read an article about it, or heard someone talking about Agile at a conference, where you learned how great and empowering Agile is, and you come away sold. But when you go to work, either management has no interest in it, or they say they do it, but it just becomes "ceremonies" that only get in the way of doing your job. If you are wondering why Agile in the workplace never measures up to the promise offered by its proponents, you are not alone. Many people blame the failure of Agile on flawed implementations. But perhaps there is more wrong than just the way we implement it. To get at the root of this, we first need to understand why agile came about in the first place, which problems it attempts to solve, and which problems it doesn't.

Target audience is anyone who has worked in an "Agile" workplace.
This would be my first public delivery of this material, but it is based on an article I have written, which is based on my own experiences as well as research. I was also interviewed for and quoted in a Logic Magazine article on this subject.

Developing Gradle Plugins w/ Kotlin

An overview of how custom Gradle plugins can be used to improve developer experience by encapsulating common setups. We will see how using Gradle's new Kotlin DSL can be used to make this development much easier. We will also review some best practices and how to avoid common gotchas.

Audience should have some familiarity with using Gradle as a build tool, but experience with developing plugins is not needed.

This was presented at JConf 2022: https://www.youtube.com/watch?v=7kNLBmAMAno

Functional Kotlin

A brief introduction to functional programming constructs in the Kotlin language. The audience will walk away with an idea of how they can using functional programming ideas in their code today to make their code and their tests cleaner and easier to understand.

A brief introduction to functional programming constructs in the Kotlin language. We will explore some basic functional programming principles and look at Kotlin code samples which demonstrate these principles. We will learn about the Kotlin standard functions, and what they can be used for. We will also look at how to test functional Kotlin. The audience will walk away with an idea of how they can use functional programming ideas in their code today to make their code and their tests cleaner and easier to understand. This talk is designed for novices to functional programming, Kotlin, or both, although even seasoned veterans may discover a few tricks to hone their technique.

Slides: https://wakingrufus.github.io/functional-kotlin/
This was presented at Devnexus 2023

Static Web Development with Kotlin DSLs

In this session, we will look at how Kotlin's language features enable us to build DSLs to bring the benefits of dynamic web programming to static web development.
We will:
- review the benefits of static websites
- review the language features in kotlin used for building DSLs
- look at how the kotlinx HTML and CSS DSLs can be used
- learn how to build our own DSLs by live coding an extension to the HTML DSL

Target audience is intermediate level kotlin programmers wanting to learn more about Kotlin's DSL capability and get an introduction to the revival of the static web movement at the same time. I have presented this at Chicago Kotlin User Group.

An earlier version of this talk was recorded for a Chicago Kotlin User Group meetup:
https://www.youtube.com/watch?v=lIR5VVoCBbQ

Kotlin in 2019

A brief review of the new features and developments this year in Kotlin.

This will cover:
- Gradle Multiplatform projects
- Improvements for inline classes
- Operations for unsigned number arrays
- Experimental functions in the standard library
- Accessing the reified type using reflection on JVM
- Functions for bit manipulation
- Duration and Time Measurement API
- Null-check optimizations planned for Kotlin 1.4

Slides: https://wakingrufus.neocities.org/kotlin-2019/0.html

This was recorded at GOTO Nights Chicago + CKUG on Dec 10, 2019
https://youtu.be/nLKJJASfRh4

Kotlin in 2022

A brief review of the new features and developments this year in Kotlin.

This will cover:
- Prototype of context receivers
- Callable references to functional interface constructors
- underscore operator for type args.
- Implementation by delegation to an inlined value of an inline class
- Stable definitely non-nullable types
- Kotlin K2 Compiler
- A new approach to the incremental compilation in Gradle

This talk is best suited for people with moderate experience with the Kotlin language, regardless of platform (JVM BE, FE, Native, or Android).
https://www.youtube.com/live/PQ61TzbT88M?feature=share&t=2610