Jonathan Lalou's Blog

Lecturer

Roberto Cortez contributes as a developer within the Quarkus group at Red Hat, concentrating on Java runtime enhancements for containerized settings. His background includes advancing from application user to primary maintainer, with a focus on compilation efficiencies and indigenous executables. Roberto regularly disseminates knowledge on streamlined Java deployments through various forums.

Abstract

This exposition scrutinizes the inner workings of Quarkus, a framework engineered for Kubernetes compatibility, which relocates conventional execution-phase tasks to assembly stages to curtail asset consumption. It dissects the pivotal function of add-ons in amalgamating external modules, facilitating attributes such as instantaneous updates, automated provisions, and GraalVM-based indigenous builds. Via empirical illustrations and programmatic excerpts, the narrative assesses strategies for add-on construction, their effects on efficacy, and wider ramifications for distributed infrastructures.

Historical Context and Paradigm Shift in Java Frameworks

Conventional Java environments, exemplified by Spring or WildFly, traditionally postpone substantial initialization to operational phases. Developers assemble classes into archives like JARs or WARs via builders such as Maven or Gradle, subsequently delegating to the environment for dissection, annotation examination, and resource instantiation. This engenders elevated memory demands from broad class importation and introspection, coupled with protracted activation intervals—frequently surpassing ten seconds prior to substantive operations.

Quarkus subverts this convention by transposing maximal computations to the construction epoch. Leveraging assembly instruments, it scrutinizes the holistic application milieu during compilation, executing refinements typically deferred. For example, setup documents like application.properties undergo parsing at build, obviating recurrent operational burdens. This “sealed-universe” presumption—wherein the complete scope is predefined—permits obsolete code excision, diminishing imported classes and memory footprint.

The advantages are manifold: calculations transpire singularly at assembly, not iteratively per instance; superfluous setup classes are discarded; and initiation hastens markedly. In nebulous ecosystems, where expenditures align with utilization, these economies yield fiscal merits. Additionally, by attenuating dependence on fluid attributes like introspection and surrogates, Quarkus bolsters foreseeability and security, transmuting prospective operational anomalies into assembly-era alerts.

This reconfiguration resonates with contemporary requisites for encapsulated, expandable solutions. Quarkus not only accommodates JVM execution but thrives in indigenous compilation through GraalVM, where constraints—like unsupported fluid class importation—demand preemptive resolutions. Add-ons surface as the cardinal instrument herein, encapsulating module-specific rationale to assure congruence sans altering the module proper.

Architectural Design of Extensions and Build Mechanisms

Quarkus add-ons compartmentalize capabilities, segregating fundamental execution from module assimilations. Each add-on encompasses dual components: deployment (assembly-era) and execution (operational-era). The deployment component exploits build phases and build artifacts—loosely interlinked notions akin to Maven stages and outputs. Build phases ingest and yield build artifacts, forging a sequence that composes the solution.

Build artifacts may be unitary (yielded once) or plural (yielded multiply), affording granular oversight. For illustration, a LaunchModeBuildItem denotes development, evaluation, or production modes, swaying ensuing phases. Add-ons interact through communal build artifacts; one might ingest REST terminus particulars from another for bespoke handling.

Jandex, an indexing utility, surveys the class route for annotations, derivations, or realizations, enabling metadata-guided determinations. Bytecode capturers seize assembly-era entities for operational reconstitution, circumventing instantiation expenses. Contemplate a module with a protracted constructor:

public class Warrior {
    public Warrior() {
        System.out.println("Preparing...");
        Thread.sleep(10000); // Emulated latency
        System.out.println("Preparation done!");
    }
    public String strike() { return "Energy blast!"; }
}

Within the add-on’s handler:

@BuildStep
void captureWarrior(RecorderContext recorderContext) {
    Warrior warrior = new Warrior();
    recorderContext.capture(warrior);
}

Quarkus fabricates bytecode to regenerate the entity operationally, sidestepping the latency.

For indigenous congruence, add-ons enroll introspection metadata or furnish replacements. GraalVM’s sealed-universe precludes fluid attributes unless overtly configured, thus add-ons manage this unobtrusively.

Empirical Assimilation: Scenarios and Refinements

To exemplify, ponder amalgamating DataFaker, a mock data generator. It functions in JVM mode yet falters indigenously owing to static initializers invoking stochastic services during assembly. An add-on rectifies this:

• Unearth suppliers via Jandex: index.getAllKnownSubclasses(AbstractProvider.class).

• Enroll instantaneous reload monitors: HotDeploymentWatchedFileBuildItem for YAML setups.

• Capture Faker entities: Employing non-standard constructors or replacements for serialization.

• Indigenous rectifications: ReflectiveClassBuildItem for constructors; replacements to postpone stochastic initialization.

Programmatic fragment for supplier unearthing:

@BuildStep
MultiBuildItem unearthSuppliers(IndexView index) {
    Collection<ClassInfo> suppliers = index.getAllKnownSubclasses(AbstractProvider.class.dotName());
    for (ClassInfo supplier : suppliers) {
        // Handle YAML, monitor reload, yield DataFakerProviderBuildItem
    }
}

This enables infusion:

@Inject
@AnimeCharacters // Bespoke qualifier
Faker faker;

Replacements supersede problematic static segments:

@TargetClass(StochasticService.class)
final class StochasticServiceReplacement {
    @Alias
    static StochasticService INSTANCE;

    @Substitute
    public static StochasticService employDirect() {
        // Postpone to operation
        return new StochasticService(new Stochastic());
    }
}

Such amalgamations not only resolve congruence but augment usability, like auto-reinvigorating bespoke suppliers.

Add-ons also unlock Quarkus traits: Dev Services instantiate vessels predicated on discerned dependencies; perpetual testing reexecutes impacted evaluations; unified setup rationalizes arrangements.

Wider Ramifications for Creation and Deployment

By embedding module rationale in add-ons, Quarkus cultivates a dynamic milieu—myriad accessible via code.quarkus.io, spanning Red Hat-endorsed to communal inputs. Creators can fabricate bespoke add-ons for proprietary modules, assuring comprehensive Quarkus merits sans bifurcating originals.

Efficacy gains are considerable: diminished memory and swifter initiations suit serverless and Kubernetes milieus, curtailing expansion latencies. Indigenous images, transmuting to executables, amplify this for peripheral computation or constrained apparatuses.

Hurdles encompass cognitive reorientations—imaginatively discerning assembly-era prospects—and module erudition for precise amalgamations. Yet, the framework’s adaptability, with elective traits like bytecode fabrication, accommodates diverse intricacy.

In recapitulation, Quarkus add-ons epitomize a refined progression in Java environments, accentuating proficiency and creator encounter. They authorize designers to erect durable, refined solutions, synchronizing with nebulous-native doctrines and establishing a criterion for prospective runtimes.

Links:

• Lecture video: https://www.youtube.com/watch?v=zVEcqrHQXwI
• Roberto Cortez on LinkedIn: https://www.linkedin.com/in/rcortez777/
• Roberto Cortez on Twitter/X: https://twitter.com/rcortez777
• Red Hat website: https://www.redhat.com/

Lecturer

Aditi is a Senior Product Manager for Amazon FSx at Amazon Web Services (AWS). With years of experience working directly with customers on high-performance workloads, she focuses on pushing the technical boundaries of what is possible with cloud storage to meet the demands of modern compute-intensive applications.

Abstract

This article examines the critical role of high-performance storage in supporting modern AI/ML, analytics, and High-Performance Computing (HPC) workloads. As organizations scale their compute resources—incorporating hundreds or thousands of CPU and GPU cores—storage often becomes the primary bottleneck, preventing linear performance scaling. We explore the technical architectures of Amazon FSx and Amazon S3, focusing on how these services address the needs of both “lift-and-shift” file-based applications and “cloud-native” S3-based data lakes. By analyzing customer use cases in genomics, media rendering, and large language model (LLM) training, we detail the methodologies for achieving peak performance at scale.

The Storage Bottleneck in Compute-Intensive Workloads

Modern high-performance workloads are characterized by their extreme reliance on massive datasets and high-core-count compute clusters. In an ideal cloud environment, adding more compute resources should lead to a proportional increase in work completed—a concept known as linear scaling. However, traditional storage solutions often fail to keep pace with the throughput demands of these clusters, leading to a performance plateau.

When storage becomes the bottleneck, compute instances sit underutilized as they compete for access to the same data store. This is particularly detrimental given that 90% to 95% of the expenditure for these workloads is typically allocated to compute resources. Consequently, an inefficient storage layer not only extends the time to insight but also significantly increases the total cost of ownership (TCO). To avoid this, storage must be architected to scale linearly alongside compute.

Navigating the Path to the Cloud: File Systems vs. Object Storage

Organizations generally approach high-performance storage on AWS from two distinct backgrounds: those with long-standing on-premises file-based workflows and those who have built native cloud applications around object storage.

The Persistence of File-Based Architectures

Despite the rise of object storage, file systems remain the preferred interface for many researchers and developers due to three primary factors: Familiar Interface: The intuitive nature of files and directories simplifies complex data management for data scientists and developers.
* Granular Permissions: File systems provide robust POSIX permissions, allowing for fine-grained control over which users can read, write, or execute specific files.
* Consistent Data Access:* For workloads where multiple users or compute nodes access the same data simultaneously, the strong consistency of file systems ensures that all parties see the most recent data updates.

Amazon FSx for High-Performance File Access

Amazon FSx addresses these needs by providing fully managed file systems that offer the performance of local storage with the scalability of the cloud. For “lift-and-shift” scenarios, FSx allows organizations to move their existing HPC and AI/ML pipelines to AWS without refactoring their applications.

Accelerating Generative AI and ML Workloads

The emergence of generative AI has placed a renewed emphasis on data strategy. Whether an organization is building a model from scratch or fine-tuning a foundational model, the quality and accessibility of its proprietary data are the primary differentiators.

Retrieval Augmented Generation (RAG)

To move beyond generic AI responses and reduce hallucinations, many organizations are implementing Retrieval Augmented Generation (RAG). RAG allows foundational models to access evolving, large-scale data lakes without requiring the data to be manually loaded into a prompt.

The RAG methodology involves:
1. Vectorization: Converting organizational data into vectors—numeric representations that capture semantic meaning.
2. Semantic Search: Using spatial similarity to compare a query vector against the data lake’s vectors to find the most relevant information.
3. Augmentation: Feeding the retrieved context back into the model to generate a more accurate and business-specific response.

Ingestion and Data Strategy with Amazon S3

Amazon S3 serves as the foundational data lake for these AI workflows due to its cost-effectiveness and virtually unlimited scalability. Organizations typically utilize two ingestion patterns:
* Batch Ingestion: Suitable for static or infrequently changing data such as historical records and product catalogs.
* Real-Time Ingestion: Essential for agentic workflows where AI models must respond to the latest available information.

Modernizing Self-Managed Databases with Amazon FSx

While fully managed services like Amazon RDS are popular, certain business and technical requirements drive organizations toward self-managed database architectures on AWS.

Drivers for Self-Managed Databases

Organizations choose to self-manage databases like Oracle, SQL Server, or SAP HANA for several reasons:
* Granular Control: The ability to choose specific versions of the database engine and the underlying operating system.
* Custom Protection Policies: Implementing specific backup intervals and recovery procedures that may not be available in managed services.
* High Resilience: Scaling databases across multiple Availability Zones or regions with custom failover configurations.

Optimization through Storage Features

A common oversight in database deployment is the potential for the storage layer to add significant value beyond simple data persistence. Amazon FSx file systems (including FSx for NetApp ONTAP, OpenZFS, and Windows File Server) enable features like:
* Snapshots and Cloning: Facilitating rapid testing and database upgrades by creating near-instantaneous copies of production environments.
* Performance Tuning: Choosing the right FSx service can significantly optimize the TCO and performance of database environments, particularly for high-transaction workloads.

Conclusion

As compute power continues to expand, the storage layer must evolve from a passive repository into a high-performance engine. By leveraging Amazon FSx and S3, organizations can eliminate storage bottlenecks, enabling their most demanding AI, HPC, and database workloads to scale linearly and cost-effectively in the cloud.

Links:

• Amazon FSx Product Page
• Amazon S3 Product Page
• AWS re:Invent 2025 – High-performance storage for AI/ML, analytics, and HPC workloads (STG336)
• AWS re:Invent 2025 – Accelerate gen AI and ML workloads with AWS storage (STG201)
• AWS re:Invent 2025 – Improve self-managed database performance and agility with Amazon FSx (STG337)

Lecturer

Kevin Dubois is a Senior Principal Developer Advocate at IBM, previously with Red Hat, focusing on Java, AI, and cloud-native development. As a Java Champion and Technical Lead for the CNCF Developer Experience Technical Advisory Group, Kevin authors content, speaks internationally, and contributes to open-source projects. Mario Fusco, co-presenter, is a Senior Principal Software Engineer at IBM (Red Hat), leading the Drools project. A Java Champion with expertise in functional programming and domain-specific languages, Mario coordinates the Milano Java User Group and frequently speaks on software engineering topics. Relevant links include Kevin’s LinkedIn profile (https://ch.linkedin.com/in/kevindubois), Mario’s LinkedIn profile (https://it.linkedin.com/in/mario-fusco-3467213), and Mario’s X account (https://x.com/mariofusco).

Abstract

This article investigates patterns in agentic AI systems as presented by Kevin Dubois and Mario Fusco, emphasizing orchestration of AI services for complex tasks. It delineates foundational components, workflow-based orchestration, autonomous agent models, and extensible planners. Through analysis of methodologies in LangChain4j with Quarkus, it elucidates contexts, implementations, and ramifications for building sophisticated AI applications.

Foundations of AI Services and Agentic Systems

Kevin and Mario initiate their discourse by establishing core elements of AI-infused applications, particularly within Java ecosystems using LangChain4j and Quarkus. An AI service fundamentally interfaces with a large language model (LLM) to process inputs and yield responses. However, effective integration demands more: precise prompting to elicit desired outputs, memory management to sustain conversational context, tool invocation for external actions, and data augmentation via retrieval-augmented generation (RAG).

Prompting emerges as pivotal; vague instructions yield suboptimal results, whereas structured prompts enhance accuracy. Memory, absent in standalone LLMs, requires client-side tracking—LangChain4j automates this, customizable via caching. Tools enable LLMs to perform actions like database queries or email dispatch, via function calling where LLMs request tool usage.

RAG integrates proprietary data: embeddings store vectorized information in databases like Pinecone, retrieved to enrich prompts. Moderation filters harmful content, ensuring ethical outputs.

Agentic systems extend this: agents, autonomous entities with goals, leverage these components. Patterns categorize into workflows (predefined paths) and autonomous agents (dynamic LLM-directed processes). Contexts include scenarios needing multi-step reasoning, like trip planning involving weather, flights, and accommodations.

Implications: These foundations enable modular, scalable AI, but demand careful design to mitigate errors like hallucinations.

Code illustrates basics:

@RegisterAiService
interface WeatherAgent {
    String getWeather(String city);
}

This defines an AI service interfacing with an LLM for weather queries.

Workflow-Based Orchestration of Agents

Workflow patterns orchestrate agents through coded sequences, suitable for predictable tasks. Kevin and Mario detail sequential, parallel, conditional, and looping workflows in LangChain4j.

Sequential invokes agents in order: e.g., weather retrieval followed by outfit suggestion. Parallel executes concurrently, aggregating outputs—useful for independent subtasks like multi-city weather checks.

Conditional branches based on outputs: if weather is rainy, suggest indoor activities. Looping iterates until conditions met, like refining content via reviewer-critic cycles.

Methodology employs builders:

AgenticSystem system = AgenticSystem.builder()
    .sequence(weatherAgent, outfitAgent)
    .build();

Execution yields structured results, with event logs for monitoring.

Contexts: Workflows suit deterministic processes, reducing LLM variability. Implications: Enhance efficiency but limit adaptability; error handling via retries or prompt adjustments is crucial.

Autonomous and Dynamic Agent Orchestration

Autonomous patterns empower an LLM-orchestrator to dynamically select agents, ideal for unstructured tasks. The orchestrator evaluates inputs, plans invocations, and executes, adapting via reasoning.

Mario explains: Orchestrator prompts guide tool (agent) selection. Execution involves planning, tool calls, and result integration until resolution.

AgenticSystem system = AgenticSystem.builder()
    .autonomous(orchestrator)
    .agents(agent1, agent2)
    .build();

Contexts: Handles ambiguity, like open-ended queries. Implications: Increases flexibility but risks infinite loops or off-track reasoning; human-in-the-loop mitigates via approvals.

Multimodal extensions process PDFs or generate images, expanding applicability.

Extensible Planners for Custom Agentic Patterns

To accommodate diverse needs, Mario introduces pluggable planners, abstracting orchestration. This service provider interface (SPI) allows custom implementations, like goal-oriented patterns using A* search.

Planners initialize with agents, determining next actions: invoke agents (sequentially/parallel) or conclude. Existing patterns refactor atop this.

Goal-oriented example: Define prerequisites and goals; algorithm generates invocation graphs.

Planner customPlanner = new GoalOrientedPlanner(agents);
AgenticSystem system = AgenticSystem.builder()
    .planner(() -> customPlanner)
    .build();

Hybridization combines patterns, e.g., goal-oriented with loops for refinement.

Contexts: Custom scenarios like adaptive learning systems. Implications: Fosters innovation, but requires algorithmic expertise; promotes modularity in AI design.

In summary, Kevin and Mario’s patterns advance agentic AI, blending structure with dynamism for robust applications.

Links:

• Lecture Video
• Kevin Dubois on LinkedIn
• Mario Fusco on LinkedIn
• Mario Fusco on X

Keynote Speakers

Jamal Eason serves as the Director of Product Management for Android Studio at Google, guiding its evolution to support high-quality app creation across devices. Educated at Harvard Business School, he focuses on AI integrations and workflow efficiencies.

Tor Norbye holds the role of Engineering Director for Android Studio at Google, leading technical advancements in IDE capabilities. With a Stanford University background, his work emphasizes tools for debugging, testing, and cross-platform development.

Abstract

This in-depth review investigates updates to Android Studio, emphasizing AI-driven features, testing tools, and build optimizations to streamline developer processes. It explores methodologies for Gemini-assisted coding, XR emulation, and enterprise licensing, contextualized within Android’s diverse ecosystem. By dissecting demonstrations and roadmaps, the analysis gauges implications for productivity, quality assurance, and scalable engineering.

Road Map Evolutions and Core Updates

Jamal Eason and Tor Norbye outline Android Studio’s accelerated release cadence, aligning with IntelliJ while incorporating Android-specific features. Eason recaps Ladybug and Maricat cycles, highlighting Wear preview, Health Services, and SDK insights integration to preempt publishing issues.

Methodologically, doubled releases facilitate rapid iterations, with platform drops syncing to IntelliJ and feature drops adding Android enhancements. Bug resolutions exceed 700, underscoring quality focus.

Implications include faster adoption of platform changes, reducing fragmentation risks in multi-device apps.

AI-Powered Assistance with Gemini

Norbye demonstrates Gemini’s workflow integrations, from code suggestions to crash resolutions. Contextual prompts generate tests or documentation, with enterprise plans ensuring data security.

Code sample for Gemini query:

// Prompt: Generate unit test for this function
fun add(a: Int, b: Int): Int = a + b

Gemini outputs comprehensive tests, implying accelerated debugging. Contexts involve privacy-compliant models, with implications for inclusive development via natural language interfaces.

Testing and Emulation Advancements

Norbye showcases backup/restore testing, simulating data migrations across versions. XR emulators enable spatial app validation, detecting issues like occlusion.

Visual linting flags UI flaws in previews, while device streaming via Firebase supports remote testing. These methodologies enhance reliability, implying reduced post-launch defects.

Build and Enterprise Optimizations

Eason introduces gradual R8 for selective shrinking, phased sync for faster loads, and fused libraries for efficient AARs. IDE sync and JDK alignment streamline configurations.

Enterprise Gemini offers management controls, while cloud instances provide remote environments. Implications span cost savings and compliance in large teams.

Links:

• Jamal Eason on LinkedIn
• Tor Norbye on LinkedIn
• Lecture Video

Lecturer

Anders Norås is a software engineer and speaker known for exploring unconventional approaches to coding and language design. He frequently presents on topics that challenge traditional programming practices while revealing deeper insights into how languages shape thought processes.

Abstract

The Oulipo literary movement of the 1960s imposed artificial constraints on writing to spark creativity and produce novel works. Anders Norås applies similar principles to programming, reimagining familiar exercises under unusual restrictions. By removing common language features or enforcing mathematical structures, developers gain fresh perspectives on problem-solving. The presentation demonstrates how such constraints reveal hidden capabilities within languages, encourage exploration of alternative paradigms, and foster deeper appreciation for the tools we use daily. Far from mere novelty, this approach yields practical lessons about flexibility, idiom discovery, and creative thinking in software development.

The Oulipo Tradition and Its Relevance to Programming

The Ouvroir de littérature potentielle, or Workshop of Potential Literature, sought to expand creative possibilities through self-imposed rules. Authors produced works without using specific letters, following mathematical patterns, or adhering to other arbitrary constraints. These limitations, rather than stifling expression, forced innovative solutions and surprising results.

Programming shares fundamental similarities with writing. Both involve crafting structures from symbolic systems to convey meaning or achieve outcomes. Both benefit from deliberate practice and exploration of form. Just as Oulipo writers discovered new literary techniques, programmers can uncover language capabilities and problem-solving approaches by temporarily restricting their usual tools and patterns.

This method serves multiple purposes. It combats the complacency that develops from repeatedly solving problems the same way. It encourages examination of features developers might otherwise overlook. Most importantly, it transforms routine tasks into opportunities for discovery and renewed engagement with the craft.

Exploring Familiar Problems Under Novel Constraints

Classic programming exercises provide ideal subjects for constraint-based experimentation. The FizzBuzz problem, for instance, typically relies heavily on conditional statements. Removing the ability to use if statements or ternary operators forces alternative implementations that reveal language-specific idioms and capabilities.

One approach in C# leverages pattern matching within switch expressions to handle the logic. The resulting code, while unconventional, demonstrates how modern language features can replace traditional control structures. Translating the same constraint to Java yields an elegant, albeit unusual, solution using string repetition methods. These variations highlight how different languages encourage distinct thinking patterns even when solving identical problems.

Chessboard traversal problems offer another rich domain. The standard Warnsdorff’s rule provides an efficient algorithmic solution for visiting every square exactly once. However, constraint exercises might require solving the same task through exhaustive backtracking, ant colony optimization simulating natural behavior, genetic algorithms, or Monte Carlo tree search. Each method exposes different aspects of computational thinking and language expressiveness.

The value lies not in replacing established algorithms but in understanding the range of possible approaches. By deliberately limiting options, developers gain appreciation for why certain solutions feel natural in specific languages and discover techniques transferable to everyday work.

Benefits and Practical Applications

Constraint-based programming yields several advantages. It reveals language features that receive little attention in typical development. It encourages deeper engagement with syntax and semantics, moving beyond surface-level usage. It fosters creativity by breaking habitual patterns, often leading to more elegant or insightful solutions even after constraints are lifted.

Teams can apply these ideas in several ways. Code katas or brown-bag sessions focused on constrained implementations build collective knowledge and discussion. Exploring how the same problem manifests across languages strengthens architectural thinking and technology evaluation skills. Individual developers benefit from occasional deliberate practice that prevents skill stagnation.

The approach also serves as an effective teaching tool. Students or new team members gain rapid insight into language philosophy when asked to solve problems while avoiding common constructs. The resulting discussions illuminate design decisions embedded in language evolution.

Broader Implications for Software Development Culture

Modern development increasingly involves instructing AI systems rather than writing every line manually. In this environment, human strengths shift toward system thinking, trade-off analysis, and creative problem framing. Constraint exercises hone precisely these capabilities by forcing reconsideration of fundamental assumptions.

The Oulipo-inspired mindset aligns with broader movements in software craftsmanship that value deliberate practice and reflection. It echoes the Japanese concept of finding meaning in the space between elements—discovering insights that emerge when conventional approaches are temporarily set aside.

Programming communities benefit when members periodically step outside comfort zones. New libraries, paradigms, and techniques often arise from individuals willing to question established norms. By cultivating curiosity through playful constraint, developers contribute to collective advancement while maintaining personal engagement with the craft.

Embracing Constraints as Catalysts for Growth

The central insight from Oulipo applied to code is that limitations can liberate. By temporarily removing familiar tools or imposing unusual rules, programmers discover unexpected pathways and deepen their mastery of available ones. What begins as an exercise in absurdity often yields practical wisdom and renewed appreciation for the languages and techniques we employ daily.

This practice requires no special resources beyond willingness to experiment. A simple problem, a chosen constraint, and honest reflection suffice to begin. Over time, the habit of viewing constraints as invitations rather than obstacles transforms how developers approach challenges both large and small.

In a field where routine can dull creativity, the workshop of potential code offers a refreshing reminder that innovation often hides in the space between what we usually do and what becomes possible when we choose differently.

Links:

• Video: Ouvroir de Code Potentiel by Anders Norås
• Anders Norås on LinkedIn

Lecturer

Danny Leybovich is a Product Lead at Anthropic, dedicated to building the infrastructure and models that empower the next generation of AI developers. With a focus on high-reasoning models and developer experience, Danny has been instrumental in the launch of Claude Code and the evolution of Anthropic’s agentic framework. His work centers on the practical realities of moving AI from “cool demo” to “reliable autonomous system.”

Abstract

2025 marked a pivotal shift in the artificial intelligence landscape: the transition from interactive chatbots to autonomous AI agents. This article synthesizes the key discoveries made by Anthropic during this transformative year, particularly through the development of Claude Code and the deployment of the Opus 4.5 frontier model. It explores the “agentic architecture” required for long-horizon autonomous work, emphasizing the critical roles of context engineering and skill acquisition. The analysis examines the shift toward “agent-first” workflows, where the model is no longer a passive assistant but an active participant with multi-hour reasoning capabilities. By investigating patterns of reliability and the evolution of AI engineering practices, this article provides a roadmap for the next wave of agentic AI.

The Shift to Agent-First Workflows

In the early stages of generative AI, the predominant interaction pattern was the “chat” interface—a stateless exchange where a human provided a prompt and the model provided a response. 2025 saw the obsolescence of this limited model in favor of “agent-first” workflows. In an agentic architecture, the model is granted the autonomy to use tools, manage its own memory, and pursue goals over extended periods—sometimes lasting hours.

This shift changes the fundamental role of the developer. Instead of engineering a single prompt, the developer now engineers an environment in which an agent can succeed. This involves defining clear objectives, providing access to necessary APIs, and implementing “guardrails” that ensure the agent remains on track during autonomous loops. The rise of “Claude Code”—an agent that can autonomously file GitHub issues and build applications—serves as the flagship example of this transition.

Advanced Context Engineering: Beyond the Context Window

While early AI discussions focused heavily on the size of the “context window,” Anthropic’s experience in 2025 highlighted that quality of context is far more important than raw volume. Context engineering is the practice of strategically selecting and formatting the information provided to the model to maximize reasoning accuracy and minimize hallucinations.

Effective context engineering for agents involves:

1. State Management: Keeping track of what the agent has already done and what remains to be accomplished.
2. Relevant Document Retrieval: Using RAG (Retrieval-Augmented Generation) to pull only the most pertinent information into the reasoning loop.
3. Semantic Chunking: Ensuring that the information is presented in a way that the model can easily digest and connect to other data points.

By focusing on context engineering, developers can enable agents to maintain “state” across long horizons, allowing for complex tasks like refactoring an entire codebase or conducting multi-step regulatory research without losing the thread of the original objective.

Tool Construction and Skill Acquisition

A primary differentiator for AI agents is their ability to interact with the world through tools. In 2025, Anthropic refined the methodology for “teaching” agents new skills through tool construction. A “skill” is essentially a well-defined tool—such as a Python interpreter, a SQL query engine, or a web search function—that the model knows how and when to invoke.

The engineering challenge lies in creating “reliable” tools. If a tool’s output is ambiguous or inconsistent, the agent’s reasoning loop will break. Therefore, tool writing has become a core discipline within AI engineering. Developers must create tools that provide “structured feedback” to the model, allowing the agent to self-correct if a tool call fails. This iterative loop of tool use and self-correction is what allows agents to handle “long-horizon” tasks that were previously impossible for LLMs.

Analyzing the Performance of Opus 4.5

The release of the Opus 4.5 frontier model provided the reasoning “horsepower” necessary for the agentic revolution. Unlike smaller models that might prioritize speed, Opus 4.5 is optimized for high-reasoning tasks. Its performance characteristics include a significant reduction in “logic drift”—the tendency of a model to lose focus during long sequences of thought.

In production environments, Opus 4.5 has demonstrated an ability to navigate “deep” decision trees. For example, when tasked with finding a bug in a complex software system, the model can formulate a hypothesis, write a test to prove it, analyze the test results, and then iteratively refine its approach. This capability for “autonomous debugging” is a hallmark of the newest wave of AI, where the model’s intelligence is leveraged not just for text generation, but for problem-solving in dynamic environments.

Code Sample: Defining a Secure Tool for Claude Agentic Workflows

'''
 Conceptual tool definition for an Anthropic Agent
 This tool allows the agent to safely query a database
''' 

def get_tool_definition():
    return {
        "name": "query_database",
        "description": "Allows the agent to execute read-only SQL queries to retrieve customer data.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "The SQL query to execute. Must be read-only."
                },
                "max_rows": {
                    "type": "integer",
                    "default": 10
                }
            },
            "required": ["query"]
        }
    }

'''
This structure enables the model to 'reason' about when it needs 
to fetch data versus when it can rely on its internal knowledge.
'''

Long-Horizon Autonomous Reliability

The final frontier explored in 2025 was the challenge of reliability. For an agent to be truly useful, it must be able to work for hours without human intervention. This requires a robust infrastructure that can handle model timeouts, API failures, and unexpected edge cases.

Anthropic’s research into long-horizon agents suggests that reliability is not a feature of the model alone, but a result of the model-infrastructure synergy. This includes:

• Checkpointing: Periodically saving the agent’s state so it can resume after a failure.
• Human-in-the-Loop (HITL) Triggers: Designing the agent to “ask for help” when it reaches a confidence threshold that is too low.
• Verification Loops: Implementing a secondary model or a deterministic process to verify the agent’s output before it is committed.

These patterns are what define the current state of the art in AI engineering, moving the industry toward a future where agents are trusted partners in the enterprise.

Conclusion

The lessons of 2025 are clear: the future of AI belongs to autonomous agents. By mastering the disciplines of context engineering, tool construction, and long-horizon reliability, developers can leverage models like Claude Opus 4.5 to solve problems of unprecedented complexity. As we look ahead, the trends established this year—particularly the move toward agent-first workflows—will define the next decade of technological innovation. The demo era is over; the production era of agentic AI has begun.

Links:

• Anthropic Official Website
• Claude Model Documentation
• Anthropic on AWS Bedrock

Lecturer

Andreas Dangel is a distinguished software engineer with extensive expertise in Java, Spring, SQL, and agile methodologies. With a professional career spanning several decades, he has significantly contributed to the IoT consumer electronics industry. Andreas has been a pivotal figure in the open-source community, serving as a maintainer of PMD since 2012 and a committer at the Apache Software Foundation for the Maven project. Currently based in Munich, he continues his professional endeavors at MicroDoc.

Abstract

This article explores the comprehensive transformation of PMD, a leading multi-language static code analyzer, through its significant transition to version 7. It examines the fundamental principles of PMD—including its rule-based architecture and copy-paste detection—while detailing the modernization of its core engine to support evolving language features and improved performance. The analysis highlights the challenges faced during this decade-long development cycle, the shift in architectural paradigms to accommodate complex language parsing, and the strategic roadmap for the future of automated code quality assurance.

The Architecture of Static Analysis: Understanding PMD

PMD serves as a sophisticated static code analyzer designed to identify problematic patterns, common mistakes, and stylistic inconsistencies across various programming languages. Originally established in 2002 as the “Project Mistake Detector,” the tool has evolved into a robust, rule-based ecosystem supporting over ten languages. The system’s utility is grounded in its ability to detect issues that often elude standard compilers, categorized into domains such as error-prone constructs, best practices, code style, and performance.

The engine operates on a rule-based methodology where every detectable problem is governed by a specific rule. PMD offers users more than 400 predefined rules, including 270 specifically for Java. These rules can be customized through two primary methods: writing custom Java classes or utilizing XPath expressions to query the source code’s Abstract Syntax Tree (AST). To facilitate the latter, the PMD ecosystem includes a “Rule Designer” application, allowing developers to visualize code structures and test XPath queries in real-time.

Beyond standard rule checking, PMD includes a specialized Copy-Paste Detector (CPD). Unlike the core engine, which requires deep language parsing, CPD utilizes a different technological approach that allows it to support an even broader range of languages for identifying duplicated code blocks.

Implementation and Integration Strategies

PMD’s versatility is reflected in its diverse integration options within the modern software development lifecycle. Written in Java, the tool can be executed via a simple command-line interface (CLI) or integrated into various build and development environments.

Build Tool Integration

For Java-centric projects, integration via build automation tools is the standard approach:

• Maven: Utilizing the maven-pmd-plugin, developers can automate code verification and copy-paste detection as part of the build process.
• Gradle and Ant: Similar plugins exist to ensure code quality is maintained continuously without manual intervention.
• Quality Gates: By configuring the build to fail upon rule violations, PMD serves as a mandatory quality gate, ensuring that no substandard code reaches the repository.

IDE and CI/CD Ecosystems

To provide immediate feedback, PMD supports major Integrated Development Environments (IDEs) including Eclipse, IntelliJ IDEA, and VS Code. Furthermore, it is deeply integrated into Continuous Integration (CI) services. For instance, Jenkins utilizes specialized plugins to visualize results and track the history of violations across builds, providing insights into whether code quality is improving or deteriorating over time. Modern cloud services and GitHub Apps also leverage PMD to perform automatic code reviews during pull requests, providing comments directly on the affected code blocks.

Innovations in PMD 7: Redesigning the Engine

The transition to PMD 7 represents a fundamental shift in how the tool processes source code. The primary driver for this major release was the need to overcome the limitations of the aging architecture that had been in place for nearly two decades.

The internal redesign focuses on several key areas:

1. Parsing Modern Java: As Java’s release cadence accelerated, PMD needed a more flexible way to handle new language features like records, sealed classes, and pattern matching.
2. Performance Optimization: The new version introduces architectural changes that improve the speed of analysis, particularly for large-scale projects with hundreds of rules.
3. Language Support Expansion: While Java remains a core focus, PMD 7 strengthens its multi-language capabilities, including better support for languages like Salesforce’s Apex.

One of the significant challenges in this journey was maintaining backward compatibility while significantly altering the AST structure. The development team had to balance the introduction of more descriptive node types with the risk of breaking existing custom rules written by the community.

Future Directions and Sustainability

Looking ahead, the PMD project aims to enhance its analysis capabilities by incorporating more data-flow and control-flow sensitivity. This would allow the tool to detect more complex logic errors that require understanding the state of variables across different execution paths.

Sustainability remains a focal point for the project. As an open-source initiative maintained by a small core team of three individuals and occasional contributors, the “Journey to PMD 7” also serves as a case study in open-source lifecycle management. The roadmap includes simplifying the process of writing and maintaining rules to encourage more community participation and ensuring the tool remains relevant in an era of increasing automated development.

Links:

• Andreas Dangel on LinkedIn
• PMD Project on GitHub
• Munich Java User Group (JUGM) Website
• Lecture Video: Journey to PMD 7

Lecturer
Josh Long is a Spring Developer Advocate at VMware, widely recognized as one of the most prominent voices in the Spring ecosystem. Known affectionately as “Mr. Spring,” he is the author of numerous books and a prolific speaker who travels the globe sharing insights on modern Java development. Long co-hosts the “Coffee with a Java Champion” YouTube channel and continues to champion practical, production-ready Spring applications.

Abstract
In this engaging session at Devoxx Greece 2026, Josh Long showcases the transformative capabilities of Spring Boot 4 alongside Java 25. Through live coding of a dog adoption service, he demonstrates powerful new features including virtual threads, API versioning, modular architecture with Spring Modulith, resilient patterns, and seamless integration with AI capabilities. The presentation highlights how the Spring ecosystem empowers developers to build scalable, observable, secure, and intelligent applications with remarkable efficiency.

Java 25 and the Evolution of Spring Boot 4

Spring Boot 4 represents a significant generational leap, aligned with Spring Framework 7. Long emphasizes the decomposition of auto-configuration, resulting in leaner classpaths and faster startup times. Java 25 introduces compelling enhancements, most notably the ability to run simple applications with a single void main() method, effectively delivering the first truly elegant Java scripting experience.

These advancements set the stage for building modern, efficient services that leverage the full power of the JVM while maintaining developer productivity.

Building a Modular Dog Adoption Service

Long begins with a practical example: a service to help adopt dogs. Using Spring Initializr, he configures a project with PostgreSQL, Spring Data JDBC, web support, security, observability through OpenTelemetry and Actuator, and development tools.

The application employs a clean, feature-oriented package structure rather than traditional layered architecture. Records simplify domain modeling, while Spring Data repositories provide type-safe data access with compile-time query generation via AOT processing—beneficial for both JVM and native image deployments.

API Versioning and Resilience Features

To handle evolving requirements, Long demonstrates Spring’s new API versioning capabilities. Multiple endpoint versions coexist, with sensible defaults and header-based selection, ensuring backward compatibility.

Resilience4j integration showcases retryable methods and circuit breakers. Long simulates downstream failures to illustrate automatic recovery, highlighting how declarative resilience patterns simplify robust service design.

Modular Architecture with Spring Modulith

A standout demonstration involves refactoring into feature modules—dogs, cats, and veterinary services—using Spring Modulith. This enforces architectural boundaries at compile time while supporting event-driven communication between modules through ApplicationModuleListener and the outbox pattern for reliable, eventually consistent inter-module interactions.

The framework automatically generates documentation, C4 architecture diagrams, and verifies module dependencies, bridging the gap between intended design and runtime reality.

Security and Production Readiness

Security configuration leverages Spring Security 7’s additive customizers, preserving sensible defaults while enabling features like one-time token login and password migration. Passkeys (WebAuthn) integration provides passwordless authentication using biometrics, representing a significant usability and security improvement.

Observability is built-in through Actuator and OpenTelemetry, with production considerations like resource limits addressed from the start.

Integrating AI Capabilities

Long concludes by incorporating Spring AI 2.0, demonstrating how to augment the application with intelligent assistants. Using skills and tool calling, the service can answer domain-specific questions about dogs and cats, showcasing the natural convergence of Spring Boot with modern AI workflows.

The Bright Future of Java and Spring Development

Throughout the session, Long reinforces that the combination of Java’s efficiency, Spring’s comprehensive ecosystem, and new generative AI tools positions developers exceptionally well. Despite industry hype cycles, the fundamentals of solid engineering—modularity, resilience, observability, and security—remain paramount.

Spring Boot 4 and Java 25 deliver the tools necessary to build systems that are faster, more scalable, more maintainable, and more intelligent than ever before.

Links:

• Video: Bootiful Spring Boot 4
• Josh Long on X/Twitter
• Spring Boot

Lecturer

Brian Vermeer is a Staff Developer Advocate at Snyk, where he focuses on developer security, DevSecOps practices, and emerging risks in modern application architectures. A recognized Java Champion and active community leader who co-leads the Netherlands Java User Group (NLJUG), Brian brings extensive experience in application security, secure coding, and helping organizations build more resilient systems. He frequently speaks at international conferences on topics ranging from traditional web vulnerabilities to the novel attack surfaces introduced by artificial intelligence and large language models.

Abstract

As organizations rapidly integrate Large Language Models into production applications, new categories of security and privacy vulnerabilities emerge alongside familiar web application risks. Brian Vermeer provides a compelling, demonstration-heavy exploration of these challenges through a fictional car rental application called “Really Good Rentals.” He demonstrates practical attack vectors such as prompt injection, RAG poisoning, memory manipulation, and tool abuse, while outlining layered mitigation strategies including input/output guardrails, scoped permissions, human-in-the-loop verification, and architectural defenses essential for building trustworthy LLM-powered systems.

The Allure and Inherent Risks of LLMs in Production Applications

Brian begins by drawing a relatable analogy: just as children enthusiastically misuse new toys in unexpected ways, developers often rush to incorporate powerful new technologies like LLMs without fully appreciating the expanded attack surface they create. While LLMs offer remarkable capabilities for natural language processing, code generation, and intelligent automation, they introduce significant risks when granted access to tools, user data, or execution privileges.

He presents a simplified architecture of a typical LLM-powered application, highlighting key components: user prompts, system instructions, conversation memory, retrieval-augmented generation (RAG) pipelines, and tool-calling mechanisms. Because LLMs are fundamentally stateless, the surrounding application bears responsibility for maintaining context, which creates multiple points where malicious actors can influence behavior through carefully crafted inputs.

Context Poisoning Through RAG and Memory Manipulation

A central demonstration revolves around the “Really Good Rentals” application. Brian shows how a seemingly innocuous file upload feature with inadequate path validation allows attackers to perform directory traversal and overwrite critical documents stored in the vector database, such as terms-of-service files. By injecting a modified cancellation policy containing trigger phrases like “vroom vroom,” the attacker can later invoke this policy through normal chat interactions, tricking the LLM into granting unauthorized credits or violating business rules.

This technique, termed RAG poisoning, illustrates how tainted retrieval sources can persistently influence model behavior across conversations. Similar vulnerabilities arise through traditional injection attacks in search functionality, where SQL injection not only extracts data but also poisons the conversation memory fed to the LLM on subsequent interactions. Brian emphasizes that classic web vulnerabilities gain dramatically amplified impact when they shape the context provided to powerful generative models.

Abusing Permissions, Tool Calling, and Advanced Prompt Injection

Brian demonstrates how overly broad tool permissions create dangerous scenarios. In older models like GPT-3.5, carefully crafted prompts could coerce the LLM into executing arbitrary SQL statements with destructive consequences. Even with more recent, safety-aligned models, insufficient scoping of available tools allows privilege escalation and unauthorized actions.

Advanced prompt injection techniques go beyond simple overrides. Multi-turn attacks gradually extract personally identifiable information by leveraging accumulated conversation memory. When combined with tool calling capabilities, especially with locally hosted models, attackers can trigger hallucinations that inadvertently expose sensitive data during operations such as account creation or data processing.

The presentation underscores that granting LLMs access to powerful tools without rigorous permission boundaries and validation is equivalent to giving untrusted code broad system access.

Mitigation Strategies and Architectural Defenses

Brian outlines a comprehensive defense-in-depth approach spanning multiple layers:

• Input and Output Guardrails: Deploying dedicated LLM-as-a-Judge mechanisms that evaluate both incoming prompts and generated outputs for malicious content, policy violations, or harmful instructions. These guardrails act as critical safety nets.

• Limited-Scope and Permission-Aware Tools: Designing tools with granular permissions, explicit user confirmation flows for sensitive operations, and runtime validation of actions against the authenticated user’s privileges.

• Structured Outputs and Schema Enforcement: Using techniques that force models to produce responses conforming to predefined schemas, significantly reducing the potential for unexpected or harmful outputs.

• Model Selection and Routing: Strategically routing sensitive operations to private, self-hosted models while reserving more powerful commercial models for less critical tasks.

• Traditional Security Foundations: Maintaining rigorous input sanitization, dependency updates, secure file handling, and regular security scanning. Brian stresses that foundational web application security remains non-negotiable even in AI-enhanced systems.

Additional considerations include implementing rate limiting to prevent “denial of pocket money” attacks that exhaust token quotas through malicious prompting, as well as comprehensive auditing of all tool invocations and model interactions.

Broader Implications for Secure AI Development

The talk concludes with forward-looking guidance for organizations adopting LLM technologies. Brian encourages treating LLMs as powerful but inherently unpredictable components requiring the same rigorous engineering discipline applied to any critical system. Key principles include careful context management, strict permission boundaries, deterministic fallback mechanisms where possible, and continuous security education for development teams.

By sharing concrete attack demonstrations and corresponding defenses, Brian equips attendees with actionable insights to build more secure, privacy-preserving AI applications while continuing to harness their transformative potential.

Links:

• Video: Breaching LLM-Powered Apps Overcoming Security and Privacy Challenges
• Brian Vermeer Website
• Brian Vermeer at Snyk
• Brian Vermeer on X/Twitter
• Snyk LLM Security Resources

Lecturer

The session is delivered by product managers from Amazon Web Services who oversee the development and roadmap of AWS CloudFormation and the AWS Cloud Development Kit.

Abstract

This article provides an exhaustive and detailed retrospective on the notable progress achieved throughout the past year in AWS infrastructure as code services, with particular emphasis on both AWS CloudFormation and the AWS Cloud Development Kit (CDK). It meticulously examines a range of enhancements, including improved validation mechanisms, clearer error diagnostics, expanded construct libraries, seamless integration with artificial intelligence assistance through Model Context Protocol servers, and advanced troubleshooting utilities. The discussion analyzes how these collective innovations substantially elevate deployment reliability, enhance developer productivity, and introduce greater intelligence into infrastructure management practices for organizations of all scales.

The Critical and Enduring Role of Infrastructure as Code in Modern Cloud Architectures

Infrastructure as code has firmly established itself as an indispensable discipline for enterprises striving to achieve consistency, traceability, and accelerated iteration in their cloud operations. AWS CloudFormation offers a robust declarative approach, allowing practitioners to define resources through structured templates in JSON or YAML formats, thereby guaranteeing identical provisioning outcomes across development, staging, and production environments.

Complementing this, the AWS Cloud Development Kit empowers developers with programmatic flexibility, enabling infrastructure definition in familiar programming languages while automatically generating underlying CloudFormation templates. This duality accommodates diverse team preferences and skill sets.

The advancements introduced over the year have strategically bridged these paradigms, delivering unified capabilities that address contemporary challenges related to scale, complexity, and the evolving demands of developer experience in dynamic cloud ecosystems.

Significant Refinements Enhancing AWS CloudFormation Reliability and Practitioner Usability

AWS CloudFormation has benefited from meaningful improvements in change set validation processes, enhanced clarity in error messaging, and more intuitive management of deployment workflows. These refinements work collectively to substantially reduce the frequency of failed deployments by surfacing potential conflicts, resource constraints, or configuration incompatibilities earlier in the provisioning lifecycle.

Furthermore, the introduction of server-side APIs now enables programmatic pre-validation of proposed changes, allowing integration into continuous integration pipelines for automated safeguards that prevent runtime disruptions and promote greater confidence in infrastructure updates.

Substantial Growth and Maturation Within the AWS Cloud Development Kit Ecosystem

The AWS Cloud Development Kit has experienced considerable expansion in supported programming languages and the availability of high-level constructs. Numerous libraries, both community-contributed and AWS-maintained, have progressed from experimental developer preview stages to full general availability, covering an extensive array of common architectural patterns across networking, security, serverless computing, and data processing domains.

This maturation process provides developers with higher-level abstractions that encapsulate established best practices, thereby significantly reducing the amount of boilerplate code required and promoting greater architectural consistency across distributed teams.

Transformative Integration of Artificial Intelligence Assistance Through Model Context Protocol Servers

One of the most pivotal innovations involves the creation of specialized Model Context Protocol servers tailored specifically for CDK and CloudFormation contexts. These servers curate and expose AWS-specific expertise—including recommended practices, construct libraries at various maturity levels, and detailed cloud context information—directly to artificial intelligence-powered coding assistants.

As a result, developers receive highly contextually relevant suggestions that align precisely with AWS service conventions and idioms, dramatically accelerating the creation of secure, efficient, and idiomatic implementations while substantially lowering the cognitive burden associated with recalling intricate service details.

Strengthening Troubleshooting and Validation Tooling for Proactive Issue Resolution

New diagnostic capabilities encompass server-side APIs designed for interrogating deployment states and identifying root causes of issues, complemented by local static analysis utilities that perform early detection of syntax errors within CDK source code.

These tools operate across both programmatic CDK definitions and the generated CloudFormation templates, enabling practitioners to identify and resolve configuration problems well before they manifest during actual deployments.

Community-Driven Construct Libraries and Enhanced Cloud Context Integration

The ecosystem continues to benefit from active contributions spanning AWS internal teams and external community participants, with constructs systematically progressing through alpha evaluation and eventual general availability phases.

Additional cloud context features further enrich artificial intelligence interactions by providing service-specific insights and recommendations.

Practitioners are strongly encouraged to explore dedicated workshops that offer guided paths for understanding and implementing MCP server integration in real-world scenarios.

Measurable Organizational Benefits and Strategic Adoption Considerations

These multifaceted improvements collectively lower entry barriers for effective infrastructure management while delivering tangible advantages. Development teams realize enhanced confidence in deployment outcomes, accelerated onboarding for new members, and improved adherence to evolving architectural standards across projects.

The incorporation of artificial intelligence guidance represents a fundamental paradigm shift toward more intelligent, assisted development experiences that amplify human expertise rather than seeking to replace it.

Looking Toward the Future of Intelligent Infrastructure Orchestration

Continued investment in these areas clearly signals an ongoing commitment to deepening the convergence between programmatic expressiveness and declarative safety, increasingly augmented by artificial intelligence capabilities that guide practitioners toward optimal architectural outcomes.

Organizations that fully leverage these evolving tools position themselves advantageously for sustained operational excellence amid the accelerating complexity of modern cloud environments.

Links:

• Lecture Video