> For the complete documentation index, see [llms.txt](https://docs.xplatform.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.xplatform.com/talon/concepts-and-architecture.md).

# Concepts & Architecture

## Overview

Talon is a high-performance microservices platform designed for building ultra-low latency, fault-tolerant distributed systems. This section provides a comprehensive understanding of Talon's core concepts, architectural patterns, and operational models.

Understanding these concepts is essential for:

* **Architects** designing Talon-based systems
* **Developers** building Talon microservices
* **Operators** managing Talon deployments
* **Technical decision-makers** evaluating Talon for their use cases

## What You'll Learn

This section covers the foundational concepts and architectural patterns that underpin the entire Talon platform. Each topic builds on the others to provide a complete mental model of how Talon works.

### Core Architecture

[**Messaging Model**](/talon/concepts-and-architecture/messaging-model.md) - How microservices communicate

Talon's messaging abstraction provides a unified interface for message exchange across different messaging backbones (Solace, JMS, etc.). Learn how:

* Messages are modeled as strongly-typed POJOs
* Channel subscriptions and message routing work
* Different messaging bindings integrate with the platform
* Message delivery guarantees are provided

[**Microservice Architecture**](/talon/concepts-and-architecture/microservice-architecture.md) - The anatomy of a Talon microservice

Understand the structure of a Talon microservice:

* [Runtime Architecture](/talon/concepts-and-architecture/microservice-architecture/runtime-architecture.md) - The runtime components (AEP Engine, SMA, XVM, etc.)
* [Development Model](/talon/concepts-and-architecture/microservice-architecture/development-model.md) - Development artifacts (ADM models, user code, configuration)
* [Configuration Model](/talon/concepts-and-architecture/microservice-architecture/configuration-model.md) - How configuration is managed and applied

### Operational Concepts

[**Microservice Operation**](/talon/concepts-and-architecture/microservice-operation.md) - How microservices behave at runtime

Follow a microservice through its complete lifecycle:

* [Lifecycle](/talon/concepts-and-architecture/microservice-operation/lifecycle.md) - Complete microservice lifecycle with all phases and events
* [Initialization](/talon/concepts-and-architecture/microservice-operation/cluster-initialization.md) - How microservices start up and initialize
* [Cluster Join](/talon/concepts-and-architecture/microservice-operation/cluster-join.md) - How instances discover and join clusters
* [Message Processing](/talon/concepts-and-architecture/microservice-operation/message-processing.md) - The message processing loop and transaction flow
* [Cluster Consensus](/talon/concepts-and-architecture/microservice-operation/cluster-consensus.md) - How distributed consensus is achieved
* [Cluster Failover](/talon/concepts-and-architecture/microservice-operation/cluster-failover.md) - Handling primary failures and backup promotion

### High Availability & Consistency

[**Consensus Models**](/talon/concepts-and-architecture/consensus-models.md) - State Replication vs Event Sourcing

Talon provides two consensus models for achieving high availability:

* **Event Sourcing** - Replicate inbound messages for deterministic state reconstruction
* **State Replication** - Replicate state changes automatically

Understand the trade-offs between latency, complexity, and flexibility.

[**Transactions**](/talon/concepts-and-architecture/transactions.md) - ACID guarantees in distributed systems

Learn how Talon provides transactional guarantees:

* Atomic commits of state changes and outbound messages
* Transaction isolation and consistency
* Integration with consensus models
* Savepoints and transaction control

### Platform Services

[**Threading Model**](/talon/concepts-and-architecture/threading-model.md) - How Talon manages concurrency

Talon's single-threaded business logic model eliminates race conditions while maintaining high throughput:

* Thread architecture and responsibilities
* Disruptor-based event processing
* Thread affinitization for performance
* NUMA-aware configuration

[**Discovery Model**](/talon/concepts-and-architecture/discovery-model.md) - How components find each other

The discovery service enables microservices to locate:

* Other microservice instances for clustering
* XVM containers for deployment
* Message buses for connectivity
* Discovery providers (Multicast, SMA, Local)

[**Operating Model**](/talon/concepts-and-architecture/operating-model.md) - Administration, monitoring, and troubleshooting

Understand the operational aspects:

* Statistics collection and heartbeats
* Administrative commands and control
* Analysis and troubleshooting tools
* Performance monitoring

## Architecture Principles

Talon's architecture is guided by several key principles:

### 1. Event-Driven Processing

All business logic executes in response to events (messages, lifecycle events, timer events). This ensures deterministic, reproducible behavior across instances.

### 2. Single-Threaded Business Logic

Message handlers execute on a single thread, eliminating the need for locks, mutexes, or concurrent data structures in application code.

### 3. Transparent High Availability

Clustering, replication, and failover happen automatically without application code changes. The platform handles distributed consensus.

### 4. Message-Oriented Architecture

Communication between microservices happens exclusively through messages. This loose coupling enables independent deployment and scaling.

### 5. Strong Typing

All messages and state are strongly-typed POJOs generated from declarative models. This eliminates serialization errors and provides compile-time safety.

### 6. Configuration as Code

All runtime configuration is expressed in declarative XML (DDL) with support for templating, profiles, and overrides.

## How These Concepts Fit Together

Here's how the concepts relate to building and running a Talon microservice:

1. **Development**: Use the [Development Model](/talon/concepts-and-architecture/microservice-architecture/development-model.md) to understand what artifacts you create (ADM models, handlers, configuration)
2. **Runtime**: The [Runtime Architecture](/talon/concepts-and-architecture/microservice-architecture/runtime-architecture.md) shows how those artifacts are loaded and executed by the AEP Engine, SMA, and XVM
3. **Communication**: The [Messaging Model](/talon/concepts-and-architecture/messaging-model.md) explains how your microservice sends and receives messages via the SMA
4. **Lifecycle**: [Microservice Operation](/talon/concepts-and-architecture/microservice-operation.md) describes what happens from startup through steady-state processing to shutdown
5. **High Availability**: [Consensus Models](/talon/concepts-and-architecture/consensus-models.md) and [Transactions](/talon/concepts-and-architecture/transactions.md) explain how consistency and fault tolerance are achieved
6. **Performance**: The [Threading Model](/talon/concepts-and-architecture/threading-model.md) and [Discovery Model](/talon/concepts-and-architecture/discovery-model.md) describe how Talon achieves ultra-low latency
7. **Operations**: The [Operating Model](/talon/concepts-and-architecture/operating-model.md) covers monitoring, administration, and troubleshooting

## Next Steps

After understanding the concepts in this section, proceed to:

* [**Developing Applications**](/talon/developing-applications.md) - Put these concepts into practice by building microservices
* [**Microservice Template**](/talon/developing-applications/microservice-template.md) - Start with template projects for Event Sourcing or State Replication
* [**Reference**](/talon/reference.md) - Look up specific annotations, events, and configuration elements

## Additional Resources

For hands-on learning:

* Start with [Get Started](/get-started/set-up-your-dev-environment.md) to set up your development environment
* Review [Introduction](/talon/introduction.md) for a high-level overview of Talon
* Explore the [Microservice Template](/talon/developing-applications/microservice-template.md) section for complete implementation examples