Kotlin by JetBrains
Creative UIs with Compose | Chris Horner
updated
• Coroutines Mastery course - coroutinesmastery.com
• Coroutines | Kotlin Documentation - kotlinlang.org/docs/coroutines-overview.html
• kotlinx.coroutines - github.com/Kotlin/kotlinx.coroutines
Some KotlinConf talks on coroutines:
• Taming Asynchronous Beasts: Debugging and Performance Tuning in a Coroutine World | Marcin Moskała - youtube.com/watch?v=QTX5_JV4TVU
• Coroutine Debugging in IntelliJ IDEA | Alexey Merkulov - youtube.com/watch?v=3vaAVtnrzAM
• Lifecycles, Coroutines and Scopes | Alejandro Serrano Mena - youtube.com/watch?v=VyBxy3_Mj6Q
• Collect Like a Pro: a deep dive on the Android lifecycle-aware coroutines APIs | Manuel Vivo - youtube.com/watch?v=qJB5iX2cOu0
• Untangling Coroutine Testing by Márton Braun - youtube.com/watch?v=nKCsIHWircA
• JetBrains/lincheck - Framework for testing concurrent code on JVM languages - github.com/JetBrains/lincheck
• #talking-kotlin on Slack - slack-chats.kotlinlang.org/c/talking-kotlin
Hosts:
Sebastian Aigner
• Website - sebi.io
• Bluesky - https://bsky.app/profile/sebi.io
Márton Braun
• Website - zsmb.co
• Bluesky - https://bsky.app/profile/zsmb.co
Guest:
• Marcin Moskała - https://kt.academy/user/marcinmoskala
0:00 Introduction
1:18 Branding discussion
3:23 Handling preconceptions
4:54 What are coroutines?
7:17 Lightweight threads?
11:07 Where coroutines live
13:27 Sequence Builder Example
17:37 The design of coroutines
20:52 What Makes Coroutines special vs other languages?
26:56 Coroutines vs Loom
34:55 Easy to start, hard to master
41:07 Common mistakes
49:33 Flows
58:52 Thinking about Flows
1:02:41 Derailing the conversation
1:03:55 Flows for single values
1:12:27 Structured concurrency
1:18:53 The 4 advantages
1:24:40 Seb tries web dev / The web is broken?!
1:31:15 collectAsStateWithLifecycle
1:32:00 Gardening break
1:36:23 Scopes and contexts
1:43:22 Testing coroutines
1:50:29 Lincheck
1:51:32 Turbine
1:55:05 Coroutines Mastery course
2:01:43 Wrap-up
This supportive and practical livestream is designed for people from underrepresented groups in tech who already have some speaking experience and are ready to level up. If you’re passionate about Kotlin and want to share your story, your knowledge, or your unique perspective with the wider community — this is for you.
Join Pamela Hill and Cheuk Ting Ho, two seasoned CFP writers, experienced speakers, and friendly faces from multiple program committees (including KotlinConf!). They’ll guide you through what makes a CFP stand out, how to shape your Kotlin journey into a strong proposal, and what reviewers are really looking for — all with a down-to-earth, no-gatekeeping approach.
This isn’t just a tutorial — it’s a space to connect, gain confidence, and have a little fun while preparing to share your voice with the Kotlin world.
Let’s get your KotlinConf talk ready — because your voice belongs here.
#kotlin #server
Kirill also opens up about his own journey — from junior developer to CEO — and how JetBrains balances innovation, culture, and growth while serving over 15M developers worldwide.
We cover:
🤖 How AI and agents will transform the entire software development lifecycle
🚀 The role of Kotlin + Juni in empowering both professionals and new creators
⚓ JetBrains’ unique “pirate ship” culture and scaling creativity across teams
👩💻 Advice for developers adapting to the AI-driven future of engineering
#JetBrains #AI #Kotlin #DeveloperTools
We’ll start from scratch—setting up dependencies, creating an LLM client, and sending prompts to models.You’ll see how to handle responses, translate text, and even connect your agent to the real world by calling tools.
Step by step, we’ll implement a money transfer example, showing how to define tools, register them, and let the agent use them dynamically.
You’ll also learn how Koog simplifies working with multiple models, handles conversation history, and manages tool calls automatically.
By the end, you’ll understand what makes an AI agent tick: an LLM acting as the “brain” plus tools it can call in a loop.
This demo is just the beginning—Koog gives you the flexibility to scale from prototypes to production-ready AI agents.
🔗 Useful resources:
📦 Koog repository: github.com/JetBrains/koog
📚 Koog documentation: docs.koog.ai
💻 Project accompanying this video (contains code samples): github.com/svtk/koog-tutorials
📝 Tutorial accompanying this video: github.com/svtk/koog-tutorials/blob/master/tutorials/IntroToAIAgents.md
#kotlin #ai #koog
In this case study, Andrei Nevedomskii, Kotlin Competence Lead at Wolt, explains:
• The transition from a Python monolith to Kotlin microservices
• Why Kotlin’s type safety, concise syntax, and Java interoperability make it a strong choice for backend development
• How Wolt teams use both Ktor and Spring with Kotlin for flexibility and performance
• The role of Kotlin in improving developer productivity, reliability, and time to production
• Scaling to 150+ engineers and 150+ active repositories powered by Kotlin
• How internal Kotlin tools now allow launching services in minutes instead of days
Wolt operates in 30 countries with over 50 million users, and continues to invest in Kotlin for both backend and mobile. They are currently hiring Kotlin engineers in Finland, Sweden, and Germany.
👉 Watch the full video to learn why Wolt chose Kotlin for server-side development and how it supports their growth at scale.
#kotlin #Ktor #Spring #ServerSideKotlin #KotlinMicroservices #CaseStudy #Wolt #DoorDash #KotlinBackend
A real-life story of using Kotlin Notebook in an environment where every decision counts. Out in the open sea, there’s no room for guesswork — and that’s where the power of interactive programming come in to plan, adapt and win during one of the trickiest challenges out there: the 24-hour sailing race. It’s all about strategy, maps, constantly changing weather, speed, and having fun with Kotlin on waves!
All hands on deck — let’s code!
Two years ago, sitting in the audience at KotlinConf, I was mesmerised by the idle animation on the big screen. It was in the style of old school DVD player screen savers, with Kotlin's various logos through the years bouncing from edge to edge.
I later found out that this was a pre-rendered video, and not a screen saver that I could just grab and start using. This meant that I had no choice but to build it myself, as a native macOS application running on Kotlin/Native.
Join me for a tale of Kotlin success and macOS failures, as we explore just what it takes to build a screen saver in Kotlin.
We'll see how easy it is to call native platform APIs from Kotlin code, what challenges the development of such an unusual application presents, and how macOS is very much not our friend on this whole journey.
In the JVM world, the virtual machine and its class loaders do the heavy lifting of linking and loading our applications with dependencies. When we use Kotlin Multiplatform to produce a native binary, we lose the simplicity of JAR archives and .class files.
In this session, we'll explore the differences between how JVM and native platforms handle dependencies. We'll look at some of the common blockers that native platforms throw our way and possible workarounds. We'll also compare dependency management tools used on Apple platforms like CocoaPods and Swift Package Manager to see their strengths and weaknesses.
Learn how native dependencies interact, how they are loaded and the unexpected complexities of the native world.
Two years ago, StoneCo, one of the largest fintech companies in Latin America serving more than 4 million users, embarked on a journey to unify its mobile apps using Kotlin Multiplatform (KMP), aiming to balance the efficiency of code sharing with the seamless user experience required in the fintech sector. This talk explores our journey - how we evaluated multiple cross-platform frameworks, overcame technical and organizational challenges, and achieved 55% code sharing across two large-scale mobile applications.
You'll hear how we made the decision to adopt KMP, how we trained 130 mobile engineers to embrace this paradigm shift, and the measurable impact it has had on team productivity, developer satisfaction, and app performance. Whether you're considering KMP or scaling it in your organization, this session will provide actionable insights from a real-world, long-term implementation.
Managing a large, multi-team Kotlin codebase that has grown and evolved over eight years is no small feat. Introducing architectural changes and ensuring alignment across multiple autonomous teams adds another layer of complexity.
In this talk, you’ll learn strategies to build more robust, maintainable, and future-ready codebases, whether you’re scaling a project or working in a large team. We’ll show how integrating static analysis tools like Ktlint and Detekt into your CI pipeline can help you establish consistent coding standards and systematically reduce technical debt. As a bonus, we’ll explore how we were able to leverage custom Detekt rules to help us safely enable r8 in a multimodule Android app.
Have you ever wondered what the Kotlin/Native runtime does? What actually happens, under the hood, when you instantiate an object? How is an object layed out? How does the runtime manage memory? What happens when an object is no longer needed?
In this talk, you will get a look at how all these problems are solved by the Kotlin/Native runtime. This is a high level talk about a very low level topic; you only need to know a bit of Kotlin to follow along.
Kotlin is loved for its expressiveness, Quarkus for its blazing-fast runtime, and LangChain4j for integrating AI into modern applications. But what happens when you bring all three together? You unlock the potential to build cutting-edge, AI-powered applications efficiently.
Despite the growing demand for AI-driven solutions, integrating AI workflows into existing applications remains a challenge for many Kotlin developers. Pain points include complex setup, lack of synergy between frameworks, and maintaining high performance while leveraging AI tools.
This talk offers a solution: combining LangChain4j and Quarkus to create Kotlin applications that leverage AI capabilities seamlessly. We’ll explore how to streamline integration, manage dependencies, and use Kotlin’s idiomatic features to simplify AI workflows.
Who is this talk for? Kotlin developers curious about embedding AI into their apps, and Quarkus fans eager to explore its potential in AI-driven use cases. Attendees will leave with actionable insights, including code samples, to build AI-powered applications confidently.
We're happy to announce that Buck2, a large-scale open source build system from Meta, now supports Kotlin and Android. Buck2 builds all Android applications at Meta with a focus on fast incremental iterations with code. We will start building an app from basics and then learn some advance buck2 capabilities, like Remote Execution, Source-only ABI, and Build Tools API integrations
The AWS SDK for Kotlin is a massive multiplatform project, spanning over 300 services and targeting 8 distinct platforms.
In this session, we’ll share first-hand insights into managing the challenges of a large Kotlin Multiplatform project, detailing how the AWS SDK for Kotlin was designed, developed, and scaled. You’ll hear about the best practices we adopted, the lessons learned, and the strategies that worked (and didn’t) at AWS scale.
Join us as we discuss design tradeoffs, maintaining backwards compatibility, adding support for Kotlin Multiplatform, automating build and release processes, and more!
Join us live from the ICPC World Finals in Baku! Watch Andrew ‘ecnerwala’ He take on David ‘SecondThread’ Harmeyer in a PvP match filled with Kotlin Heroes challenges. See these two grandmasters showcase their problem-solving skills as they tackle tough algorithmic tasks in Kotlin.
#ICPC, #competitive programming, #JetBrains, #Kotlin, #Junie
Join the discussion: github.com/Kotlin/KEEP/issues/394
See everything new in Kotlin 2.2: kotlinlang.org/docs/whatsnew22.html
Kotlin 2.2 lets you generate boxed versions of methods working with value classes to make them consumable from Java code. This means that you can now safely use them in libraries and support both Kotlin and Java clients.
Being a full-stack developer is valuable in today's tech landscape - you can own features end-to-end, make holistic architectural decisions, and adapt quickly to changing project needs. This versatility is especially crucial in smaller teams and startups.
However, the role can be intimidating. The list of technologies one is expected to master is extensive: Kubernetes, Postgres, Kotlin, Gradle, Ktor, React, Remix, Node.js, and NPM. Even the most experienced developers struggle to keep up with it all.
Perhaps we should step back and examine this problem from a fresh perspective. Do we truly need all these technologies? After all, HTML and CSS remain relatively stable, unlike frameworks that seem to change every six months.
Many applications don't require the complexity of a modern Javascript Single Page Application (SPA). Everything eventually renders to HTML anyway! Using technologies like HTML, CSS, HTMX, AlpineJS, and Unpoly, you can achieve 98% of SPA functionality with minimal frontend code and less complexity. These tools enhance and build upon HTML and CSS rather than trying to replace them.
In this presentation, I'll show how HTMX and kotlinx.html combine beautifully with Ktor to create modern, interactive web applications. You'll see how these technologies work together seamlessly - Ktor's powerful backend capabilities, kotlinx.html's type-safe HTML generation, and HTMX's elegant approach to frontend interactions. This stack offers a refreshingly simple way to build dynamic web applications while keeping your codebase clean and maintainable.
Swift is an open-source programming language by Apple, primarily used for building apps within the Apple ecosystem.
A new major version of Swift - Swift 6 was released at the end of the previous year. The standout feature of the release is strict concurrency mode, which aims to prevent data races.
In this talk, we will take a quick look at Swift actors and / features, which share a lot of similarities with Kotlin Coroutines. We will explore what does Swift 6 do to prevent data races, and, perhaps, discuss if we can expect a similar feature in future versions of Kotlin.
The talk assumes that the attendees are familiar with Kotlin Coroutines.
Follow along as the Android team walks you through the process of taking some of their architectural building blocks, such as SavedState and System Back, through the process of decoupling them from platform specific implementations and how they approached the task of writing good common APIs in preparation for future integrations with other platforms while maintaining the quality achieved in android.
Want to turn your Kotlin journey into a rollercoaster of frustration? You’re in the right place! In this session, we’ll uncover the ultimate strategies for making life harder: delightfully obtuse anti-patterns, enthusiastically misusing language features, and blissfully ignoring ecosystem best practices.
Packed with real-world blunders, this talk is your shortcut to chaos!
A common challenge developers face when working with data streams is collecting and analyzing this data as fast as possible to uncover meaningful insights or take fast actions.
In this talk, I’ll show you how I tackled this by building a Bluesky bot that turns raw data collected from the Bluesky’s stream of posts into actionable insights.
In this talk you will learn how to:
• Collect data into streams
• Use probabilistic data structures such as Bloom Filters, TopK and Count-Min Sketch
• Use Retrieval-Augmented Generation for adding your own knowledge base into your LLM queries
• Use semantic caching for reducing LLM calls
• Use vector siilarity search to classify the data
• Efficiently querythe data
Whether you’re curious about GenAI, interested in data-driven analytics, or simply love experimenting with creative tech solutions, this session will inspire you with practical techniques and real-world applications.
Do you have a complex business rule-set problem? You know the kind where you have business rules (logic) spread across multiple platforms, systems and applications? Some of them might even be alter egos of the same rule hiding in different apps. You never know which one might turn up where, there is no single source of truth, solving errors takes hours of debugging, and making changes requires (oftentimes) painful coordination across teams and applications (ugh).
We faced this exact challenge at Posten Bring As - Norwegian National Postal Service founded way back in 1647 - a 377-year-old institution with software spanning more generations than most families! Our business logic was scattered across multiple platforms, some almost as old as the company itself (well, not quite, but it sure felt like it).
In my session I’m spilling the tea. We discover how the team at century-old Norwegian postal services giant tackled modern challenges with cutting-edge technology.
We’ll look through real-world use cases at Posten Bring. We’ll reflect on what we did - key learnings, what went well and most importantly - what didn’t quite go as planned. We’ll also look through some resources to get started. We'll learn how KMP provides a unified framework for code sharing and execution across various platforms to solve the challenge of different codebases targeting different runtimes.
This talk is for you if troublesome and unruly business logic keeps you up at night and you want that to end NOW. It is also for you if you like to hear a good story.
Kotlin-inject-anvil is a dependency injection framework for Kotlin Multiplatform. It verifies the dependency graph at compile time and generates the necessary code to instantiate the object graph at runtime. The framework aims to provide a safe dependency injection solution without the boilerplate and configurations common in many other libraries.
This talk will introduce kotlin-inject-anvil, discussing its benefits and how it scales in large, modularized codebases. We'll explore how to leverage the strengths of each host platform while maximizing common Kotlin Multiplatform code. Since each codebase is unique, I'll demonstrate how we adapt the framework for our own internal use cases at Amazon.
Uber has one of the largest Android codebases in the world, and while Kotlin is first class, millions of lines of Java remain to be converted. Come along for the ride as we walk you through the tooling and processes we've built and integrated while working with the community to safely mass migrate our production Java code to Kotlin code, which we're now utilizing to scale out more migrations to other technologies.
We'll cover the motivations for tackling a migration of this magnitude, the challenges for LSCs (Large Scale Changes) in huge monorepos and organizations, generating migration data sets to power cutting-edge AI tools, using agentic systems and pipelines to deterministically tackle the migrations at scale, the risks and mitigations for migrating this much production code, how to manage thousands of PRs, and where we'll be taking this technology next.
While Kotlin is seeing widespread adoption for Server side development, Ktor, Kotlin's minimalistic and flexible framework for server and client side development, is sometimes overlooked, largely because Spring Boot still offers an exhaustive range of starters.
To bridge this gap, kotlin developers can utilise Ktor's fluent Plugin API to provide all the functionality they need for their own use cases, and those of the wider community.
In this session, we will discuss developing plugins for Ktor and demonstrate a few interesting plugins that complement the standard set of Ktor’s features.
You’ll learn how to seamlessly integrate essential functionalities like Kafka for message-driven architectures, implement advanced rate limiting for traffic control, and enhance system resilience with a sophisticated Circuit Breaker plugin. Each plugin is crafted to offer flexibility and ease of integration, making your development experience smoother and more efficient.
Slides: https://kotl.in/Ido-Flax
Repos:
Flaxoos - Extra Ktor Plugins: github.com/Flaxoos/extra-ktor-plugins
Demo System: github.com/Flaxoos/ktor-webinar-real-time-event-system
Data representation and analysis in finance has a large literature already present in R and Python, two of the most common suspects. They have the community, tooling and a long tradition. But what about Kotlin with some of the libraries in the family, like DataFrame and Kandy? Kotlin, traditionally known for its focus in mobile and backend development, has emerged as a strong contender in the data science space. This session explores the potential of Kotlin for financial data analysis, focusing on the use of the DataFrame library and the Kandy visualization framework.
We will demonstrate how Kotlin provides a rich, statically typed language environment, ensuring safety, conciseness, and performance in handling large datasets commonly encountered in financial contexts. DataFrame provides the capacity to manipulate structured data, while Kandy enables high-quality visualizations.
This presentation will also provide a comparative analysis between Kotlin, R, and Python. We will examine common use cases such as dividend history, stock valuation based on price and yields. While R and Python have established ecosystems for data science, Kotlin's performance, tooling, and modern features offer new possibilities for finance professionals looking for a more efficient alternative.
Discover how Kotlin can power AI without relying on large language models. In this session, we'll explore preparing data using Kotlin Notebooks, training machine learning models directly in Kotlin, and implementing a strategy-driven bot for an online board game. Whether you're a Kotlin enthusiast or curious about alternative approaches to AI, this talk will show how Kotlin shines as a tool for building efficient, specialized AI systems
Virtually every Android developer uses AndroidX libraries. With KMP, the usage is expanding to other platforms as well. The wide adoption makes API design and evolution of these libraries critical for the user experience. Join me to learn about the life of an API in AndroidX: from an idea, to a design, to a review, and through an API evolution. You will hear about our API review process and our use of Metalava and Kotlin Binary Compatibility Verification tools to wrangle JVM, Android, and KMP libraries.
Want to build a website using Kotlin? Kobweb is a modern web framework that makes web development enjoyable by leveraging Compose HTML and drawing inspiration from Jetpack Compose. With Kobweb, you can create a portfolio site, product landing page, personal blog, and more—all while benefiting from Kotlin’s concise, expressive, and type-safe syntax. In this live coding session, we’ll introduce the fundamentals of Kobweb and Compose HTML, walking you through the process of building a functional website using Kotlin/JS. By the end, you’ll see just how easy it is to develop and export a traditional website—embracing HTML, CSS, and the DOM through a Kotlin-first, Compose-powered approach. This talk is designed for beginners, and no prior web development experience is required. If you’re curious about web development and want to explore a Kotlin-powered, type-safe, Compose API for building modern websites, this session is the perfect place to start!
Whether it's a Kotlin library or an Android app, developers want their inner loop to be fast: code, compile, test, repeat. With Gradle, there are no extra steps—you run the test, and it takes care of the rest, whether you’re tweaking a single line of code or upgrading all your dependencies.
In this talk, learn how to tame the inner dev loop. We'll explore the recent evolution of Gradle's performance features, such as Configuration Cache and Isolated Projects, and how to organize your Kotlin build to make the most of it.
What you’ll learn:
How Koog agents work with context and how you can control their behavior.
How to use the built-in tracing features for debugging and observability.
Ways to integrate external tools and APIs to extend agent capabilities.
How to build a trip planning agent.
Join us to discover why Koog is perfect for developers ready to move from simple agents to dynamic, stateful, and explainable systems – all in pure Kotlin.
Trip planning example project: github.com/JetBrains/koog/tree/develop/examples/trip-planning-example
Koog repository github.com/JetBrains/koog
Koog documentation docs.koog.ai
Koog community Slack channel: kotlinlang.slack.com/messages/koog-agentic-framework
#Koog #AIagent #Kotlin #AIDevelopment #AgentFramework #ToolAugmentation #Tracing #Debugging #StatefulAgents #ExplainableAI
To enable it:
* Ensure you are using Kotlin 2.2 or later in your project
* Add -Xnested-type-aliases as a compiler argument
KEEP: github.com/Kotlin/KEEP/blob/nested-typealias/proposals/nested-typealias.md
How do I create libraries for Kotlin Multiplatform projects? Kotlin lets you share common code between different target platforms, but by default only a limit set of platform-agnostic APIs are available to the code. Growing the amount of APIs available required Kotlin Multiplatform libraries.
I’ll talk through what it looks like to create such a library, drawing from my experience building and maintaining one of my own since the early days of Kotlin/Native. We'll talk about how to find shared abstractions around different platform APIs, how to handle the fast-paced evolution of this environment, and what this all felt like as a first-time library developer. When we're done, you’ll be ready to leverage the growing ecosystem as well as make your own contributions.
The ability to process continuous data streams and deliver real-time insights has become crucial in modern application architectures. As a developer you are probably very comfortable with RESTful services, and shifting to event-driven thinking opens new possibilities for responsiveness and scalability (as well as new challenges and growing paints).
This talk will explore building real-time analytics dashboards by combining Apache Flink's powerful stream processing capabilities with Ktor's flexible web framework. We'll journey through the mental model transformation from request/response patterns to continuous event flows, demonstrating how this shift enables truly reactive applications.
You'll learn:
• How Apache Flink handles stateful stream processing, offering advantages for complex analytics use cases
• Leveraging Flink's Table API and SQL capabilities to express complex transformations with familiar syntax
• Implementing real-time dashboards with Ktor and other Kotlin libraries
By the end of this session, you'll understand how to bridge the gap between powerful backend stream processing and engaging user interfaces, all while staying in the Kotlin ecosystem. Regardless, if you're a seasoned data streaming engineer or just beginning to explore beyond REST, you'll bring home practical techniques for delivering real-time insights to your users.
Many of us use Android Studio and IntelliJ every day, and appreciate how its rich feature set makes our job easier. Most people know that both products are built on the IntelliJ Platform, the same that underpins the popular IDEs from JetBrains, which has seen lasting success for over 20 years. It’s a solid, expansive, and by far the best foundation on which we could stand on to deliver developer goodies.
However, some parts of the IntelliJ Platform show the signs of time; in particular its UI framework, Swing, is proving the most limiting, having been around for almost 30 years. Don’t get us wrong — it works, and the IDEs themselves prove you can ship complex UIs by using Swing on the IntelliJ Platform. But as we looked at how nice it is to develop UIs on desktop by using Compose for Desktop, we thought: why don’t we do the same?
Enter Project Sparkles, which aims at gradually introducing new high-quality, polished UI surfaces in Android Studio and IntelliJ, developed in Compose for Desktop, with all the bells and whistles you can expect from a top-tier interface. In this talk, we’ll cover how Project Sparkles is impacting the development of Android Studio and IntelliJ, addressing long-standing user feedback, and how Google and JetBrains are working together to build a framework to make your favorite IDE even better and easier to understand.
We’ll demonstrate a few examples of features already shipping that are powered by Project Sparkles, explain what our goals and ambitions are, and even show some sneak peeks of things you may see in a future IDE version. We will also cover a roadmap on when developers can expect to use Compose for Desktop as a supported UI framework for IntelliJ plugin development!
UI enthusiasts, assemble!
Original title: Project Sparkles: How Compose for Desktop is changing Android Studio and IntelliJ
IntelliJ IDEA's refactoring support is second to none, but the Refactor This menu only has 9 items. Where is all the power hiding?
Join Dmitry and Duncan on a whistle-stop live-coding tour of our favourite IDE's invisible refactorings. Marvel as Alt-Enter reveals refactorings before your very eyes. Gasp as they change depending on context. Wonder how completely different they can be simply by moving the cursor one character to the left or right, and feel the tension mount as they approach the deadline. Can they really show more than one refactoring a minute?
Q: Why should I care about Java nullness annotations?
A: Because they’ll make Kotlin code that uses Java libraries safer, and because they’ll make it easier to convert Java code to Kotlin.
JSpecify released a set of nullness annotations for Java in July. Unlike all the other nullness annotations for Java, JSpecify’s are defined by tool-agnostic specification. That means that all the Java nullness analyzers will agree on what they mean, and the Kotlin compiler will too. And that means that your Kotlin code will be able to use null-safe types instead of platform types when it depends on well-annotated Java libraries.
In this talk, we’ll explain how Java nullness annotations will help you, and how JSpecify’s work. We’ll also tease upcoming projects that aren’t about nullness but might help your Kotlin code too.
Here’s what you’ll learn:
What is Koog, including its philosophy, vision, and growing ecosystem.
Why choose Kotlin for AI agent development.
What Koog’s core architecture and agent model looks like under the hood.
How to build and run your first “Hello Agent” with minimal setup.
Whether you're a Kotlin developer or an AI enthusiast, you’ll find this session insightful.
Link to the web search agent example: github.com/JetBrains/koog/blob/develop/examples/src/main/kotlin/ai/koog/agents/example/websearch/WebSearchAgent.kt
0:00 Introduction
3:48 Koog vision
6:41 Koog benefits
12:17 Kotlin for AI
14:31 Koog architecture
17:56 The simplest agent
18:45 Tools
19:48 Agent strategy and strategy graphs
24:13 Live coding: web search agent
43:09 Live coding: explaining strategy
1:04:27 Q&A
#Kotlin #AI #Koog #Agents #AIagent #KotlinDevelopment #OpenSource #Tutorial #Livestream #Coding


