Jonathan Lalou's Blog

Archive for the ‘en-US’ Category

At ScalaDays Lausanne 2019, Nicolas Rinaudo, CTO of Besedo, delivered a candid and insightful talk on Scala best practices, drawing from his experience merging Node, Java, and Scala teams. Speaking at EPFL’s 10th anniversary conference, Nicolas shared pitfalls he wished he’d known as a beginner, from array comparisons to exceptions, offering practical solutions. His interactive approach—challenging the audience to spot code issues—drew laughter, applause, and questions on tools like Scalafix, making his session a highlight for developers seeking to write robust Scala code.

Array Comparisons and Type Annotations

Nicolas began with a deceptive array comparison using ==, which fails due to arrays’ reference equality on the JVM, unlike other Scala collections. Beginners from Java or JavaScript backgrounds often stumble here, expecting value equality. The fix, sameElements, ensures correct comparisons, while Scala 3’s immutable arrays behave sanely. Another common error is omitting type annotations on public methods. Without explicit types, the compiler may infer overly broad types like Some instead of Option, risking binary compatibility issues in libraries. Nicolas advised always annotating public members, noting Scala 3’s requirement for implicit members, though the core issue persists, emphasizing vigilance for maintainable code.

Sealed Traits and Case Classes

Enumerations in Scala, Nicolas warned, are treacherous, allowing non-exhaustive pattern matches that compile but crash at runtime. Sealed traits, with subtypes declared in the same file, enable the compiler to enforce exhaustive matching, preventing such failures. He recommended enabling fatal warnings to catch these issues. Similarly, non-final case classes can be extended, leading to unexpected equality behaviors, like two distinct objects comparing equal due to inherited methods. Making case classes final avoids this, though Scala’s default remains unchanged even in Scala 3. Nicolas also noted that sealed traits aren’t foolproof—subtypes can be extended unless final, a subtlety that surprises learners but is manageable with disciplined design.

Exceptions and Referential Transparency

Exceptions, common in Java, disrupt Scala’s referential transparency, where expressions should be replaceable with their values without altering behavior. Nicolas likened exceptions to goto statements, as their origin is untraceable, and Scala’s unchecked exceptions evade compile-time checks. For instance, parsing a string to an integer may throw a NumberFormatException, but most inputs fail, making it a common case unsuitable for exceptions. Instead, use Option for absent values, Either for errors with context, or Try for Java interop. These encode errors in return types, enhancing predictability. Scala 3 offers no changes here, so Nicolas’s advice remains critical for writing transparent, robust code.

Enforcing Best Practices

To prevent these pitfalls, Nicolas advocated rigorous code reviews, citing research showing reduced defects. Automated tools like WartRemover, Scalafix, Scapegoat, and Scalastyle detect issues during builds, though some, like WartRemover’s strict defaults, may need tuning. Migrating to Scala 3 addresses many problems, such as implicit conversions and enumeration ambiguities, with features like the enum keyword and explicit import rules. Nicolas invited the audience to share additional practices, pointing to his companion website for detailed articles. His acknowledgment of Scala contributors, especially for Scala 3 insights, underscored the community’s role in evolving best practices, making his talk a call to action for cleaner coding.

Links:

• Session Video
• Session Abstract
• Scalafix Repository
• WartRemover Repository
• Nicolas’s Best Practices Site

Hashtags: #ScalaDays2019 #Scala #BestPractices #FunctionalProgramming

At ScalaDays Lausanne 2019, Manohar Jonnalagedda and Jakob Odersky, researchers turned industry innovators, unveiled a Scala-powered approach to secure multi-party computation (MPC) at EPFL’s 10th anniversary conference. Their talk, moments before lunch, captivated attendees with a protocol to average salaries without revealing individual data, sparking curiosity about privacy-preserving applications. Manohar and Jakob, from Inpher, detailed a compiler transforming high-level code into secure, distributed computations, addressing real-world challenges like GDPR-compliant banking and satellite collision detection, earning applause and probing questions on security and scalability.

A Privacy-Preserving Protocol

Manohar opened with a relatable scenario: wanting to compare salaries with Jakob without disclosing personal figures. Their solution, a privacy-preserving protocol, lets three parties—Manohar, Jakob, and their CTO Dmitar—compute an average securely. Each generates three random numbers summing to zero, sharing them such that each party holds a unique view of partial sums. In Scala, this is modeled with a SecretValue type for private integers and a SharedNumber list, accessible only by the corresponding party. Each sums their shares, publishes the result, and the final sum reveals the average without exposing individual salaries. This protocol, using random shares, ensures no single party can deduce another’s data unless all communications are intercepted, balancing simplicity and security.

Secure Multi-Party Computation

Jakob explained MPC as a cryptographic subfield enabling joint function computation without revealing private inputs. The salary example used addition, but MPC supports multiplication via Beaver triplets, precomputed by a trusted dealer for efficiency. With addition and multiplication, MPC handles polynomials, enabling linear and logistic regression or exponential approximations via Taylor polynomials. Manohar highlighted Scala’s role in modeling these operations, with functions for element-wise addition and revealing sums. The protocol achieves information-theoretic security for integers, where masked values are indistinguishable, but floating-point numbers require computational security due to distribution challenges. This flexibility makes MPC suitable for complex computations, from machine learning to statistical analysis, all while preserving privacy.

Real-World Applications

MPC shines in domains where data sensitivity or legal constraints, like GDPR, restrict sharing. Manohar cited ING, a bank building credit-scoring models across European countries without moving user data across borders, complying with GDPR. Another compelling case involved satellite operators—American, Russian, or Chinese—secretly computing collision risks to avoid incidents like the 2009 Iridium-Cosmos crash, which threatened the International Space Station. Jakob emphasized that Inpher’s XOR platform, legally vetted by Baker McKenzie, ensures GDPR compliance by keeping data at its source. These use cases, from finance to defense, underscore MPC’s value in enabling secure collaboration, with Scala providing a robust, type-safe foundation for protocol implementation.

Building a Compiler for MPC

To scale MPC beyond simple embeddings, Manohar and Jakob’s team developed a compiler at Inpher, targeting a high-level language resembling Python or Scala for data scientists. This compiler transforms linear algebra-style code into low-level primitives for distributed execution across parties’ virtual machines, verified to prevent data leaks. It performs static analysis to optimize memory and communication, inferring masking parameters to minimize computational overhead. For example, multiplying masked floating-point numbers risks format explosion, so the compiler uses fixed-point representations and statistical bounds to maintain efficiency. The output, resembling assembly for MPC engines, manages memory allocation and propagates data dimensions. While currently MPC-focused, the compiler’s design could integrate other privacy techniques, offering a versatile platform for secure computation.

Links:

• Session Video
• Session Abstract
• Inpher XOR Platform
• SP DZ Protocol Reference

Hashtags: #ScalaDays2019 #Scala #Privacy #MPC

Hugues Tennier, a dedicated advocate for equitable digital interfaces, delivered a succinct yet potent guide at DotCSS 2018 on elevating site usability through foundational accessibility tenets. With a focus on subtle yet seismic adjustments, he empowers creators to craft environments where diverse users thrive, from those with visual impairments to casual browsers under duress. Tennier’s framework underscores that inclusivity is not an addendum but the bedrock of resonant design.

Enhancing Visibility and Scalability

Tennier commences with color contrast, a linchpin for low-vision individuals or those navigating bright externalities. He recommends ratios surpassing WCAG benchmarks, verifiable via Chrome DevTools’ color picker—where hues above a stark threshold signal inaccessibility. This vigilance ensures content pierces veils of glare or haze, democratizing comprehension.

Pivotally, he champions resizable text, countering the fallacy of pixel-bound rigidity. Relative units like em or rem scale harmoniously with user preferences, accommodating 200% zooms sans distortion. A “Buy Now” button exemplifies: pixelated padding contracts uncomfortably at magnification, whereas rem fonts paired with em margins expand proportionally, preserving tap targets and legibility. Heights, too, warrant caution; fixed values invite overflow, but fluid metrics foster seamless growth.

These maneuvers, Tennier asserts, transcend compliance—they cultivate empathy, envisioning interfaces that adapt to life’s variances rather than impose uniformity.

Structuring Semantics and Interaction Clarity

Semantic HTML forms the next pillar, streamlining navigation for screen reader devotees via logical heading hierarchies. Sequential H1 through H6 milestones guide users briskly, averting disorientation amid skipped strata.

Visible focus indicators reclaim agency for keyboard navigators, whose tab traversals demand luminous cues. Dismissing default outlines is permissible, Tennier concedes, provided substitutes—vibrant borders or glows—affirm position without aesthetic compromise.

Finally, discerning links from buttons averts interpretive pitfalls: anchors herald navigational leaps, intoned as such by assistive tech, while buttons signal actions like submissions, primed for Enter or Space invocations. Divs, bereft of innate semantics, falter in announcements, underscoring the peril of repurposing for interactivity.

Tennier encapsulates these as duty-bound refinements—contrast, scalability, semantics, focus, and apt elements—that transmute exclusionary hurdles into welcoming pathways. In weaving accessibility into the warp and weft of creation, we honor the web’s inclusive ethos.

Links:

• Hugues Tennier Website
• Hugues Tennier on LinkedIn

The landscape of web development has traditionally been dominated by JavaScript and its ecosystem of tools and frameworks. However, with Kotlin’s growing versatility, particularly its Kotlin/JS capabilities, new avenues are opening up for developers who prefer Kotlin’s syntax and features. Erik Hellman, an experienced software consultant with a deep background in various programming languages, explored this exciting intersection at KotlinConf 2019. His session, “Building Progressive Web Apps in Kotlin,” introduced how Kotlin, combined with its JavaScript support, could be used to create modern web applications, also known as Progressive Web Apps (PWAs).

Erik Hellman’s talk aimed to show developers how they could leverage their Kotlin knowledge to build PWAs, potentially using popular JavaScript frameworks like React, Vue.js, or LitElement through Kotlin wrappers or directly with Kotlin/JS. This approach offers an alternative for those who find Kotlin more aligned with their development style than TypeScript or plain JavaScript, or for teams looking to unify their technology stack around Kotlin.

Kotlin/JS: Bridging Kotlin to the Web

At the heart of building web applications with Kotlin is Kotlin/JS, which allows Kotlin code to be compiled (or “transpiled”) into JavaScript. Erik Hellman explained the fundamentals of Kotlin/JS, including how it maps Kotlin concepts to their JavaScript equivalents and enables interoperability with existing JavaScript libraries and browser APIs. This capability is crucial, as it allows Kotlin developers to tap into the vast JavaScript ecosystem while writing code in a language they are comfortable and productive with.

The session would have covered how to set up a Kotlin/JS project, manage dependencies, and structure code for web development. Erik might have also discussed the benefits of using Kotlin for web development, such as its strong type system, null safety, and conciseness, which can lead to more robust and maintainable web applications compared to traditional JavaScript development. The focus was on providing a pathway for Kotlin enthusiasts to extend their skills into the PWA domain.

Progressive Web Apps: Enhancing the Web Experience

Progressive Web Apps (PWAs) represent an evolution of web applications, aiming to provide a user experience similar to native mobile apps. Key features of PWAs include offline capabilities (through service workers), installability on user devices, push notifications, and fast performance. Erik Hellman’s talk would have explored how these PWA characteristics can be implemented using Kotlin/JS.

A significant part of building PWAs involves working with service workers for caching and offline support, and web app manifests for installability. Erik demonstrated how to write service worker logic in Kotlin and manage the manifest file within a Kotlin/JS project. He might have also touched upon techniques for optimizing performance and ensuring a smooth user experience, which are critical aspects of successful PWAs. The overall goal was to equip Kotlin developers with the knowledge to build modern, engaging web experiences that leverage the latest web platform features.

Current State and Future Promise

During his 2019 presentation, Erik Hellman acknowledged that while Kotlin/JS was powerful, the tooling and ecosystem were still maturing, particularly around areas like code splitting for service workers. He noted that finding help and up-to-date information sometimes required tapping into the Kotlin community, such as the official Slack channel.

Despite these challenges, he conveyed a sense of optimism, stating that Kotlin/JS looked “really really promising” as an alternative for web development, especially for projects where Kotlin was already in use for other components (like backend or mobile). He suggested that for many use cases, Kotlin/JS was already a viable option. His talk concluded by pointing towards the continued development and improvement of Kotlin/JS, anticipating it would become an even more compelling choice for building PWAs in the future, offering a robust and enjoyable development experience for Kotlin aficionados venturing into the web.

Links:

• Erik Hellman on LinkedIn
• Erik Hellman’s Blog

Simplifying Complex Architectures with Axon and Spring Boot

In his Spring I/O 2019 presentation, Allard Buijze, founder and CTO of AxonIQ, demonstrates how to build and scale event-driven microservices with Axon Framework and Spring Boot, making the process “excitingly boring” due to its simplicity. Buijze addresses the common misconception that microservices, especially event-driven variants, require complex and hard-to-grasp technologies, often diverting focus from core business logic to integration challenges.

The talk highlights the synergy between Spring Boot’s powerful autoconfiguration capabilities and Axon Framework’s support for Command Query Responsibility Segregation (CQRS) and Event Sourcing (ES). Through live coding, Buijze illustrates how this combination trivializes the development of scalable event-driven applications. Axon Framework, an open-source Java framework created by Buijze, is designed to help developers build scalable and maintainable applications using a message-driven approach, simplifying the complexities inherent in distributed systems.

Key takeaways from this session include:

• Trivializing Event-Driven Microservices: Leveraging Spring Boot and Axon to simplify the architecture and development of microservices.
• CQRS and Event Sourcing in Practice: Understanding how Axon Framework provides the necessary building blocks for these patterns.
• Message-Driven Architecture: Components communicate via commands, events, and queries, promoting loose coupling and flexibility.
• Scalability and Maintainability: Designing systems that are easy to extend and manage over time.
• Focus on Business Logic: Shifting developer attention from infrastructure concerns to core business requirements.

Allard Buijze has extensive experience in designing and developing enterprise applications with a strong focus on scalability and performance. He is a recognized expert in Domain-Driven Design (DDD) and CQRS, and regularly shares his insights at conferences and workshops.

Links

• Video (Spring I/O 2019)
• Slides
• GitHub Repository
• AxonIQ – Our Story
• Axon Framework on GitHub
• Allard Buijze on gotopia.tech

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:

• Britt Barak on LinkedIn

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:

• Mandy Michael on LinkedIn

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.

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:

• The Awwwesomes Website
• Adobe Website
• Aga Naplocha on LinkedIn

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.
• RestTemplate Customization: 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

• Video (Spring I/O 2019)
• Slides
• GitHub Repository
• Joris Kuipers on Spring I/O Speakers