Posts Tagged ‘Multiplatform’
[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:
[KotlinConf2018] Performant Multiplatform Serialization in Kotlin: Eric Cochran’s Approach to Code Sharing
Lecturer
Eric Cochran is an Android developer at Pinterest, focusing on performance across the app stack. He contributes to open-source projects, notably the Moshi JSON library. Relevant links: Pinterest Engineering Blog (publications); LinkedIn Profile (professional page).
Abstract
This article analyzes Eric Cochran’s exploration of Kotlin Serialization for multiplatform projects, emphasizing its role in enhancing code reuse across platforms. Set in the context of Pinterest’s performance-driven Android development, it examines methodologies for integrating serialization with data formats and frameworks. The analysis highlights innovations in type safety and performance, with implications for cross-platform scalability and library evolution.
Introduction and Context
Eric Cochran presented at KotlinConf 2018, focusing on Kotlin Serialization’s potential to unify code in multiplatform environments. As an Android developer at Pinterest, Cochran’s work on serialization formats like Moshi informed his advocacy for Kotlin’s experimental library. The context is the growing need for shared logic in apps targeting JVM, JS, and Native, where serialization ensures seamless data handling across diverse runtimes.
Methodological Approaches to Serialization
Cochran outlined Kotlin Serialization’s setup: Annotate data classes with @Serializable to generate compile-time adapters, supporting JSON, Protobuf, and CBOR. Integration with frameworks like OkHttp or Ktor involves custom serializers for complex types. He demonstrated parsing dynamic JSON structures, emphasizing compile-time safety over Moshi’s runtime reflection. Performance optimizations included minimizing allocations and leveraging inline classes. Cochran compared Moshi’s factory-based API, noting its JVM-centric limitations versus Kotlin Serialization’s multiplatform readiness.
Analysis of Innovations and Features
Kotlin Serialization innovates with compile-time code generation, avoiding reflection’s overhead, unlike Moshi’s Java type reliance. It supports multiple formats, enhancing flexibility compared to JSON-centric libraries. Inline classes reduce boxing, boosting performance. Limitations include poor dynamic type handling and manual serializer implementation for custom cases. Compared to Moshi, it offers broader platform support but lacks mature metadata APIs.
Implications and Consequences
The library implies greater code sharing in multiplatform apps, reducing duplication and maintenance. Its performance focus suits high-throughput systems like Pinterest’s. Consequences include a shift toward compile-time solutions, though experimental status requires caution. Future integration with Okio’s multiplatform efforts could resolve reflection issues, broadening adoption.
Conclusion
Cochran’s insights position Kotlin Serialization as a cornerstone for multiplatform data handling, offering a performant, type-safe alternative that promises to reshape cross-platform development.
Links
- Lecture video: https://www.youtube.com/watch?v=p8Wt_atMA50
- Lecturer’s X/Twitter: @ericcochran
- Lecturer’s LinkedIn: Eric Cochran
- Organization’s X/Twitter: @PinterestEng
- Organization’s LinkedIn: Pinterest
[KotlinConf2018] Reflections on Kotlin’s Future: Insights from the KotlinConf 2018 Closing Panel
Lecturers
The panel featured JetBrains and community experts, including Kotlin developers and contributors like Jake Wharton and Venkat Subramaniam. Relevant links: JetBrains Blog (publications); Jake Wharton’s LinkedIn; Venkat Subramaniam’s LinkedIn (professional pages).
Abstract
This article synthesizes the KotlinConf 2018 Closing Panel’s discussions on Kotlin’s roadmap, features, and community growth. Contextualized in Kotlin’s rapid adoption, it examines questions on version 1.3, multiplatform, and concurrency models. The analysis highlights innovations like coroutines, with implications for accessibility, tooling, and future development.
Introduction and Context
The KotlinConf 2018 Closing Panel convened experts to reflect on Kotlin’s trajectory post-version 1.2. Topics ranged from release timelines to Kotlin/Native’s concurrency model and beginner accessibility. Set against Kotlin’s appeal to Java developers and its expanding multiplatform scope, the panel addressed community concerns and future directions, emphasizing JetBrains’ commitment to a robust ecosystem.
Methodological Approaches to Panel Discussion
Panelists addressed audience queries systematically. On version 1.3, they outlined stabilization goals, followed by post-1.3 focus on multiplatform libraries. Kotlin/Native’s distinct memory model was justified for safety, contrasting JVM threads. For beginners, they recommended community resources like Kotlin Slack. Coroutines were compared to RxJava, favoring simplicity for sequential tasks. Dokka improvements and GPU programming were acknowledged as future explorations.
Analysis of Innovations and Features
Kotlin 1.3 introduced stable coroutines, enhancing asynchronous programming versus RxJava’s complexity. Kotlin/Native’s concurrency model avoids shared mutable state, unlike iOS or JVM, ensuring safety but requiring adaptation. Multiplatform libraries promise code reuse, though Angular integration remains unexplored. The panel emphasized restraint in using Kotlin’s vast features to maintain readability, addressing its steep learning curve.
Implications and Consequences
The panel’s insights imply Kotlin’s evolution toward a versatile, beginner-friendly language. Coroutines simplify concurrency, but Native’s model may slow adoption. Enhanced tooling like Dokka and potential GPU support could broaden applications. Consequences include a growing community, though developers must balance feature richness with clarity to avoid complexity.
Conclusion
The KotlinConf 2018 Closing Panel illuminated Kotlin’s path as a multiplatform powerhouse, balancing innovation with accessibility, poised for continued growth with community feedback shaping its future.
Links
- Lecture video: https://www.youtube.com/watch?v=heqjfkS4z2I
- Lecturers’ X/Twitter: @JakeWharton; @venkat_s
- Lecturers’ LinkedIn: Jake Wharton; Venkat Subramaniam
- Organization’s X/Twitter: @JetBrains
- Organization’s LinkedIn: JetBrains
[KotlinConf2018] Architecting iOS with Kotlin Multiplatform: Kevin Galligan’s Vision for Mobile Convergence
Lecturer
Kevin Galligan is president of Touchlab, a mobile development firm. He organizes Droidcon NYC and the New York Android meetup, focusing on platform convergence. Relevant links: Touchlab Blog (publications); LinkedIn Profile (professional page).
Abstract
This article traces Kevin Galligan’s overview of Kotlin Multiplatform for Android and iOS. Set in the rise of multiplatform libraries, it examines shared architecture patterns, inspired by Google’s J2ObjC. The analysis highlights methodologies for repositories and concurrency, with implications for cross-platform consistency and library ecosystems.
Introduction and Context
Kevin Galligan addressed KotlinConf 2018, reflecting on 2016’s J2ObjC experiments. Kotlin Multiplatform, enabling shared Android-iOS logic, was poised for growth in 2018-2019. Galligan reviewed libraries, gaps, and resources, set against Touchlab’s mobile expertise and community engagement.
Methodological Approaches
Galligan proposed a shared repository pattern, using expect/actual for platform-specific database access. Concurrency used frozen objects for thread safety, with Android bypassing freezing. Libraries like SQLDelight and Ktor were highlighted, with coroutines noted as immature for Native.
Analysis of Innovations and Features
Multiplatform innovates code reuse, reducing duplication. Expect/actual abstracts platform differences. Compared to J2ObjC, Kotlin offers native compilation. Limitations include coroutine readiness and freezing complexity.
Implications and Consequences
Galligan’s vision implies unified mobile architectures, streamlining development. It fosters a growing library ecosystem.
Conclusion
Galligan’s insights herald Kotlin Multiplatform’s role in mobile convergence, urging library development.
Links
- Lecture video: https://www.youtube.com/watch?v=Dul17VSiejo
- Lecturer’s X/Twitter: @kevingalligan
- Lecturer’s LinkedIn: Kevin Galligan
- Organization’s X/Twitter: @touchlab
- Organization’s LinkedIn: Touchlab
[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] Opening Keynote
Lecturer
The Opening Keynote of KotlinConf 2017 features Maxim Shafirov, Andrey Breslav, Dmitry Jemerov, and Stephanie Cuthbertson. Maxim Shafirov, CEO of JetBrains, has led the company’s efforts in developing innovative developer tools, including IntelliJ IDEA and Kotlin. Andrey Breslav, Kotlin’s lead designer, brings a deep understanding of language design, focusing on pragmatic solutions for JVM developers. Dmitry Jemerov, a senior developer at JetBrains, contributes technical expertise to Kotlin’s development. Stephanie Cuthbertson, involved with Android’s adoption of Kotlin, offers insights into its mobile ecosystem impact. Their collective leadership has driven Kotlin’s growth as a modern programming language.
Abstract
The Opening Keynote of KotlinConf 2017, delivered in San Francisco from November 1–3, 2017, set the tone for the inaugural Kotlin conference. This article examines the keynote’s exploration of Kotlin’s rapid rise, its strategic vision, and its impact on the developer community. Led by JetBrains’ leadership, the keynote highlighted Kotlin’s adoption in Android, its multiplatform ambitions, and the collaborative efforts driving its ecosystem. The analysis delves into the context of Kotlin’s emergence, the technical and community-driven advancements presented, and the implications for its future in software development.
Context of Kotlin’s Emergence
KotlinConf 2017 marked a significant milestone as the first conference dedicated to Kotlin, a language developed by JetBrains to enhance Java’s capabilities while ensuring seamless JVM interoperability. Held in San Francisco, the event attracted 1,200 attendees and sold out, reflecting Kotlin’s growing popularity. The keynote, led by Maxim Shafirov, emphasized the language’s recent endorsement by Google as a first-class language for Android development, a pivotal moment that accelerated its adoption. With 150 talk submissions from 110 speakers, the conference required an additional track, underscoring the community’s enthusiasm and the language’s broad appeal.
The keynote contextualized Kotlin’s rise within the evolving landscape of software development, where developers sought modern, concise languages to address Java’s verbosity and complexity. Maxim and Andrey highlighted Kotlin’s design philosophy, focusing on readability, type safety, and ease of adoption. The event’s organization, supported by Trifork and a program committee, ensured a diverse range of topics, from Android development to server-side applications, reflecting Kotlin’s versatility and the community’s collaborative spirit.
Technical Advancements and Multiplatform Vision
Andrey Breslav’s segment of the keynote outlined Kotlin’s technical strengths and future directions, particularly its multiplatform capabilities. Kotlin’s ability to simplify functional programming and reduce boilerplate code was a key focus, with the compiler handling complex type inference to enhance developer productivity. The keynote introduced plans for common native libraries, enabling shared code for I/O, networking, and serialization across platforms like iOS and Android. This multiplatform vision aimed to unify development workflows, reducing fragmentation and enabling developers to write platform-agnostic code.
The keynote also addressed Kotlin’s experimental features, such as coroutines, which were in active development. Andrey emphasized backward compatibility, ensuring that even experimental features would remain stable in production environments. This commitment to reliability, coupled with tools to facilitate migration to finalized designs, reassured developers of Kotlin’s suitability for enterprise applications. The technical advancements presented underscored Kotlin’s potential to bridge diverse development ecosystems, from mobile to native platforms.
Community Engagement and Ecosystem Growth
The keynote highlighted the pivotal role of the Kotlin community in driving the language’s success. Maxim and Dmitry acknowledged the contributions of partners like Gradle and Spring, which enhanced Kotlin’s interoperability with existing tools. The conference provided platforms for engagement, including office hours for bug reporting and voting mechanisms to gather feedback. These initiatives empowered developers to influence Kotlin’s evolution, fostering a sense of ownership within the community.
The keynote also celebrated the social aspects of KotlinConf, with events like the keynote party featuring live music and networking opportunities. These gatherings strengthened community ties, encouraging collaboration among developers, startups, and Fortune 500 companies adopting Kotlin. The emphasis on community-driven growth highlighted Kotlin’s role as a collaborative project, with JetBrains actively seeking feedback to refine features and address pain points, ensuring the language’s relevance and adaptability.
Implications for Software Development
KotlinConf 2017’s keynote underscored Kotlin’s transformative potential in software development. Its adoption by 17% of Android projects at the time signaled its growing influence in mobile development, where it simplified tasks like UI design and asynchronous programming. The multiplatform vision promised to extend these benefits to iOS and other platforms, reducing development complexity and fostering code reuse. For enterprises, Kotlin’s production-readiness and support for high-quality codebases offered a compelling alternative to Java.
The keynote’s focus on community engagement set a precedent for inclusive development, encouraging contributions from diverse stakeholders. The promise of recorded sessions ensured global accessibility, amplifying the conference’s impact. For the industry, KotlinConf 2017 highlighted the shift toward modern languages that prioritize developer experience, positioning Kotlin as a leader in this transition. The keynote’s strategic vision laid the groundwork for Kotlin’s continued growth, influencing both individual developers and large-scale projects.
Conclusion
The Opening Keynote of KotlinConf 2017 encapsulated the excitement and ambition surrounding Kotlin’s rise as a modern programming language. By highlighting its technical strengths, multiplatform potential, and vibrant community, Maxim, Andrey, Dmitry, and Stephanie positioned Kotlin as a transformative force in software development. The keynote’s emphasis on collaboration, innovation, and developer empowerment underscored Kotlin’s role in shaping the future of programming. As JetBrains continues to evolve Kotlin, the insights from KotlinConf 2017 remain a cornerstone of its journey, inspiring developers to embrace its capabilities.