DEV Community: Lu Han

Dynamic Loading Mechanisms in 10 Popular Programming Languages

Lu Han — Sat, 07 Jun 2025 17:36:17 +0000

Dynamic loading is a crucial technique in modern software development. It allows programs to load and use code modules at runtime, rather than having all dependencies fixed at compile time. This enables plugin systems, modular architectures, hot updates, and more.

In this article, we’ll explore how 10 mainstream programming languages implement dynamic loading, using a simple calculator project as a running example. We’ll cover the core principles, code samples, and best practices for each language.

What Is Dynamic Loading?

Dynamic loading refers to loading code modules or libraries at runtime and creating object instances in memory as needed. Unlike static linking, where all dependencies are resolved at compile time, dynamic loading offers:

🔥 Hot-swapping: Update features without restarting the program
🎯 On-demand loading: Reduce memory usage and startup time
🔧 Plugin architecture: Support third-party extensions
🚀 Modular design: Lower coupling and improve code reuse

Project Architecture

All examples implement the same interface for a calculator with four basic operations: addFn(a, b), subFn(a, b), mulFn(a, b), and divFn(a, b) (with zero-division checks).

The architecture consists of:

Application: Calls a unified interface
Dynamic Loader: Manages loading logic
Implementation Module: Provides actual functionality

1. Python – `importlib` Dynamic Module Import

Python uses the importlib module for dynamic loading. It can import modules and instantiate classes at runtime.

import importlib

class DynamicCalculatorLoader:
    def load_calculator(self, calculator_type):
        module = importlib.import_module(f"calculator_{calculator_type}")
        calculator_class = getattr(module, f"{calculator_type.capitalize()}Calculator")
        return calculator_class()

Highlights: No compilation needed, module cache via sys.modules, dynamic typing.

2. Java – Reflection and ClassLoader

Java leverages reflection and class loaders to load classes dynamically, even from external JARs.

URLClassLoader classLoader = new URLClassLoader(new URL[]{jarUrl});
Class<?> clazz = classLoader.loadClass("com.example.Calculator");
Calculator calculator = (Calculator) clazz.getDeclaredConstructor().newInstance();

Highlights: Bytecode loading, security sandbox, runtime inspection.

3. Rust – Dynamic Library Loading (`libloading`)

Rust uses the libloading crate to load dynamic libraries (.so, .dll, .dylib) and call functions via C ABI.

let lib = Library::new("libcalc.dylib")?;
let func: Symbol<unsafe extern fn() -> i32> = lib.get(b"addFn")?;

Highlights: Zero-cost abstractions, memory safety, system-level performance.

4. C++ – System Dynamic Library APIs

C++ uses platform APIs (dlopen/dlsym on Unix, LoadLibrary/GetProcAddress on Windows) for dynamic loading.

void* handle = dlopen("libcalculator.so", RTLD_LAZY);
auto addFn = (int(*)(int, int))dlsym(handle, "addFn");

Highlights: Low-level control, cross-platform, high performance.

5. C# – Reflection and Assembly Loading

C# uses reflection and Assembly.LoadFrom to load assemblies and create instances.

Assembly assembly = Assembly.LoadFrom("Calculator.dll");
Type type = assembly.GetType("Calculator.BasicCalculator");
object instance = Activator.CreateInstance(type);

Highlights: Managed code, rich metadata, automatic memory management.

6. Go – Interfaces and Reflection

Go doesn’t support traditional dynamic libraries, but achieves similar results via interfaces and factory patterns.

var calc calculator.Calculator = &calculator.BasicCalculator{}
result := calc.AddFn(a, b)

Highlights: Static typing, interface-based polymorphism, native concurrency.

7. Swift – Protocols and Type System

Swift uses protocols and type casting for dynamic invocation.

let calculators: [Calculator] = [BasicCalculator(), AdvancedCalculator()]
for calc in calculators {
    print(calc.addFn(a, b))
}

Highlights: Protocol-oriented, type safety, performance optimizations.

8. TypeScript – Dynamic `import()` and Factory Pattern

TypeScript uses ES6 dynamic import() and factory patterns for module loading.

const module = await import('./calculator');
const calculator = new module.BasicCalculator();

Highlights: Async loading, type safety, flexible module system.

9. Dart – Factory Pattern and Reflection

Dart uses factory constructors and reflection APIs for dynamic instantiation.

var calculator = CalculatorFactory.create('BasicCalculator');

Highlights: Event loop concurrency, JIT/AOT compilation, cross-platform.

10. Kotlin – Reflection API and Factory Pattern

Kotlin uses reflection and factory patterns, similar to Java but with more concise syntax.

val clazz = Class.forName("BasicCalculator").kotlin
val instance = clazz.createInstance() as Calculator

Highlights: Java interoperability, null safety, coroutine support.

Performance Comparison

Language	Load Speed	Memory	Type Safety	Learning Curve
C++	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐
Rust	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐
Go	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐
Java	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐
C#	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐
Kotlin	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐
Swift	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐
TypeScript	⭐⭐	⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐
Python	⭐⭐	⭐⭐	⭐⭐	⭐⭐⭐⭐⭐
Dart	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐

Best Practices

Interface Design: Define clear contracts.
Error Handling: Robust exception management.
Version Compatibility: Plan for backward compatibility.
Security: Validate module sources.
Performance Monitoring: Track load times and memory usage.

Conclusion

Dynamic loading is vital in modern software architecture. Each language offers unique mechanisms:

Low-level languages (C++, Rust): Maximum performance and control
Managed languages (Java, C#): Balance of usability and safety
Scripting languages (Python, JavaScript): Maximum flexibility
Modern languages (Go, Swift, Kotlin): Blend of traditional strengths

Choose the right approach based on your project’s needs, team expertise, and performance requirements.

References:

Project Source Code
Official documentation for each language
Best practices for dynamic loading

If you found this article helpful, follow for more deep dives into programming language internals and architecture!

A2A Protocol with Local LLMs: A Comprehensive Guide for Developers

Lu Han — Thu, 05 Jun 2025 19:05:58 +0000

Introduction

The Agent2Agent (A2A) Protocol is an open communication standard that enables AI agents built on different frameworks to communicate and collaborate effectively. While Google’s official examples rely on cloud services like Google AI Studio and Vertex AI, this guide demonstrates how to run the entire A2A ecosystem using local language models through Ollama and LM Studio, making it accessible to developers worldwide, especially those in regions with limited cloud access.

Today, I'm sharing my journey building a complete Agent-to-Agent (A2A) ecosystem where five different AI frameworks collaborate using local LLMs - no cloud APIs required!

🎯 What We're Building

This project demonstrates real cross-agent communication using:

Travel Agent (Semantic Kernel) - Orchestrates complex trip planning
Currency Agent (LangGraph) - Provides real-time currency conversion
YouTube Agent (AG2/AutoGen + MCP) - Extracts video content for research
Reimbursement Agent (Google ADK) - Handles expense workflows with forms
File Chat Agent (LlamaIndex) - Enables document conversations with file uploads

All powered by local LLMs (Ollama/LM Studio) and connected via A2A JSON-RPC protocol! 🔥

🛠️ Core Technologies

Local LLM Infrastructure

Ollama: Download from ollama.com
LM Studio: Download from lmstudio.ai

AI Frameworks Integration

Framework	Agent	Purpose	Port
LangGraph	Currency Agent	Real-time currency conversion	10000
AG2 (AutoGen)	YouTube Agent	Video transcript analysis	10010
Google ADK	Reimbursement Agent	Expense processing with forms	10020
Semantic Kernel	Travel Agent	Trip planning orchestration	10030
LlamaIndex	File Chat Agent	Document parsing & Q&A	10040

💻 Quick Start Guide

1. Setup Environment

# Create virtual environment
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

2. Start Local LLM Service

# Option 1: Ollama
ollama serve

# Option 2: LM Studio
# Download and run LM Studio, load your preferred model

3. Launch Agents

# Currency Agent (LangGraph)
./start_remote_agent.sh langgraph --host localhost --port 10000 --llm-provider ollama --model-name qwen2.5:7b

# YouTube Agent (AG2 + MCP)
./start_remote_agent.sh ag2 --host localhost --port 10010 --llm-provider ollama --model-name qwen2.5:7b

# Travel Agent (Semantic Kernel)
./start_remote_agent.sh semantickernel --host localhost --port 10030 --llm-provider ollama --model-name qwen2.5:7b

# Reimbursement Agent (Google ADK)
./start_remote_agent.sh google_adk --host localhost --port 10020 --llm-provider ollama --model-name qwen2.5:7b

# File Chat Agent (LlamaIndex)
./start_remote_agent.sh llama_index_file_chat --host localhost --port 10040 --llm-provider ollama --model-name qwen2.5:7b

4. Start Host Interface

# Web UI Host
./start_host_agent.sh
# Visit http://localhost:12000

# Or CLI Host
./start_cli.sh --agent http://localhost:10000

🔧 A2A Protocol Implementation

Each agent exposes a standardized Agent Card via .well-known/agent.json:

{
  "name": "Currency Agent",
  "description": "Helps with exchange rates for currencies",
  "version": "1.0.0",
  "url": "http://localhost:10000/",
  "capabilities": {
    "pushNotifications": true,
    "streaming": true
  },
  "skills": [
    {
      "id": "convert_currency",
      "name": "Currency Exchange Rates Tool",
      "description": "Helps with exchange values between various currencies",
      "examples": ["What is exchange rate between USD and GBP?"],
      "tags": ["currency conversion", "currency exchange"]
    }
  ]
}

Communication happens via JSON-RPC 2.0:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "message/send",
  "params": {
    "sessionId": "test-session",
    "message": {
      "messageId": "msg-01",
      "role": "user",
      "parts": [{
        "type": "text",
        "text": "Convert 100 USD to CNY"
      }]
    }
  }
}

🎮 Real-World Demo: Multi-Agent Travel Planning

Here's where the magic happens! Let's see how agents collaborate:

# User request to Travel Agent
curl -X POST http://localhost:10030 \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "message/send",
    "params": {
      "message": {
        "role": "user",
        "parts": [{
          "text": "Plan a 7-day Seoul trip with $5000 budget, include currency conversion"
        }]
      }
    }
  }'

What happens behind the scenes:

Travel Agent receives the request
Automatically calls Currency Agent to get USD→KRW exchange rate
Plans detailed itinerary with converted budget
Returns comprehensive travel plan with real currency data

Response:

# 📍 Seoul 7-Day Travel Plan

## 💰 Budget & Exchange Rate
- **Total Budget**: 5000 USD  
- **Current Rate**: 1 USD = 1376.78 KRW
- **Korean Won Budget**: ~6,883,900 KRW

## 🗓️ Detailed Itinerary
### Day 1: Arrival Seoul (Budget: 800,000 KRW)
- **Accommodation**: Myeongdong Hotel (120,000 KRW/night)
- **Transport**: Incheon Airport Express → Myeongdong (9,000 KRW)
- **Dinner**: Myeongdong street food (30,000 KRW)
...

🔥 Advanced Features

1. Multi-Framework Integration

Each agent uses its native framework:

LangGraph: Graph-based workflow for currency conversion
Semantic Kernel: Plugin architecture for travel planning
AG2 + MCP: Multi-agent collaboration with Model Context Protocol
Google ADK: Form-based workflows for reimbursements
LlamaIndex: RAG pipeline for document chat

2. Form-Based Interactions

The Reimbursement Agent demonstrates complex form workflows:

{
  "status": {
    "state": "input-required",
    "message": {
      "parts": [{
        "data": {
          "form": {
            "type": "object",
            "properties": {
              "date": {"type": "string", "format": "date"},
              "amount": {"type": "string", "format": "number"},
              "purpose": {"type": "string"}
            }
          },
          "form_data": {
            "amount": "500",
            "purpose": "Business trip transportation"
          }
        }
      }]
    }
  }
}

3. File Upload & Processing

File Chat Agent handles multiple formats:

{
  "parts": [
    {
      "type": "text",
      "text": "Analyze this document"
    },
    {
      "type": "file",
      "file": {
        "name": "report.pdf",
        "mimeType": "application/pdf",
        "bytes": "base64-encoded-content"
      }
    }
  ]
}

🎯 Key Benefits

🔒 Privacy First

100% Local: No data sent to cloud APIs
Your LLMs: Use any model you prefer
Full Control: Complete ownership of your AI pipeline

🧩 Framework Flexibility

Best of Both Worlds: Use each framework's strengths
Easy Integration: Standardized A2A protocol
Modular Design: Add/remove agents independently

🚀 Production Ready

Streaming Support: Real-time responses
Error Handling: Robust error recovery
Monitoring: Built-in logging and debugging

🔗 Resources & Links

🎉 Conclusion

Building a multi-agent AI ecosystem doesn't have to be complex. With the right architecture and standardized protocols, different AI frameworks can collaborate seamlessly.

The future of AI is collaborative - where specialized agents work together to solve complex problems. This project shows it's not just possible, but practical with today's tools!

Enjoy 👇

hello-a2a-python