Kotlin - the new and noteworthy

Kotlin 2.0, released almost a year ago, marked a significant milestone in the language's evolution. At the heart of this major version lies the new compiler front-end, codenamed K2. The release delivered better performance and stabilization of the language features across multiple compilation targets. Despite being a major release, Kotlin 2.0 prioritized a smooth migration path, focusing on refinement rather than introducing drastic changes.

We will first take a look at the key features of the 2.0 release, highlighting the introduction of frontend intermediate representation (FIR) and the new control flow engine.

Then, we'll shift our focus to the horizon, and discuss the new features on Kotlin's roadmap:

* Guard conditions - enhancing control flow and null safety
* Context parameters - improving code organization
* Union types for errors - bringing more expressiveness to type systems
* Named-based destructuring - for better readability and reducing errors
* Contracts - enabling more precise static analysis

Whether you're a seasoned Kotlin developer or just starting out, this talk promises to expand your understanding of the language.

Debugging with IntelliJ IDEA

Historically, debuggers are used to help locate and fix bugs. Nowadays, the debugger in IntelliJ IDEA can help you do much more than that. Let's see how the debugger helps make the development process more productive. I demo various features for debugging Java applications, including not-so-standard ones, like:

* Lambda breakpoints
* Stream chain tracing
* Dropping the frame
* Emulated method breakpoint
* Evaluate and log
* Non-suspending breakpoints
* Custom data renderers and more

100% live coding session

Debug Faster, Code Better: 90 Minutes of IntelliJ IDEA in Action

Having used IntelliJ IDEA since 2004, I’ve discovered countless productivity features that can transform how we work. In this session, I’ll share tips and tricks to help you streamline workflows and get the most out of this powerful IDE. The workshop is tailored for Java developers and is divided into two focused segments:

Part 1: Development Efficiency

We’ll dive into techniques to make everyday tasks faster and more efficient, including:
* Advanced refactoring tools to improve code quality
* Fast navigation and smarter code completion options
* Using live templates for repetitive tasks
* Customizing the IDE for your workflow
* Integrations with tools like Spring, JPA, Git, and more

Part 2: Advanced Debugging

The debugging capabilities in IntelliJ IDEA are very powerful. We will take a closer look at what you can do with breakpoints:
* Lambda breakpoints
* Stream chain tracing
* Emulated method breakpoints
* Filters and conditions
* Non-suspending and dependent breakpoints

I will also demonstrate how these features can help in different debugging scenarios. Additionally, we will explore remote debugging and other tools that make debugging more productive.

This session will show many practical tips to help you work smarter, debug faster, and use IntelliJ IDEA more effectively. Whether you are just starting with the IDE or already have experience, you will find useful ideas that can improve your daily work.

IntelliJ IDEA Tips & Tricks

IntelliJ IDEA is packed with useful features that enhance developer productivity and simplify working with code. This session will take you through the cool features of IntelliJ IDEA: refactorings, shortcuts, fast navigation, a variety of code completion options, live templates, configuration options, language injection, the debugger (which is a gem on its own), and other productivity features that the IDE provides.

We will also look at the latest additions to IntelliJ IDEA, such as improvements for Spring and JPA support and, of course, the AI assistant, which brings advancements in Machine Learning closer to developer tooling.

The talk includes the new features coming from the IntelliJ IDEA engineering team

Kotlin Standard Library Gems

Kotlin's standard library has a lot of useful functionality to offer. In this presentation, we will unearth some hidden gems that will come in handy the next time you write Kotlin code. Because if you know how to wield it, the Kotlin standard library is a powerful tool that can help you be more productive in solving your problems and be more expressive in your code.

The key takeaways:

1. Working with collections: use functions like 'chunked', 'windowed', 'zip', and 'zipWithNext' for concise data processing. Apply fold and reduce operations for advanced aggregations.

2. Scope functions: understand the purpose of 'let', 'apply', and 'also', and how to use them effectively while avoiding common mistakes.

3. Type-safe builders, a.k.a DSL. Learn how to construct collections and objects efficiently, manage scoped mutability, and utilize type inference.

4. Other hidden features: simplify tasks with functions like 'filterIsInstance' for type filtering, 'compareBy' for multi-property sorting, 'groupBy' for data organization, 'coerceIn' for value clamping, and more!

Kotlin DSL in under an hour

Learn how to create type-safe and statically typed DSLs in Kotlin. In this session, you will learn about the language features that make DSL creation possible:
- Top-level extension functions and properties
- Trailing lambda expressions as function parameters
- SAM type conversion
- Functional literals with receiver
- Infix functions
- Standard library scope functions
- Context parameters
Step by step, using the features above, I will convert Java code based on the builder pattern into an internal Kotlin DSL. The talk highlights the specific cases for using the DSL approach in Kotlin and the tradeoffs for introducing this programming technique into the projects.

Idiomatic Kotlin

It's easy to start using Kotlin — like Java, so your experience will easily allow you to begin programming in Java style. However, learning Kotlin's best practices is a must to take full advantage of the language.

Kotlin programming language provides many features for writing concise code. On the flip side, overusing those features will result in clever code that is harder to maintain. Let’s analyze how these features could be applied in different scenarios.

This session will examine the features that make programs look beautiful and readable:

* Functions and expressions
* Extensions and standard library goodies
* Null-safety quirks & bolts
* Type-safe builders, a.k.a DSLs

Creative Live Coding with OpenRNDR

Programming doesn’t always have to be about mobile, web applications, and databases. Instead, let’s have some fun and use Kotlin to create something expressive, beautiful, and eye-catching.

In this session, Anton will explore the OpenRNDR framework for creative coding with Kotlin. We’ll start from the basics by drawing some geometric shapes on the canvas. Then, by applying some basic math, we’ll see how to transform the visuals into tangible artwork you might want to put on your living room wall!

You will learn about generative art techniques, algorithms, interfacing with MIDI devices, and visualization for creative live performances and installations.

Data Analysis with Kotlin Notebook

Notebooks are an environment where you can write and execute code fragments and create beautiful interactive tables displaying hierarchical data, which makes it a good place for prototyping and trying out ideas.

This talk offers a glimpse into the practical applications of Kotlin Notebook for data analytics and is suitable for developers of all levels.

I will show you how to use Kotlin Notebook for data analysis, demonstrating how it parses and visualizes complex data, briefly touching on the Dataframe and Kandy libraries, and showcasing how you can improve different aspects of software development.

Things you will learn in this presentation:
* How to configure and use Kotlin Notebook plugin in IntelliJ IDEA
* How to use the Kotlin Dataframe library for transforming the data
* How to create nice-looking graphs in notebooks with Kandy

Harnessing the Power of AI in IntelliJ IDEA

AI-powered tools are transforming software development, but how much control do they give developers over their workflow?

In this session, we’ll explore how AI assistance in IntelliJ IDEA—through both JetBrains AI Assistant and the new Junie coding agent—supports developers in writing, understanding, and improving code.

I will demonstrate the capabilities of the AI-assisted coding in IntelliJ IDEA by exercising the prompts for various development workflows: explore legacy code, improve existing code via refactoring and tests, learn new technology, or implement new functionality in your application.

Is it a productivity booster or a placebo? I will do my best to explain in this session.

Creative Coding with Kotlin and Compose

Programming doesn’t always have to be about mobile, web applications, and databases. Instead, let’s have some fun and use Kotlin to create something expressive, beautiful, and eye-catching.

In this session, Anton will explore Compose Multiplatform for creative coding with Kotlin. We’ll start from the basics by drawing some geometric shapes on the canvas. Then, by applying some basic math, we’ll see how geometric shapes can transform into tangible, visual artwork that you might want to put on your living room wall!

Then, we'll add some application controls using a MIDI keyboard and discover the possibilities for interacting with the device to control the program.

#generativeart #fun #mindthegeek

Spring extensions for Kotlin

Spring Framework provides first-class support for Kotlin thanks to the features provided by the programming language. The Spring Framework uses Kotlin extension functions to add new specific conveniences to existing APIs. In this session, you will learn about the extensions and DSLs provided in Spring for Kotlin developers. Also, you will learn about Kotlin's language features that make extending the existing Java APIs possible.

Kreatures Hiding in the Shadows: The Lesser-Known Kotlin Features

Kotlin is a modern programming language initially created as a "better Java." However, Kotlin provides not just a better syntax but also a ton of new interesting features. In this session, you will learn about the subset of the lesser-known features that might not be immediately useful and look obscure at first sight. How does the reified keyword in Kotlin work? What is the difference between inline and crossinline, and why is noinline required? What's the deal with context parameters, and what's the lambda with the receiver? After this session, you will have an idea about the hidden Kotlin features and when to apply these features.

Ktor from the Ground Up

Ktor is a Kotlin-first, asynchronous web framework that fully embraces Kotlin’s capabilities to make web development straightforward and enjoyable. With coroutines at its core, Ktor provides a natural way to handle concurrency, while its expressive DSLs simplify tasks like configuration and routing. In this session, we’ll dive into Ktor’s features for backend development, focusing on how its modular design allows for easy customization and extension. We’ll walk through building a sample application with WebSockets and a database, showing how Ktor’s Kotlin-native approach and flexible architecture make it an excellent choice for creating modern web applications.

"Sudo, Make Me a Sandwich!" - Live coding with AI tools

AI-assisted coding promises to boost developer productivity, but how much can we actually rely on these tools? In this live coding session, we’ll put AI-powered development assistants to the test—experimenting with code completion, agentic workflows, retrieval-augmented generation (RAG), and other techniques inside IntelliJ IDEA.

Through real-world trial and error, we’ll see what these tools can (and can’t) do, explore their strengths and quirks, and discuss how developers can stay in control while leveraging AI in their workflows. Expect surprises, insights, and maybe even a sandwich—if the AI can figure it out!

A fun live coding session, oriented on developer meetups