Jonathan Lalou's Blog

Lecturer
Aicha Laafia is a Java software engineer at Havana Group, currently based in France while originally from Morocco. She is passionate about sustainable technology, green programming, and advocating for greater representation of women in tech. Aicha actively participates in various communities, serves as a Women Techmakers and Girls Code ambassador, and facilitates IAmRemarkable workshops. She was recently promoted to Oracle ACE Associate, recognizing her contributions to the Java ecosystem.

Abstract
In this engaging session from Voxxed Days Amsterdam 2026, Aicha Laafia explores significant enhancements to Java’s stream processing capabilities and string handling introduced in JDK 25. She addresses longstanding pain points with traditional streams—such as the inability to maintain state mid-pipeline, complex custom collectors for batching or sliding windows, and error-prone string concatenation for SQL, JSON, or logs—through the new Stream Gatherers API and String Templates. Drawing on live code demonstrations and relatable examples from Formula 1 racing data, the presentation illustrates how these features introduce memory and statefulness to streams, simplify data transformations, and promote safer, more readable code. The talk underscores Java’s continued evolution toward more expressive and maintainable programming paradigms, encouraging developers to upgrade and share knowledge about these advancements.

The Persistent Challenges with Traditional Java Streams

Java developers have long appreciated streams for producing cleaner, more declarative, and expressive code compared to imperative loops. However, as Aicha points out, streams can occasionally leave programmers feeling frustrated or even “like complete idiots” when attempting advanced operations. The core limitation stems from the stateless nature of intermediate operations like map, filter, or flatMap. Each element processes independently and is immediately forgotten, making it impossible to track accumulated state, create overlapping windows, or group data mid-pipeline without terminating the stream via a collector.

Common pain points include manual batching implementations that rely on counters, lists, and careful index management to avoid off-by-one errors or lost elements. Grouping overlapping data—for instance, creating sliding windows of size n for rolling averages or trend detection—often requires intricate custom collectors that become difficult to understand or maintain over time, even for the original author. Furthermore, once a collector is applied, the pipeline ends; no further stream operations are possible afterward. These issues lead to verbose, error-prone code or a reluctant fallback to traditional for-loops, undermining the very benefits streams were meant to deliver.

Aicha emphasizes that these problems arise because prior to JDK 25, streams lacked “memory.” Elements flowed through independently without retaining context from previous items, forcing developers into workarounds that compromised readability and maintainability.

Introducing Stream Gatherers: Bringing Memory and Flexibility to Streams

JDK 25 addresses these limitations head-on with the Stream Gatherers API, which equips streams with stateful processing capabilities while remaining intermediate operations. Unlike terminal collectors, gatherers allow continued chaining after stateful transformations. A gatherer consists of up to four components, though only the integrator is mandatory:

• Initializer (optional): Executes once before any elements arrive, establishing initial state such as an empty list or counter.
• Integrator: The core logic, invoked for every element. It receives the current element, the mutable state, and a downstream consumer. Developers implement accumulation or transformation here, returning true to continue or false to short-circuit the pipeline.
• Combiner (optional): Essential for parallel streams, merging partial states from different threads.
• Finisher (optional): Runs once at the end of the stream, ensuring no residual state (such as an incomplete final batch) is lost by pushing any remaining elements downstream.

This design provides a short-circuit mechanism and supports parallel execution when a combiner is supplied. Aicha demonstrates creating a custom batching gatherer in roughly 15 lines of code—far simpler than equivalent custom collectors or manual loops. The initializer creates an empty list; the integrator adds elements until the batch size is reached, then pushes the batch downstream and clears the buffer; the finisher handles any trailing incomplete batch.

Even better, JDK 25 ships with five built-in gatherers that eliminate most custom implementations:

• windowFixed(n): Produces non-overlapping batches of exactly size n, including a final potentially smaller batch.
• windowSliding(n): Generates overlapping windows, ideal for rolling calculations, trend detection, or analyzing sequential data patterns in production monitoring.
• scan: Accumulates intermediate results similar to a fold, emitting every partial value starting from an initial element—unlike reduce, which yields only the final result.
• fold: Similar accumulation but treats the operation as intermediate, returning an Optional while permitting further pipeline chaining.
• mapConcurrent(maxConcurrency, mapper): Executes the mapper on virtual threads (up to the specified concurrency limit) while preserving encounter order, making it particularly suited for I/O-bound tasks without manual thread management.

These tools transform previously cumbersome tasks into concise, readable one- or few-line operations.

Live Demonstration: Analyzing Formula 1 Data with Gatherers

To illustrate practical application, Aicha uses racing data from Max Verstappen’s 2025 Formula 1 season, modeled as a record containing round number, Grand Prix name, position, and points. She contrasts traditional approaches—often involving dozens of lines of custom collector code with initializer, accumulator, combiner, and finisher—with gatherer-based solutions.

For batching every three races to compute cumulative points and wins, a windowFixed(3) gatherer replaces extensive custom logic, producing clean batches while automatically handling the final incomplete group. Sliding windows demonstrate overlapping views, such as performance trends across consecutive race triplets, again in just a few lines.

Accumulation across the entire season uses scan to emit running totals after each race, revealing Verstappen’s final 421 points and near-miss championship outcome. These examples highlight how gatherers retain “memory” of prior elements, enabling stateful yet fluent pipelines.

Aicha also touches on String Templates, another JDK 25 feature that enhances safety and readability. Traditional string concatenation or String.format often leads to injection vulnerabilities in SQL or JSON and creates “plus soup” that is hard to read. String Templates provide a clean, type-safe interpolation mechanism that reduces errors and improves security for logging, queries, and data serialization.

Implications and Recommendations for Modern Java Development

The introduction of gatherers and string templates reflects Java’s ongoing commitment to evolving without breaking compatibility, offering developers more powerful abstractions while preserving the language’s robustness. By reducing reliance on custom collectors and imperative workarounds, these features promote more maintainable, expressive codebases that are easier to reason about and debug.

Gatherers particularly shine in data processing pipelines, analytics, monitoring, and any domain requiring windowed or accumulated views. Their support for parallelism and short-circuiting adds efficiency, while the built-in variants cover the majority of common use cases, lowering the barrier to advanced stream usage.

Aicha encourages the community to upgrade to the latest JDK, experiment with these capabilities, write articles, and deliver talks to spread awareness. She notes that many scenarios previously abandoned to “for-loop hell” now become elegant stream solutions thanks to gatherers.

Code Sample: Batching with windowFixed

// Traditional complex collector approach omitted for brevity

// With Gatherers in JDK 25
var batches = races.stream()
    .gather(Gatherers.windowFixed(3))
    .map(batch -> computeStats(batch))  // e.g., sum points, count wins
    .toList();

Code Sample: Sliding Window for Trends

var slidingWindows = races.stream()
    .gather(Gatherers.windowSliding(3))
    .map(window -> analyzeTrend(window))
    .toList();

Code Sample: Accumulation with scan

var runningTotals = pointsStream
    .gather(Gatherers.scan(() -> 0, Integer::sum))
    .toList();  // Emits every intermediate sum

These snippets demonstrate the dramatic reduction in complexity while preserving full pipeline fluency.

In conclusion, Aicha Laafia’s presentation provides both a clear diagnosis of historical stream limitations and a compelling vision for their resolution in JDK 25. By incorporating statefulness through gatherers and safer string handling, Java strengthens its position as a modern, versatile language suitable for complex data-driven applications. Developers who adopt these features will benefit from shorter, more readable code, fewer maintenance headaches, and enhanced productivity.

Links:

• Video URL
• Aicha Laafia on LinkedIn
• Aicha Laafia Oracle ACE Profile

Lecturer

Gadi Hutt is a Senior Director of Product Management at AWS, specializing in the development and strategic scaling of specialized silicon. With an extensive background in semiconductor engineering and cloud infrastructure, Gadi has been a pivotal figure in the evolution of the AWS Annapurna Labs team. His work focuses on delivering high-performance, cost-efficient compute solutions that address the exponential resource demands of modern artificial intelligence. He is joined by industry leaders such as Joe Spisak, Product Director at Meta, and Oren Shomar, Director of Engineering at poolside, who provide empirical evidence of the impact of these specialized chips on global AI model development.

Abstract

The rapid proliferation of generative artificial intelligence (GenAI) has introduced unprecedented computational challenges, characterized by skyrocketing training costs and intricate scaling requirements. This article examines the architectural innovations of AWS Trainium2, the second-generation purpose-built chip designed specifically for high-performance deep learning. By analyzing the integration of Trainium2 into the AWS UltraCluster environment and the supporting Neuron SDK, we explore how specialized silicon provides a viable alternative to general-purpose GPUs. The discussion highlights real-world applications by Meta and poolside, demonstrating significant gains in price-performance for training Mixture of Experts (MoE) models and deploying agentic systems. Furthermore, the article outlines the methodological shift toward optimized software-hardware co-design as a necessity for sustaining the next generation of AI innovation.

The Architectural Foundation of Purpose-Built Silicon

The foundational shift in AI infrastructure is driven by the realization that general-purpose hardware often encounters bottlenecks when processing the massive parameter counts of modern Large Language Models (LLMs). Gadi explains that AWS Trainium2 was engineered to alleviate these constraints by focusing on three primary pillars: compute density, high-speed interconnectivity, and memory efficiency.

A critical innovation in this generation is the transition to a more robust node technology that allows for significantly higher teraflops (TFLOPS) per chip compared to its predecessor. This is complemented by the AWS Nitro System, which offloads networking and storage functions, allowing the Trainium processors to dedicate nearly 100% of their resources to model arithmetic. The architecture supports a diverse range of data types, including FP8 and Transformer Engine optimizations, which are essential for maintaining precision while reducing computational overhead.

Scaling with AWS UltraClusters and Elastic Fabric Adapter

Individual chip performance is only one aspect of the solution; the ability to scale to tens of thousands of chips is where the true breakthrough occurs. Gadi describes the AWS UltraCluster as a massive, non-blocking network of Trainium2 instances connected via the second-generation Elastic Fabric Adapter (EFA). This infrastructure enables petabit-scale networking, which is crucial for the frequent synchronization required during distributed training.

The EFA technology utilizes a custom-built protocol designed to minimize latency and jitter, which are often the limiting factors in synchronous training workloads. By providing a high-bandwidth, low-latency fabric, AWS allows developers to treat an entire cluster of thousands of nodes as a single, unified computer. This capability is particularly relevant for training foundational models where the dataset and model weights are too large to fit into the memory of a single machine.

Industry Validation: Meta and the Llama Ecosystem

The practical utility of Trainium2 is underscored by its adoption by major industry players. Joe Spisak from Meta highlights the collaborative effort to integrate Trainium2 into the Llama model ecosystem. For a company operating at Meta’s scale, the primary objective is to maximize “tokens per dollar.”

Joe notes that the integration of Trainium2 with the PyTorch framework via the AWS Neuron SDK allows Meta to leverage their existing codebases while benefiting from the superior price-performance of AWS silicon. This partnership demonstrates that purpose-built hardware can successfully support the most demanding open-source model architectures, providing the global community with more efficient paths to fine-tuning and deploying sophisticated AI systems.

Case Study: High-Efficiency Training at poolside

Oren Shomar from poolside provides a deep dive into the specific challenges of building AI for software engineering. Their workload requires massive-scale training on code repositories, which involves long-sequence lengths and complex reasoning patterns. poolside transitioned to Trainium2 to overcome the cost barriers associated with traditional GPU clusters.

Oren emphasizes the role of the Neuron SDK in this transition. The compiler’s ability to automatically optimize graph execution and manage memory across the Trainium cores was a decisive factor in achieving their performance targets. By using Trainium2, poolside was able to maintain a rapid iteration cycle, training new model variants in a fraction of the time and cost previously required, thereby accelerating their path to delivering agentic reasoning capabilities to developers.

The Neuron SDK: Bridging Frameworks and Silicon

The success of specialized silicon is inextricably linked to the software stack that exposes its power. The AWS Neuron SDK acts as the interface between popular machine learning frameworks like PyTorch and JAX and the underlying Trainium hardware.

The Neuron compiler performs sophisticated optimizations, including operator fusion and tensor tiling, to ensure that the hardware is utilized at peak efficiency. Gadi highlights the “Neuron Distributed” library, which provides high-level abstractions for data parallelism, pipeline parallelism, and tensor parallelism. This allows researchers to scale their models across an UltraCluster without having to manually manage the complexities of collective communication or device-specific memory management.

Conclusion: The Imminent Future of AI Infrastructure

The trajectory of GenAI necessitates a departure from the “one-size-fits-all” hardware approach. Through the development of Trainium2 and the accompanying ecosystem, AWS has established a new benchmark for scalable AI training. Gadi concludes that the commitment to continuous innovation—evidenced by the early announcement of Trainium4—ensures that the industry can keep pace with the evolving complexity of AI models. As price-performance becomes the dominant metric for AI viability, specialized silicon like Trainium will be the cornerstone of a sustainable and innovative technological future.

Links:

• AWS Trainium Official Page
• AWS Neuron SDK Documentation
• Gadi Hutt on LinkedIn
• Joe Spisak on LinkedIn
• poolside Official Website

Lecturers

Jakub Holý is a Senior Software Engineer based in Oslo, Norway. Born in Czechoslovakia, he studied Software Engineering at the Czech Technical University and Humanities at Charles University in Prague. With over two decades of experience, Jakub has worked extensively with Clojure and Datomic. He is a passionate advocate for scientific computing and has been a key driver in the development of Wolframite, a bridge between Clojure and the Wolfram Engine.
Thomas Clark is a mathematician and developer who focuses on the intersection of symbolic computation and functional programming. He has contributed significantly to the Scicloj ecosystem, working to bring high-performance numerical and symbolic tools to the Clojure community. Together with Jakub, he has worked to ensure that Wolframite 1.0 provides a robust, production-ready interface for complex computational tasks.

Abstract

Wolframite is a revolutionary library that bridges the gap between the Clojure programming language and the Wolfram Engine (the power behind Mathematica). This article analyzes the motivations behind this integration, the technical challenges of connecting a general-purpose functional language with a massive symbolic computational kernel, and the practical applications of such a tool. By providing a Clojure-idiomatic interface to over 7,000 Wolfram functions, Wolframite empowers developers to perform complex tasks ranging from quantum physics simulations to simple video editing, all within a unified environment. The library leverages Clojure’s strengths in data processing and the Scicloj ecosystem to provide a more comfortable and well-designed language for the numerical scientific community.

The Rationale for the Clojure-Wolfram Bridge

The primary motivation for Wolframite is the need to integrate the “unparalleled computational kernel” of Wolfram with the wider software world. While the Wolfram Language is incredibly powerful for symbolic and numerical computation, it often exists in a silo. Clojure, as a general-purpose language hosted on the JVM, offers excellent interoperability, concurrency models, and a robust ecosystem for web services and data processing.
Jakub Holý and Thomas Clark argue that by bringing these two worlds together, they provide the scientific community with a “more comfortable general language” while giving Clojure developers access to capabilities that would take decades to reimplement from scratch. This includes specialized domains such as:
* Advanced Mathematical Functions: Direct access to thousands of algorithms for calculus, algebra, and statistics.
* Real-world Data: Built-in access to the Wolfram Knowledgebase, including geographic, weather, and financial data.
* Symbolic Computation: The ability to manipulate mathematical expressions as data, which aligns perfectly with Clojure’s homoiconic nature.

Core Architecture and Functionality

Wolframite 1.0 is designed to feel native to Clojure developers. The library manages the lifecycle of the Wolfram Engine and provides a seamless translation layer between Clojure data structures and Wolfram expressions. The core workflow involves four primary pillars:
1. Starting the Engine: Initializing the Wolframite bridge and the underlying kernel.
2. Translation: Converting Clojure maps, vectors, and symbols into a format the Wolfram Engine understands.
3. Evaluation: Sending the translated expressions to the kernel for processing.
4. Result Retrieval: Converting the Wolfram output back into immutable Clojure data.
The library includes a namespace with “vars” for all 7,000+ Wolfram functions, allowing for IDE auto-completion and documentation access. For example, a developer can call a Wolfram function for image processing as if it were a standard Clojure function.

Code Sample: Symbolic Evaluation

(require '[wolframite.core :as w])
;; Initialize the connection
(w/start-wolfram!)
;; Evaluate a symbolic derivative
(w/eval '(D (Power x 2) x))
;; => (* 2 x)

Documentation and Community Integration

A significant portion of the development effort for Wolframite has been dedicated to its documentation. Jakub notes that each documentation page is originally a Clojure namespace rendered as a notebook, ensuring that all examples are executable and verified. This approach follows the Scicloj philosophy of “literate programming” and reproducible research.
Wolframite is not intended to be used in isolation; it is designed to leverage the powerful Scicloj libraries for visualization and data processing. This allows a researcher to perform heavy symbolic lifting in Wolfram, then use Clojure to pipe that data into a web frontend or a high-performance database. The “deep dives” in the documentation showcase this by solving complex problems in cavity physics and data analysis.

Links:

• Wolframite: Bring computational intelligence to Clojure (Lecture)
• Wolframite GitHub Repository
• Scicloj Community

Lecturer

Frank Greco is a distinguished Java Champion and enterprise architect with a deep focus on AI, Cloud, and Edge computing. As a senior consultant and long-standing educator, he chairs the NYJavaSIG and has co-authored industry standards such as JSR #381. Frank is dedicated to helping developers navigate the practical implementation of machine learning within enterprise ecosystems.

Abstract

As generative AI moves from experimental prototypes to enterprise production, the focus has shifted from monolithic models to specialized architectures. This article analyzes two critical trends: Distilled Models and Mixture of Experts (MoE). By exploring how large models can “teach” smaller, more efficient versions and how sub-networks can be orchestrated to handle niche tasks, this study provides a roadmap for building cost-effective, high-performance AI applications in memory-constrained environments.

The Methodology of Model Distillation

The current evolution of AI prioritizes efficiency and latency over raw parameter count. Model distillation is a process where a large, high-parameter model (the “Teacher”) is used to train a significantly smaller model (the “Student”).

The technical process involves:

1. Reasoning Extraction: The teacher model is prompted to solve problems using Chain of Thought (CoT) reasoning.
2. Pattern Learning: The student model is trained on the teacher’s thought process and step-by-step logic.
3. Optimization: The resulting student model—such as the DeepSeek variants—retains much of the reasoning capability of the larger model while requiring significantly less memory and providing faster response times.

This is particularly relevant for Java developers who need to deploy AI features in environments where the infrastructure costs of running a massive LLM would be prohibitive.

Mixture of Experts (MoE) Architecture

Beyond distillation, the industry is transitioning toward “Mixture of Experts” (MoE) architectures. Instead of one massive, uniform neural network, an MoE system consists of a collection of specialized sub-networks.

In this configuration, a “router” analyzes the incoming prompt and determines which “expert” sub-network is best suited to answer. For instance, a technical query about Java garbage collection would be routed to a code-specialized network, whereas a question about financial regulation would go to a legal-specialized expert. This approach ensures higher precision and reduces the total active parameters needed for a single query, leading to more efficient processing at scale.

Conclusion: The Developer as Orchestrator

The emergence of these specialized architectures changes the role of the enterprise developer. Rather than simply querying a single general-purpose model, developers must now act as orchestrators, selecting the right combination of distilled models and expert networks for their specific domain. By understanding these architectural shifts, engineers can build AI-integrated systems that are both powerful and economically viable for large-scale production.

Links:

• Frank Greco on LinkedIn
• Frank Greco on Twitter/X
• NYJavaSIG Website

Lecturer

Elma Westergren is an occupational therapist specializing in how technology impacts professional identities, particularly in software development. She collaborates with developers to explore AI’s effects on work meaning. Markus Westergren is a software architect with experience in AI integrations, focusing on the human aspects of technological change. Together, they examine occupational science in the context of AI-driven shifts.

Abstract

This article investigates how AI reshapes developers’ professional identities, drawing from occupational science and Viktor Frankl’s logotherapy. It explains concepts of identity construction, discrepancy, and disruption amid AI automation. Contextualized by predictions of job transformations, it highlights methodologies for adaptation, such as role evolution to “AI shepherd.” Through developer narratives, the narrative analyzes implications for meaning-making, resilience, and career fulfillment. The discussion offers strategies for navigating existential challenges, emphasizing purposeful responses to inevitable change.

AI’s Impact on Occupational Identity

AI’s advance prompts existential queries among developers: as agents handle coding, what defines value? Occupational science views work as identity-forming, providing purpose through production, relationships, and adaptation. Frankl’s framework posits meaning derives from choices in unchangeable circumstances.

Context: Leaders like Zuckerberg and Amodei forecast AI eliminating roles; Huang deems coding obsolete. Developers experience disruption—acute crises where core tasks automate, eroding self-concept.

Methodologically, phases include construction (building identity), discrepancy (role gaps), disruption (worth crises). Narratives illustrate: one developer felt “obsolete” as AI coded faster, triggering anxiety.

Analysis: Discrepancy arises from past “code writer” identities clashing with AI realities. Implications: unaddressed, this leads to burnout; proactive reconstruction fosters thriving.

Identity Disruption and Psychological Effects

Disruption manifests as loss: developers question relevance when AI outperforms in tasks once central. Frankl’s logotherapy suggests meaning through attitude—choosing responses to AI.

Examples: some resist, clinging to manual coding; others adapt, viewing AI as tools enhancing creativity. Contextualized, this mirrors historical shifts like automation in manufacturing, where reskilling mitigated losses.

Implications for morale: disruption erodes engagement; meaning-focused interventions restore purpose. Analysis: relationships—mentoring, collaborations—provide fulfillment beyond code.

Methodologies for Identity Reconstruction

Reconstruction involves evolving roles: from coders to “AI shepherds,” guiding agents strategically. Architectural thinking—designing systems holistically—gains prominence.

Strategies: honest dialogues on feelings, tool experimentation, peer sharing. Frankl’s dimensions map: work (new roles), relationships (connections), attitude (adaptation).

Demonstrations: hallway talks at conferences build networks; 30-minute AI trials demystify tools.

Analysis: Cycles through phases refine responses, building resilience. Implications: experience strengthens adaptation, turning anxiety into growth.

Organizational and Broader Implications

Organizations must foster safety for discussions, providing training for transitions. Broader: AI augments, not replaces, thoughtful professionals.

Future: hybrid human-AI teams emphasize human strengths like ethics, creativity.

In summary, thriving requires choosing meaning through work, connections, and attitudes, transforming AI challenges into opportunities.

Links:

• Lecture video: https://www.youtube.com/watch?v=Jo5mOBRr2b4
• Elma Westergren on LinkedIn: https://www.linkedin.com/in/elma-westergren-0b0b0b1b/
• Markus Westergren on LinkedIn: https://www.linkedin.com/in/markus-westergren-0b0b0b1b/

Lecturer

Christoph Bühler is a Research Assistant at the University of St. Gallen, focusing on software engineering, programming languages, system security, and infrastructure as code. His work explores securing AI applications. Relevant links include his LinkedIn profile (https://ch.linkedin.com/in/christoph-b%C3%BChler-a3a262270) and institutional page (https://programming-group.com/members/buehler).

Abstract

This article investigates Christoph Bühler’s discourse on agentic AI security, spotlighting vulnerabilities in tools like Model Context Protocol (MCP). It analyzes risks from function calling, proposes permission-based controls, and evaluates efficiency. Encompassing industry trends, academic citations, and future behavior analysis, it underscores mitigation’s urgency.

The Ascent of Agentic AI and Emerging Vulnerabilities

Christoph traces AI’s rapid evolution, from OpenAI’s valuation surge to widespread developer adoption, as evidenced by surveys and citations of foundational papers. The shift to agentic systems, where LLMs interact via tools and MCP—a JSON-RPC interface—marks a pivotal change. This enables dynamic actions but introduces risks, as agents inherit full user privileges. Real-world incidents, such as database deletions or drive wipes, illustrate how unchecked agents can cause harm. Contexts include the non-deterministic nature of LLMs, complicating safeguards, and prompt injections exploiting natural language weaknesses. The implications are severe, eroding trust and exposing systems to exploits that deterministic tools might prevent.

Permission-Based Controls as a Foundational Mitigation

To address these, Christoph proposes encapsulating MCP servers with permission-based access controls, akin to mobile app permissions. Developers define capabilities—file read/write, network domains—ensuring agents operate within bounds. This deterministic layer confines executions, blocking unauthorized accesses like SSH key theft. The methodology wraps servers in Docker, mapping policies to runtime constraints, with minimal overhead (0.6ms). Contexts involve compatibility with existing MCP implementations, allowing seamless adoption. The implications enhance safety without sacrificing functionality, providing a practical barrier against non-deterministic behaviors.

Extending Mitigation Through Behavior Analysis

Christoph outlines future directions, including runtime isolation for behavior analysis. Agents run unrestricted, with post-execution assessments distinguishing benign from malicious actions. This helps predict risks from prompt-agent interactions, aiding practitioners in safeguarding applications. Contexts draw from malware detection traditions, adapting them to AI’s unique challenges. The implications offer proactive tools for threat anticipation, complementing permission controls in a comprehensive security strategy.

Broader Ramifications for AI Governance

The talk emphasizes confining AI to avert historical errors like viruses. By prioritizing transparency and controls, developers can harness agentic potential responsibly. The contexts reflect industry hype outpacing security, necessitating balanced approaches. The implications advocate for human-centric governance, ensuring AI augments rather than endangers.

Links:

• Lecture Video
• Christoph Bühler on LinkedIn
• University of St. Gallen Programming Group

Lecturer

Daniel Istvan Buza is an accomplished Senior Software Engineer and Technical Lead with extensive experience in architecting Java-based ecosystems. His expertise spans a broad spectrum of technologies, including Spring, Angular, Kafka, MongoDB, and Microservices. As a leader of multiple development teams, Daniel focuses on enhancing code quality through initiatives like coding dojos and rigorous peer reviews. He is a dedicated mentor within the software community, constantly exploring innovative methodologies to bridge the gap between development and quality assurance.

Abstract

This article analyzes the transition from traditional unit testing to comprehensive acceptance and end-to-end (E2E) testing frameworks. It utilizes a real-world case study of a “silent” frontend-backend failure to illustrate why high test coverage often fails to detect integration defects. The discussion centers on the implementation of Playwright as a primary tool for stateful and stateless testing within a Java environment. By evaluating strategies for mocking external dependencies like Kafka and S3, and addressing common pitfalls such as internationalization and time zone sensitivities, this analysis provides a technical roadmap for building resilient CI/CD pipelines that go beyond the limitations of isolated component tests.

The Vulnerability of Isolated Testing

A critical challenge in modern web development is the “integration gap”—a scenario where backend and frontend components pass their respective unit tests but fail when operating in tandem. A common example involves dynamic attribute renaming: if a backend developer renames a field in a DTO (Data Transfer Object) and updates the corresponding tests, the backend remains “green.” However, if the frontend is not simultaneously updated to expect the new attribute name, the UI may fail to display data correctly, resulting in empty columns or broken features that are highly visible to users but invisible to isolated test suites.

This discrepancy highlights a fundamental truth: test coverage does not equate to test quality. Even 100% coverage cannot guarantee system correctness if the interactions between disparate services are not explicitly verified. To address this, teams must move toward “Acceptance Tests” (AC tests) that simulate actual user interactions across the entire stack.

Leveraging Playwright for Java-Centric Environments

For teams primarily composed of backend developers, selecting a testing tool that integrates seamlessly with the existing Java ecosystem is paramount. Playwright, a framework developed by Microsoft, has emerged as a robust solution due to its native Java support and its ability to automate browsers like Chrome, Firefox, and Safari.

Core Interactions in E2E Testing

The majority of web application functionality can be verified through four fundamental interaction types:

1. Clicking: Interacting with buttons, links, and navigation elements.
2. Input: Filling text and search fields.
3. Assertion: Verifying visual properties, such as the presence, color, or size of elements.
4. File Operations: Managing the upload and download of documents.

By focusing on these interactions, developers can create scripts that mirror user behavior, ensuring that the “happy path” of the application remains functional regardless of internal refactoring.

Architectural Strategies: Stateful vs. Stateless Testing

When implementing E2E tests, developers must choose between two primary architectural approaches: stateful and stateless testing.

Stateful (Environment-Targeted) Testing

In this model, tests are executed against a persistent environment with a shared database and live external APIs. This approach is highly realistic but introduces the risk of “pollution,” where data left by one test affects the outcome of subsequent tests. It requires rigorous cleanup procedures to maintain environment stability.

Stateless (Containerized) Testing

Stateless testing involves spinning up a fresh, full-featured frontend-backend pair within a CI/CD pipeline for every test run. This often utilizes embedded databases (e.g., MongoDB) and mocks for external dependencies like S3 buckets or Kafka topics. While more complex to set up, this method provides total isolation and reproducibility. However, it requires careful management of operating system dependencies within the test containers to ensure Playwright can execute the browsers correctly.

Technical Pitfalls and Best Practices

The transition to advanced automated testing reveals several subtle challenges that can undermine test reliability.

• Internationalization (i18n): Relying on UI text for selectors can lead to massive test failures when translation files are updated. Using unique element IDs is a safer alternative, though it may limit the ability to verify that the correct error messages are being displayed to the user.
• Time Zone Sensitivity: UI elements displaying timestamps will vary based on the local environment. Playwright allows developers to explicitly specify a locale to ensure consistent assertions across geographically distributed teams.
• Synchronicity: A major source of test flakiness is the misuse of Thread.sleep(). Developers should instead utilize Playwright’s built-in “wait for condition” methods to handle asynchronous backend tasks, which are more resilient to varying network or processing speeds.

Conclusion

Modern software delivery requires a testing strategy that transcends the unit level. By integrating Playwright into the Java development lifecycle, teams can automate complex user journeys and bridge the gap between frontend and backend. While no single testing setup is superior, a combination of stateful environment checks and isolated CI/CD pipelines provides the most comprehensive defense against integration defects. Developers are encouraged to treat their test code with the same rigor as production code, striving for cleanliness and maintainability to ensure long-term system reliability.

Links:

• Daniel Istvan Buza on LinkedIn
• Playwright Official Documentation
• Lecture Video: Fail Again, Fail Better!
• JUG Munich Website

Lecturer

Sundar Pichai is the Chief Executive Officer of Alphabet Inc. and its subsidiary Google. Holding degrees from the Indian Institute of Technology Kharagpur, Stanford University, and the Wharton School of the University of Pennsylvania, he has overseen the organization’s strategic shift toward an AI-first approach over the past decade.

Abstract

This article analyzes the technological breakthroughs, system architectures, and product paradigms presented at the Google I/O 2026 Keynote. Key announcements include the introduction of the Gemini 3.5 model family, the Gemini Omni multimodal world model, the Google Antigravity 2.0 agent-first development platform, and the integration of autonomous agents across Search, Workspace, and Android XR hardware. The technical, economic, and security implications of these innovations are examined in detail.

Infrastructure Scale and Custom Silicon Evolution

Scaling state-of-the-art artificial intelligence models requires unprecedented investments in compute infrastructure and specialized hardware architectures. Capital expenditure has escalated significantly, transitioning from 31 billion dollars annually in 2022 to an estimated range of 180 to 190 billion dollars. This dramatic funding increase underscores the foundational compute demands required to serve thousands of trillions of tokens across billions of global consumer and enterprise touchpoints.

A central driver of this infrastructure strategy is the eighth generation of custom Tensor Processing Units (TPUs). Google introduced a dual-chip paradigm tailored for distinct machine learning workloads:

• TPU 😯 (Training Optimized): Engineered specifically for large-scale pre-training, delivering nearly three times the raw computing power of previous iterations.
• TPU 8i (Inference Optimized): Architected to minimize latency and improve energy efficiency, delivering up to two times better performance per watt.

+-----------------------------------+
|      Google TPU Generation 8      |
+-----------------+-----------------+
| TPU 8O          | TPU 8i          |
| (Training)      | (Inference)     |
+-----------------+-----------------+
| * 3x Power      | * Low Latency   |
| * Distributed   | * ~1500 Tok/s   |
| * Multi-site    | * 2x Perf/Watt  |
+-----------------+-----------------+

To bypass the physical limits of individual data center facilities, the Jackson Pathways framework allows distributed pre-training across multiple global sites simultaneously. In inference benchmarks, next-generation Flash models executing on TPU 8i silicon achieved output processing rates approaching 1,500 tokens per second. Overall platform usage expanded to 3.2 quadrillion tokens per month, driven by over 8.5 million active developers.

+-----------------------------------+
|      Monthly Token Trajectory     |
+-----------------------------------+
| 2024: 9.7 Trillion Tokens         |
| 2025: 480 Trillion Tokens         |
| 2026: 3.2 Quadrillion Tokens      |
+-----------------------------------+

Frontier Multimodal Models and World Simulation

The frontier of generative modeling is shifting from static media generation to dynamic world simulation. The flagship Gemini Omni model unifies core large language model reasoning with specialized generative media models such as Veo, Nano Banana, and Genie.

       +--------------------+
       | Gemini Core Engine |
       +---------+----------+
                 |
     +-----------+-----------+
     |           |           |
+----+-----+ +---+------+ +--+-----+
|   Veo    | |   Nano   | | Genie  |
| (Video)  | |  Banana  | | (Sims) |
+----+-----+ +---+------+ +--+-----+
     |           |           |
     +-----------+-----------+
                 |
       +---------v----------+
       |    Gemini Omni     |
       |   (World Model)    |
       +--------------------+

Gemini Omni functions as a world model capable of understanding kinetic energy, gravitational mechanics, three-dimensional geometry, and physical interactions. It processes heterogeneous inputs—text, raster images, structured data, and video streams—to generate high-fidelity, interactive outputs.

To address the proliferation of synthetic media, Google expanded its digital provenance framework. The SynthID watermarking technology—which has marked over 100 billion images and videos alongside 60,000 years of audio assets—is complemented by explicit Content Credentials. Integrated into Google Search and Chrome via Circle to Search and context menu controls, these mechanisms verify whether content originated from physical hardware sensors or underwent generative editing.

Agentic Development Frameworks and Autonomous Systems

Agentic capabilities represent a fundamental shift from assisted output creation to goal-driven autonomous execution. Gemini 3.5 Flash serves as the foundational model for high-speed agentic tasks, demonstrating superior latency-to-intelligence ratios and performing four times faster than previous frontier models.

Google Antigravity 2.0

The agent-first software development platform, Antigravity 2.0, reorganizes developer workflows around multi-agent orchestration, asynchronous execution, and subagent teamwork. Key system primitives include:

• Subagent Networks: Division of complex engineering goals into parallel subtasks.
• Execution Hooks and Harnesses: Sandboxed environments providing file read/write, terminal command invocation, and automated unit test verification.
• CLI and Native SDK Integrations: Programmatic control binding into local development environments, Android, Firebase, and Google AI Studio.

In stress-testing evaluations, an autonomous network of 93 Antigravity subagents executed over 15,000 model requests and processed 2.6 billion tokens over a 12-hour period to construct a fully functional operating system kernel—including memory management, task scheduling, and file systems—from scratch.

+-----------------------------------+
|  Antigravity Autonomous OS Build  |
+-----------------------------------+
| Subagents Active:  93             |
| Model Requests:   >15,000         |
| Tokens Processed:  2.6 Billion    |
| Build Duration:    12 Hours       |
| Total API Cost:   <$1,000         |
+-----------------------------------+

Consumer Agent Integration: Gemini Spark

For end-user workflows, Gemini Spark introduces persistent background execution environments running on dedicated virtual machines in Google Cloud. Utilizing the Model Context Protocol (MCP) and the Antigravity agent harness, Spark handles multi-step, asynchronous directives without requiring active user sessions.

Agent commerce protocols extend these execution capabilities to financial transactions:

• Universal Commerce Protocol (UCP): An open-source communication layer standardizing product search, inventory mapping, and checkout across diverse merchant platforms.
• Agent Payments Protocol (AP2): Security protocols utilizing cryptographic digital mandates and strict spending boundaries to execute authenticated transactions on behalf of users.

+---------------+
| User Intent   |
+-------+-------+
        |
        v Cryptographic Mandate
+---------------+
| Agent (AP2)   |
+-------+-------+
        |
        v Validated Boundary
+---------------+
| Google Pay    |
+-------+-------+
        |
        v Digital Trail
+---------------+
| Merchant      |
+---------------+

Agentic Search, Generative Interfaces, and Spatial Computing

Google Search has transitioned into a native AI Search engine, consolidating traditional indexing with real-time generative capabilities.

Dynamic Generative UI

Leveraging Gemini 3.5 Flash within containerized execution sandboxes, Search dynamically designs and renders interactive user interfaces on the fly. When handling complex conceptual queries, the system writes layout code, computes parameters, and renders custom widgets or stateful micro-applications directly within the search results stream.

User Query
    |
    v
Intent Analysis
    |
    v
Agent Harness (Antigravity)
    |
    v
Generates UI & Code
    |
    v
Dynamic Rendered Visual

Spatial Computing and Intelligent Eyewear

In spatial computing, Android XR expands beyond headsets to intelligent eyewear. Audio glasses featuring integrated Gemini models deliver context-aware, heads-up interactions via directional audio drivers. Operating in tandem with personal intelligence APIs, these wearables interpret real-time environmental context, facilitate hands-free navigation, execute app workflows via voice, and interface with smartwatches for compact visual previews.

Scientific Discovery Engine and Singularitarian Horizons

The application of artificial intelligence to physical sciences represents a pivotal paradigm shift. Gemini for Science consolidates predictive tools, code synthesis, paper digestion, and hypothesis formulation into unified laboratory workflows.

Central to this scientific strategy is high-performance dynamic simulation. Alpha Earth Foundations models planetary mechanics as a digital twin to predict climate anomalies, deforestation, and agricultural vulnerability. In atmospheric science, Weather Next superseded classical numerical fluid dynamics, accurately forecasting Category 5 hurricane trajectories days prior to landfall.

+-----------------------------------+
|  Alpha Earth & Weather Next Engine|
+-----------------------------------+
| Physical Data Assimilation        |
|                |                  |
|                v                  |
| AI Twin Simulation Layer          |
|                |                  |
|                v                  |
| Predictive Early Alerts           |
+-----------------------------------+

In molecular biology, Isomorphic Labs leverages deep generative architectures to model molecular interactions at atomic precision. Moving beyond static target predictions toward preclinical drug discovery, the platform actively accelerates therapeutic candidate synthesis for oncology and autoimmune pathologies. These systems signify a systematic transition toward digital-speed empirical research.

Links:

• Google Official Website
• Sundar Pichai on LinkedIn
• Demis Hassabis on LinkedIn
• Demis Hassabis on Twitter/X
• Warby Parker Official Website
• Gentle Monster Official Website
• Samsung Electronics Official Website

Lecturer

Kenneth Walsh is a Senior Technical Evangelist at AWS, specializing in cloud financial management (FinOps) and developer productivity. With a background in software engineering and systems architecture, Kenneth focuses on empowering developers to treat “cost as a first-class citizen” in the software development lifecycle. Stacy McOwan is an AWS Developer Advocate who bridges the gap between high-level architectural decisions and day-to-day coding practices. Stacy is a frequent speaker on serverless efficiency and the application of AI to infrastructure management. Together, they provide a pragmatic guide for developers to identify inefficiencies and automate cost optimization using native AWS tools.

Abstract

For the modern cloud developer, the responsibility for system performance and reliability has expanded to include cost efficiency. As cloud environments scale, manual cost management becomes unsustainable, necessitating the adoption of automated, developer-led optimization practices. This article examines the tools and techniques available on AWS to reduce cloud spend without compromising performance. We delve into the use of Amazon Q Developer for AI-powered architectural recommendations and the Kiro CLI for identifying “low-hanging fruit” in resource utilization. The discussion highlights the transition from reactive cost analysis to a “cost-aware” development culture, where optimization is integrated into the CI/CD pipeline. Through the lens of compute, serverless, and observability, this article provides a blueprint for building fiscally responsible applications that maximize the value of every cloud dollar.

The Shift Toward Cost-Aware Development

Historically, cost management was the domain of the finance department or the infrastructure team. However, in a cloud-native world, the code written by a developer directly impacts the AWS bill. A poorly optimized database query or an oversized Lambda function can lead to significant unnecessary expenditure. Kenneth introduces the concept of “cost as a design constraint,” similar to security or latency. When developers are empowered with the right data, they can make informed trade-offs early in the design phase.

Stacy notes that the primary barrier to optimization is often “visibility and friction.” If finding an expensive resource requires navigating dozens of dashboards, it won’t happen. The goal is to bring cost data into the developer’s natural environment—the IDE and the command line. By making optimization a “feature” of the development process, organizations can foster a culture where efficiency is celebrated and waste is proactively eliminated.

AI-Driven Optimization with Amazon Q Developer

One of the most significant innovations in cloud management is the integration of Generative AI into the optimization workflow. Amazon Q Developer serves as a specialized AI assistant that can analyze a developer’s infrastructure and suggest specific, actionable changes. Kenneth demonstrates how Amazon Q can be used to “right-size” instances by analyzing historical CPU and memory usage patterns.

Beyond simple resource sizing, Amazon Q can provide architectural guidance. For example, it might suggest moving a synchronous process to an asynchronous, event-driven model using Amazon SQS to reduce the “idle time” of compute resources. This level of insight allows developers to not just “pay less for what they have” but to “build better systems that cost less by design.”

'''# Example of using AWS SDK to query for cost-optimization recommendations'''
import boto3

client = boto3.client('support')

def get_cost_recommendations():
    response = client.describe_trusted_advisor_check_summaries(
        checkIds=['eW927uS9S'] # Example ID for Cost Optimization checks
    )
    for summary in response['summaries']:
        print(f"Check: {summary['name']}, Potential Savings: {summary['hasFindings']}")

get_cost_recommendations()

The Kiro CLI: Automating the Identification of Waste

While AI provides high-level guidance, developers often need tactical tools to find specific instances of waste. The Kiro CLI (Cloud Intelligence Reports) is an open-source tool that allows developers to run “cost audits” directly from their terminal. Stacy explains that Kiro can identify “orphaned” resources—such as unattached EBS volumes, old snapshots, or elastic IPs that are not associated with an instance—which are often the biggest contributors to “invisible” cloud spend.

The power of Kiro lies in its ability to be integrated into automation. By running Kiro as part of a weekly “clean-up” script or as a pre-deployment check, teams can ensure that their environments don’t accumulate technical and financial debt over time. Kenneth emphasizes that “low-hanging fruit” optimization—cleaning up what you aren’t using—should be the first step for any organization looking to reduce its cloud bill.

Serverless and Observability: Efficiency in Action

Serverless technologies like AWS Lambda are inherently cost-efficient because they follow a “pay-for-value” model. However, Stacy warns that even serverless can be wasteful if misconfigured. “Lambda Power Tuning” is a methodology where developers test different memory configurations to find the optimal balance between execution speed and cost. Since Lambda charges based on GB-seconds, doubling the memory can sometimes reduce the cost if it cuts the execution time by more than half.

Observability is another area where costs can spiral. Logging everything at “DEBUG” level in production creates massive CloudWatch bills. The lecturers advocate for “intelligent logging,” where detailed logs are only captured during incidents or for a small percentage of transactions. By using Amazon CloudWatch Logs Insights to analyze logging patterns, developers can identify which log groups are generating the most cost and adjust their retention policies accordingly.

Conclusion: Building a Sustainable Cloud Practice

Cost optimization is not a one-time event; it is a continuous practice that requires the right tools, data, and mindset. Kenneth and Stacy conclude that by leveraging AI assistants like Amazon Q and automation tools like the Kiro CLI, developers can take ownership of their cloud spend without it becoming a burden. The ultimate goal is to build applications that are not just technically sound but also economically sustainable. When cost optimization becomes an integral part of the developer workflow, the focus shifts from “cutting costs” to “optimizing value,” enabling the organization to reinvest those savings into further innovation and growth.

Links:

• AWS Cost Management
• Amazon Q Developer
• Kiro CLI GitHub Repository
• AWS FinOps Hub

In the intricate interplay of pixels and polygons, where digital dimensions dance, Chris Ryan, a self-professed enthusiast of orthogonal artistry, unveils the underpinnings of 3D graphics. Eschewing the opacity of engines like Unity, Chris, an all-around engineer, constructs a C++ crucible to expose the mechanics—points, matrices, transforms—driving virtual vistas. His pedagogy, a bottom-up ballet, bridges novices to nuanced techniques, spotlighting sequential subtleties and multi-threaded musings.

Chris confesses his amateur allure: no expert, but an explorer of Euclidean elegance. His canvas: a C++ program, peeling back the pipeline—points plotted, matrices multiplied, perspectives projected—to illuminate 3D’s inner workings.

Points and Matrices: The Geometry Genesis

The journey begins with coordinates: 2D dots evolve into 3D vertices, vectors venturing through virtual voids. Chris clarifies: matrices mold movements—rotation, scaling, translation—mathematical maestros orchestrating object odysseys.

His demo: a cube, corners computed, transformed through matrix multiplications—row-major rigor rendering rotations. Chris’s counsel: master matrices, for they maneuver the mesh’s march.

Transforms and Coordinate Spaces: From Model to Screen

Transforms traverse terrains: model to world, world to view, view to screen—a cascade of coordinate conversions. Chris charts: model space molds objects, world space weaves scenes, view space aligns eyes, screen space flattens for display.

Rasterization resolves: 3D depths distilled to 2D displays, depth buffers dictating dominance. Chris cautions: affine errors—interpolation inaccuracies—mar mappings, demanding derivative diligence.

Rasterization Realities: Rendering the Raster

Rasterization reigns: pixels painted, triangles traced, interpolation iterating intensities. Chris’s code: scanlines sweep surfaces, z-buffers zapping overlaps—ensuring foreground fidelity.

His highlight: rasterization’s rigor, consuming cycles—60 million pixels per second, full HD faltering at 30fps on modest machines. Chris’s clarity: optimize judiciously, for pixel-pushing predominates.

Multi-Threading Musings: Parallelizing Pixels

The pipeline’s sequential soul—single-threaded—spurs scrutiny. Chris explores: multi-threading matrices, a minor marvel; rasterization’s richness resists parallel promises. GPU glances gleam, yet data transfers deter—his demo, lean with points, sidesteps silicon speedups.

His horizon: simplicity suffices for starters, but game engines’ grandeur—point profusion—demands GPU gusto.

Links:

• Chris Ryan on LinkedIn