Anton Arhipov
Developer Advocate, JetBrains
Tallinn, Estonia
Actions
Anton is a Developer Advocate in the Kotlin team at JetBrains. With a professional background in server-side development, Anton has been building tools for developers for more than ten years. Recognized as a Java Champion since 2014, he often speaks at software conferences and contributes to the Kotlin YouTube channel.
Awards
Area of Expertise
Topics
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 Assistant provides AI-powered features for software development based on the JetBrains AI service. The service transparently connects you, the IDE user, to different large language models.
This session demonstrates the capabilities of the AI Assistant 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.
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.
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
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.
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.
Ktor from Ground Up
Ktor is an asynchronous web framework built using Kotlin and coroutines. It enables developers to create both server and client applications. In this session, we will focus primarily on Ktor for backend development. We’ll see what features Ktor provides and create a simple application with WebSockets and a database.
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
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.
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.
Kotlin 2.0 and beyond
Kotlin 2.0, released in May 2024, 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 improvements in Kotlin 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 ideas 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.
Getting the Most from JPA with Kotlin
Let's explore JPA with Kotlin! Java Persistence API (JPA) is a widely adopted approach for database access in JVM applications. Implementations like Hibernate and EclipseLink are very popular, and Spring Data JPA continues to be the most used Spring Data implementation.
However, JPA was originally designed with Java in mind, which leads to some challenges when used with Kotlin. Kotlin's design principles, such as classes being final by default and built-in null-safety in the type system, don't always align seamlessly with JPA's assumptions.
In this session, we'll examine how to effectively use JPA in Kotlin programs and learn the best practices for defining JPA entities correctly in Kotlin. We'll discuss common pitfalls and how to avoid them, ensuring your Kotlin-JPA integration is smooth and efficient.
You'll come away with practical knowledge and a comprehensive checklist to follow when using JPA with Kotlin. This checklist will cover important aspects such as entity declaration, property mapping, and handling nullable fields.
We'll also touch upon some Kotlin-specific features that can enhance your JPA usage, like data classes and extension functions. By the end of this session, you'll have a solid understanding of how to leverage JPA effectively in your Kotlin projects, balancing the strengths of both technologies.
Debug Faster, Code Better: 90 Minutes of IntelliJ IDEA in Action
IntelliJ IDEA is packed with features designed to boost productivity and streamline coding workflows. In this session, we'll explore some of the most practical tools to enhance Java development in enterprise environments. This 90-minute session is divided into two parts:
Part 1: Development Efficiency
We’ll look at essential techniques to improve everyday tasks: refactorings, fast navigation, code completion options, and live templates. We'll also discuss static code analysis tools, configuring the IDE for your workflow, and leveraging IntelliJ’s integrations with Spring, JPA, Git, and more.
Part 2: Advanced Debugging
This section will focus on IntelliJ IDEA’s debugging capabilities. We’ll dive into features like remote debugging, lambda breakpoints, stream chain tracing, emulated method breakpoints, non-suspending breakpoints, custom data renderers, and more, providing practical ways to debug Java applications effectively.
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top