Posts Tagged ‘JetBrains’
[KotlinConf2023] KotlinConf’23 Keynote: The Future of Kotlin is Bright and Multiplatform
KotlinConf’23 kicked off with an energizing keynote, marking a much-anticipated return to an in-person format in Amsterdam. Hosted by Hadi Hariri of JetBrains, the session brought together key figures from both JetBrains and Google, including Roman Elizarov, Svetlana Isakova, Egor Tolstoy, and Grace Kloba (VP Engineering for Android Developer Experience at Google), to share exciting updates and future directions for the Kotlin language and its ecosystem. The conference also featured a global reach with KotlinConf Global events in 41 countries. The main announcements from the keynote are also available in a blog post on the Kotlin blog.
The keynote celebrated Kotlin’s impressive growth, with statistics highlighting its widespread adoption, particularly in Android development where it’s the most popular language, used in over 95% of the top 1000 Android apps. A major focus was the upcoming Kotlin 2.0, centered around the new K2 compiler, which promises significant performance improvements, stability, and a foundation for future language evolution. The K2 compiler is nearing completion and is set to be released as Kotlin 2.0. The IntelliJ IDEA plugin will also adopt the K2 frontend, aligning with IntelliJ releases.
The Evolution of Kotlin: K2 Compiler and Language Features
The K2 compiler was a central theme of the keynote, marking a major milestone for Kotlin. This new compiler front-end, which also powers the IDE, is designed to be faster, more stable, and enable the development of new language features and tooling capabilities more rapidly. Kotlin 2.0, built on K2, is expected to bring these benefits to all Kotlin developers, enhancing both compiler performance and IDE responsiveness.
Looking beyond Kotlin 2.0, the speakers provided a glimpse into potential future language features that are under consideration. These included:
* Static Extensions: Allowing extension functions to be resolved statically, potentially improving performance and clarity.
* Collection Literals: Introducing a more concise syntax for creating collections, like using square brackets for lists, with efficient implementations.
* Name-Based Destructuring: Offering a more flexible way to destructure objects based on property names rather than just position.
* Context Receivers: A powerful feature for providing contextual information to functions in a more implicit and structured manner. This feature, however, is being approached carefully to ensure it aligns well with Kotlin’s principles.
* Explicit Fields: Providing more control over backing fields for properties.
The team emphasized a careful approach to evolving the language, ensuring new features are well-designed and maintainable. Compiler plugins were also highlighted as an avenue for extending Kotlin’s capabilities.
Kotlin in the Ecosystem: Google’s Investment and Multiplatform Growth
Grace Kloba from Google took the stage to reiterate Google’s strong commitment to Kotlin. She shared insights into Google’s investments in the Kotlin ecosystem, including the development of Kotlin Symbol Processing (KSP) and the continued focus on making Kotlin the default choice for Android development. Google officially supported Kotlin for Android development by early 2017. The Kotlin DSL is now the default for Gradle build scripts in Android Studio, enhancing developer experience with features like semantic highlighting and code completion. Google also actively contributes to the Kotlin Foundation and encourages the community to participate through programs like the Kotlin Foundation Grants Program, which focuses on supporting multiplatform libraries and frameworks.
Kotlin Multiplatform (KMP) was another major highlight, showcasing its growing maturity and adoption. The vision for KMP is to allow developers to share code across various platforms—Android, iOS, desktop, web, and server-side—while retaining the ability to write platform-specific code when needed. The keynote celebrated the increasing number of multiplatform libraries and tools, including KMM Bridge, that simplify KMP development. The future of KMP looks bright, with efforts to further improve the developer experience and expand its capabilities.
Compose Multiplatform and Emerging Technologies
The keynote also showcased the advancements in Compose Multiplatform, JetBrains’ declarative UI framework for building cross-platform user interfaces. A significant announcement was the alpha release of Compose Multiplatform for iOS, enabling developers to write their UI once in Kotlin and deploy it on both Android and iOS, and even desktop and web. This opens up new possibilities for code sharing and faster development cycles for mobile applications.
Finally, the team touched upon Kotlin’s expansion into emerging technologies like WebAssembly (Wasm). JetBrains is developing a new compiler backend for Kotlin targeting WebAssembly with its garbage collection proposal, aiming for high-performance Kotlin code in the browser. Experiments with running Compose applications in the browser using WebAssembly were also mentioned, hinting at a future where Kotlin could offer a unified development experience across an even wider range of platforms. The keynote concluded with an invitation for the community to dive deeper into these topics during the conference and to continue contributing to Kotlin’s vibrant ecosystem.
Links:
[KotlinConf2019] Exploring the Power of Kotlin/JS
Sebastian Aigner, a developer advocate at JetBrains, captivated KotlinConf2019 with his deep dive into Kotlin/JS, the JavaScript target for Kotlin. With a passion for web development, Sebastian showcased how recent advancements make Kotlin/JS a compelling choice for building web applications. From streamlined tooling to seamless JavaScript interoperability, he outlined the current state and future potential of Kotlin/JS, inspiring both newcomers and seasoned developers to leverage Kotlin’s paradigms in the browser.
Simplifying Development with the New Gradle Plugin
Kotlin/JS has evolved significantly, with the new Kotlin/JS Gradle plugin emerging as the cornerstone for browser and Node.js development. Sebastian explained that this plugin unifies previously fragmented approaches, replacing deprecated plugins like kotlin2js and kotlin-frontend. Its uniform Gradle DSL simplifies project setup, offering sensible defaults for Webpack bundling without requiring extensive configuration. For developers transitioning to multi-platform projects, the plugin’s compatibility with the Kotlin multi-platform DSL minimizes changes, enabling seamless integration of additional targets. By automating JavaScript environment setup, including yarn and package.json, the plugin empowers Kotlin developers to focus on coding rather than managing complex JavaScript tooling.
Mastering Dependency Management with npm
The JavaScript ecosystem, with over a million npm packages, offers unparalleled flexibility, and Kotlin/JS integrates effortlessly with this vast library. Sebastian highlighted how the Gradle plugin manages npm dependencies directly, automatically updating package.json when dependencies like React or styled-components are added. This eliminates the need for separate JavaScript environment setup, saving time, especially on non-standard platforms like Windows. Developers can import Kotlin libraries (e.g., coroutines, serialization) alongside JavaScript packages, with Gradle handling the JavaScript-specific versions. This unified approach bridges the gap between Kotlin’s structured ecosystem and JavaScript’s dynamic world, making dependency management intuitive even for those new to JavaScript.
Bridging Kotlin and TypeScript with Dukat
Interoperating with JavaScript’s dynamic typing can be challenging, but Sebastian introduced Dukat, an experimental tool that converts TypeScript declaration files into Kotlin external declarations. By leveraging TypeScript’s de facto standard for type definitions, Dukat enables type-safe access to npm packages, such as left-pad or react-minimal-pie-chart. While manual external declarations require tedious annotation, Dukat automates this process, generating headers for packages with TypeScript support or community-contributed definitions. Sebastian encouraged early adoption to provide feedback, noting that Dukat already powers browser and Node.js API wrappers. This tool promises to simplify integration with JavaScript libraries, reducing the friction of crossing the static-dynamic typing divide.
Enhancing Testing and Debugging with Source Maps
Testing and debugging are critical for robust applications, and Kotlin/JS delivers with integrated tools. Sebastian demonstrated how the Gradle plugin supports platform-specific test runners like Karma, allowing tests to run across browsers (e.g., Firefox, headless Chrome). Source maps, automatically generated since Kotlin 1.3.60, provide detailed stack traces for Node.js and interactive debugging in browser DevTools. Developers can set breakpoints in Kotlin code, inspect variables, and trace errors directly in Chrome’s console, as shown in Sebastian’s pong game demo. Gradle test reports further enhance diagnostics, offering HTML-based insights into test failures, making Kotlin/JS development as robust as its JVM counterpart.
Optimizing with the IR Backend
The upcoming Intermediate Representation (IR) backend marks a significant leap for Kotlin/JS. Sebastian outlined its benefits, including aggressive code size optimizations through dead code elimination. Unlike the current backend, which may ship the entire standard library, the IR backend, combined with Google Closure Compiler, reduces zipped file sizes dramatically—down to 30 KB from 3.9 MB in some cases. Faster compilation speeds, especially for incremental builds, enhance developer productivity, particularly in continuous build scenarios with Webpack’s dev server. The IR backend also supports platform-agnostic compiler plugins, simplifying multi-platform development. Sebastian noted that pre-alpha IR support in Kotlin 1.3.70 requires manual exports due to its closed-world assumption, urging developers to explore early releases.
Looking Ahead: WebAssembly and Framework Support
Sebastian concluded with a glimpse into Kotlin/JS’s future, highlighting potential support for ECMAScript 6 modules and frameworks like Angular and Vue.js. While JetBrains provides React wrappers, extending first-class support to other frameworks requires addressing their unique tooling and compilers. The IR backend also opens doors to WebAssembly, enabling Kotlin to target browsers more efficiently. Though no timelines were promised, these explorations reflect JetBrains’ commitment to aligning Kotlin/JS with modern web trends. Sebastian’s call to action—trying the Code Quiz app at the Kotlin booth and contributing to Dukat—emphasized community involvement in shaping Kotlin/JS’s evolution.
Links:
[KotlinConf2019] Kotless: A Kotlin-Native Approach to Serverless with Vladislav Tankov
Serverless computing has revolutionized how applications are deployed and scaled, but it often comes with its own set of complexities, including managing deployment DSLs like Terraform or CloudFormation. Vladislav Tankov, then a Software Developer at JetBrains, introduced Kotless at KotlinConf 2019 as a Kotlin Serverless Framework designed to simplify this landscape. Kotless aims to eliminate the need for external deployment DSLs by allowing developers to define serverless applications—including REST APIs and event handling—directly within their Kotlin code using familiar annotations. The project can be found on GitHub at github.com/JetBrains/kotless.
Vladislav’s presentation provided an overview of the Kotless Client API, demonstrated its use with a simple example, and delved into the architecture and design concepts behind its code-to-deployment pipeline. The core promise of Kotless is to make serverless computations easily understandable for anyone familiar with event-based architectures, particularly those comfortable with JAX-RS-like annotations.
Simplifying Serverless Deployment with Kotlin Annotations
The primary innovation of Kotless, as highlighted by Vladislav Tankov, is its ability to interpret Kotlin code and annotations to automatically generate the necessary deployment configurations for cloud providers like AWS (initially). Instead of writing separate configuration files in YAML or other DSLs, developers can define their serverless functions, API gateways, permissions, and scheduled events using Kotlin annotations directly on their functions and classes.
For example, creating a REST API endpoint could be as simple as annotating a Kotlin function with @Get("/mypath"). Kotless then parses these annotations during the build process and generates the required infrastructure definitions, deploys the lambdas, and configures the API Gateway. This approach significantly reduces boilerplate and the cognitive load associated with learning and maintaining separate infrastructure-as-code tools. Vladislav emphasized that a developer only needs familiarity with these annotations to create and deploy a serverless REST API application.
Architecture and Code-to-Deployment Pipeline
Vladislav Tankov provided insights into the inner workings of Kotless, explaining its architecture and the pipeline that transforms Kotlin code into a deployed serverless application. This process generally involves:
1. Annotation Processing: During compilation, Kotless processes the special annotations in the Kotlin code to understand the desired serverless architecture (e.g., API routes, event triggers, scheduled tasks).
2. Terraform Generation (Initially): Kotless then generates the necessary infrastructure-as-code configurations (initially using Terraform as a backend for AWS) based on these processed annotations. This includes defining Lambda functions, API Gateway resources, IAM roles, and event source mappings.
3. Deployment: Kotless handles the deployment of these generated configurations and the application code to the target cloud provider.
He also touched upon optimizations built into Kotless, such as “outer warming” of lambdas to reduce cold starts and optimizing lambdas by size. This focus on performance and ease of use is central to Kotless’s philosophy. The framework aims to abstract away the underlying complexities of serverless platforms, allowing developers to concentrate on their application logic.
Future Directions and Multiplatform Aspirations
Looking ahead, Vladislav Tankov discussed the future roadmap for Kotless, including ambitious plans for supporting Kotlin Multiplatform Projects (MPP). This would allow developers to choose different runtimes for their lambdas—JVM, JavaScript, or even Kotlin/Native—depending on the task and performance requirements. Supporting JavaScript lambdas, for example, could open up compatibility with platforms like Google Cloud Platform more broadly, which at the time had better support for JavaScript runtimes than JVM for serverless functions.
Other planned enhancements included extended event handling for custom events on AWS and other platforms, and continued work on performance optimizations. The vision for Kotless was to provide a comprehensive and flexible serverless solution for Kotlin developers, empowering them to build efficient and scalable cloud-native applications with minimal friction. Vladislav encouraged attendees to try Kotless and contribute to its development, positioning it as a community-driven effort to improve the Kotlin serverless experience.
Links:
[KotlinConf2019] Kotlin Multiplatform Programming: Present and Future with Dmitry Savvinov and Liliia Abdulina
Kotlin Multiplatform Programming (MPP) has been a significant focus for JetBrains, aiming to extend Kotlin’s reach beyond traditional JVM and Android development. At KotlinConf 2019, Dmitry Savvinov and Liliia Abdulina, both from the Kotlin team at JetBrains, delivered an insightful overview of MPP’s capabilities in version 1.3.X and offered a glimpse into its future direction. Dmitry Savvinov, a key contributor to Kotlin Contracts and heavily involved in MPP, brought his compiler expertise to the discussion. The official Kotlin language website, the central hub for MPP information, is kotlinlang.org.
Their talk was structured to cover the fundamentals of multiplatform projects, illustrate these basics with examples, provide guidelines for designing first multiplatform projects, and showcase a production-like application to demonstrate design principles in action. This comprehensive approach aimed to equip developers with the knowledge needed to start leveraging MPP effectively.
Core Concepts of Kotlin Multiplatform
Dmitry Savvinov and Liliia Abdulina began by explaining the core building blocks of Kotlin Multiplatform projects. These foundational concepts are crucial for understanding how code can be shared and specialized across different platforms:
* Source Sets: The fundamental unit of code organization in MPP. A project is typically structured with a commonMain source set containing platform-agnostic Kotlin code. Platform-specific source sets (e.g., jvmMain, jsMain, iosMain) contain code tailored for each target and can depend on commonMain.
* Targets: These define the platforms the project will compile for, such as JVM, Android, JavaScript, iOS (Native), Linux, Windows, and macOS. Each target has its own compilations.
* Compilations: A compilation process for a specific target that produces the appropriate artifacts (e.g., JVM bytecode, JavaScript files, native executables).
* expect and actual Declarations: This powerful mechanism allows common code in commonMain to declare an expect class, function, or property. Platform-specific source sets must then provide an actual implementation for that declaration, bridging the gap between shared logic and platform-specific APIs. For example, a common module might expect a function to generate a UUID, and the JVM and Native modules would provide actual implementations using their respective platform libraries.
These concepts enable developers to write shared business logic, data models, and algorithms once in commonMain and then reuse them across multiple platforms, significantly reducing code duplication and improving consistency.
Designing and Implementing Multiplatform Projects
Beyond the basic syntax, Dmitry and Liliia provided guidance on how to approach the design of a multiplatform project. This involved discussing strategies for identifying what code can and should be shared, how to structure modules for optimal maintainability, and best practices for using expect/actual effectively.
They used toy examples to illustrate these basics in a clear and understandable manner, helping attendees grasp how these pieces fit together in a real project. The presentation then progressed to showcase a “more or less production-like application”. This larger example would have served to demonstrate how the design principles discussed could be applied to build a substantial, real-world multiplatform application, highlighting how to manage dependencies, handle platform-specific interactions, and structure a scalable MPP architecture. The focus was on providing practical insights that developers could apply to their own projects, whether starting from scratch or integrating MPP into existing applications.
The Trajectory of Kotlin Multiplatform: Beyond 1.3.X
While detailing the state of MPP in Kotlin 1.3.X, Dmitry Savvinov and Liliia Abdulina also looked towards its future development. At KotlinConf 2019, MPP was still evolving, with ongoing improvements to tooling, library support, and the overall developer experience. Their talk touched upon the roadmap for MPP, including planned enhancements to areas like Kotlin/Native (for performance and interoperability), library ecosystem growth, and further refinements to the build system and IDE support within IntelliJ IDEA and Android Studio.
The vision presented was one of Kotlin as a truly universal language, enabling developers to target a wide array of platforms with a unified codebase and skillset. The commitment from JetBrains to invest heavily in MPP was clear, with the aim of making it a robust and production-ready solution for cross-platform development. The session would have encouraged developers to explore MPP, provide feedback, and contribute to its growing ecosystem, reinforcing the community-driven aspect of Kotlin’s development.
Links:
[KotlinConf2019] Ktor for Mobile Developers: Conquering the Server with Dan Kim
For many mobile developers, the thought of venturing into server-side development can be daunting, often perceived as a realm of unfamiliar languages, complex frameworks, and different programming paradigms. Dan Kim, an experienced developer, aimed to demystify this process at KotlinConf 2019 with his talk, “Ktor for Mobile Developers: Fear the server no more!”. He showcased Ktor, a Kotlin-based framework for building asynchronous servers and clients, as an accessible and powerful tool for mobile developers looking to create backend components for their applications. The official website for Ktor is ktor.io.
Dan Kim’s session was designed to demonstrate how existing Kotlin knowledge could be leveraged to easily build server-side applications with Ktor. He promised a practical, real-world example, walking attendees through everything needed to get a server up and running: authentication, data retrieval, data posting, and deployment, ultimately aiming to give mobile developers the confidence to build their own backend services.
Introducing Ktor: Simplicity and Power in Kotlin
Ktor is a framework built by JetBrains, designed from the ground up with Kotlin and coroutines in mind, making it inherently asynchronous and well-suited for building scalable network applications. Dan Kim introduced Ktor’s core concepts, such as its flexible pipeline architecture, routing capabilities, and features for handling HTTP requests and responses. A key appeal of Ktor for mobile developers is that it allows them to stay within the Kotlin ecosystem, using a language and paradigms they are already familiar with from Android development.
The presentation would have highlighted Ktor’s ease of use and minimal boilerplate. Unlike some larger, more opinionated server-side frameworks, Ktor offers a more unopinionated and lightweight approach, allowing developers to choose and configure only the features they need. This can include functionalities like authentication, content negotiation (e.g., for JSON or XML), templating engines, and session management, all installable as “features” or plugins within a Ktor application.
Building a Real-World Server-Side Component
The core of Dan Kim’s talk was a hands-on demonstration of building a server-side component. He aimed to build a RESTful API and a web application, complete with authentication, and deploy it to Google Cloud, all within an impressively small amount of code (around 350 lines, as he mentioned). This practical example would have covered essential aspects of backend development:
* Routing: Defining endpoints to handle different HTTP methods (GET, POST, etc.) and URL paths.
* Request Handling: Processing incoming requests, extracting parameters, and validating data.
* Authentication: Implementing mechanisms to secure endpoints and manage user identity, possibly integrating with external services.
* Data Interaction: Showing how to get data from and post data to other services or a database (though the specifics of database interaction might vary).
* Deployment: Walking through the process of deploying the Ktor application to a cloud platform like Google Cloud, making the backend accessible to mobile clients.
By tackling these common server-side tasks using Ktor and Kotlin, Dan aimed to alleviate the fears mobile developers might have about backend development and demonstrate that they already possess many of the necessary skills.
Empowering Mobile Developers to Go Full-Stack
The overarching message of Dan Kim’s presentation was one of empowerment. He sought to show that with Ktor, mobile developers no longer need to “fear the server”. The framework provides a gentle learning curve and a productive environment for building robust and efficient backend services. This capability is increasingly valuable as mobile applications become more sophisticated and often require custom backend logic to support their features.
Dan Kim’s practical demonstration, from basic Ktor setup to cloud deployment, was intended to give attendees a clear understanding of how to connect their own server-side components to virtually any API. By simplifying the backend development process, Ktor enables mobile developers to potentially take on more full-stack responsibilities, leading to greater control over their application’s entire architecture and a faster development cycle for new features. He hoped his session would provide the confidence needed for mobile developers to start building their own server-side solutions with Kotlin and Ktor.
Links:
[KotlinConf2019] KotlinConf 2019 Keynote: People, Ideas, and Software in the Kotlin Ecosystem with Andrey Breslav
The opening keynote of KotlinConf 2019, delivered by Andrey Breslav, the then Lead Language Designer for Kotlin at JetBrains, set an inspiring tone for the conference. Addressing a packed room of 1,700 attendees, with many more watching online, Andrey articulated a vision of Kotlin that extends beyond mere syntax and features, emphasizing it as an ecosystem built upon three pillars: people, ideas, and software. His presentation underscored the collaborative spirit that fuels Kotlin’s growth and the continuous feedback loop that shapes its evolution. The official Kotlin language website, central to this ecosystem, is kotlinlang.org.
Andrey Breslav began by reflecting on Kotlin’s journey and its burgeoning community. He highlighted that the success and adoption of Kotlin are deeply intertwined with the people who use it, contribute to it, and advocate for it. This “people-first” perspective was a recurring theme, as he stressed that Kotlin is designed to bring developers together, fostering a common way of working and shared values. The vibrant interactions at KotlinConf itself, with developers from around the world sharing experiences and knowledge, served as a living testament to this community-centric approach.
The Power of Ideas and Continuous Improvement
A core tenet of Kotlin’s development philosophy, as outlined by Andrey Breslav, is the importance of ideas and the relentless pursuit of improvement. He emphasized that the Kotlin team at JetBrains actively seeks and values feedback from the developer community. This feedback loop is critical, whether it comes through direct communication, bug reports, feature requests, or even passively through anonymized usage statistics collected by JetBrains’ IDEs. These statistics, he explained, help the team understand how Kotlin is used in real-world scenarios, identify pain points (like slow code completion in specific environments), and prioritize areas for enhancement.
This data-informed approach allows the Kotlin team to make more effective decisions about the language’s future direction. Andrey encouraged attendees to participate in this feedback process, assuring them that their input, no matter how small, contributes to making Kotlin better for everyone. He cited examples where community feedback directly influenced language features and tooling improvements, reinforcing the idea that Kotlin’s evolution is a collaborative effort. This commitment to listening and adapting ensures that Kotlin remains a pragmatic and powerful tool that addresses the real-world needs of developers.
Software as a Collaborative Endeavor
The third pillar, software, encompasses not only the Kotlin language itself but also the rich ecosystem of libraries, tools, and frameworks that surround it. Andrey Breslav highlighted the importance of this broader ecosystem in making Kotlin a productive and enjoyable language to work with. He acknowledged the contributions of the community in building these resources, from open-source libraries to educational materials and tutorials.
Furthermore, Andrey spoke about JetBrains’ ongoing efforts to enhance the Kotlin tooling, including the compiler and IDE support, to improve performance, stability, and developer experience. He touched upon initiatives aimed at making Kotlin more versatile, enabling its use across various platforms—JVM, Android, JavaScript, Native—and for different types of applications, from server-side systems to mobile apps and web frontends. The keynote celebrated the milestones achieved, such as the growing adoption of Kotlin Multiplatform, while also looking ahead to future challenges and opportunities. Andrey concluded by reiterating that every form of participation, from writing code and tutorials to sharing experiences and even simple social media interactions, adds value to the Kotlin community and contributes to its collective success.
Links:
[KotlinConf2019] A Vibrant Gathering of the Global Kotlin Community
KotlinConf 2019, held in Copenhagen, Denmark, from December 4-6, marked a significant moment for the Kotlin ecosystem, bringing together a passionate global community of developers, enthusiasts, and industry leaders. With over 1,600 attendees on-site and many thousands more joining via live stream, the conference was a testament to Kotlin’s burgeoning popularity and its expanding footprint across various domains of software development. The event, meticulously organized by JetBrains, the creators of Kotlin, served as a vibrant hub for knowledge sharing, networking, and celebrating the language’s latest advancements and future directions. The official Kotlin language website, a key resource for developers, is kotlinlang.org.
The atmosphere, as captured in highlight reels and attendee testimonials, was electric, filled with excitement and a shared enthusiasm for the language’s capabilities. Attendees praised the depth of technical talks, the relatability of the content to their daily work, and the motivating nature of keynote presentations that often held an element of suspense regarding new feature announcements. More than just a series of lectures, KotlinConf fostered a strong sense of community, a recurring theme in participants’ feedback, who often cited the community itself as one of the best parts of their Kotlin experience. This collective energy underscored Kotlin’s journey from a promising JVM language to a versatile tool impacting Android development, backend systems, web frontends, and multiplatform projects.
A Hub for Learning and Innovation
KotlinConf 2019 provided a rich learning environment, offering a diverse range of sessions that catered to various skill levels and interests. From in-depth explorations of Kotlin’s newest features to practical workshops and discussions on best practices, the conference was a platform for developers to enhance their skills and gain new perspectives. The content was designed to be both insightful and applicable, with many attendees noting the direct relevance of the talks to their ongoing projects and challenges. This focus on practical application, combined with a forward-looking vision for the language, made the event invaluable for professionals seeking to stay at the forefront of software development.
The conference also served as a crucial touchpoint for JetBrains to engage with the Kotlin community, gather feedback, and share their roadmap for the language’s evolution. This open dialogue is a hallmark of Kotlin’s development philosophy, ensuring that the language continues to meet the needs of its users and adapt to the ever-changing technological landscape. The excitement around new announcements and the opportunity to interact directly with the minds behind Kotlin added an extra layer of dynamism to the event, reinforcing its status as a premier conference for anyone invested in the Kotlin ecosystem. The success of such an event relies heavily on the engagement of its community, from the speakers sharing their expertise to the attendees bringing their curiosity and passion, all contributing to what many described as an “industrial revolution” in software development.
Links:
[KotlinConf2018] Mastering Concurrency: Roman Elizarov’s Practical Guide to Kotlin Coroutines
Lecturer
Roman Elizarov is a seasoned software developer at JetBrains, with over 17 years of experience in high-performance trading software at Devexperts. An expert in Java and JVM, he teaches concurrent programming at St. Petersburg ITMO and serves as Chief Judge for the Northeastern European Regional Programming Contest. Relevant links: JetBrains Blog (publications); LinkedIn Profile (professional page).
Abstract
This article follows Roman Elizarov’s practical application of Kotlin coroutines to address concurrency challenges. Set in the context of large-scale systems, it examines methodologies for state confinement and communication via channels. The analysis highlights coroutines’ innovations in eliminating shared mutable state, with implications for robust, scalable architectures.
Introduction and Context
Roman Elizarov engaged KotlinConf 2018 attendees with a deep dive into coroutines, building on his prior introductory talk. With a vision for a unified language across distributed systems, Elizarov showcased coroutines as a solution to concurrency without shared mutable state. His examples addressed real-life coordination, set against his experience with high-throughput trading systems processing millions of events per second.
Methodological Approaches to Concurrency
Elizarov demonstrated coroutines confining state to single coroutines, communicating via channels. Each coroutine handles a specific task, receiving input and sending output through channels, avoiding locks. For UI integration, coroutines on the main thread directly update views or report via channels for decoupled architectures. Builders like launch and async orchestrate tasks, while suspend functions enable non-blocking code.
Analysis of Innovations and Features
Coroutines innovate by simplifying async programming. Channels provide fan-out communication, unlike threads’ shared state. Compared to Java’s CompletableFuture, coroutines preserve sequential code structure. Limitations include a learning curve for channel patterns and ensuring proper context management.
Implications and Consequences
Elizarov’s approach implies cleaner, safer concurrency models, reducing bugs in complex systems. It suits UI-driven apps and distributed systems, enhancing scalability. The consequence is a shift toward channel-based designs, though teams must master coroutine semantics.
Conclusion
Elizarov’s practical guide positions coroutines as a cornerstone for modern concurrency, offering a robust alternative to traditional threading models.
Links
- Lecture video: https://www.youtube.com/watch?v=a3agLJQ6vt8
- Lecturer’s X/Twitter: @relizarov
- Lecturer’s LinkedIn: Roman Elizarov
- Organization’s X/Twitter: @JetBrains
- Organization’s LinkedIn: JetBrains
[KotlinConf2017] What’s New & Cool in Kotlin Tools
Lecturer
Dmitry Jemerov is a senior software engineer and the Kotlin IDE team lead at JetBrains, where he drives the development of tools and plugins to enhance Kotlin’s developer experience. With extensive experience in building IntelliJ IDEA plugins and supporting build tools like Gradle, Maven, and Ant, Dmitry has played a pivotal role in shaping Kotlin’s ecosystem. His leadership ensures that Kotlin’s tooling aligns with the language’s pragmatic design, fostering productivity across diverse development environments.
Abstract
Kotlin’s tooling ecosystem is integral to its success as a modern programming language, enabling developers to create efficient, cross-platform applications. This article analyzes Dmitry Jemerov’s presentation at KotlinConf 2017, which showcases new features in the Kotlin plugin for IntelliJ IDEA, with a focus on version 1.2 enhancements. It explores the context of Kotlin’s tooling evolution, the methodology behind multiplatform project support, incremental compilation advancements, and integration with build systems. The analysis highlights the implications of these innovations for developer productivity and cross-platform development, emphasizing Kotlin’s commitment to seamless, high-performance workflows.
Context of Kotlin Tooling Evolution
KotlinConf 2017, held in San Francisco from November 1–3, 2017, marked a significant milestone for Kotlin, reflecting its rapid adoption following Google’s endorsement for Android development. Dmitry Jemerov’s presentation focused on the Kotlin plugin for IntelliJ IDEA, a cornerstone of the language’s developer experience. As Kotlin expanded beyond JVM-based applications to multiplatform projects, including JavaScript and native targets, the need for robust tooling became paramount. Dmitry’s talk addressed this demand, showcasing features designed to streamline development across diverse platforms while maintaining Kotlin’s hallmark simplicity and interoperability.
The context of Dmitry’s presentation reflects the challenges of supporting a versatile language like Kotlin, which targets JVM, JavaScript, and native platforms. Developers required tools that could handle common and platform-specific code seamlessly, integrate with build systems like Gradle, and optimize compilation for performance. Dmitry’s leadership in the Kotlin IDE team positioned him to address these needs, demonstrating how JetBrains’ tools empower developers to tackle complex, multiplatform projects with efficiency and confidence.
Multiplatform Project Support
Dmitry’s methodology for supporting multiplatform projects centers on structuring Kotlin projects into common and platform-specific modules. Common modules contain shared Kotlin code, ensuring reusability across platforms, while platform-specific modules incorporate language-specific code, such as Java for JVM or JavaScript for web applications. The Kotlin compiler integrates these modules, producing artifacts like JAR files or APKs tailored to each platform’s requirements. This approach enables developers to write shared business logic once, reducing duplication and ensuring consistency across Android, iOS, and web environments.
In his live demos, Dmitry showcased how IntelliJ IDEA’s Kotlin plugin facilitates this structure, providing seamless navigation between common and platform-specific code. The plugin’s ability to combine common Kotlin code with platform-specific sources, such as Java for JVM modules, streamlines the build process. This methodology enhances developer productivity by simplifying project configuration and ensuring that multiplatform development remains intuitive, even for complex applications spanning multiple targets.
Incremental Compilation and Build Optimization
A key innovation highlighted by Dmitry was the advancement of incremental compilation across Kotlin’s target platforms. Incremental compilation optimizes build times by recompiling only modified code, a critical feature for large projects. For JVM targets, incremental compilation was already robust, but Dmitry announced the near-completion of JavaScript incremental compilation for Kotlin 1.1.6, with plans to extend it to native and multiplatform projects. This ensures that developers experience minimal delays during development, even in complex, multi-module environments.
Dmitry also emphasized integration with Gradle’s build cache and incremental compilation features, aligning Kotlin’s tooling with industry-standard build systems. By embedding IntelliJ inspections into continuous integration pipelines like TeamCity, the Kotlin plugin enables automated code quality checks, failing builds when issues exceed defined thresholds. This methodology reduces manual oversight, ensuring that code quality remains high without impeding development speed, particularly for teams managing large codebases.
IDE Integration and Developer Experience
The Kotlin plugin for IntelliJ IDEA enhances developer experience through advanced IDE features, such as code completion, refactoring, and inspections. Dmitry demonstrated how the plugin supports multiplatform projects with context-aware suggestions, simplifying the development of common and platform-specific code. The plugin’s integration with IntelliJ’s CI server allows for real-time code analysis, catching potential issues during builds. This seamless integration ensures that developers can focus on coding rather than configuring tools, aligning with Kotlin’s philosophy of getting out of the developer’s way.
Dmitry’s presentation also highlighted the plugin’s configurability, allowing developers to customize inspections and thresholds to suit project needs. While acknowledging the current limitations, such as slower inspection speeds, he outlined plans for future optimizations, including SonarQube integration. These enhancements underscore JetBrains’ commitment to delivering a fast, unobtrusive development experience, making Kotlin’s tooling a competitive advantage for multiplatform and high-performance applications.
Implications for Software Development
The advancements in Kotlin’s tooling, as presented by Dmitry, have profound implications for software development. Multiplatform project support enables developers to create unified codebases for diverse platforms, reducing maintenance costs and fostering code reuse. Incremental compilation and build optimizations address the performance bottlenecks of large-scale projects, enhancing productivity for teams working on Android, web, or native applications. The integration of IDE features with build systems ensures consistent code quality, making Kotlin a compelling choice for enterprises and startups alike.
For the broader ecosystem, these tools strengthen Kotlin’s position as a versatile, developer-friendly language. The ability to seamlessly integrate with Gradle and IntelliJ IDEA positions Kotlin as a leader in modern development workflows, challenging traditional languages like Java. Dmitry’s invitation for community feedback at JetBrains’ booth and office hours reflects a collaborative approach, ensuring that tooling evolves in response to real-world needs. As Kotlin’s ecosystem grows, its tooling innovations will continue to drive adoption across diverse development domains.
Conclusion
Dmitry Jemerov’s presentation at KotlinConf 2017 illuminated the transformative potential of Kotlin’s tooling, particularly with the IntelliJ IDEA plugin’s version 1.2 enhancements. By supporting multiplatform projects, optimizing incremental compilation, and integrating with build systems, these tools empower developers to create efficient, cross-platform applications. The focus on developer experience, through intuitive IDE features and automated inspections, aligns with Kotlin’s pragmatic design philosophy. As JetBrains continues to refine these tools, they solidify Kotlin’s role as a leading language for modern software development, fostering productivity and innovation.
Links
[KotlinConf2017] Introduction to Coroutines
Lecturer
Roman Elizarov is a distinguished software developer with over 16 years of experience, currently serving as a senior engineer at JetBrains, where he has been a key contributor to Kotlin’s development. Previously, Roman worked at Devexperts, designing high-performance trading software and market data delivery systems capable of processing millions of events per second. His expertise in Java, JVM, and real-time data processing has shaped Kotlin’s coroutine framework, making him a leading authority on asynchronous programming. Roman’s contributions to Kotlin’s open-source ecosystem and his focus on performance optimizations underscore his impact on modern software development.
Abstract
Kotlin’s introduction of coroutines as a first-class language feature addresses the challenges of asynchronous programming in modern applications. This article analyzes Roman Elizarov’s presentation at KotlinConf 2017, which provides a comprehensive introduction to Kotlin coroutines, distinguishing them from thread-based concurrency and other coroutine implementations like C#’s async/await. It explores the context of asynchronous programming, the methodology behind coroutines, their practical applications, and their implications for scalable software development. The analysis highlights how coroutines simplify asynchronous code, enhance scalability, and integrate with existing Java libraries, offering a robust solution for handling concurrent tasks.
Context of Asynchronous Programming
The rise of asynchronous programming reflects the demands of modern applications, from real-time mobile interfaces to server-side systems handling thousands of users. Roman Elizarov, speaking at KotlinConf 2017 in San Francisco, addressed this shift, noting the limitations of traditional thread-based concurrency in monolithic applications. Threads, while effective for certain tasks, introduce complexity and resource overhead, particularly in high-concurrency scenarios like microservices or real-time data processing. Kotlin, designed by JetBrains for JVM interoperability, offers a pragmatic alternative through coroutines, a first-class language feature distinct from other implementations like Quasar or JavaFlow.
Roman contextualized coroutines within Kotlin’s ecosystem, emphasizing their role in simplifying asynchronous programming. Unlike callback-based approaches, which lead to “callback hell,” or reactive streams, which require complex chaining, coroutines enable synchronous-like code that is both readable and scalable. The presentation’s focus on live examples demonstrated Kotlin’s ability to handle concurrent actions—such as user connections, animations, or server requests—while maintaining performance and developer productivity, setting the stage for a deeper exploration of their mechanics.
Methodology of Kotlin Coroutines
Roman’s presentation detailed the mechanics of Kotlin coroutines, focusing on their core components: suspending functions and coroutine builders. Suspending functions allow developers to write asynchronous code that appears synchronous, pausing execution without blocking threads. This is achieved through Kotlin’s compiler, which transforms suspending functions into state machines, preserving execution state without the overhead of thread context switching. Roman demonstrated launching coroutines using builders like launch and async, which initiate concurrent tasks and allow waiting for their completion, streamlining complex workflows.
A key aspect of the methodology is wrapping existing Java asynchronous libraries into suspending functions. Roman showcased how developers can encapsulate callback-based APIs, such as those for network requests or database queries, into coroutines, transforming convoluted code into clear, sequential logic. The open-source Kotlinx Coroutines library, actively developed on GitHub, provides these tools, with experimental status indicating ongoing refinement. Roman emphasized backward compatibility, ensuring that even experimental features remain production-ready, encouraging developers to adopt coroutines with confidence.
Applications and Scalability
The practical applications of coroutines, as demonstrated by Roman, span mobile, server-side, and real-time systems. In mobile applications, coroutines simplify UI updates and background tasks, ensuring responsive interfaces without blocking the main thread. On the server side, coroutines enable handling thousands of concurrent connections, critical for microservices and high-throughput systems like trading platforms. Roman’s live examples illustrated how coroutines manage multiple tasks—such as animations or user sessions—efficiently, leveraging lightweight state management to scale beyond traditional threading models.
The scalability of coroutines stems from their thread-agnostic design. Unlike threads, which consume significant resources, coroutines operate within a single thread, resuming execution as needed. Roman explained that garbage collection handles coroutine state naturally, maintaining references to suspended computations without additional overhead. This approach makes coroutines ideal for high-concurrency scenarios, where traditional threads would lead to performance bottlenecks. The ability to integrate with Java libraries further enhances their applicability, allowing developers to modernize legacy systems without extensive refactoring.
Implications for Software Development
Kotlin coroutines represent a paradigm shift in asynchronous programming, offering a balance of simplicity and power. By eliminating callback complexity, they enhance code readability, reducing maintenance costs and improving developer productivity. Roman’s emphasis on production-readiness and backward compatibility reassures enterprises adopting Kotlin for critical systems. The experimental status of coroutines, coupled with JetBrains’ commitment to incorporating community feedback, fosters a collaborative development model, ensuring that coroutines evolve to meet real-world needs.
The implications extend beyond individual projects to the broader software ecosystem. Coroutines enable developers to build scalable, responsive applications, from mobile apps to high-performance servers, without sacrificing code clarity. Their integration with Java libraries bridges the gap between legacy and modern systems, making Kotlin a versatile choice for diverse use cases. Roman’s invitation for community contributions via GitHub underscores the potential for coroutines to shape the future of asynchronous programming, influencing both Kotlin’s development and the JVM ecosystem at large.
Conclusion
Roman Elizarov’s introduction to Kotlin coroutines at KotlinConf 2017 provided a compelling vision for asynchronous programming. By combining suspending functions, coroutine builders, and seamless Java interoperability, coroutines address the challenges of modern concurrency with elegance and efficiency. The methodology’s focus on simplicity and scalability empowers developers to create robust, high-performance applications. As Kotlin continues to evolve, coroutines remain a cornerstone of its innovation, offering a transformative approach to handling concurrent tasks and reinforcing Kotlin’s position as a leading programming language.