Jonathan Lalou's Blog

Lecturer
M. Frost is a recognized AI ethicist, governance specialist, and technologist with nearly a decade of hands-on experience bridging artificial intelligence development with policy, risk management, and responsible innovation practices. She has advised numerous organizations on implementing practical AI governance frameworks, contributed to bioethics initiatives, and helped develop trustworthy AI standards. Frost excels at translating complex regulatory and ethical concepts into actionable guidance for technical practitioners.

Abstract
In this essential session at Devoxx Greece 2026, M. Frost makes a compelling case that AI governance has evolved from a specialized legal and policy concern into a fundamental responsibility shared by developers, designers, architects, and product leaders. With regulations such as the EU AI Act moving into active enforcement phases and a dynamic compliance landscape in the United States, technical decisions now carry direct implications for legal compliance, ethical integrity, and business risk. Frost equips attendees with practical frameworks, decision-making tools, and real-world strategies to integrate governance considerations throughout the development lifecycle while preserving innovation and creativity.

Understanding Why Governance Matters for Technical Teams

AI governance is no longer confined to boardroom discussions or legal reviews. It directly influences architectural choices, data handling practices, model selection, and feature design. The EU AI Act establishes a risk-based regulatory framework with specific requirements for prohibited uses, transparency obligations, human oversight mechanisms, and documentation standards for high-risk systems. In the US, a patchwork of state-level initiatives creates additional complexity, while industry standards and corporate policies attempt to establish consistent practices.

Frost argues that treating governance as an afterthought inevitably leads to higher remediation costs, potential legal exposure, and damaged user trust. Developers who incorporate governance principles early can make more informed technical decisions, reduce downstream risks, and build systems that are both innovative and sustainable.

The Interconnected Pillars of Responsible AI Development

Effective AI governance rests on several foundational pillars that technical teams must consider holistically:

• Fairness and Bias Mitigation: Addressing different forms of algorithmic bias, developing appropriate measurement techniques, understanding intersectionality across demographic factors, and implementing continuous monitoring throughout the model lifecycle.
• Transparency and Explainability: Tackling the challenges of black-box systems, implementing mechanisms that support the “right to explanation,” and designing human-AI interactions that foster appropriate trust and understanding.
• Security and Safety: Protecting against adversarial attacks, ensuring robust data protection measures, and maintaining system integrity when deployed in real-world, unpredictable environments.
• Privacy Protection: Establishing meaningful informed consent processes, applying differential privacy techniques where appropriate, and minimizing unnecessary surveillance or data collection risks.
• Accountability Structures: Clarifying liability assignment, implementing effective auditing and review processes, and establishing clear organizational ownership for AI system behavior and outcomes.
• Broader Societal Considerations: Evaluating potential impacts on employment patterns, accessibility for diverse user groups, mental health implications of AI interactions, and preservation of human autonomy and agency.

These pillars frequently create tensions and trade-offs. Privacy protections may conflict with security requirements. Fairness improvements can sometimes reduce model performance. Governance work involves making these trade-offs explicit and deliberate rather than accidental.

Practical Frameworks for Integrating Governance into Development

Frost introduces several actionable tools designed specifically for technical practitioners. A straightforward four-question decision framework helps evaluate new features, models, or system changes:

1. What do we need to do? — Clearly articulate the intended product goals, use cases, and desired outcomes.
2. What should we do? — Identify and prioritize relevant ethical principles and organizational values.
3. What must we do? — Map applicable legal, regulatory, and industry-specific requirements.
4. What can we do? — Assess technical feasibility, resource constraints, and organizational capabilities.

This iterative process, drawing inspiration from established standards such as NIST’s AI Risk Management Framework and corporate responsible AI programs, encourages teams to address governance questions proactively during design and development phases rather than as compliance checkboxes after implementation.

Additional practices include maintaining comprehensive decision documentation, identifying appropriate points for human oversight or intervention, and ensuring audit trails that support both internal review and potential regulatory examination.

Addressing the Challenges of Agentic and Multi-Agent Systems

The emergence of multi-agent and increasingly autonomous systems introduces additional governance complexities. Key considerations include managing agent autonomy levels, controlling tool access and permissions, handling memory and context persistence, and monitoring for goal drift or unintended optimization behaviors.

Frost advocates designing such systems with clear modular boundaries, implementing comprehensive logging and traceability mechanisms, and maintaining appropriate human oversight capabilities, particularly for high-stakes decisions or actions with potential for significant impact.

She cautions against “agent washing”—the tendency to overstate the autonomy or capabilities of systems that still operate within relatively narrow, human-defined parameters—and encourages rigorous, evidence-based assessment of actual system behaviors.

Building AI Systems That Earn Trust Through Responsible Practices

Governance should not be viewed as a constraint on innovation but as a discipline that enables the creation of systems worthy of user and societal trust. Frost encourages technical teams to engage with governance questions from the earliest stages of projects, participate actively in shaping both internal practices and external standards, and recognize their role as active contributors to AI’s broader societal impact.

The choices made during development—around data selection, model training approaches, feature design, and deployment strategies—collectively determine whether AI systems ultimately serve to benefit or inadvertently harm individuals and communities.

Conclusion and Resources for Continued Learning

The session concludes by reinforcing that responsible AI development is a shared responsibility requiring collaboration across technical, product, legal, and leadership functions. Frost provides curated resources and recommended reading for teams seeking to deepen their governance capabilities, emphasizing practical starting points rather than overwhelming comprehensive overviews.

Attendees leave equipped with mental models, decision frameworks, and concrete strategies for incorporating governance considerations into their daily work, enabling them to build AI systems that are not only technically excellent but also ethically sound and regulatorily compliant.

Links:

• Video: What You Need to Know About AI Governance

Lecturer

Hang Celia is a developer advocate at Amazon Web Services (AWS) based in Hong Kong, specializing in AI and robotics integrations. Saras Wang is a senior AWS Hero from Hong Kong, actively contributing to social media platforms and community discussions on cloud technologies.

Abstract

This article investigates the integration of voice control with agentic AI for managing humanoid robots, robot dogs, and drones, drawing from a collaborative project with the Hong Kong Institute of Information Technology (HKIIT). It examines the architecture for low-latency command processing, intent recognition, and responsive behaviors, while analyzing methodologies for handling continuous speech and multi-robot coordination, along with their broader implications for real-world applications.

Overview of Agentic AI and Its Future Predictions

Agentic AI marks a significant advancement in the field of artificial intelligence, shifting from passive response systems to proactive entities capable of independent planning, decision-making, and execution of complex tasks in dynamic settings. Hang Celia sets the stage by drawing on insights from leading investment analyses, which project a profound impact on various industries. For example, Goldman Sachs anticipates that by 2027, agentic AI could automate as much as 25% of routine work activities, thereby reshaping labor markets and boosting productivity across sectors. Similarly, McKinsey’s projections suggest that by 2030, this technology might account for 30% of current work hours, highlighting its potential to revolutionize operational efficiencies, especially in areas demanding real-time adaptability such as automated systems and robotics.

Building on these forecasts, agentic AI extends beyond traditional large language models by incorporating advanced capabilities like logical reasoning, external tool integration, and iterative problem-solving over multiple stages. Hang illustrates this evolution through practical demonstrations, where an agent might receive a natural language command, break it down into actionable components, query external resources via APIs, and refine its approach based on ongoing feedback. This stands in stark contrast to earlier AI paradigms, which were largely reactive and limited to single-turn interactions, and instead positions agentic systems as versatile facilitators for sophisticated human-machine collaborations, particularly in controlling physical devices like robots.

The underlying methodology for deploying agentic AI in such contexts relies heavily on cloud-based services, with AWS offerings like Amazon Bedrock providing the orchestration layer that enables seamless access to knowledge repositories and function executions. This not only facilitates rapid prototyping but also ensures that the systems can scale to handle diverse inputs and outputs. Consequently, the implications are far-reaching, as agentic AI holds the promise of making advanced robotic controls more intuitive and widespread, extending their utility from specialized research environments to everyday applications in homes, offices, and industrial facilities.

Architecture for Voice-Controlled Robotics

The architectural design of the voice-controlled robotics system is engineered to support seamless and natural interactions, combining speech processing, natural language comprehension, and agentic execution to achieve responses with minimal delay and maximal accuracy. Saras Wang provides a detailed walkthrough of the system’s structure, which harnesses a suite of AWS services to transform spoken commands into precise directives for a variety of robots, including humanoids, quadruped models, and aerial drones. At its core, the setup begins with Amazon Transcribe, which converts audio streams into text in real time, enabling the system to interpret ongoing conversations without requiring artificial pauses or structured phrasing.

From there, the processed text feeds into Amazon Bedrock, where intent detection occurs, identifying the user’s objectives and mapping them to specific robot functions. This integration allows for flexible handling of commands, such as directing a humanoid to perform a gesture while simultaneously instructing a drone to adjust its position. Saras emphasizes the importance of WebSockets in maintaining bidirectional communication channels, which facilitate not only command issuance but also feedback loops from the robots, ensuring that the system can adapt to changing conditions or confirm task completions.

In terms of methodology, the approach prioritizes optimization for diverse environments, incorporating noise-reduction algorithms to filter out background interference and edge computing elements to minimize latency in transmission. Challenges like varying accents or ambiguous phrasing are addressed through machine learning models trained on extensive datasets, which refine recognition over time. Overall, this architecture enhances usability by making robotic control as intuitive as everyday speech, while its modular design supports expansions to new device types or additional functionalities without overhauling the core framework.

Multi-Robot Coordination and Parallel Execution

Coordinating actions across multiple robots introduces layers of complexity in terms of synchronization and resource allocation, yet the project demonstrates effective solutions through strategic function calling and API optimizations that enable simultaneous operations. Hang elaborates on how agentic AI can trigger parallel invocations, allowing a single voice command to engage several devices without sequential bottlenecks. For instance, a directive to have all robots rotate could be decomposed, with the agent assigning unique tasks to each unit—perhaps turning one left, another right, and a third forward—while ensuring no conflicts in shared spaces.

Saras offers practical code insights to illustrate this parallelism:

import concurrent.futures

def control_robot(robot_id, action):
    '''# API call to robot'''
    response = robot_api.execute(robot_id, action)
    return response

with concurrent.futures.ThreadPoolExecutor() as executor:
    future1 = executor.submit(control_robot, 'robot1', 'turn_left')
    future2 = executor.submit(control_robot, 'robot2', 'move_forward')
    results = [future1.result(), future2.result()]

This code leverages threading to execute commands concurrently, significantly reducing overall response times. The methodology involves designing robot APIs to support asynchronous calls, with AWS Lambda or similar services handling orchestration to distribute loads evenly. In real-world contexts, this prevents overloads during high-demand scenarios, such as coordinated search operations with drones and ground robots.

The implications for scalability are substantial, as this framework can extend to fleets of dozens or hundreds of units, applicable in logistics warehouses or disaster response teams. By prioritizing parallel processing, the system not only improves efficiency but also enhances reliability, as failures in one robot do not halt the entire operation.

Challenges, Innovations, and Real-World Implications

While the fusion of voice interfaces with agentic AI offers immense promise, it also surfaces obstacles like debugging intricate integrations and managing network dependencies, which the project overcomes through iterative innovations and tool leveraging. Saras reflects on initial hurdles: early attempts avoided frameworks for perceived simplicity, but this led to unresolved issues in error handling and scalability. Transitioning to structured frameworks, such as AWS CLI for API conversions, resolved these, underscoring the importance of utilizing pre-existing solutions to address common pitfalls without reinventing foundational elements.

Innovations include adapting request-response APIs to streaming formats for continuous dialogues, facilitated by Amazon Q’s automation capabilities. Hang notes experiments with digital humans, where APIs process multilingual documentation—such as simplified Chinese sources—via AI-driven implementations, broadening accessibility.

Broader real-world implications span from educational tools, where students command robots intuitively, to assistive technologies for the elderly, enhancing independence. Future enhancements might include office automation, where voice directives control devices seamlessly, transforming how humans interact with intelligent systems in daily life.

Conclusion

The HKIIT-AWS collaboration vividly demonstrates how agentic AI and voice control can elevate robotics to new levels of practicality and engagement. By tackling coordination challenges and harnessing AWS infrastructure, it establishes a foundation for innovative applications that bridge the gap between human intent and machine action.

Links:

• https://www.youtube.com/watch?v=ZKqV1Ok-2-c

Lecturer

Walter Sun holds the position of Senior Vice President and Global Head of Artificial Intelligence at SAP, leading development teams across regions to advance AI integration in business solutions. With a doctorate from the Massachusetts Institute of Technology, Walter has pioneered expert agents and knowledge graphs for enterprise applications. Aaron Boucher leads SAP BTP and BDC solutions for the Americas at SAP, with twenty-five years in implementing and leading technology teams for business process optimization. Sai Patnaik specializes in SAP cloud integrations at SAP Labs, bringing twenty years of experience in IT, focusing on seamless connectivity between SAP and non-SAP systems.

Abstract

This extensive exploration scrutinizes SAP’s Business Technology Platform and its AI enhancements for augmenting SAP applications. It dissects the portfolio strategy, embedded AI features, developer tools for custom extensions, integration methodologies, and real-world deployments. By evaluating contextual enterprise needs, innovative approaches like Joule and edge integration, and ramifications for agility, compliance, and efficiency, the article illuminates how these technologies empower businesses to innovate and adapt.

Portfolio Strategy and Embedded AI Capabilities

SAP’s portfolio centers on S/4HANA Cloud ERP, complemented by HR, procurement, and CRM suites, all underpinned by the Business Technology Platform for development. This structure ensures seamless extensions, with business AI layered across to deliver ready-to-use features.

Over one hundred AI use cases address pain points, such as automated goods receipt in transportation management, reducing manual efforts for large volumes. Joule, an AI copilot, integrates across applications, using retrieval-augmented generation for contextual responses, enhancing user productivity.

Developer Tools for Custom AI Extensions

The platform’s low-code/no-code tools, like Build Apps and Process Automation, enable rapid prototyping. Generative AI hubs provide access to models from AWS, facilitating custom assistants and code generation.

Extensions maintain clean cores, avoiding modifications that complicate upgrades. Tools like ABAP Cloud and CAP support modern development, with AI assisting in code creation and testing.

Code sample for a simple AI-assisted extension in JavaScript using CAP:

const cds = require('@sap/cds');

cds.connect.to('db').then(async () => {
  const { Books } = cds.entities;
  const books = await SELECT.from(Books);
  console.log(books);
});

This illustrates connecting to databases for extensions.

Integration Methodologies for Seamless Connectivity

Integration Suite offers prebuilt connectors for SAP and non-SAP systems, with AI aiding flow creation. Edge Integration Cell deploys runtimes near Rise systems, reducing latency and ensuring compliance.

Architectures leverage AWS regions for localized deployments, managing lifecycles from a central suite.

Real-World Deployments and Business Outcomes

Customers like Dulux process five hundred messages daily via integrations. Coca-Cola Hellenic integrates with carriers reliably, while Mahindra achieves seamless SAP-non-SAP connectivity.

These deployments enhance efficiency, reduce costs, and support innovation.

Implications for Enterprise Agility and Compliance

The platform fosters agility by enabling quick adaptations without core changes. AI-driven insights improve decision-making, while edge solutions address data residency.

Future directions include broader AI adoption, promising sustained competitiveness.

In conclusion, SAP BTP with AI revolutionizes application extensions, blending innovation with reliability for transformative business value.

Links:

• Video Lecture
• Walter Sun on LinkedIn
• Aaron Boucher on LinkedIn
• Sai Patnaik on LinkedIn
• SAP Company Website

Lecturer

George Patrașcu is a seasoned software engineer at eMAG/CTO with more than twenty years of professional experience, including significant time in architectural leadership positions. Currently contributing to the Invoice and Payments platform team, George plays an active role in shaping internal developer guidelines and promoting sound architectural practices throughout a large organization characterized by hundreds of autonomous teams and diverse technology stacks.

Abstract

Within expansive microservices ecosystems featuring autonomous teams, frequent deployments, and heterogeneous technologies, business logic commonly becomes entangled with infrastructure specifics, yielding systems that are difficult to maintain, evolve, or understand. George Patrașcu presents Hexagonal Architecture—also recognized as Ports and Adapters—as a pragmatic methodology for protecting core domain logic from external dependencies including relational databases, RESTful services, event streams such as Kafka, and various third-party integrations. Grounded firmly in production realities at eMAG, the session provides balanced coverage of conceptual foundations, detailed C# implementation examples, testing approaches, and honest discussion of trade-offs encountered in practice.

The Challenges of Traditional Layered Architectures in Evolving Systems

Conventional layered architectures consisting of presentation, business, and data access tiers deliver initial value for straightforward applications. However, sustained growth across hundreds of teams utilizing varied languages (Java, .NET, Python, Scala), communication mechanisms (REST, Kafka), and continuous integration practices exposes fundamental weaknesses.

Business rules gradually permeate multiple layers: service classes reference persistence entities directly, controllers embed data access logic, and external service contracts influence domain models. Bounded contexts, a cornerstone of Domain-Driven Design, demand careful translation through anti-corruption layers, yet traditional designs frequently fail to maintain clean separation.

Resulting issues include duplicated business logic across backend-for-frontend components, mobile client platforms, and core services; severely compromised unit testing due to pervasive infrastructure dependencies; and cascading changes whenever external contracts, database schemas, or framework versions evolve. Simple folder structures offer no enforceable boundaries, while multi-module projects introduce tedious mapping layers that increase cognitive load.

Core Concepts of Hexagonal Architecture: Ports, Adapters, and the Application Core

Hexagonal Architecture fundamentally inverts dependency direction to position the domain model at the center. Business logic and associated domain entities reside within the core, depending exclusively upon abstract ports rather than concrete implementations. Input ports, implemented by driving adapters (REST controllers, message consumers), expose use cases to external actors. Output ports, realized by driven adapters (repositories, external clients), allow the core to interact with infrastructure without awareness of underlying details.

This structure adheres strictly to the Dependency Inversion Principle: high-level policy (domain) remains independent of low-level mechanisms (infrastructure). The hexagonal representation visually encapsulates the core, with ports serving as interfaces through which adapters connect. Domain objects and language remain pure, expressed in business terms rather than technical artifacts.

Flexible structuring accommodates varying scales: monolithic single projects for initial simplicity, separation of adapters by technical domain (isolating payment processors or external APIs), or evolution from modular monoliths toward independent microservices. This “build modular from the start” philosophy supports rapid feature development followed by natural service extraction when boundaries emerge.

Implementation Details, Trade-offs, and Testing Strategies

Practical development begins with domain modeling. For a rescue fleet management system, an AssembleFleet input port defines the primary use case contract. Implementation within a domain service orchestrates inventory retrieval and selection logic expressed purely in business concepts.

Driven adapters address external complexities: a Swappy client manages API pagination, performs type coercions (string passenger counts to domain integers), and implements anti-corruption filtering for inconsistent partner data. Custom domain annotations (@DomainService) facilitate integration with dependency injection frameworks without introducing technical concerns into the core.

Persistence strategies favor rich domain models mapped via ORM capabilities (e.g., shadow properties, complex types), minimizing dual maintenance of entities. This preserves core purity while leveraging framework strengths.

Testing follows clear separation: exhaustive unit tests exercise domain logic in complete isolation, while integration tests utilize fakes and mocks for adapters, verifying translation correctness without external system dependencies.

Trade-offs warrant careful consideration. The pattern excels with rich domain models containing substantial behavior but may introduce unnecessary indirection for straightforward query-dominant services. Hybrid approaches applying hexagonal principles selectively to complex logic paths, combined with CQRS separation or vertical slice organization, often prove optimal. The speakers caution against architectural dogmatism—context, team maturity, and problem complexity should guide application extent.

Architectural fitness functions, implemented via tools like ArchUnit, provide automated verification of boundaries even when AI assistance generates code.

Implications for Autonomous Teams and Long-Term Maintainability

Within large organizations featuring hundreds of developers operating with significant autonomy and minimal centralized control, Hexagonal Architecture strikes an effective balance. Teams retain freedom in implementation details while benefiting from consistency promoted through architecture guilds and shared guidelines. The pattern facilitates technology migration, incremental refactoring, and clear delineation of responsibilities.

By maintaining domain logic independent of infrastructure specifics, services demonstrate greater resilience to external changes—whether API contract updates, database platform shifts, or new integration requirements. This aligns naturally with trunk-based development, feature flag strategies, and high-frequency deployment practices, enhancing overall organizational agility.

Not every service necessitates complete hexagonal purity. Selective application targeting areas of highest coupling delivers outsized returns in testability, evolvability, developer onboarding speed, and long-term maintenance costs.

Links:

• Video: Ports, Adapters, and Other Ways to Stop Breaking Your Business Logic
• Hexagonal Architecture Original Article by Alistair Cockburn
• eMAG Technology
• ArchUnit

Lecturer

Isabel Zimmerman is a Senior Software Engineer at Posit, PBC (formerly RStudio). She was the first full-time Python open-source hire at the company and began her tenure building MLOps packages before shifting focus to the Python experience inside interactive development environments. Her current work centers on Positron, a next-generation data-science IDE. Beyond computing she is an avid fantasy reader and bookbinder, interests that inform her view of tools as objects that can carry quiet power across generations of users.

Abstract

Every practitioner occupies a position on the continuum between tool user and tool builder. This keynote explores that continuum through the dual lenses of technical excellence and human empathy. Drawing on concrete examples from the Positron IDE and the broader open-source Python ecosystem, it articulates a set of “hard skills” (modularity, reproducibility, flexibility) and “soft skills” (knowing the user, discoverability, small improvements with large impact, and explaining one’s work). The argument is that tools become delightful only when both categories are deliberately cultivated, and that the barrier to becoming a builder has never been lower.

From Consumer to Creator: Reframing Everyday Practice

A tool is defined simply as anything that carries out a particular function. Under that definition most data scientists already build tools—whether a Git alias that corrects a habitual typo, a reusable function shared in Slack, a dashboard that informs business decisions, or a private utility that solves a personal measurement problem. The psychological barrier that prevents many practitioners from identifying as builders is therefore largely artificial. Framing the act of extraction and encapsulation as tool construction lowers that barrier and simultaneously improves personal productivity and future reproducibility.

The transition from pure consumer to occasional creator is further eased by contemporary language models. Functions that once required manual packaging can now be sketched in natural language and refined iteratively. The resulting artifacts need not be public; a private package that accelerates one’s own daily workflow is already a contribution to the wider ecosystem because it reduces friction for at least one user—oneself.

Hard Skills of Tool Design

Three technical properties form the backbone of robust tools. Modularity allows a system to grow with its users. By leaning on existing community infrastructure—FastAPI for REST endpoints, Code OSS for the editor substrate—builders can concentrate effort on the distinctive value they wish to add. The same modular surface also supplies clear extension points, encouraging specialized packages that solve narrow, high-value problems.

Reproducibility remains a foundational requirement of trustworthy science. Graphical exploration interfaces are powerful, yet they risk introducing non-reproducible click sequences. Positron’s data explorer illustrates one resolution: every filter and sort operation is internally represented so that a single button can emit executable code that recreates the identical view. The cycle of exploration is thereby closed inside a language rather than left as a sequence of manual steps.

Flexibility must be tempered by the Zen of Python’s preference for simplicity. Functions that accept an ever-expanding union of input types quickly become unmaintainable. Preferring a small number of well-defined entry points and composing them later yields systems that remain extensible without collapsing under their own complexity. Context windows supplied to language models follow the same principle: start with a carefully chosen default set of information and allow the user to add or remove context explicitly.

Soft Skills and the Human Side of Interfaces

Technical excellence alone does not produce tools that people love. Empathy for the intended user is equally decisive. Data work is characterized by iterative exploration of uncharted territory, whereas classical software engineering often constructs well-specified structures in known domains. An interface optimized solely for the latter will frustrate the former. Permanent, always-available consoles, column-aware completions, and language-server optimizations tuned to data-frame idioms are concrete expressions of that empathy.

Discoverability ensures that high-impact features do not remain secret passages. Action bars that surface “render on save,” one-click code-cell insertion, and help panes that render richly formatted docstrings bring frequently needed capabilities into immediate view. Small ergonomic improvements—running a Streamlit or Dash application with the correct launcher rather than a plain Python invocation—accumulate into large reductions in daily friction.

Finally, the act of explaining one’s work closes a vital feedback loop. Writing documentation, type annotations, or even lightweight notes in a project file forces clarity of thought. The same artifacts later serve both future collaborators and future selves. The principle “if your writing helps even one person it is worth doing, especially if that person is you” applies equally to private architectural notes and public getting-started guides.

Closing the Loop Between Building and Using

Tools improve through continuous cycles of use, observation of pain points, and iterative refinement. Feedback—whether GitHub issues, hallway conversations, or structured user testing—supplies the raw material for those cycles. Because every practitioner is simultaneously a consumer and a potential contributor, each unique perspective enriches the shared ecosystem. The mission is not the construction of a final, perfect package but the ongoing cultivation of experiences that feel beautiful, empowering, and precisely fitted to the work at hand.

Links:

• Lecture video
• Positron IDE
• Posit

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/