Archive for the ‘en-US’ Category
[KotlinConf2019] Sharing Is Caring: Kotlin Multiplatform for Android Developers with Britt Barak
The vision of writing code once and running it across multiple platforms is a long-held dream in software development. Britt Barak, an experienced Android and Kotlin developer, and Google Developer Expert, brought this vision closer to reality for Android developers at KotlinConf 2019. Her talk, “Sharing Is Caring – Kotlin Multiplatform for Android Developers,” explored the exciting, albeit then-experimental, capabilities of Kotlin Multiplatform (KMP) and how it could revolutionize the way Android developers collaborate with teams working on iOS, backend, or JavaScript projects.
Britt Barak emphasized the common scenario where Android developers work alongside backend services or with iOS and JavaScript teams developing similar functionalities. The ability to share Kotlin code across these platforms promised significant savings in implementation time, testing effort, and overall development efficiency. Her session focused on creating a full-stack Kotlin project, demonstrating how to share code between an Android app and a backend Kotlin component, ultimately leading to more efficient and robust applications.
The Promise of Kotlin Multiplatform
Kotlin Multiplatform (KMP) allows developers to write common logic in Kotlin and compile it for various targets, including JVM (for Android and backend), JavaScript (for web frontends), and Native (for iOS and other native applications). Britt Barak highlighted the power of this approach: sharing business logic, data models, and even presentation logic (in some architectures) can drastically reduce redundancy and inconsistencies between different platform implementations.
The core idea is to isolate platform-agnostic code in a “common” module. This module can then be consumed by platform-specific modules (e.g., Android, iOS, JVM backend) which implement the platform-dependent parts, such as UI or interactions with platform-specific APIs. This separation allows teams to leverage Kotlin’s strengths across their entire stack while still catering to the unique requirements of each platform. Britt’s presentation aimed to show Android developers how they could take the lead in initiating such code-sharing efforts, benefiting not only their own workflow but also that of their teammates on other platforms.
Practical Implementation and Considerations
Britt Barak’s session was hands-on, guiding attendees through the process of setting up and building a Kotlin Multiplatform project. She covered key KMP concepts such as:
* Common Modules: Where shared Kotlin code resides, free of platform-specific dependencies.
* Platform-Specific Modules: Modules targeting specific platforms (Android, JVM, JS, Native) that can depend on common modules and implement platform-specific functionalities using expect/actual declarations.
* expect and actual Keywords: A powerful mechanism in KMP that allows common code to declare an expected functionality (expect), which platform-specific modules then provide concrete implementations for (actual). This is crucial for accessing platform-specific APIs (like device sensors, file systems, or UI elements) from shared code.
She demonstrated how to structure a project to share code effectively between an Android application and a backend Kotlin component, showcasing the potential for building more cohesive and maintainable full-stack applications. This practical approach would have involved setting up the build system (Gradle), defining dependencies, and writing shared business logic that could be consumed by both the Android client and the server. The goal was to illustrate how to build “more efficient and robust applications” through strategic code sharing.
Navigating the Experimental Landscape and Community Support
At the time of KotlinConf 2019, Kotlin Multiplatform was still an experimental feature. Britt Barak acknowledged this, preparing attendees for a landscape where documentation might sometimes be a bit dated, and tooling was rapidly evolving. However, she also pointed to the strong and growing community support as a significant asset. The official Kotlin Slack and various online forums were highlighted as valuable resources for troubleshooting and learning from others’ experiences.
She shared the sentiment that KMP was gaining popularity in a positive way, with many developers interested and actively contributing to its growth. This collaborative environment was seen as a good sign for the future development and stabilization of KMP. Britt encouraged developers to embrace this journey, start experimenting with multiplatform projects, and contribute to the community by sharing their own code and experiences. Her message was clear: despite its experimental nature, Kotlin Multiplatform offered a powerful and awesome way to achieve cross-platform code sharing, and it was a “really good time to jump on on the ride”.
Links:
[DotCSS2018] DotCSS 2018: Mandy Michael – Variable Fonts Ushering in Typographic Horizons
Mandy Michael, an innovative front-end developer renowned for her CSS artistry, illuminated the transformative promise of variable fonts at DotCSS 2018. As a self-proclaimed tinkerer rather than a traditional designer, she demonstrates how these fonts transcend mere efficiency, unlocking realms of adaptive, interactive typography that harmonizes with the web’s fluidity. Michael’s discourse blends practical gains with visionary applications, positioning variable fonts as harbingers of a more nuanced digital vernacular.
Streamlining Performance While Amplifying Flexibility
Michael demystifies variable fonts as singular files encapsulating myriad styles, where traditional suites demand separate downloads for each weight or variant. Forged by designers via interpolable axes—spanning weight, width, or slant—these fonts grant granular access to intermediary values, from 100 to 900 in 1-unit increments. This continuum facilitates seamless animations, unmarred by the jarring leaps of static counterparts.
Browser compatibility, she assures, is robust across majors, with macOS High Sierra as the sole caveat for Firefox users. Performance perks shine in comparisons: Adobe’s Source Sans variable edition clocks in at 394 KB for exhaustive coverage, dwarfing the 924 KB aggregate of its static kin—even pruned selections. A lone network call supplants cascades of requests, synergizing with HTTP/2 for swifter loads. Yet, beyond bandwidth thrift, variable fonts liberate creativity; their slimmer profiles embolden bolder experimentation without fiscal remorse.
Michael illustrates with bespoke text effects—slimy oozes via Chi by Fontself or vanishing shadows in Dec—where axes morph glyphs in real-time, rendering editable, screen-reader-friendly prose that supplants cumbersome images or canvases.
Adaptive Typography for Inclusive, Dynamic Experiences
The true alchemy of variable fonts, per Michael, resides in environmental responsiveness. Axes like optical size or grade adjust legibility across devices—from wristworn smartwatches to expansive projectors—ensuring hierarchy endures. Scroll-triggered swells in Chi or proximity-based sizing via Sensor API exemplify this; fonts now converse with context, elevating readability in dim alcoves or glaring outdoors.
Emerging CSS media queries, such as prefers-color-scheme: dark, further this dialogue. Michael’s demo toggles oozing text in shadowed modes, blending transitions for intuitive shifts. Audio-responsive variants, attuned to vocal inflections, hint at conversational interfaces for voice assistants, visually encoding tone sans verbosity.
Accessibility amplifies: interpolated contrasts mitigate low-vision strains, while dynamic weights enhance scannability. Michael envisions fonts as APIs, manipulable by JavaScript for user-centric tweaks—be it luminance detection or gestural inputs. Though nascent, these facets dissolve erstwhile constraints, where performance once curbed flair. Now, content’s essence—its rhythm, intent—guides form, fusing print’s poise with web’s interactivity. As Michael avows, this epoch invites developers to sculpt purposeful, performant narratives, unhindered by yesteryear’s shackles.
Links:
[VivaTech 2019] What’s Your Next Bet
A 22-minute fireside chat at VivaTech 2019, moderated by Harry Stebbings, Founder of Stride VC and The Twenty Minute VC, featured Pär-Jörgen Pärson, General Partner at Northzone, available on YouTube. Connected via LinkedIn and LinkedIn, Harry and Pär-Jörgen discussed VC decision-making. This 1000–1200-word post, for VCs, startup founders, and tech enthusiasts, explores lessons from market cycles and Spotify’s success.
Navigating Market Cycles
Pär-Jörgen, having weathered the 2001–2003 dot-com crash (95% value loss) and 2008–2009 cleantech wipeout, emphasized resilience. These cycles taught him to prioritize sustainable growth over hype-driven valuations. Europe’s VC ecosystem, now complete with angel-to-growth financing, avoids early exits (e.g., $60 million sales once deemed successes). In 2018, six of eight global IPOs were European, reflecting a maturing market. Pär-Jörgen advises founders to choose investors wisely, ensuring alignment for tough times, as market booms tempt over-valuation risks.
Aligning Interests in VC
Pricing, Pär-Jörgen argued, hinges on aligned interests, often undermined by high valuations with anti-dilution clauses. These misalignments strain founder-VC partnerships during downturns. He recommends founders stress-test investor alignment pre-investment, prioritizing resilience over maximizing valuation. Northzone avoids consensus-driven decisions, relying on individual conviction to back founders like Spotify’s Daniel Ek. This approach, coupled with transparent, meritocratic fund structures, has driven Northzone’s success, including three multi-billion-dollar exits, despite long-term performance uncertainty in VC.
Lessons from Spotify’s Growth
Pär-Jörgen’s early bet on Spotify, led by Daniel Ek, hinged on Daniel’s vision and ability to oscillate between granular details (e.g., instant playback UX) and strategic abstraction. Initially reluctant to lead, Daniel’s paranoia and customer focus—balancing creators, consumers, and labels—built a two-sided marketplace over a decade. Spotify’s near-death moments, resolved in hours, underscore the value of experienced VCs who remain calm. Pär-Jörgen’s latest unannounced investment in group travel reflects his knack for spotting young, serial founders with high-growth potential.
[DotCSS2018] DotCSS 2018: Aga Naplocha – Igniting Innovation Through Unconventional CSS
Aga Naplocha, a dynamic UX consultant and co-founder of The Awwwesomes, captivated the audience at DotCSS 2018 with her exploration of CSS as a canvas for audacious creativity. Frustrated by the monotony of grid-locked interfaces, she advocates for leveraging underutilized CSS features to infuse web projects with vitality and originality. Naplocha’s session serves as both a lament for stale aesthetics and a blueprint for reinvention, urging designers and developers alike to draw from diverse inspirations.
Rediscovering Inspiration Beyond Digital Echo Chambers
Naplocha opens with a personal anecdote of creative paralysis, where a routine assignment unearthed a profound dissatisfaction with ubiquitous layouts—endless columns and rectangles that stifle imagination. This epiphany, amplified by a satirical critique from 2015 decrying web design’s blandness, prompted her to unplug from online trend mills like Dribbble and Behance. Instead, she turned to analog sources: vintage magazines borrowed from a friend, whose eclectic collages and asymmetrical compositions rekindled her zeal.
This detour into print media revealed parallels to the web’s untapped potential, where content could dictate form rather than conform to it. Transitioning back online, Naplocha encountered brutalist websites—raw, rule-defying sites that prioritize uniqueness over polish. Exemplars like Bloomberg’s bold, GIF-laden articles demonstrate how even corporate entities can embrace eccentricity, blending vibrant hues and retro flair to elevate mundane narratives. She posits that such nonconformity, though occasionally UX-taxing, injects essential weirdness into the digital tapestry, challenging the hegemony of sanitized grids.
Furthermore, Naplocha emphasizes simplicity as the gateway to collaboration. By distilling complex visions into elemental CSS—eschewing heavy libraries—she bridges the chasm between novice designers and seasoned coders, democratizing innovation.
Harnessing CSS for Expressive, Nonconformist Layouts
Delving into technical territory, Naplocha unveils CSS clipping and masking as scissors for digital paper, enabling precise visibility control without raster dependencies. Clipping carves crisp, vector-based boundaries via paths or polygons, ideal for geometric precision, while masking modulates transparency pixel-by-pixel for gradient fades and layered illusions. She illustrates with a fixed-position header that unveils text through a scrolling mask, creating depth akin to overlapping transparencies—achievable with minimal code, yet profoundly impactful for prototyping.
Distinguishing the duo, Naplocha notes clipping’s efficiency for sharp edges versus masking’s computational heft for nuanced opacity. She extends this to shape-outside, liberating text from rectangular tyranny by wrapping around custom contours, such as circular initials or polygonal SVGs. A caveat: floated elements require explicit dimensions for coordinate anchoring, and complementary clipping ensures silhouettes align seamlessly.
Naplocha ties these techniques to broader movements, like SVG filters for glitch artistry or variable fonts for fluid expressiveness. Her finale spotlights a pure-CSS perspective skew on architectural copy, crediting James Bosworth’s CodePen, and rallies for side projects as low-stakes proving grounds. From the Stedelijk Museum’s stark brutalism to a Parisian brutalist basketball court, she curates real-world muses, echoing Henri Matisse’s creed that “creativity takes courage.” In her view, CSS’s arsenal empowers us to architect wilder webs, fostering environments where experimentation trumps convention.
Links:
[SpringIO2019] Boot Loot: Level Up Your Spring Game Like the Pros
Mastering Spring Boot Customization and Configuration
In his Spring I/O 2019 presentation, Joris Kuipers dives deep into the advanced capabilities of Spring Boot, extending beyond its familiar features like autoconfiguration and actuator support. He explores how developers can truly “level up their game” by leveraging custom autoconfiguration and type-safe configuration classes. Kuipers provides practical insights into customizing RestTemplates while ensuring that instrumentation from Boot and Cloud remains intact. The talk also covers strategies for reducing the cardinality of Boot-provided metrics and defining custom ones, as well as handling the migration of older Spring applications to Boot, including considerations for external directories on the classpath.
Throughout this fast-paced session, Joris Kuipers shares a wealth of tips, tricks, and best practices gleaned from his extensive experience with Spring Boot and Cloud in diverse production environments. Whether you’re new to Spring Boot or a seasoned user, this presentation offers hands-on techniques that can be immediately applied to your projects. Key topics include:
- Custom Autoconfiguration and Type-Safe Configuration: Moving beyond basic configurations to create robust and maintainable applications.
RestTemplateCustomization: Ensuring proper instrumentation and integration within Spring Boot and Cloud ecosystems.- Advanced Metrics Management: Reducing cardinality and defining custom metrics for better observability.
- Migrating Legacy Spring Applications: Practical approaches to integrate older applications with the Spring Boot environment.
- Error Handling and Validation: Best practices for managing default error pages and implementing effective bean validation.
Joris Kuipers has been building enterprise Java applications for 25 years and has previously served as a trainer and consultant for SpringSource, continuing to teach Spring training for the Trifork Academy.
Links
[KotlinConf2019] Putting Down the Golden Hammer: Pragmatic Kotlin with Huyen Tue Dao
Learning a new programming language, especially one as rich and expressive as Kotlin, often comes with the temptation to use every new feature and syntactic sugar—the “golden hammer”—everywhere. Huyen Tue Dao, a prominent Android developer then known for her work at Trello and her insightful contributions to the Kotlin community, addressed this phenomenon at KotlinConf 2019. Her talk, “Putting Down the Golden Hammer,” shared valuable lessons learned from nearly three years of full-time Kotlin development, emphasizing the importance of pragmatism, readability, and maintainability over merely clever code. Huyen’s insights can often be found on her blog, randomlytyping.com.
Huyen began by acknowledging the allure of Kotlin’s advanced features. While these constructs can be powerful and lead to concise code, she cautioned that their overuse or misuse can sometimes negatively impact code clarity and long-term maintainability. The journey of a developer learning Kotlin often involves an initial phase of enthusiasm for these new tools, followed by a more mature understanding of when and how to apply them judiciously.
The Evolution of a Kotlin Developer’s Approach
Huyen Tue Dao shared her personal evolution in approaching various Kotlin features. She reflected on how code written early in her Kotlin journey might look different from her current practices, shaped by experience, trial, and error. This evolution is natural and signifies a deeper understanding of the language’s nuances and the trade-offs involved in different coding styles.
One key area she touched upon (common in such discussions) is the balance between conciseness and readability. Kotlin allows for very compact code, but sometimes a slightly more verbose approach can be easier for others (and one’s future self) to understand and maintain. She stressed that while Kotlin’s features are designed to make developers more productive, this productivity should not come at the expense of creating code that is difficult to reason about or debug. The goal should be to write “better Kotlin,” which implies code that is not only functionally correct and efficient but also clear, pragmatic, and maintainable.
Pragmatism in Feature Usage: Scope Functions, Nullability, and More
Huyen Tue Dao delved into specific Kotlin features and utilities, discussing both their “fun and shiny” aspects and how they can be overused or even abused. For instance, scope functions (let, run, with, apply, also) are powerful tools for executing a block of code within the context of an object. However, excessive nesting or unclear usage can lead to code that is hard to follow. Huyen advocated for intentionality: choosing the right scope function for the task and ensuring its use enhances clarity rather than obscuring it.
Null safety is another cornerstone of Kotlin, designed to prevent NullPointerExceptions. Huyen discussed the importance of being deliberate about nullability. While Kotlin’s type system helps manage nulls effectively, developers still need to make conscious decisions about whether a type should be nullable and handle nullable types appropriately, without resorting to excessive safe calls (?.) or non-null asserted calls (!!) that might hide underlying design issues. She emphasized being clear about why something is nullable and documenting such decisions when necessary, especially when assumptions about nullability change or when interacting with APIs where null safety guarantees might be different.
Towards Readable and Maintainable Kotlin
Ultimately, Huyen Tue Dao’s message was a call for mindful Kotlin development. She encouraged the audience to revel in Kotlin’s wonderful syntax and features but to always keep readability, maintainability, and pragmatism at the forefront. Understanding the underlying implementation of certain features can also be crucial to avoid potential performance issues.
The aim is not to write code that merely feels “sexy and Kotlin-y” but to craft solutions that are robust, easy for a team to work with, and stand the test of time. Recognizing the potential pitfalls of overusing certain constructs and consciously choosing simpler, clearer alternatives when appropriate leads to what Huyen termed “even better and even more fun Kotlin”. Her talk served as a valuable reminder that true mastery of a language lies not just in knowing its features, but in knowing when and how to use them wisely.
Links:
[DevoxxFR 2019] Micronaut: The Ultra-Light JVM Framework of the Future
At Devoxx France 2019, Olivier Revial, a developer at Stackeo in Toulouse, presented Micronaut: The Ultra-Light JVM Framework of the Future. This session introduced Micronaut, a modern JVM framework designed for microservices and serverless applications, offering sub-second startup times and a 10MB memory footprint. Through slides and demos, Revial showcased Micronaut’s cloud-native approach and its potential to redefine JVM development.
Limitations of Existing Frameworks
Revial began by contrasting Micronaut with established frameworks like Spring Boot and Grails. While Spring Boot simplifies development with auto-configuration and standalone applications, it suffers from runtime dependency injection and reflection, leading to slow startup times (20–25 seconds) and high memory usage. As codebases grow, these issues worsen, complicating testing and deployment, especially in serverless environments where rapid startup is critical. Frameworks like Spring create a barrier between unit and integration tests, as long-running servers are often relegated to separate CI processes.
Micronaut addresses these pain points by eliminating reflection and using Ahead-of-Time (AOT) compilation, performing dependency injection and configuration at build time. This reduces startup times and memory usage, making it ideal for containerized and serverless deployments.
Micronaut’s Innovative Approach
Micronaut, created by Grails’ founder Graeme Rocher and Spring contributors, builds on the strengths of existing frameworks—dependency injectiaon, auto-configuration, service discovery, and HTTP client/server simplicity—while introducing innovations. It supports Java, Kotlin, and Groovy, using annotation processors and AST transformations for AOT compilation. This eliminates runtime overhead, enabling sub-second startups and minimal memory footprints.
Micronaut is cloud-native, with built-in support for MongoDB, Kafka, JDBC, and providers like Kubernetes and AWS. It embraces reactive programming via Reactor, supports GraalVM for native compilation, and simplifies testing by allowing integration tests to run alongside unit tests. Security features, including JWT and basic authentication, and metrics for Prometheus, enhance its enterprise readiness. Despite its youth (version 1.0 released in 2018), Micronaut’s ecosystem is rapidly growing.
Demonstration
Revial’s demo showcased Micronaut’s capabilities. He used the Micronaut CLI to create a “hello world” application in Kotlin, adding a controller with REST endpoints, one returning a reactive Flowable. The application started in 1–2 seconds locally (6 seconds in the demo due to environment differences) and handled HTTP requests efficiently. A second demo featured a Twitter crawler storing tweets in MongoDB using a reactive driver. It demonstrated dependency injection, validation, scheduled tasks, and security (basic authentication with role-based access). A GraalVM-compiled version started in 20 milliseconds, with a 70MB Docker image compared to 160MB for a JVM-based image, highlighting Micronaut’s efficiency for serverless use cases.
Links:
Hashtags: #Micronaut #Microservices #DevoxxFR2019 #OlivierRevial #JVMFramework #CloudNative
[VivaTech 2019] Funding and Growing Tomorrow’s Unicorns
A 25-minute panel at VivaTech 2019, moderated by Emmanuelle Duten of Les Echos/Capital Finance, featured Philippe Botteri, Partner at Accel, Virginie Morgon, CEO of Eurazeo, and David Thevenon, Partner at SoftBank Investment Advisers, available on YouTube. Connected via LinkedIn, LinkedIn, and LinkedIn, they discussed Europe’s unicorn boom. This 1000–1200-word post, for investors, entrepreneurs, and policymakers, explores the drivers of unicorn growth.
Europe’s Unicorn Momentum
Philippe highlighted Europe’s unicorn surge, with 17–18 created in 2018, fueled by $23 billion in investments. Accel’s $575 million fund targets 22 European cities, a shift from London-Tel Aviv dominance 15 years ago. Virginie noted that two-thirds of 2018’s new unicorns were European, driven by ambitious founders and growing growth capital. David emphasized Europe’s robust ecosystem, with SoftBank’s investments in Germany and beyond, signaling that the region now rivals global hubs, supported by professional early-stage and growth investors.
Characteristics of Unicorn Founders
Virginie stressed that unicorn founders, like Farfetch’s José Neves, exhibit exceptional execution and ambition, mastering complex platforms (e.g., logistics, delivery). Philippe cited Doctolib’s Stan, whose passion for transforming European healthcare inspired Accel’s Series A investment, now a unicorn. David pointed to OYO’s Ritesh Agarwal, scaling from 13 to 200,000 hotel rooms since 2015, driven by urgency and global vision. These founders combine strategic thinking, platform-building (e.g., Grab’s shift to financial services), and relentless focus, distinguishing them in competitive markets.
Supporting Unicorn Growth
Beyond capital, VCs provide operational support. Philippe’s Accel leverages its global network (Silicon Valley, London, India) to help software startups relocate to the U.S., hiring top sales talent. Virginie’s Eurazeo offers strategic guidance, from commercial partnerships to U.S. expansion, as seen with ContentSquare. David’s SoftBank provides long-term capital (12-year funds) and market access (China, Latin America), fostering peace of mind for innovation. This hands-on partnership—$100 million on average to reach unicorn status—ensures rapid scaling, even if profitability lags behind growth.
[DotCSS2018] DotCSS 2018: Dan Cederholm – Reflections on Two Decades with CSS
Dan Cederholm, a pioneering figure in web design and founder of SimpleBits, reflected deeply on his journey with CSS during his presentation at DotCSS 2018. Drawing from over two decades of experience, he shared lessons that extend far beyond syntax and selectors, touching on resilience, community, and the ephemeral nature of digital creation. Cederholm’s candid recounting of triumphs and setbacks offers timeless wisdom for developers navigating the ever-evolving landscape of web technologies.
Embracing Bold Steps and Community Sharing
Cederholm’s narrative begins in the early 2000s, a period marked by the shift from table-based layouts to CSS-driven designs. He vividly recalls the 2002 redesign of Wired News, a landmark project that propelled the industry forward by abandoning support for outdated browsers like Netscape 4. Inspired by Jeffrey Zeldman’s provocative article “To Hell with Bad Browsers,” Cederholm approached his then-employer, Fast Company magazine, with a proposal to follow suit. To his surprise, his forward-thinking boss greenlit the initiative, leading to a 2003 overhaul that, despite backlash from a shrinking cohort of legacy users, cemented Cederholm’s commitment to progressive standards.
This pivotal moment not only honed his technical skills but also ignited a passion for documentation and mentorship. While iterating on the Fast Company site, Cederholm chronicled his process on a rudimentary blog, despite lacking formal writing credentials. This habit of sharing raw, in-progress insights—complete with the era’s notorious browser bugs—fostered unexpected connections. Invitations to speak and collaborate followed, transforming personal experimentation into professional opportunities. Cederholm underscores a key takeaway: vulnerability in sharing imperfect knowledge builds bridges, turning solitary coding sessions into collaborative dialogues that propel collective advancement.
Moreover, these early risks taught him the value of persistence amid imperfection. The browser wars demanded ingenious workarounds, yet each hack refined his problem-solving acumen. Today, as frameworks proliferate, Cederholm urges newcomers to view challenges not as barriers but as catalysts for growth, reminding us that mastery emerges from repeated trial and adaptation.
Navigating Evolution and Impermanence
As the web matured, so did Cederholm’s toolkit, evolving from vanilla CSS to preprocessors like Sass. Initially resistant—citing concerns over code readability and the philosophy of keeping CSS accessible for novices—he eventually embraced Sass after a colleague’s pragmatic suggestion to simply rename files. This incremental adoption, starting with variables for vendor prefixes and nesting for media queries, revolutionized his responsive workflows. The experience with Sass, much like his initial foray into CSS, highlighted the pitfalls of premature dismissal; what begins as reluctance often blossoms into indispensable efficiency.
Cederholm also touches on broader philosophical shifts, such as his evolving stance on methodologies like Atomic CSS. Initially skeptical of utility class names, he came to appreciate their utility in rapid prototyping, especially within team environments. This openness stems from a core principle: prioritize tools that minimize code volume and maximize clarity. Yet, he tempers enthusiasm with caution, advocating for mindful integration rather than wholesale overhaul.
Ultimately, Cederholm’s reflections circle back to transience. In an industry where innovations cascade rapidly—rendering yesterday’s hacks obsolete—he finds solace in impermanence. Echoing the sentiment of his Adventure pin design, “Everything is stardust,” he posits that the pressure to master every novelty dissipates when viewed against the web’s fleeting canvas. This perspective liberates creators to experiment joyfully, unburdened by the fear of obsolescence. As he concludes, the true legacy of CSS lies not in enduring code but in the enduring habits of curiosity and camaraderie it instills.
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.