Archive for the ‘en-US’ Category
[DotJs2025] Supercharge Web Performance with Shared Dictionaries: The Next Frontier in HTTP Compression
In an era where digital payloads traverse global networks at breakneck speeds, the subtle art of data compression remains a cornerstone of efficient web delivery, often overlooked amid flashier optimizations. Antoine Caron, engineering manager for frontend teams at Scaleway, reignited this vital discourse at dotJS 2025, advocating for shared dictionaries as a transformative leap in HTTP efficiency. With a keen eye on performance bottlenecks, Antoine dissected how conventional compressors like Gzip and Brotli falter on repetitive assets, only to unveil a protocol that leverages prior transfers as reference tomes, slashing transfer volumes by up to 70% in real-world scenarios. This isn’t arcane theory; it’s a pragmatic evolution, already piloted in Chrome and poised for broader adoption via emerging standards.
Antoine’s clarion call stemmed from stark realities unearthed in the Web Almanac: a disconcerting fraction of sites neglect even basic compression, forfeiting gigabytes in needless transit. A Wikipedia load sans Gzip drags versus its zipped twin, a 15% velocity boon; jQuery’s minified bulk evaporates over 50KB under maximal squeeze, a 70% payload purge sans semantic sacrifice. Yet, Brotli’s binary prowess, while superior for static fare, stumbles on dynamic deltas—vendor bundles morphing across deploys. Enter shared dictionary compression: an HTTP extension where browsers cache antecedent responses as compression glossaries, enabling servers to encode novelties against these baselines. For jQuery’s trek from v3.6 to v3.7, mere 8KB suffices; YouTube’s quarterly refresh yields 70% thrift, prior payloads priming the pump.
This mechanism, rooted in Google’s erstwhile SDCH (Shared Dictionary Compression over HTTP) and revived in IETF drafts like Compression Dictionary Transport, marries client-side retention with server-side savvy. Chrome’s 2024 rollout—flagged under chrome://flags/#shared-dictionary-compression—harnesses Zstandard or Brotli atop these shared tomes, with Microsoft Edge’s ZSDCH echoing for HTTPS. Antoine emphasized pattern matching: regex directives tag vendor globs, caching layers sequester these corpora, subsequent fetches invoking them via headers like Dictionary: . Caveats abound—staticity’s stasis, cache invalidation’s curse—but mitigations like periodic refreshes or hybrid fallbacks preserve robustness.
Antoine’s vision extends to edge cases: CDN confederacies propagating dictionaries, mobile’s miserly bandwidths reaping richest rewards. As Interop 2025 mandates cross-browser parity—Safari and Firefox intent-to-ship signaling convergence—this frontier beckons builders to audit headers, prototype pilots, and pioneer payloads’ parsimony. In a bandwidth-beleaguered world, shared dictionaries don’t merely optimize; they orchestrate a leaner, more equitable web.
The Mechanics of Mutual Memory
Antoine unraveled the protocol’s weave: clients stash responses in a dedicated echelon, servers probe via Accept-Dictionary headers, encoding diffs against these reservoirs. Brotli’s static harbors, once rigid, now ripple with runtime references—Zstd’s dynamism amplifying for JS behemoths. Web Almanac’s diagnostics affirm: uncompressed ubiquity persists, yet 2025’s tide, per Chrome’s telemetry, portends proliferation.
Horizons of Header Harmony
Drafts delineate transport: dictionary dissemination via prior bodies or external anchors, invalidation via etags or TTLs. Antoine’s exhortation: audit via Lighthouse, experiment in canaries—Scaleway’s vantage yielding vendor variances tamed. As specs solidify, this symbiosis promises payloads pared, performance propelled.
Links:
[DotJs2024] Embracing Reactivity: Signals Unveiled in Modern Web Frameworks
As web architectures burgeon in intricacy, the quest for fluid state orchestration intensifies, demanding primitives that harmonize intuition with efficiency. Ruby Jane Cabagnot, a Oslo-based full-stack artisan and co-author of Practical Enterprise React, illuminated this quest at dotJS 2024. With a portfolio spanning cloud services and DevOps, Ruby dissected signals’ ascendancy in frameworks like SolidJS and Svelte, tracing their lineage from Knockout’s observables to today’s compile-time elixirs. Her exposition: a clarion for developers to harness these sentinels, streamlining reactivity while amplifying responsiveness.
Ruby’s odyssey commenced with historical moorings: Knockout’s MVVM pioneers observables, auto-propagating UI tweaks; AngularJS echoed with bidirectional bonds, model-view symphonies. React’s virtual DOM and hooks refined declarative flows, context cascades sans impurity. Yet, SolidJS and Svelte pioneer signals—granular beacons tracking dependencies, updating solely perturbed loci. In Solid, createSignal births a reactive vessel: name tweaks ripple to inputs, paragraphs—minimal footprint, maximal sync. Svelte compiles bindings at build: $: value directives weave reactivity into markup, runtime overhead evaporated.
Vue’s ref system aligns, signals as breath-easy bindings. Ruby extolled their triad: intuitiveness supplants boilerplate bazaars; performance prunes needless re-renders, DOM diffs distilled; developer delight via declarative purity, codebases crystalline. Signals transcend UIs, infiltrating WebAssembly’s server tides, birthing omnipresent reactivity. Ruby’s entreaty: probe these pillars, propel paradigms where apps pulse as dynamically as their environs.
Evolutionary Echoes of Reactivity
Ruby retraced trails: Knockout’s observables ignited auto-updates; AngularJS’s bonds synchronized realms. React’s hooks democratized context; Solid/Svelte’s signals granularize, compile-time cunning curbing cascades—name flux mends markup sans wholesale refresh.
Signals’ Synergies in Action
Solid’s vessels auto-notify dependents; Svelte’s directives distill runtime to essence. Vue’s refs render reactivity reflexive. Ruby rejoiced: libraries obsolete, renders refined, ergonomics elevated—crafting canvases concise, performant, profound.
Links:
[GopherConUK2025] When Failure Is Not an Option: Surviving Cloud Outages in Go
Lecturer
Kevin Holditch serves as the Vice President of Platform at Form3, where he oversees the architectural evolution and engineering strategies of cloud-native financial infrastructure. Having joined Form3 in 2016 as one of its founding engineers, Kevin has guided the company’s scaling journey from a small initial team to a major technology provider powering critical payment systems across the United Kingdom and Europe. His career prior to Form3 spans technical leadership roles across high-scale engineering organizations, including EasyJet and ASOS.
Abstract
Modern financial technology demands uninterrupted availability, tight latency constraints, and operational independence from single cloud provider failures. This paper explores how Form3 transitioned its payment gateway architecture from a single-cloud AWS Java application to an active-active-active, cloud-agnostic platform engineered in Go across AWS, Google Cloud Platform (GCP), and Microsoft Azure. The analysis focuses on three specific technical challenges inherent in multi-cloud topology: cross-cluster Pod Disruption Budgets, automated rolling node-pool upgrades, and continuous disaster recovery through automated production-grade chaos engineering. By treating entire cloud providers as independent availability zones, the system achieves deterministic resilience while fulfilling regulatory mandates on zero vendor lock-in.
Architecture Evolution: From Single-Cloud Java to Cloud-Agnostic Go
Form3 operates as a unified RESTful API layer that abstracts the intricate protocol differences of global financial payment schemes. Payment networks such as BACS and Faster Payments (FPS) in the United Kingdom, alongside European payment rails, differ fundamentally across network transport channels, payload specifications, and state transitions. The platform insulates financial institutions from these underlying variations through a standardized interface.
+-----------------------------------------------+
| Client Ingress (API) |
+-----------------------------------------------+
|
+-----------------+-----------------+
| | |
v v v
+-----------+ +-----------+ +-----------+
| AWS | | GCP | | Azure |
| Load Bal. | | Load Bal. | | Load Bal. |
+-----------+ +-----------+ +-----------+
| | |
v v v
+-----------+ +-----------+ +-----------+
| K8s | | K8s | | K8s |
| Cluster A | | Cluster B | | Cluster C |
+-----------+ +-----------+ +-----------+
| | |
+--------+--------+--------+--------+
| |
v v
+-------------------+ +-------------------+
| CockroachDB | | NATS JetStream |
| (Distributed SQL) | | (Message Fabric) |
+-------------------+ +-------------------+
In its initial implementation, the platform utilized an AWS-native architecture built with Java microservices running on Amazon Elastic Container Service (ECS). Asynchronous service-to-service communication was managed via Amazon SQS, with relational data stored in Amazon RDS PostgreSQL. This architectural posture prioritized rapid market entry by delegating operational heavy lifting to managed AWS services.
// Sample multi-region ping handler in Go
package main
import (
"encoding/json"
"net/http"
)
type HealthResponse struct {
Status string `json:"status"`
Region string `json:"region"`
}
func HealthCheck(w http.ResponseWriter, r *http.Request) {
resp := HealthResponse{
Status: "HEALTHY",
Region: "multi-cloud-node",
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(resp)
}
The onboarding of Tier-1 retail banks introduced stricter regulatory and throughput constraints. Regulatory guidance from the UK Prudential Regulation Authority (PRA) requires financial institutions to maintain explicit exit strategies from cloud vendors to mitigate systemic concentration risk. To fulfill high-throughput targets exceeding 1,000 transactions per second alongside stringent Service Level Agreements (SLAs), Form3 abandoned single-cloud fallback strategies in favor of an active-active-active topology across three distinct cloud providers.
The system uses private network cross-links between AWS, GCP, and Azure, enabling pods in separate managed Kubernetes clusters to communicate via direct IP routing. In this topology, entire cloud providers function as virtual availability zones. Transitioning the microservice codebase from Java (Spring Boot) to Go delivered immediate operational benefits: startup times dropped from tens of seconds to near-instantaneous container initialization, eliminating test execution bottlenecks and reducing runtime memory footprints. Additionally, Go’s explicit error handling and minimal runtime abstraction eliminated hidden reflection mechanisms, improving codebase maintainability.
Distributed Consensus and State Preservation Across Provider Boundaries
Sustaining ACID transactional guarantees across disparate cloud vendors requires database and messaging infrastructure capable of consensus-based replication over public cloud interconnections. Form3 replaced proprietary cloud messaging and database layers with cloud-agnostic, distributed Go-native software components: CockroachDB for relational state storage and NATS JetStream for high-throughput event streaming.
CockroachDB implements the PostgreSQL wire protocol, allowing existing SQL schemas and drivers to transition seamlessly. Underneath, it relies on Raft consensus protocols to maintain consistency across distributed nodes. To prevent double-spending and ensure financial data integrity, the cluster operates in a right-consistent mode spanning all three cloud providers. A write operation is committed only after achieving write quorum across a minimum of two separate cloud vendors.
// Example CockroachDB transaction retry logic in Go
package main
import (
"context"
"database/sql"
"fmt"
_ "github.com/lib/pq"
)
func ExecutePayment(ctx context.Context, db *sql.DB, id string, amt int64) error {
tx, err := db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
query := `UPDATE accounts SET balance = balance - $1 WHERE id = $2`
if _, err := tx.ExecContext(ctx, query, amt, id); err != nil {
return fmt.Errorf("update failed: %w", err)
}
return tx.Commit()
}
NATS JetStream acts as the persistence-backed messaging fabric. Originally authored in Go by the team behind high-frequency trading platforms at Tibco, NATS provides low-latency, lightweight message distribution. JetStream extends base NATS with Raft-driven state replication, allowing message streams to survive the total failure of any single cloud provider without loss of message ordering or state corruption.
Cross-Cluster Pod Disruption Budgets (XPDB)
Standard Kubernetes Pod Disruption Budgets (PDB) operate strictly within the boundaries of a single cluster control plane. In an architecture comprising three uncoordinated Kubernetes clusters sharing a single logical CockroachDB deployment, native PDB mechanisms introduce systemic availability risks.
If a nine-node CockroachDB cluster is distributed evenly with three nodes per cloud provider, maintaining database quorum requires a minimum of five operational nodes at all times. If each independent cluster configures a standard PDB allowing one pod to be unavailable (maxUnavailable: 1), concurrent node maintenance or rolling updates across clusters could simultaneously terminate one pod per cloud provider. This aggregate loss of three pods reduces active cluster capacity to six nodes—dangerously close to losing quorum.
To solve this cross-cluster coordination failure, Form3 developed and open-sourced Cross-Cluster Pod Disruption Budget (XPDB). XPDB implements a centralized or peer-coordinated budget counter across N distinct Kubernetes clusters.
“`
[AWSReInventPartnerSessions2024] Demystifying AI-First Organizational Identity: Strategic Pathways and Operational Frameworks for Enterprise Transformation
Lecturer
Beth Torres heads strategic accounts for Eviden within the Atos Group, facilitating client alignment with artificial intelligence transformation initiatives. Kevin Davis serves as CTO of the AWS business group at Eviden, architecting machine learning operations and generative operations platforms. Eric Trell functions as AWS Cloud lead for Atos, optimizing hybrid and multi-cloud infrastructures.
Abstract
This scholarly examination articulates the distinction between conventional artificial intelligence adoption and genuine AI-first organizational identity, wherein intelligence permeates decision-making, customer engagement, and product architecture. It contrasts startup-native implementations with enterprise retrofitting, delineates MLOps/GenOps operational frameworks, and establishes ethical governance across model construction, deployment guardrails, and continuous monitoring. Cloud-enabled legacy data accessibility emerges as a pivotal enabler, alongside considerations for responsible artificial intelligence stewardship.
Conceptual Differentiation: AI Adoption versus AI-First Organizational Paradigm
The progression from cloud-first to AI-first organizational models necessitates embedding artificial intelligence as foundational infrastructure rather than peripheral augmentation. Whereas startups construct products with intelligence intrinsically woven throughout, established enterprises frequently append capabilities—exemplified by chatbot overlays—onto legacy systems.
AI-first identity manifests through operational preparedness: strategic platforms enabling accelerated use-case development by abstracting foundational complexities including data acquisition, quality assurance, and infrastructure provisioning. Artificial Intelligence Centers of Excellence institutionalize this preparedness, directing resources toward rapid return-on-investment validation through structured experimentation.
MLOps and GenOps frameworks streamline model lifecycle management at enterprise scale, addressing data integrity, ethical transparency, and governance requirements. Cloud-first positioning substantially facilitates this transition; mainframe-resident operational data, previously inaccessible for generative applications, becomes replicable to AWS environments without comprehensive modernization.
Ethical Governance and Technical Enablement Mechanisms
Responsible artificial intelligence necessitates multilayered ethical consideration. A tripartite framework structures this responsibility:
During model construction, training corpora undergo scrutiny for bias, provenance, and representativeness. Deployment guardrails leverage AWS-native capabilities to enforce content policies and contextual grounding. Continuous monitoring implements anomaly detection with predefined response protocols, calibrated according to interface interactivity levels.
\# Conceptual Bedrock guardrail implementation
import boto3
bedrock = boto3.client('bedrock-runtime')
guardrail = {
'contentPolicy': [{'blockedTopics': ['prohibited-content']}],
'contextualGrounding': True
}
response = bedrock.invoke_model(
modelId='anthropic.claude-3',
body=prompt,
guardrailConfig=guardrail
)
Security compartmentalization within Bedrock preserves data isolation for sensitive domains such as healthcare. Production readiness extends beyond prompt efficacy to encompass data validation, accuracy verification, and misinformation mitigation within innovation toolchains.
Strategic Ramifications and Transformation Imperatives
AI-first positioning defends against startup disruption by enabling comparable innovation velocity. Ethical frameworks safeguard reputational integrity while ensuring output reliability. Cloud-mediated legacy data accessibility democratizes generative capabilities across historical systems.
Organizational consequences include systematic competitive advantage through intelligence-permeated operations, regulatory alignment via auditable governance, and cultural evolution toward experimentation-driven development. The paradigm compels reevaluation of educational curricula to incorporate technology ethics as core competency.
Links:
[DevoxxUK2025] Concerto for Java and AI: Building Production-Ready LLM Applications
At DevoxxUK2025, Thomas Vitale, a software engineer at Systematic, delivered an inspiring session on integrating generative AI into Java applications to enhance his music composition process. Combining his passion for music and software engineering, Thomas showcased a “composer assistant” application built with Spring AI, addressing real-world use cases like text classification, semantic search, and structured data extraction. Through live coding and a musical performance, he demonstrated how Java developers can leverage large language models (LLMs) for production-ready applications, emphasizing security, observability, and developer experience. His talk culminated in a live composition for an audience-chosen action movie scene, blending AI-driven suggestions with human creativity.
The Why Factor for AI Integration
Thomas introduced his “Why Factor” to evaluate hype technologies like generative AI. First, identify the problem: for his composer assistant, he needed to organize and access musical data efficiently. Second, assess production readiness: LLMs must be secure and reliable for real-world use. Third, prioritize developer experience: tools like Spring AI simplify integration without disrupting workflows. By focusing on these principles, Thomas avoided blindly adopting AI, ensuring it solved specific issues, such as automating data classification to free up time for creative tasks like composing music.
Enhancing Applications with Spring AI
Using a Spring Boot application with a Thymeleaf frontend, Thomas integrated Spring AI to connect to LLMs like those from Ollama (local) and Mistral AI (cloud). He demonstrated text classification by creating a POST endpoint to categorize musical data (e.g., “Irish tin whistle” as an instrument) using a chat client API. To mitigate risks like prompt injection attacks, he employed Java enumerations to enforce structured outputs, converting free text into JSON-parsed Java objects. This approach ensured security and usability, allowing developers to swap models without code changes, enhancing flexibility for production environments.
Semantic Search and Retrieval-Augmented Generation
Thomas addressed the challenge of searching musical data by meaning, not just keywords, using semantic search. By leveraging embedding models in Spring AI, he converted text (e.g., “melancholic”) into numerical vectors stored in a PostgreSQL database, enabling searches for related terms like “sad.” He extended this with retrieval-augmented generation (RAG), where a chat client advisor retrieves relevant data before querying the LLM. For instance, asking, “What instruments for a melancholic scene?” returned suggestions like cello, based on his dataset, improving search accuracy and user experience.
Structured Data Extraction and Human Oversight
To streamline data entry, Thomas implemented structured data extraction, converting unstructured director notes (e.g., from audio recordings) into JSON objects for database storage. Spring AI facilitated this by defining a JSON schema for the LLM to follow, ensuring structured outputs. Recognizing LLMs’ potential for errors, he emphasized keeping humans in the loop, requiring users to review extracted data before saving. This approach, applied to his composer assistant, reduced manual effort while maintaining accuracy, applicable to scenarios like customer support ticket processing.
Tools and MCP for Enhanced Functionality
Thomas enhanced his application with tools, enabling LLMs to call internal APIs, such as saving composition notes. Using Spring Data, he annotated methods to make them accessible to the model, allowing automated actions like data storage. He also introduced the Model Context Protocol (MCP), implemented in Quarkus, to integrate with external music software via MIDI signals. This allowed the LLM to play chord progressions (e.g., in A minor) through his piano software, demonstrating how MCP extends AI capabilities across local processes, though he cautioned it’s not yet production-ready.
Observability and Live Composition
To ensure production readiness, Thomas integrated OpenTelemetry for observability, tracking LLM operations like token usage and prompt augmentation. During the session, he invited the audience to choose a movie scene (action won) and used his application to generate a composition plan, suggesting chord progressions (e.g., I-VI-III-VII) and instruments like percussion and strings. He performed the music live, copy-pasting AI-suggested notes into his software, fixing minor bugs, and adding creative touches, showcasing a practical blend of AI automation and human artistry.
Links:
[RivieraDev2025] Dhruv Kumar – Platform Engineering + AI: The Next-Gen DevOps
At Riviera DEV 2025, Dhruv Kumar delivered an engaging presentation on platform engineering, a discipline reshaping software delivery by addressing modern development challenges. Stepping in for Silva Devi, Dhruv, a senior product manager at CloudBees, explored how platform engineering, augmented by artificial intelligence, streamlines workflows, enhances developer productivity, and mitigates the complexities of cloud-native environments. His talk illuminated the transformative potential of internal developer platforms (IDPs) and AI-driven automation, offering a vision for a more efficient and secure software development lifecycle (SDLC).
The Challenges of Modern Software Development
Dhruv began by highlighting the evolving responsibilities of developers, who now spend only about 11% of their time coding, according to a survey by software.com. The remaining time is consumed by non-coding tasks such as testing, deployment, and managing security vulnerabilities. The shift-left movement, while intended to empower developers by integrating testing and deployment earlier in the process, often burdens them with tasks outside their core expertise. This is compounded by the transition to cloud environments, which introduces complex microservices architectures and distributed systems, creating navigation challenges and integration headaches.
Additionally, the rise of AI has accelerated software development, increasing code volume and tool proliferation, while supply chain attacks exploit these complexities, demanding constant vigilance from developers. Dhruv emphasized that these challenges—fragmented workflows, heightened security risks, and tool overload—necessitate a new approach to streamline processes and empower teams.
Platform Engineering: A Unified Approach
Platform engineering emerges as a solution to these issues, providing a cohesive framework for software delivery. Dhruv defined it as the discipline of designing toolchains and workflows that enable self-service capabilities for engineering teams in the cloud-native era. Central to this is the concept of an internal developer platform (IDP), which integrates tools and processes across the SDLC, from coding to deployment. By establishing a common SDLC model and vocabulary, platform engineering ensures that stakeholders—developers, QA, and security teams—share a unified understanding, reducing miscommunication and enhancing actionability.
Dhruv highlighted three pillars of effective platform engineering: a standardized SDLC model, secure best practices embedded in workflows, and the freedom for developers to use familiar tools. This last point, supported by a Forbes study from September 2023, underscores that happier developers, using tools they prefer, complete tasks 10% faster. By fostering collaboration and reducing context-switching, platform engineering creates an environment where developers can focus on innovation rather than operational overhead.
AI as a Catalyst for Optimization
Artificial intelligence plays a pivotal role in amplifying platform engineering’s impact. Dhruv explained that AI’s value lies not in generating code but in filtering noise and optimizing practices. By leveraging a robust SDLC data model, AI can provide actionable insights, provided it is fed high-quality data. For instance, AI-driven testing can prioritize time-intensive issues, streamline QA processes, and run only relevant tests based on code changes, reducing costs and feedback cycles. Dhruv cited examples like AI agents identifying vulnerabilities in code components or assessing risks in production ecosystems, automating fixes where appropriate.
He also introduced the Model Context Protocol (MCP), an open standard that enables applications to provide context to large language models, enhancing AI’s ability to deliver precise recommendations. From troubleshooting CI/CD pipelines to onboarding new developers, AI, when integrated with platform engineering, empowers teams to address bottlenecks and scale efficiently in a cloud-native world.
Empowering Developers and Securing the Future
Dhruv concluded by emphasizing that platform engineering, bolstered by AI, re-engages all actors in the software delivery process, from developers to leadership. By normalizing data across tools and providing metrics like DORA (DevOps Research and Assessment), IDPs offer visibility into bottlenecks and investment opportunities. This holistic approach not only secures the tech stack against supply chain attacks but also fosters a culture of productivity and developer satisfaction.
He encouraged attendees to explore CloudBees’ platform, which exemplifies these principles by breaking free from traditional platform limitations. Dhruv’s call to action urged developers to adopt platform engineering practices, leverage AI for optimization, and provide feedback to refine these evolving methodologies, ensuring a future where software delivery is both efficient and resilient.
Links:
[PyConUS2025] Lightning Talks Friday Afternoon: Community Practice, Creative Tools, and Critical Reflection
Lecturer
This session was hosted by community organizers who facilitated a rapid series of five-minute presentations by conference attendees. The speakers included Rodrigo Girão Serrão, a frequent contributor of educational lightning talks and author of Python-focused writing at mathspp.com; Laís Carvalho, associated with the Humble Data beginner workshops; Cheuk Ting Ho, Python Software Foundation Fellow, Humble Data co-founder, and developer advocate formerly with JetBrains; Quang Vu, a software engineer exploring computer vision for personal skill improvement; Meagen Voss, core team member of the Wagtail CMS project; Will Lachance, presenting solar energy modeling; Amanda Lundberg, addressing live captioning; Thomas Weiss, working with historical weather data for fire risk; Tom Rutherford, examining low-level process creation; Cody Maloney, investigating file-object lifecycle issues in the standard library; Anthony Shaw, Microsoft Python advocate and creator of the CSnakes embedding project; and Trey Hunner, Python Software Foundation Fellow, educator, and founder of Python Morsels. The collective nature of the session reflects the participatory ethos of PyCon lightning talks.
Abstract
The Friday afternoon lightning talks at PyCon US 2025 assembled a diverse sequence of short presentations that spanned pedagogical advice, beginner education, practical tooling, hobbyist computer vision, web-application failure modes, environmental modeling, accessibility practice, scientific data pipelines, language runtime internals, resource management, cross-runtime interoperation, and ethical reflection on emerging technologies. Taken together, the talks illustrate how the Python community simultaneously cultivates entry-level participation, technical craftsmanship, and critical awareness of systemic consequences.
Cultivating Participation and Beginner Pathways
Rodrigo Girão Serrão opened the session with a meta-presentation on the craft of lightning talks themselves. He emphasized that the format’s five-minute constraint, combined with stage lighting that often obscures the audience, lowers the barrier for first-time speakers. Content need not be restricted to Python; prior memorable talks had covered beer, music, puzzles, and vocal exercises. Practical guidance included sparse slides with large fonts, awareness of the hosts’ escalating applause cue, and the primacy of personal enjoyment as a predictor of audience engagement. The talk functioned both as invitation and as modeling of the form it advocated.
Laís Carvalho followed with an invitation to the Humble Data workshop, a Hatchery-program offering scheduled for the following Sunday. Humble Data provides structured, notebook-based introductions to Python and data-science fundamentals—Jupyter, pandas, matplotlib—for absolute beginners. Carvalho noted that the workshop had been delivered internationally and that completion of even a single notebook would be rewarded with conference swag. The presentation underscored the conference’s commitment to lowering technical thresholds and expanding the circle of participants who feel entitled to contribute.
Cheuk Ting Ho then addressed a lighter but recurrent conference phenomenon: the accumulation of sponsor swag. Drawing an analogy to Untappd, the beer-review application, Ho described Oscar Swag (a playful coinage), a web service that allows attendees to photograph, catalog, comment upon, and rate free merchandise. Built rapidly with the assistance of generative tools and hosted at a personal domain, the project demonstrated both the ease of contemporary web development and the social value of shared knowledge about durable versus ephemeral conference gifts. The talk illustrated how informal community tooling can emerge spontaneously from shared experience.
Technical Craft, Hobbies, and Runtime Awareness
Quang Vu presented a computer-vision pipeline developed to improve personal archery form. Consistency of body position matters more than absolute accuracy; therefore Vu employed recent Meta models (SAM and related segmentation networks) to isolate the archer’s silhouette, compute centroids, and align video frames despite changes in clothing or camera angle. Pixel-wise comparison proved brittle; segmentation-based alignment proved more robust. Remaining limitations—centroid precision, model sensitivity to rear viewpoints, temporal alignment of differing motion speeds—were candidly acknowledged, and the speaker invited collaboration. The project exemplified the transfer of professional computer-vision techniques into recreational skill acquisition.
Meagen Voss recounted a production incident on a personal Wagtail CMS site. Insertion of an animated goat GIF, intended as humorous illustration of the “testing goat” metaphor from Harry Percival’s test-driven-development literature, exhausted the memory of a modest DigitalOcean droplet running Gunicorn and Nginx. The administrative interface became partially inaccessible. Diagnosis revealed that the image-processing pipeline, combined with limited RAM, produced cascading failures. The anecdote served as a cautionary tale about resource assumptions in content-management systems and as an advertisement for Wagtail’s subsequent evolution and its upcoming virtual conference.
Will Lachance described a model for estimating solar-panel energy yield. Using historical irradiance and weather data, the system produced hourly forecasts and visualized expected production. The project’s modest computational cost and the speaker’s willingness to open the code illustrated the accessibility of domain-specific scientific computing within the Python ecosystem.
Amanda Lundberg’s talk, “Captioner is Human,” highlighted the labor of live captioning. The presentation reminded the audience that the service is performed by skilled humans rather than fully automated systems, reinforcing the ethical and practical necessity of supporting professional captioning at technical events.
Thomas Weiss demonstrated a predictive model for fire-weather conditions drawn from historical Remote Automated Weather Station (RAWS) data. Features such as temperature, relative humidity, and wind were used to flag stations meeting critical thresholds. The system ran at negligible cost and updated hourly, showing how publicly available environmental data can be operationalized for public-safety awareness.
Tom Rutherford examined the semantics and hazards of os.fork. Prior to recent Python versions, the default process-creation method on POSIX systems copied the parent’s address space while leaving only the forking thread alive in the child. Active locks or other thread-local state therefore produced deadlocks. The progressive deprecation of fork as default—first on macOS, later universally—reflects a deliberate prioritization of safety over the convenience of shared memory. Rutherford’s examples clarified why production codebases had long avoided the construct and why the language is migrating toward spawn-based isolation.
Cody Maloney reminded the audience of the necessity of closing file-like objects. A community-reported bug triggered by a gzip write into a BytesIO under Python 3.13 exposed an older reference cycle introduced when buffered writers were adopted for performance. The cycle caused the buffer to be closed before residual data were flushed, producing an exception only after a diagnostic print was added. Subsequent point releases repaired the cycle, and Python 3.14 will emit an explicit warning for unclosed gzip objects containing unwritten data. Maloney advocated the consistent use of context managers and, where appropriate, the higher-level pathlib helpers that encapsulate correct resource management while also enabling future performance optimizations.
Interoperation, Ethics, and Systemic Thinking
Anthony Shaw presented CSnakes, a project that embeds a Python interpreter inside .NET processes. Motivated by the comparative scarcity of mature machine-learning libraries in the C# ecosystem, CSnakes uses static builds of Python, parses type-annotated Python functions, and generates corresponding C# bindings. Complex signatures—including generators of nested tuples—are automatically marshaled. Asynchronous Python functions become awaitable C# methods, and free-threaded Python is supported so that .NET thread-pool workers can invoke Python concurrently. The demonstration with Hugging Face Transformers illustrated how a few hundred lines of generated C# can expose sophisticated Python pipelines as ordinary .NET methods, lowering the cost of polyglot architecture.
Trey Hunner closed the session with a comparative reflection on large language models and industrial animal agriculture. Both domains exhibit substantial negative externalities—environmental, health-related, and ethical—yet neither is likely to disappear through individual abstention alone. Systemic problems, Hunner argued, require systemic remedies rather than moralized individual restraint. The talk cautioned against gatekeeping rhetoric that shames tool users and invited the community to channel critical energy toward institutional and regulatory change. The analogy, deliberately provocative, reframed heated debates about generative AI as questions of collective design rather than personal purity.
Collectively the Friday lightning talks demonstrated the breadth of activity that five minutes can contain: pedagogical invitation, tool building, personal instrumentation, failure analysis, scientific modeling, language-runtime vigilance, cross-language embedding, and ethical systems thinking. The session itself modeled the participatory culture it celebrated.
Links:
[DevoxxFR2025] Boosting Java Application Startup Time: JVM and Framework Optimizations
In the world of modern application deployment, particularly in cloud-native and microservice architectures, fast startup time is a crucial factor impacting scalability, resilience, and cost efficiency. Slow-starting applications can delay deployments, hinder auto-scaling responsiveness, and consume resources unnecessarily. Olivier Bourgain, in his presentation, delved into strategies for significantly accelerating the startup time of Java applications, focusing on optimizations at both the Java Virtual Machine (JVM) level and within popular frameworks like Spring Boot. He explored techniques ranging from garbage collection tuning to leveraging emerging technologies like OpenJDK’s Project Leyden and Spring AOT (Ahead-of-Time Compilation) to make Java applications lighter, faster, and more efficient from the moment they start.
The Importance of Fast Startup
Olivier began by explaining why fast startup time matters in modern environments. In microservices architectures, applications are frequently started and stopped as part of scaling events, deployments, or rolling updates. A slow startup adds to the time it takes to scale up to handle increased load, potentially leading to performance degradation or service unavailability. In serverless or function-as-a-service environments, cold starts (the time it takes for an idle instance to become ready) are directly impacted by application startup time, affecting latency and user experience. Faster startup also improves developer productivity by reducing the waiting time during local development and testing cycles. Olivier emphasized that optimizing startup time is no longer just a minor optimization but a fundamental requirement for efficient cloud-native deployments.
JVM and Garbage Collection Optimizations
Optimizing the JVM configuration and understanding garbage collection behavior are foundational steps in improving Java application startup. Olivier discussed how different garbage collectors (like G1, Parallel, or ZGC) can impact startup time and memory usage. Tuning JVM arguments related to heap size, garbage collection pauses, and just-in-time (JIT) compilation tiers can influence how quickly the application becomes responsive. While JIT compilation is crucial for long-term performance, it can introduce startup overhead as the JVM analyzes and optimizes code during initial execution. Techniques like Class Data Sharing (CDS) were mentioned as a way to reduce startup time by sharing pre-processed class metadata between multiple JVM instances. Olivier provided practical tips and configurations for optimizing JVM settings specifically for faster startup, balancing it with overall application performance.
Framework Optimizations: Spring Boot and Beyond
Popular frameworks like Spring Boot, while providing immense productivity benefits, can sometimes contribute to longer startup times due to their extensive features and reliance on reflection and classpath scanning during initialization. Olivier explored strategies within the Spring ecosystem and other frameworks to mitigate this. He highlighted Spring AOT (Ahead-of-Time Compilation) as a transformative technology that analyzes the application at build time and generates optimized code and configuration, reducing the work the JVM needs to do at runtime. This can significantly decrease startup time and memory footprint, making Spring Boot applications more suitable for resource-constrained environments and serverless deployments. Project Leyden in OpenJDK, aiming to enable static images and further AOT compilation for Java, was also discussed as a future direction for improving startup performance at the language level. Olivier demonstrated how applying these framework-specific optimizations and leveraging AOT compilation can have a dramatic impact on the startup speed of Java applications, making them competitive with applications written in languages traditionally known for faster startup.
Links:
- Olivier Bourgain: https://www.linkedin.com/in/olivier-bourgain/
- Mirakl: https://www.mirakl.com/
- Spring Boot: https://spring.io/projects/spring-boot
- OpenJDK Project Leyden: https://openjdk.org/projects/leyden/
- Devoxx France LinkedIn: https://www.linkedin.com/company/devoxx-france/
- Devoxx France Bluesky: https://bsky.app/profile/devoxx.fr
- Devoxx France Website: https://www.devoxx.fr/
[KotlinConf2024] DataFrame: Kotlin’s Dynamic Data Handling
At KotlinConf2024, Roman Belov, JetBrains’ Kotlin Moods group leader, showcased Kotlin DataFrame, a versatile library for managing flat and hierarchical data. Designed for general developers, not just data scientists, DataFrame handles CSV, JSON, and object subgraphs, enabling seamless data transformation and visualization. Roman demonstrated its integration with Kotlin Notebook for prototyping and a compiler plugin for dynamic type inference, using a KotlinConf app backend as an example. This talk highlighted how DataFrame empowers developers to build robust, interactive data pipelines.
DataFrame: A Versatile Data Structure
Kotlin DataFrame redefines data handling for Kotlin developers. Roman explained that, unlike traditional data classes, DataFrame supports dynamic column manipulation, akin to Excel tables. It can read, write, and transform data from formats like CSV or JSON, making it ideal for both analytics and general projects. For a KotlinConf app, DataFrame processed session data from a REST API, allowing developers to filter, sort, and pivot data effortlessly, providing a flexible alternative to rigid data class structures.
Prototyping with Kotlin Notebook
Kotlin Notebook, a plugin for IntelliJ IDEA Ultimate, enhances DataFrame’s prototyping capabilities. Roman demonstrated creating a scratch file to fetch session data via Ktor Client. The notebook’s auto-completion for dependencies, like Ktor or DataFrame, simplifies setup, downloading the latest versions from Maven Central. Interactive tables display hierarchical data, and each code fragment updates variable types, enabling rapid experimentation. This environment suits developers iterating on ideas, offering a low-friction way to test data transformations before production.
Dynamic Type Inference in Action
DataFrame’s compiler plugin, built for the K2 compiler, introduces on-the-fly type inference. Roman showed how it analyzes a DataFrame’s schema during execution, generating extension properties for columns. For example, accessing a title column in a sessions DataFrame feels like using a property, with auto-completion for column names and types. This eliminates manual schema definitions, streamlining data wrangling. Though experimental, the plugin cached schemas efficiently, ensuring performance, as seen when filtering multiplatform talk descriptions.
Handling Hierarchical Data
DataFrame excels with hierarchical structures, unlike flat data classes. Roman illustrated this with nested JSON from the KotlinConf API, converting categories into a DataFrame with grouped columns. Developers can navigate sub-DataFrames within cells, mirroring data class nesting. For instance, a category’s items array became a sub-DataFrame, accessible via intuitive APIs. This capability supports complex data like object subgraphs, enabling developers to transform and analyze nested structures without cumbersome manual mappings.
Building a KotlinConf Schedule
Roman walked through a practical example: creating a daily schedule for KotlinConf. Starting with session data, he converted startsAt strings to LocalDateTime, filtered out service sessions, and joined room IDs with room names from another DataFrame. Sorting by start time and pivoting by room produced a clean schedule, with nulls replaced by empty strings. The resulting HTML table, generated directly in the notebook, showcased DataFrame’s ability to transform REST API data into user-friendly outputs, all with concise, readable code.
Visualizing Data with Kandy
DataFrame integrates with Kandy, JetBrains’ visualization library, to create charts. Roman demonstrated analyzing GitHub commits from the Kotlin repository, grouping them by week to plot commit counts and average message lengths. The resulting chart revealed trends, like steady growth potentially tied to CI improvements. Kandy’s simple API, paired with DataFrame’s data manipulation, makes visualization accessible. Roman encouraged exploring Kandy’s website for examples, highlighting its role in turning raw data into actionable insights.
DataFrame in Production
Moving DataFrame to production is straightforward. Roman showed copying notebook code into IntelliJ’s EAP version, importing the generated schema to access columns as properties. The compiler plugin evolves schemas dynamically, supporting operations like adding a room column and using it immediately. This approach minimizes boilerplate, as seen when serializing a schedule to JSON. Though the plugin is experimental, its integration with K2 ensures reliability, making DataFrame a practical choice for building scalable backend systems, from APIs to data pipelines.
Links:
[DevoxxFR2025] Winamax’s Journey Towards Cross-Platform
In today’s multi-device world, providing a consistent and high-quality user experience across various platforms is a significant challenge for software companies. For online gaming and betting platforms like Winamax, reaching users on desktop, web, and mobile devices is paramount. Anthony Maffert and Florian Yger from Winamax shared their insightful experience report detailing the company’s ambitious journey to unify their frontend applications onto a single cross-platform engine. Their presentation explored the technical challenges, the architectural decisions, and the concrete lessons learned during this migration, showcasing how they leveraged modern web technologies like JavaScript, React, and WebGL to achieve a unified codebase for their desktop and mobile applications.
The Challenge of a Fragmented Frontend
Winamax initially faced a fragmented frontend landscape, with separate native applications for desktop (Windows, macOS) and mobile (iOS, Android), alongside their web platform. Maintaining and developing features across these disparate codebases was inefficient, leading to duplicated efforts, inconsistencies in user experience, and slower delivery of new features. The technical debt associated with supporting multiple platforms became a significant hurdle. Anthony and Florian highlighted the clear business and technical need to consolidate their frontend development onto a single platform that could target all the required devices while maintaining performance and a rich user experience, especially crucial for a real-time application like online poker.
Choosing a Cross-Platform Engine
After evaluating various options, Winamax made the strategic decision to adopt a cross-platform approach based on web technologies. They chose to leverage JavaScript, specifically within the React framework, for building their user interfaces. For rendering the complex and dynamic visuals required for a poker client, they opted for WebGL, a web standard for rendering 2D and 3D graphics within a browser, which can also be utilized in cross-platform frameworks. Their previous experience with JavaScript on their web platform played a role in this decision. The core idea was to build a single application logic and UI layer using these web technologies and then deploy it across desktop and mobile using wrapper technologies (like Electron for desktop and potentially variations for mobile, although the primary focus of this talk seemed to be the desktop migration).
The Migration Process and Lessons Learned
Anthony and Florian shared their experience with the migration process, which was a phased approach given the complexity of a live gaming platform. They discussed the technical challenges encountered, such as integrating native device functionalities (like file system access for desktop) within the web technology stack, optimizing WebGL rendering performance for different hardware, and ensuring a smooth transition for existing users. They touched upon the architectural changes required to support a unified codebase, potentially involving a clear separation between the cross-platform UI logic and any platform-specific native modules or integrations. Key lessons learned included the importance of careful planning, thorough testing on all target platforms, investing in performance optimization, and managing the technical debt during the transition. They also highlighted the benefits reaped from this migration, including faster feature development, reduced maintenance overhead, improved consistency across platforms, and the ability to leverage a larger pool of web developers. The presentation offered a valuable case study for other organizations considering a similar move towards cross-platform development using web technologies.
Links:
- Anthony Maffert: https://www.linkedin.com/in/anthonymaffert/
- Florian Yger: https://www.linkedin.com/in/florianyger/
- Winamax: https://www.winamax.fr/
- Devoxx France LinkedIn: https://www.linkedin.com/company/devoxx-france/
- Devoxx France Bluesky: https://bsky.app/profile/devoxx.fr
- Devoxx France Website: https://www.devoxx.fr/