Skip to content
Tagged articles

state machine

178 articles · Page 1 of 2
IT Services Circle
IT Services Circle
Nov 14, 2026 · Fundamentals

QP Hierarchical State Machines: Escape Switch-Case Hell in Embedded Systems

This article explains why switch-case state machines become unmaintainable in complex embedded projects, introduces QP (Quantum Platform) as a hierarchical event-driven state machine framework, demonstrates code comparisons showing inheritance and async benefits, and provides guidance on when to adopt QP and common pitfalls to avoid.

QPQuantum Platformembedded systems
0 likes · 14 min read
QP Hierarchical State Machines: Escape Switch-Case Hell in Embedded Systems
Smart Era Software Development
Smart Era Software Development
Nov 12, 2026 · R&D Management

Multi-Agent R&D Pipeline: 3 Human Gates, 335 Reqs Delivered in 106-Min Median

Tencent's Social Security Center built a multi-agent end-to-end delivery platform that processes production requirements through nine automated stages with humans only confirming at three gates (requirement review, technical design, acceptance), achieving 335 deliveries with a 106-minute median cycle time and zero production incidents, using structured Specs, state machines, quality gates, and a knowledge base to eliminate handoff losses and context gaps.

AI in software engineeringR&D automationend-to-end delivery
0 likes · 35 min read
Multi-Agent R&D Pipeline: 3 Human Gates, 335 Reqs Delivered in 106-Min Median
Weekly Large Model Application
Weekly Large Model Application
Nov 9, 2026 · Artificial Intelligence

Eight Full-Duplex Speech Architectures Compared: True vs Pseudo Duplex, 92ms Decision Ear, and Selection Guide

This article categorizes eight technical approaches to full-duplex speech systems — from cascaded pipelines and decision-ear classifiers to native multi-stream models and expressive TTS — using an academic framework that distinguishes true full-duplex (simultaneous listen/speak, overlap, interruption) from pseudo full-duplex (millisecond state-machine switching). It benchmarks latency, data requirements, auditability, and deployment fit, citing key papers and open-source implementations.

benchmarkingcascaded pipelinedecision ear
0 likes · 21 min read
Eight Full-Duplex Speech Architectures Compared: True vs Pseudo Duplex, 92ms Decision Ear, and Selection Guide
dbaplus Community
dbaplus Community
Oct 27, 2026 · Fundamentals

TCP Connection Lifecycle: From SYN to FIN, State Machine & Troubleshooting

This article walks through the complete TCP connection lifecycle from SYN to FIN, explaining three-way handshake, four-way handshake, sliding window, flow control, congestion control algorithms (slow start, congestion avoidance, fast retransmit/recovery), the TCP state machine with 11 states, and practical troubleshooting for CLOSE_WAIT, SYN_RECV, FIN_WAIT_2, and TIME_WAIT issues using ss/tcpdump/Wireshark.

Flow ControlSliding WindowTCP
0 likes · 25 min read
TCP Connection Lifecycle: From SYN to FIN, State Machine & Troubleshooting
Random Bulletin
Random Bulletin
Oct 24, 2026 · R&D Management

Why Post-Mortem Action Items Fail at 10M QPS: Building a Closed-Loop Improvement System

This article details a systematic framework for turning post-mortem action items into verified risk reductions, covering eight required fields, single-owner accountability, a five-state tracking machine, risk-based prioritization, layered governance rhythms, three-evidence acceptance criteria, and cross-team dependency management for 10M QPS systems.

acceptance criteriaaction itemsclosed-loop improvement
0 likes · 32 min read
Why Post-Mortem Action Items Fail at 10M QPS: Building a Closed-Loop Improvement System
Data Bricklaying Diary
Data Bricklaying Diary
Oct 23, 2026 · Artificial Intelligence

Agent Workflow Runtime Governance: Classify Failures, Evidence Packages, and Escalation Paths

The article analyzes why agent workflows that succeed in demos fail in production, proposing a runtime governance framework that classifies failures into technical, data, business uncertainty, and controllable progression categories, mandates evidence-based human-in-the-loop with evidence packages, and defines a state machine with escalation paths for reliable execution.

AI productionError classificationEscalation paths
0 likes · 21 min read
Agent Workflow Runtime Governance: Classify Failures, Evidence Packages, and Escalation Paths
Architecture Development Notes
Architecture Development Notes
Oct 18, 2026 · Artificial Intelligence

Claude Code Bug: Message Interruption Misreported as User Refusal

Claude Code 2.1.301 fixed a bug where tool calls interrupted by user messages during permission checks were incorrectly logged as user refusals, conflating explicit decisions with scheduling cancellations; the article argues for a distinct 'not_executed' status with cause and retryable fields to preserve accurate model behavior and audit metrics.

AI agentClaude CodeTool Calling
0 likes · 9 min read
Claude Code Bug: Message Interruption Misreported as User Refusal
Architect
Architect
Oct 16, 2026 · R&D Management

AI Coding Accelerates: How R&D Delivery Systems Must Evolve

As AI speeds up coding, bottlenecks shift downstream to requirements clarification, review, verification, and release; the article proposes modeling delivery as a state machine with versioned specs, Harness for execution context, evidence bound to versions, expiring knowledge caches, and human guardrails for high-risk changes, starting with low-risk changes to validate the end-to-end flow.

AI-assisted DevelopmentHarnessR&D management
0 likes · 25 min read
AI Coding Accelerates: How R&D Delivery Systems Must Evolve
Ray's Galactic Tech
Ray's Galactic Tech
Oct 14, 2026 · Backend Development

From Chatbot to AI Agent: Why a Single While Loop Fails in Production

The article details the first week of the Aegis project, demonstrating why a naive while-loop agent loop fails in production and how to replace it with deterministic contracts, a finite state machine, bounded execution budgets, server-side tool authorization, and reproducible failure testing using local mocks.

AI agentGoProduction Engineering
0 likes · 25 min read
From Chatbot to AI Agent: Why a Single While Loop Fails in Production
Architecture Development Notes
Architecture Development Notes
Oct 13, 2026 · Backend Development

Claude Code Agent State vs Status: Why 'Waiting for Answer' Loses Context After an Hour

The article explains how Claude Code's agent view JSON fields state, status, and waitingFor differ in semantics and lifecycle, revealing that 'blocked' sessions waiting for user responses lose their waitingFor field after about an hour when the supervisor kills the process, unlike permission-prompt waits which keep the process alive.

Claude CodeDebuggingJSON:API
0 likes · 12 min read
Claude Code Agent State vs Status: Why 'Waiting for Answer' Loses Context After an Hour
IT Architects Alliance
IT Architects Alliance
Oct 9, 2026 · Backend Development

API Timeout After Ticket Creation: Why Query-First Recovery Beats Blind Retries

When an API times out after creating a ticket, the system must treat the result as unknown rather than failed, using persistent operation IDs to query the business service, relying on idempotency contracts for safe retries, and escalating to manual review only after exhausting a time-bounded recovery budget.

API timeoutAgent RuntimeIdempotency
0 likes · 28 min read
API Timeout After Ticket Creation: Why Query-First Recovery Beats Blind Retries
Random Bulletin
Random Bulletin
Sep 28, 2026 · Operations

Why Auto-Rollback Fails at 10M QPS: The Missing Control Loop

This article details how to build reliable automated rollback systems for high-throughput architectures by establishing change identity, causal evidence through experiment/control groups, tiered rollback actions, state-machine execution, data compatibility matrices, verification budgets, and guardrails—progressing from manual processes to closed-loop autonomy.

Verificationautomated rollbackcanary deployment
0 likes · 37 min read
Why Auto-Rollback Fails at 10M QPS: The Missing Control Loop
Niu Liu
Niu Liu
Sep 23, 2026 · Backend Development

Ordered Messages Aren't Enough: Preventing State Regressions with Versioning and State Machines

The article explains why message ordering alone fails to prevent business state regressions, detailing how version gaps and unordered consumption cause issues, and presents solutions using event versioning, state machines, and proper Kafka/RocketMQ configuration to ensure correct order processing per order ID while allowing parallelism across orders.

Event VersioningKafkaMessage Queue
0 likes · 10 min read
Ordered Messages Aren't Enough: Preventing State Regressions with Versioning and State Machines
Xiaolin Talks Programming
Xiaolin Talks Programming
Sep 23, 2026 · Backend Development

Spring Boot QR Code Login: State Machines, SSE Push, and Replay Protection for Production

This article details a production-ready QR code login implementation using Spring Boot, covering state machine design with Redis and Lua for atomic transitions, SSE for low-latency status push with polling fallback, HMAC-SHA256 with nonce for replay protection, and Redis Pub/Sub for cross-instance consistency in clustered deployments.

Lua ScriptsRedisSSE
0 likes · 28 min read
Spring Boot QR Code Login: State Machines, SSE Push, and Replay Protection for Production
Yumin Fish Harvest
Yumin Fish Harvest
Sep 21, 2026 · Backend Development

Idempotency Design for Write Services: 7 Patterns & Selection Guide

This article details seven idempotency patterns for backend write operations—including unique keys with database constraints, state machines, execution records, naturally idempotent actions, request fingerprinting, client-generated keys, and server-issued tokens—with concrete examples, SQL code, and a selection guide to match each pattern to specific business scenarios like payment callbacks, order cancellations, and duplicate purchases.

Idempotencybackend developmentconditional update
0 likes · 29 min read
Idempotency Design for Write Services: 7 Patterns & Selection Guide
Weekly Large Model Application
Weekly Large Model Application
Sep 20, 2026 · Artificial Intelligence

Voice Agent Architecture: Full-Duplex Frontend + Async Backend Delegation

This article explains a voice agent architecture that separates real-time full-duplex frontend interaction from asynchronous backend computation using delegation IDs, detailing the two-timeline mechanism, three-layer responsibility split, task state machine, and evaluation strategies to avoid stale responses and interruption mishandling.

async backenddelegation patternfull-duplex
0 likes · 8 min read
Voice Agent Architecture: Full-Duplex Frontend + Async Backend Delegation
Baidu Maps Tech Team
Baidu Maps Tech Team
Sep 18, 2026 · Artificial Intelligence

Map Road Digital Employee: Multi-Agent Platform Automates Road Network Data Analysis 6-10x Faster

This article details a multi-agent platform called Map Road Digital Employee that automates map road network data analysis, reducing case processing time from 20-30 minutes to 3-5 minutes through a four-layer agent architecture, skill-based tooling, state-machine orchestration with human-in-the-loop, and checkpoint persistence, achieving 6-10x efficiency gains while maintaining reliability.

LLM orchestrationcheckpoint persistencehuman-in-the-loop
0 likes · 25 min read
Map Road Digital Employee: Multi-Agent Platform Automates Road Network Data Analysis 6-10x Faster
Open Source Tech Hub
Open Source Tech Hub
Sep 16, 2026 · Backend Development

Automating the Build-Test-Fix Loop with AI Agents in Laravel

This article details a fully automated AI agent workflow for Laravel using Laravel Boost and OpenCode CLI, where specialized agents autonomously handle building, testing, diagnosing failures, and fixing code in a persistent queue-driven loop until tests pass, with human review only at the end.

AI agentsAgent OrchestrationCI/CD
0 likes · 22 min read
Automating the Build-Test-Fix Loop with AI Agents in Laravel
Shuge Unlimited
Shuge Unlimited
Sep 12, 2026 · Artificial Intelligence

Why Your DeepSeek Harness Agent Stops: It's Not a Bug, It's Authorization

DeepSeek Harness uses three distinct continuation mechanisms—Goal, Ralph, and Workflow—each with explicit trade-offs: Goal requires human resume due to non-persisted activation, Ralph runs fresh sessions with shared workspace, and Workflow lets models write orchestration scripts in isolated worker threads.

AI agentsDeepSeek HarnessGoal mechanism
0 likes · 24 min read
Why Your DeepSeek Harness Agent Stops: It's Not a Bug, It's Authorization
Cloud Architecture
Cloud Architecture
Sep 7, 2026 · Backend Development

Why a Single Timeout Spawned Two Risk Reviews: Production MCP Server Patterns

The article analyzes a timeout-induced duplicate risk review incident, then presents a comprehensive production-grade MCP server design covering stateless protocol alignment, schema validation, dual-key idempotency (request_key + business_key), UNKNOWN state machine, recovery workers, MCP Tasks integration, concurrency control, observability, and fault-injection testing to ensure exactly-once business effects.

IdempotencyMCPModel Context Protocol
0 likes · 27 min read
Why a Single Timeout Spawned Two Risk Reviews: Production MCP Server Patterns
inShocking
inShocking
Sep 1, 2026 · Artificial Intelligence

Spec-Driven Development: How I Enabled AI Agents to Independently Deliver Features

The author details a Spec-Driven Development (SDD) practice that structures a .specs repository with state-gated phases, four-file feature specs, evidence grading, and reusable skills to let AI agents independently investigate, design, implement, and verify features while reserving business decisions and external side effects for human approval.

AI agentsEvidence-Based DevelopmentRequirements Engineering
0 likes · 25 min read
Spec-Driven Development: How I Enabled AI Agents to Independently Deliver Features
Architecture and Beyond
Architecture and Beyond
Aug 30, 2026 · Artificial Intelligence

Agent Loop Termination: DeepSeek Harness vs Pi Architecture Deep Dive

This article compares how DeepSeek Harness and Pi determine when an agent loop ends, analyzing their multi-layer boundary models, state machines, turn/step debt tracking, stop hooks, tool conclusion semantics, cancellation handling, reason taxonomies, goal-driven outer loops, and the engineering trade-offs between a heavyweight event-sourced runtime and a lightweight embeddable kernel.

AI ArchitectureDeepSeek HarnessPi
0 likes · 40 min read
Agent Loop Termination: DeepSeek Harness vs Pi Architecture Deep Dive
DataFunSummit
DataFunSummit
Aug 24, 2026 · Artificial Intelligence

Why Powerful AI Agents Are Becoming More Like Traditional Software

Palantir's new Agent Stack shifts AI agents from short‑lived model‑prompt loops to a production‑grade architecture that adds state, events, effects, durable execution, observability and ontology, turning agents into reliable, governable software components for real‑world business tasks.

AI agentsOntologyPalantir
0 likes · 11 min read
Why Powerful AI Agents Are Becoming More Like Traditional Software
Ray's Galactic Tech
Ray's Galactic Tech
Aug 19, 2026 · Backend Development

Designing a 12‑State Payment System State Machine from Pending to Completed

This article presents a complete design for a 12‑state payment order state machine that handles high‑concurrency scenarios such as payment callbacks arriving after an order has been cancelled, using explicit state transitions, database CAS updates, Redis + DB idempotency, Outbox pattern and Kafka‑driven asynchronous processing to achieve reliable, auditable and compensatable order lifecycle management.

ConcurrencyIdempotencyKafka
0 likes · 39 min read
Designing a 12‑State Payment System State Machine from Pending to Completed
Ray's Galactic Tech
Ray's Galactic Tech
Aug 16, 2026 · Backend Development

Ditch Seata: Build a Production‑Ready SAGA Orchestrator with a 500‑Line Java State Machine

This article shows how to replace heavyweight distributed‑transaction frameworks such as Seata with a lightweight, production‑grade SAGA orchestrator built from a Java state machine, MySQL persistence and Spring Boot, covering architecture, state‑machine design, database schema, core orchestration logic, recovery, exception handling and practical deployment tips.

IdempotencyJavaSaga
0 likes · 46 min read
Ditch Seata: Build a Production‑Ready SAGA Orchestrator with a 500‑Line Java State Machine
Xike
Xike
Aug 16, 2026 · Backend Development

Idempotency Strategies for APIs: Preventing Duplicate Submissions

The article analyzes why network timeouts, client retries, user double‑clicks, and at‑least‑once MQ delivery cause duplicate intents, then details five practical idempotency techniques—conditional updates, unique constraints, Idempotency‑Key tokens, state machines with optimistic locks, and distributed locks—along with their trade‑offs and monitoring tips.

APIIdempotencydatabase
0 likes · 11 min read
Idempotency Strategies for APIs: Preventing Duplicate Submissions
DeepHub IMBA
DeepHub IMBA
Aug 15, 2026 · Artificial Intelligence

Why Most AI Agents Are Really Workflows, Not Fully Autonomous Systems

The article explains that most so‑called Agentic AI systems are built around a fixed control‑flow loop where an LLM acts as a planner, making them essentially workflows; it then details the reliability, debugging, and cost challenges that prevent true autonomy in production.

Agentic AIDebuggingLLM
0 likes · 15 min read
Why Most AI Agents Are Really Workflows, Not Fully Autonomous Systems
Dabaoshi
Dabaoshi
Aug 10, 2026 · Fundamentals

State Pattern Explained: Turning Conditional Logic into Flowing State Transitions

The article demonstrates how the State design pattern replaces tangled if‑else state checks with dedicated state classes, using an order lifecycle example to compare it with Strategy, explain role responsibilities, transition driving mechanisms, and guidelines for when to apply the pattern.

JavaState PatternStrategy Pattern
0 likes · 15 min read
State Pattern Explained: Turning Conditional Logic into Flowing State Transitions
Lin is Dream
Lin is Dream
Aug 4, 2026 · Artificial Intelligence

Zero-Code Engineering: How a Custom Protocol Lets an AI Agent Write All Your Code

The article details a month‑long experiment where a developer handed the entire coding, testing, review, merging and deployment pipeline to an AI Agent governed by a custom state‑machine protocol, enabling breakpoint‑resumable, loop‑feedback driven development without writing a single line of code.

AI agentCI/CDDevOps automation
0 likes · 12 min read
Zero-Code Engineering: How a Custom Protocol Lets an AI Agent Write All Your Code
AI Engineer Programming
AI Engineer Programming
Jul 29, 2026 · Backend Development

Imperative Control Flow vs Declarative Workflow Orchestration: When to Use State Machines

The article compares traditional imperative sequencing of function calls with declarative workflow orchestration using state machines, highlighting how the latter separates business logic into data-driven transition tables to improve flexibility, observability, and error recovery in complex, mutable backend systems.

Workflow Orchestrationdeclarative programmingimperative programming
0 likes · 9 min read
Imperative Control Flow vs Declarative Workflow Orchestration: When to Use State Machines
Xiaolin Talks Programming
Xiaolin Talks Programming
Jul 17, 2026 · Backend Development

Spring StateMachine in Production: Modeling, Redis Persistence & High-Concurrency Anti-Duplication Patterns

This article shares real-world experience using Spring StateMachine to replace sprawling if-else logic in order systems, covering state/event/guard modeling, Redis-backed persistence, a three-layer concurrency control pattern (distributed lock + optimistic lock + event idempotency), async decoupling, timeout handling, and compensation strategies with concrete code templates.

Distributed LockIdempotencyOptimistic Lock
0 likes · 17 min read
Spring StateMachine in Production: Modeling, Redis Persistence & High-Concurrency Anti-Duplication Patterns
Infinite Tech Management
Infinite Tech Management
Jul 15, 2026 · R&D Management

Practical Guide to Drawing Architecture Diagrams: Using an AI Customer Service System as an Example

This article walks through a step‑by‑step method for creating a technical architecture diagram of an AI‑powered customer service system, covering how to identify the core business flow, map states and data ownership, decide sync/async boundaries, place modules, and annotate risks and support capabilities.

AI chatbotArchitecture DiagramSynchronization
0 likes · 18 min read
Practical Guide to Drawing Architecture Diagrams: Using an AI Customer Service System as an Example
Cloud Architecture
Cloud Architecture
Jul 13, 2026 · Backend Development

Production-Grade Payment System Guide: Java Implementation for Alipay & WeChat All-Channel Integration

This article explains why a payment system is more than a simple SDK integration, presents a four‑layer architecture (access, state, event, governance), details state machines, idempotent callbacks, outbox pattern, reconciliation, high‑concurrency handling, observability, security, and provides Java code examples for integrating Alipay and WeChat across all channels.

AlipayIdempotencyJava
0 likes · 29 min read
Production-Grade Payment System Guide: Java Implementation for Alipay & WeChat All-Channel Integration
Ray's Galactic Tech
Ray's Galactic Tech
Jul 13, 2026 · Artificial Intelligence

When AI Agents Meet Cloud‑Native: Practical Multi‑Agent Orchestration for High‑Concurrency Scenarios

The article explains why naïve multi‑agent demos fail in production, defines the core concepts of Task, Step, Agent Role and Event, proposes a four‑plane cloud‑native architecture, shows concrete Go and Python code, and provides detailed guidance on state machines, reliability, observability, security and budget governance for building scalable, production‑grade AI agent systems.

AI agentsKubernetesbudget governance
0 likes · 36 min read
When AI Agents Meet Cloud‑Native: Practical Multi‑Agent Orchestration for High‑Concurrency Scenarios
Tinker Programmer
Tinker Programmer
Jul 7, 2026 · Backend Development

Why Saga Beats 2PC for Distributed Business Consistency

The article explains why traditional two‑phase commit (2PC) is unsuitable for micro‑service workflows, introduces the Saga pattern as a series of local transactions with compensations, compares orchestration‑based and choreography‑based implementations, and provides concrete design guidelines, code samples, and state‑machine persistence strategies.

ChoreographySagacompensation
0 likes · 18 min read
Why Saga Beats 2PC for Distributed Business Consistency
Architect
Architect
Jun 27, 2026 · Backend Development

From Task Cycles to a Maintainable, Observable, Replayable Agent Loop

The article explains how Loop Engineering turns multi‑round Agent execution into a maintainable, observable, and replayable closed‑loop by defining six core components, reusing traditional development patterns, presenting a CI‑failure triage demo, and highlighting architectural and practical pitfalls.

CI pipelineagent loopobservability
0 likes · 19 min read
From Task Cycles to a Maintainable, Observable, Replayable Agent Loop
Cloud Architecture
Cloud Architecture
Jun 25, 2026 · Backend Development

SpringBoot + WeChat Pay V3: Architecture for Million-Concurrent Payments

The article explains how to build a production‑grade, million‑concurrent payment pipeline with SpringBoot and WeChat Pay V3, covering the new security model, state‑machine design, idempotent handling, decoupled architecture, compensation mechanisms, and operational best practices such as connection‑pool tuning, observability, and fault‑tolerant deployment.

SpringBootWeChat Paycompensation
0 likes · 56 min read
SpringBoot + WeChat Pay V3: Architecture for Million-Concurrent Payments
Cloud Architecture
Cloud Architecture
Jun 24, 2026 · Backend Development

Spring Boot Alipay Integration: A Production-Ready Solution for High Concurrency and Financial Consistency

This article explains how to build a production‑grade Alipay payment subsystem with Spring Boot that goes beyond simple API calls, covering asynchronous flow, idempotent notification handling, state‑machine design, outbox event delivery, high‑concurrency safeguards, and end‑to‑end reconciliation.

AlipayIdempotencyOutbox
0 likes · 32 min read
Spring Boot Alipay Integration: A Production-Ready Solution for High Concurrency and Financial Consistency
Hacker Afternoon Tea
Hacker Afternoon Tea
Jun 20, 2026 · Backend Development

How Multica Agents Acquire, Execute, and Report Tasks: Inside the Task Lifecycle

This article dissects Multica's agent task lifecycle, explaining how a state‑machine model, three‑level watchdog timeouts, a string‑based failure classifier, and precise cache‑invalidation rules together ensure agents run reliably, distinguish between long‑running and stuck tasks, and report progress without overwhelming the network.

Watchdogbackend developmentcache invalidation
0 likes · 10 min read
How Multica Agents Acquire, Execute, and Report Tasks: Inside the Task Lifecycle
AI Programming Lab
AI Programming Lab
Jun 11, 2026 · Artificial Intelligence

The Complete AI Agent Development Stack: A 2026 Roadmap

This article breaks down the full technology stack for production‑ready AI agents in 2026, covering model gateways, orchestration frameworks, tool‑use protocols, memory layers, state‑machine execution, sandboxing, observability, evaluation, and human‑in‑the‑loop safeguards, while highlighting concrete tools, risks, and best‑practice trade‑offs.

AI agentTool Usememory management
0 likes · 22 min read
The Complete AI Agent Development Stack: A 2026 Roadmap
Cloud Architecture
Cloud Architecture
May 29, 2026 · Cloud Native

Batch Task Platform on Kubernetes: From Job Wrappers to Scalable Control Plane

The article explains how to design a production‑grade, unified batch‑task platform on Kubernetes that goes beyond a simple job UI, covering unified abstractions, multi‑tenant governance, state‑machine modeling, scalable scheduling, high‑concurrency handling, observability, security, and a phased roadmap for incremental implementation.

KubernetesSchedulingbatch processing
0 likes · 36 min read
Batch Task Platform on Kubernetes: From Job Wrappers to Scalable Control Plane
Java Architect Handbook
Java Architect Handbook
May 26, 2026 · Backend Development

How to Prevent Duplicate Consumption in RabbitMQ? 5 Practical Solutions for Interviews

The article explains why RabbitMQ may deliver the same message multiple times, emphasizes that business‑level idempotency is required, and compares five concrete deduplication approaches—unique message ID with a dedup table, database unique constraints, Redis SETNX, optimistic locking, and state‑machine design—detailing their implementation, suitable scenarios, and trade‑offs.

IdempotencyOptimistic LockRabbitMQ
0 likes · 13 min read
How to Prevent Duplicate Consumption in RabbitMQ? 5 Practical Solutions for Interviews
LuTiao Programming
LuTiao Programming
May 19, 2026 · Fundamentals

Don’t Limit Java Enums to SUCCESS/FAIL – 5 Advanced Enum Techniques Already Used by Top Frameworks

The article reveals five sophisticated ways to leverage Java enums—state‑machine implementation, built‑in strategy pattern, enum‑lambda combos, responsibility‑chain routing, and enum‑Map DSL—showing how major frameworks like Tomcat, Spring Boot and RocketMQ employ them to write cleaner, type‑safe, and easily extensible code.

DSLDesign PatternEnum
0 likes · 11 min read
Don’t Limit Java Enums to SUCCESS/FAIL – 5 Advanced Enum Techniques Already Used by Top Frameworks
Cloud Architecture
Cloud Architecture
May 17, 2026 · Backend Development

Production Design for Order Timeout Closure: RabbitMQ Delay Queues, Idempotent State Machine

This article presents a production‑grade architecture for automatically closing unpaid orders, detailing why simple scheduled tasks are insufficient, outlining high‑risk scenarios, defining five core objectives, comparing implementation options, and providing a complete RabbitMQ TTL + DLX solution with state‑machine idempotency, high‑concurrency handling, observability, and Kubernetes deployment guidance.

RabbitMQSpring Bootdistributed systems
0 likes · 40 min read
Production Design for Order Timeout Closure: RabbitMQ Delay Queues, Idempotent State Machine
Linyb Geek Road
Linyb Geek Road
May 15, 2026 · Backend Development

Idempotency in Practice: Handling the Same Key with Different Parameters

The article explains why simple key‑based idempotency fails when a second request carries different parameters, and demonstrates how to use database row locks, request fingerprinting, state machines, and explicit error handling to guarantee safe, non‑duplicate execution in payment‑critical APIs.

API DesignIdempotencyMessage Queue
0 likes · 13 min read
Idempotency in Practice: Handling the Same Key with Different Parameters
James' Growth Diary
James' Growth Diary
May 12, 2026 · Frontend Development

Keybinding System & Vim Emulation: 17 Contexts, 5 Result Types, State Machine

Claude Code’s keybinding engine tackles fragile CLI key handling by defining 17 compile‑time UI contexts, a union of five resolve result types, chord support, and a full Vim‑mode state machine, demonstrating how context isolation, chord sequencing, and repeat‑command logic prevent conflicts and enable extensible behavior.

CLITypeScriptVim mode
0 likes · 15 min read
Keybinding System & Vim Emulation: 17 Contexts, 5 Result Types, State Machine
James' Growth Diary
James' Growth Diary
May 6, 2026 · Backend Development

How Claude Code’s Task System Uses 7 TaskTypes and 9‑Char IDs for Clear Debugging

The article dissects Claude Code’s task architecture, explaining the 7‑type TaskType union, the 9‑character prefixed ID scheme, the TaskStatus state machine, guard functions, incremental output handling, a minimal kill‑only interface, and a stall‑watchdog that together make concurrent Agent debugging both readable and secure.

ConcurrencyTaskTypebackend design
0 likes · 18 min read
How Claude Code’s Task System Uses 7 TaskTypes and 9‑Char IDs for Clear Debugging
Architect Practice
Architect Practice
Apr 30, 2026 · Artificial Intelligence

Why Business Agents Can’t Rely Solely on LLMs: Implementing Intent Recognition and Task Decomposition

The article explains that a production‑grade business agent must combine LLM‑driven intent understanding with deterministic rule‑based control, using a perception‑understanding‑planning‑execution‑feedback loop, two‑round prompting, strict JSON schemas, permission checks, and a state‑machine architecture to avoid unsafe, uncontrolled behavior.

Business AgentLLMagent architecture
0 likes · 23 min read
Why Business Agents Can’t Rely Solely on LLMs: Implementing Intent Recognition and Task Decomposition
Architect-Kip
Architect-Kip
Apr 29, 2026 · Backend Development

A Generic State Machine Solution for Managing Business Entity Lifecycles

This article presents a comprehensive state‑machine‑based approach for managing the lifecycle of business entities such as orders and work orders, detailing core pain points, essential questions a state machine must answer, a comparative analysis of four implementation options, and a recommended solution that combines a database transition table, domain services, and optimistic‑lock concurrency control, along with architecture diagrams, code snippets, and operational guidelines.

ConcurrencyDomain ServiceOptimistic Lock
0 likes · 15 min read
A Generic State Machine Solution for Managing Business Entity Lifecycles
James' Growth Diary
James' Growth Diary
Apr 28, 2026 · Artificial Intelligence

StreamingToolExecutor: Full Breakdown of Claude Code’s Four‑Layer Parallel Tool Execution Mechanism

The article dissects Claude Code’s StreamingToolExecutor, revealing how a four‑state machine, two simple concurrency rules, and a three‑layer AbortController hierarchy enable true parallel tool execution, reduce latency, preserve result order, and handle failures with nuanced abort semantics.

AI agentsAbortControllerClaude Code
0 likes · 18 min read
StreamingToolExecutor: Full Breakdown of Claude Code’s Four‑Layer Parallel Tool Execution Mechanism
DeepHub IMBA
DeepHub IMBA
Apr 24, 2026 · Artificial Intelligence

LangChain vs LangGraph: Choosing a Toolkit or an Orchestrator

The article compares LangChain and LangGraph by implementing the same three‑stage code‑review pipeline with identical agents and Gemini 2.5 Flash calls, showing when a linear toolkit suffices and when a state‑machine orchestrator becomes necessary.

AgentLLM orchestrationLangChain
0 likes · 8 min read
LangChain vs LangGraph: Choosing a Toolkit or an Orchestrator
James' Growth Diary
James' Growth Diary
Apr 24, 2026 · Artificial Intelligence

How LangGraph Turns LLMs into a State Machine

This article dissects LangGraph's core execution engine, showing how it transforms LLM calls into a state‑machine workflow with mutable State, Nodes, Edges, Reducers, a scheduler loop, conditional branching, and parallel fan‑out/fan‑in execution.

JavaScriptLLMLangGraph
0 likes · 12 min read
How LangGraph Turns LLMs into a State Machine
Huolala Tech
Huolala Tech
Apr 22, 2026 · Backend Development

How a Platform‑Based Architecture Turns Logistics Fulfillment from Silos to Scalable Services

The article details a step‑by‑step transformation of a logistics fulfillment system from a duplicated, siloed design to a unified, plug‑in‑driven platform, explaining the underlying domain model, split‑and‑route strategies, state orchestration, code contracts, quantitative benefits, and future intelligent extensions.

logistics fulfillmentmicroservicesplatform architecture
0 likes · 15 min read
How a Platform‑Based Architecture Turns Logistics Fulfillment from Silos to Scalable Services
AI Tech Publishing
AI Tech Publishing
Apr 19, 2026 · Artificial Intelligence

How to Build Production‑Ready Agent HITL: State Machines, Event Sourcing, and Distributed Coordination

The article presents a detailed engineering guide for deploying production‑grade AI agents with Human‑in‑the‑Loop, covering a three‑layer decoupled architecture, tool‑level and hook‑level interception, a six‑state session state machine with event sourcing, robust timeout handling using CAS, and cross‑node coordination for multi‑agent workflows.

AgentHITLTimeout
0 likes · 17 min read
How to Build Production‑Ready Agent HITL: State Machines, Event Sourcing, and Distributed Coordination
AI Step-by-Step
AI Step-by-Step
Apr 5, 2026 · Artificial Intelligence

How Context Engineering Powers Dynamic Business Data Assembly for LLM Agents

The article explains why relying solely on handcrafted prompts leads to hallucinations in LLM agents and presents six concrete context‑engineering practices—XML isolation, hierarchical ordering, KV caching, vector reranking, async memory compression, and minimal few‑shot examples—illustrated with a full e‑commerce refund‑handling case study.

AgentKV cacheLLM
0 likes · 10 min read
How Context Engineering Powers Dynamic Business Data Assembly for LLM Agents
Data STUDIO
Data STUDIO
Feb 3, 2026 · Artificial Intelligence

Build a Self‑Thinking AI Agent with LangGraph: A Step‑by‑Step Guide

This tutorial explains how LangGraph adds explicit control‑flow, cycles, and shared state to LLM applications, and walks through building a Strava‑based intelligent training coach with Python code, node definitions, state design, graph assembly, and GitHub Actions deployment.

AI agentsLLMLangGraph
0 likes · 12 min read
Build a Self‑Thinking AI Agent with LangGraph: A Step‑by‑Step Guide
Liangxu Linux
Liangxu Linux
Dec 24, 2025 · Fundamentals

Mastering C Function Pointers: From Basics to Embedded Applications

This tutorial explains what function pointers are, how to declare and use them in C, and demonstrates practical embedded‑system patterns such as callbacks, state machines, command dispatch, and advanced techniques like pointer arrays and struct members, while highlighting common pitfalls.

C++Embeddedcallbacks
0 likes · 13 min read
Mastering C Function Pointers: From Basics to Embedded Applications
Ray's Galactic Tech
Ray's Galactic Tech
Dec 20, 2025 · Backend Development

Production-Ready Idempotency for RocketMQ Duplicate Consumption (Full Code)

To reliably handle RocketMQ's at-least-once delivery semantics, this guide explains why duplicate consumption is inevitable, outlines three defensive layers—Redis‑based idempotency, database unique constraints, and state‑machine checks—provides production‑grade Java code, and details ACK/retry strategies and monitoring practices for robust systems.

IdempotencyJavaRedis
0 likes · 9 min read
Production-Ready Idempotency for RocketMQ Duplicate Consumption (Full Code)
Fighter's World
Fighter's World
Dec 16, 2025 · Artificial Intelligence

Boosting Large Language Model Domain Expertise with Claude Skills

The article analyzes why generic LLMs struggle with domain‑specific reasoning, critiques fine‑tuning, RAG and prompt engineering, and presents Claude Skills—using progressive disclosure, Pydantic validation, and state‑machine control—to encode expert constraints as executable rules, illustrated with finance compliance and legal reasoning case studies and backed by Anthropic research.

ClaudeLLMProgressive Disclosure
0 likes · 20 min read
Boosting Large Language Model Domain Expertise with Claude Skills
Three Knives
Three Knives
Dec 15, 2025 · Backend Development

Why JDK’s Built‑in GZIP Is Inefficient and How Feat’s Custom Stream Solves It

The article examines the blocking‑IO and loop‑blocking problems of Java’s standard GZIPInputStream in high‑concurrency async scenarios, then details Feat framework’s reimplementation with an async‑friendly state‑machine design, fine‑grained state management, memory optimizations, full RFC 1952 compliance, and provides concrete code examples.

CompressionFeat frameworkGZIP
0 likes · 8 min read
Why JDK’s Built‑in GZIP Is Inefficient and How Feat’s Custom Stream Solves It
Selected Java Interview Questions
Selected Java Interview Questions
Nov 23, 2025 · Backend Development

Mastering Order Workflow with Spring Statemachine: A Step‑by‑Step Guide

This tutorial shows how to replace bulky if‑else or switch logic with Spring Statemachine in a Spring Boot application, covering dependency setup, state and event enums, machine configuration, persistence, service implementation, controller endpoints, and advanced conditional transitions for loan processing.

BackendConditional TransitionJava
0 likes · 10 min read
Mastering Order Workflow with Spring Statemachine: A Step‑by‑Step Guide
Three Knives
Three Knives
Nov 16, 2025 · Backend Development

Chapter 7: Understanding the MessageProcessor Mechanism in smart‑socket

This article explains the core MessageProcessor interface of the smart‑socket framework, detailing its process and stateEvent methods, the associated StateMachineEnum events, example implementations for echo and business logic servers, and recommended best‑practice guidelines for robust message handling.

JavaMessageProcessorNetworking
0 likes · 8 min read
Chapter 7: Understanding the MessageProcessor Mechanism in smart‑socket
Amap Tech
Amap Tech
Oct 15, 2025 · Artificial Intelligence

How AI Powers Gaode’s ‘Car Cruise’ for Seamless, Hands‑Free Navigation

Gaode Map’s Car Cruise transforms navigation into an AI‑native, hands‑free experience by automatically detecting routes, providing real‑time voice alerts, lane‑level guidance, and car‑play integration, all driven by a state‑machine architecture that reduces driver distraction while enhancing safety, efficiency, and user personalization.

AI navigationMobile Appcar‑play
0 likes · 19 min read
How AI Powers Gaode’s ‘Car Cruise’ for Seamless, Hands‑Free Navigation
Liangxu Linux
Liangxu Linux
Sep 17, 2025 · Fundamentals

Mastering Event‑Driven Design and State Machines for Embedded Firmware

This article explains how event‑driven programming and state‑machine concepts can be applied to microcontroller firmware, compares a simple flag‑based approach with a message‑queue solution, and presents a reusable GF1.0 framework that combines ISR, message buffering, and a main state machine for robust embedded systems.

Message Queueembedded systemsfirmware
0 likes · 32 min read
Mastering Event‑Driven Design and State Machines for Embedded Firmware
Sohu Tech Products
Sohu Tech Products
Sep 17, 2025 · Mobile Development

How to Supercharge Dual‑State Lottie Animations on iOS: A 3‑Step Performance Boost

This article walks through the performance bottlenecks of using Lottie for dual‑state animations in mobile apps and presents a three‑stage progressive optimization—basic synchronous implementation, asynchronous loading with caching, and a state‑machine‑based pending mechanism—complete with Swift code samples, diagrams, and benchmark results.

Asynchronous LoadingLottieMobile UI
0 likes · 13 min read
How to Supercharge Dual‑State Lottie Animations on iOS: A 3‑Step Performance Boost
Su San Talks Tech
Su San Talks Tech
Sep 2, 2025 · Fundamentals

Mastering Finite State Machines with Spring Statemachine: A Complete Guide

Learn the fundamentals of finite state machines, explore their core concepts and four key elements, and see how to implement and persist a Spring Statemachine for order processing with detailed code examples, diagrams, and troubleshooting tips, while also understanding common pitfalls and best practices.

AOPBackendJava
0 likes · 26 min read
Mastering Finite State Machines with Spring Statemachine: A Complete Guide
Zhuanzhuan Tech
Zhuanzhuan Tech
Aug 27, 2025 · Operations

From State Machines to a Custom Workflow Engine: Scaling Quality Inspection Processes

This article chronicles the evolution of a quality‑inspection system from a simple finite state machine to a self‑developed, lightweight workflow engine, detailing the motivations, design decisions, implementation steps, challenges faced, and future roadmap for flexible, configurable process orchestration.

backend developmentlow-codeprocess orchestration
0 likes · 19 min read
From State Machines to a Custom Workflow Engine: Scaling Quality Inspection Processes
Data STUDIO
Data STUDIO
Aug 27, 2025 · Fundamentals

Building a Lightweight State Machine with Python Enum

This article demonstrates how to implement a clear, maintainable state machine for a publishing workflow using Python's Enum type, covering state definitions, forward and backward transitions, validation, entry actions, and visualisation without external dependencies.

Design PatternEnumPython
0 likes · 7 min read
Building a Lightweight State Machine with Python Enum
Tech Freedom Circle
Tech Freedom Circle
Jul 16, 2025 · Interview Experience

How to Use and Optimize State Machines in Java for Interview Success

This article explains the concept of state machines, why traditional if‑else logic is problematic, compares popular Java state‑machine frameworks, provides performance benchmarks, walks through a complete Spring Statemachine implementation for order processing, and offers practical optimization and monitoring tips for high‑throughput scenarios.

InterviewJavaSpring
0 likes · 30 min read
How to Use and Optimize State Machines in Java for Interview Success
Architect
Architect
Jun 13, 2025 · Fundamentals

Mastering the State Pattern: Real‑World Java Examples and Spring State Machine

This article explains the State (State Machine) pattern, its typical scenarios such as order processing and elevator control, presents a complete Java implementation with abstract, concrete, and context classes, demonstrates how to model order workflows using Spring State Machine, compares related patterns, and discusses the pattern’s advantages and drawbacks.

JavaSpring State MachineState Pattern
0 likes · 14 min read
Mastering the State Pattern: Real‑World Java Examples and Spring State Machine
Bilibili Tech
Bilibili Tech
Jun 13, 2025 · Mobile Development

How Bilibili Scaled Kotlin Multiplatform Across Android, iOS, and HarmonyOS

This article details Bilibili's practical experience with Kotlin Multiplatform (KMP), covering the choice of Bazel as a build system, multi‑language interop, dependency injection, modular export, state‑machine driven single‑direction data flow, and the successful deployment of shared logic and UI across Android, iOS, and HarmonyOS platforms.

BazelCompose UICross‑platform
0 likes · 20 min read
How Bilibili Scaled Kotlin Multiplatform Across Android, iOS, and HarmonyOS
Go Programming World
Go Programming World
May 26, 2025 · Fundamentals

Using Finite State Machines in Go with the looplab/fsm Package

This article introduces the concept of finite state machines, demonstrates how to implement them in Go using the looplab/fsm library with practical code examples, explains the lifecycle callbacks, and shows how to apply FSMs to real‑world scenarios such as door state management.

FSMFinite State MachineGo
0 likes · 17 min read
Using Finite State Machines in Go with the looplab/fsm Package
Code Ape Tech Column
Code Ape Tech Column
Apr 1, 2025 · Backend Development

Designing a Payment System State Machine and Status History Table

This article explains why payment systems need a state machine, details common payment statuses, illustrates typical state transition flows, describes the design of a status‑change history table, and provides implementation guidance using hand‑written code or Spring StateMachine to ensure maintainability, auditability, and robust handling of exceptional scenarios.

auditpaymentstate machine
0 likes · 14 min read
Designing a Payment System State Machine and Status History Table
Liangxu Linux
Liangxu Linux
Mar 22, 2025 · Backend Development

Boost CPU Efficiency and Code Clarity with State‑Machine Programming

The article explains how using a state‑machine approach in embedded C programs can eliminate wasteful delay loops, ensure logical completeness, and produce clearer, more maintainable code by structuring work around events and states.

CPU efficiencyCode Maintainabilityembedded C
0 likes · 5 min read
Boost CPU Efficiency and Code Clarity with State‑Machine Programming
macrozheng
macrozheng
Feb 28, 2025 · Fundamentals

Mastering the State Pattern: Real‑World Java Examples and Best Practices

This article explains the State (State Machine) design pattern, its typical use cases, core roles, and practical Java implementations—including a login‑state example and a Spring StateMachine order workflow—while also comparing it with related patterns and outlining its advantages and drawbacks.

State Patternsoftware architecturestate machine
0 likes · 16 min read
Mastering the State Pattern: Real‑World Java Examples and Best Practices
Zhuanzhuan Tech
Zhuanzhuan Tech
Dec 20, 2024 · Backend Development

State Machine Selection and Refactoring Strategies for Complex Business Scenarios

This article analyzes the problem of exploding state‑branch logic in merchant onboarding and exit flows, presents decoupling, design‑pattern, and state‑machine solutions, compares three Java state‑machine implementations (Zhuozhou, Cola, Spring Statemachine), and offers practical selection guidance for simple to highly complex B2B use cases.

refactoringsoftware architecturestate machine
0 likes · 21 min read
State Machine Selection and Refactoring Strategies for Complex Business Scenarios
Open Source Linux
Open Source Linux
Dec 5, 2024 · Fundamentals

Mastering TCP State Machine: From LISTEN to TIME_WAIT Explained

This article provides a comprehensive guide to TCP connection states, common Linux commands for monitoring them, detailed explanations of each state transition, three‑way handshake, four‑way termination, flag meanings, keep‑alive mechanisms, and practical sysctl tuning to troubleshoot network issues.

SocketTCPkeepalive
0 likes · 29 min read
Mastering TCP State Machine: From LISTEN to TIME_WAIT Explained
G7 EasyFlow Tech Circle
G7 EasyFlow Tech Circle
Dec 3, 2024 · Backend Development

Inside the Unified Order Shipping Center: Scalable Logistics Architecture

This article examines the design and evolution of the Unified Order Shipping Center, detailing its model‑plus‑workflow architecture, core principles, metadata engine, state‑machine, API orchestration, microservice decomposition, and deployment strategy, and explains how it delivers scalable, flexible logistics capabilities across multiple business systems.

API orchestrationlogisticsmetadata engine
0 likes · 22 min read
Inside the Unified Order Shipping Center: Scalable Logistics Architecture
Java Architect Essentials
Java Architect Essentials
Sep 24, 2024 · Backend Development

Understanding the State Pattern and Implementing Order Workflow with Spring State Machine

This article explains the State design pattern, demonstrates its Java implementation with example code, introduces Spring State Machine concepts, and provides a complete step‑by‑step guide to building and testing an order status workflow using Spring State Machine, including configuration, listeners, services, and a controller.

Design PatternJavaOrder Workflow
0 likes · 13 min read
Understanding the State Pattern and Implementing Order Workflow with Spring State Machine
Bilibili Tech
Bilibili Tech
Jul 16, 2024 · Backend Development

Design and Implementation of Bilibili OGV Content Production System

The article details Bilibili’s OGV content production system, explaining why the traditional UGC workflow is insufficient, describing a supply‑chain‑style work‑order architecture with demand, plan and task entities, flexible key‑value data storage, input validation, a state‑machine‑driven task lifecycle, phased rollout, automation, and future extensions.

Content ProductionOGVstate machine
0 likes · 20 min read
Design and Implementation of Bilibili OGV Content Production System
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jun 28, 2024 · Fundamentals

Handcrafting a Minimal Kotlin Coroutine Implementation

This article analyzes the shortcomings of existing Kotlin coroutine tutorials and presents a step‑by‑step guide to building a lightweight coroutine framework from scratch, covering thread basics, CoroutineScope, launch, delay, resume, state‑machine logic, withContext, async, and Deferred with complete code examples.

Asynchronous ProgrammingCoroutinesCustom Implementation
0 likes · 15 min read
Handcrafting a Minimal Kotlin Coroutine Implementation
Code Ape Tech Column
Code Ape Tech Column
Jun 25, 2024 · Backend Development

COLA Stateless State Machine: A Lightweight, Thread‑Safe Alternative to Spring StateMachine for Java Backend Order Processing

The article explains why Spring StateMachine is heavyweight and thread‑unsafe for high‑concurrency order management, introduces the open‑source COLA stateless state machine as a simpler, lock‑free solution, and provides detailed design principles, core concepts, and extensive Java code examples.

COLAJavaSpring
0 likes · 13 min read
COLA Stateless State Machine: A Lightweight, Thread‑Safe Alternative to Spring StateMachine for Java Backend Order Processing
Open Source Linux
Open Source Linux
Jun 14, 2024 · Fundamentals

Mastering C State Machines: Switch‑Case, Table‑Driven, and Function‑Pointer Techniques

This article explains how to implement finite state machines in C using three approaches—switch‑case, table‑driven, and function‑pointer—detailing their structures, code examples, trade‑offs, and extensions such as compressed tables and hierarchical state machines for robust embedded systems.

C++Extended State MachineFinite State Machine
0 likes · 17 min read
Mastering C State Machines: Switch‑Case, Table‑Driven, and Function‑Pointer Techniques
Architecture Digest
Architecture Digest
Jun 3, 2024 · Backend Development

Spring Statemachine for Order State Management with Persistence, Exception Handling, and AOP Logging

This article explains the fundamentals of finite state machines, introduces Spring Statemachine, demonstrates how to model order lifecycle states, configure persistence with memory and Redis, handle exceptions during state transitions, and use AOP to log transition results, providing complete Java code examples.

AOPBackendJava
0 likes · 23 min read
Spring Statemachine for Order State Management with Persistence, Exception Handling, and AOP Logging
DeWu Technology
DeWu Technology
Apr 24, 2024 · Backend Development

State Machine Integration for New Product Onboarding

The article details how Dewu’s new product onboarding workflow was refactored into a Spring StateMachine‑driven architecture that separates channel‑specific logic via a Strategy‑pattern operation layer, defines clear enum status domains, and uses guards, actions, and choice states to achieve maintainable, extensible, and idempotent state transitions.

SpringWorkflowdesign patterns
0 likes · 20 min read
State Machine Integration for New Product Onboarding
Architect
Architect
Feb 15, 2024 · Backend Development

Mastering State Patterns with Spring State Machine: From Theory to Order Workflow

This article explains the classic State design pattern, demonstrates a traffic‑light example, compares Spring State Machine with COLA, and walks through building a complete order‑status workflow in Spring Boot using enums, configuration, listeners, services, and a test controller, while highlighting trade‑offs and alternatives.

BackendDesign PatternJava
0 likes · 14 min read
Mastering State Patterns with Spring State Machine: From Theory to Order Workflow
Architect
Architect
Feb 14, 2024 · Backend Development

Implementing Order Lifecycle Management with Spring Statemachine, Persistence, and AOP

This article explains the fundamentals of finite state machines, demonstrates how to model order states using Spring Statemachine, shows persistence options with in‑memory and Redis stores, and provides advanced techniques such as exception handling, extended state tracking, and AOP‑based result logging for reliable state transitions.

AOPJavaSpring
0 likes · 23 min read
Implementing Order Lifecycle Management with Spring Statemachine, Persistence, and AOP
政采云技术
政采云技术
Jan 16, 2024 · Fundamentals

Understanding Finite State Machines: Definitions, Usage, Advantages, and Their Relation to Domain‑Driven Design

This article explains what a finite state machine (FSM) is, illustrates it with a car transmission example, outlines its components and diagramming, discusses its technical pros and cons, explores business benefits, and examines how state machines relate to domain‑driven design.

Design PatternFinite State Machinedomain-driven design
0 likes · 13 min read
Understanding Finite State Machines: Definitions, Usage, Advantages, and Their Relation to Domain‑Driven Design
Code Ape Tech Column
Code Ape Tech Column
Oct 9, 2023 · Backend Development

Understanding and Implementing State Machines with Spring Statemachine

This article explains the fundamentals of finite state machines, introduces the four core concepts, demonstrates how to model order state transitions, and provides a complete Spring Statemachine implementation with persistence, event handling, testing, and advanced AOP-based error tracking in Java.

persistencestate machine
0 likes · 23 min read
Understanding and Implementing State Machines with Spring Statemachine
Java Architect Essentials
Java Architect Essentials
Oct 6, 2023 · Backend Development

Implementing Order Workflow with Spring Statemachine and Persistent State Storage

This article explains the fundamentals of finite‑state machines, introduces Spring Statemachine, demonstrates how to model an order lifecycle, configure persistence with in‑memory and Redis stores, and provides complete Java code for enums, configuration, services, controllers, listeners, testing, and exception‑handling improvements.

AOPJavaRedis
0 likes · 26 min read
Implementing Order Workflow with Spring Statemachine and Persistent State Storage
Top Architect
Top Architect
Sep 27, 2023 · Backend Development

Understanding Finite State Machines and Implementing Spring Statemachine in Java

This article explains the fundamentals of finite state machines, illustrates their concepts and diagramming, and provides a comprehensive guide on using Spring Statemachine in Java—including schema design, configuration, event handling, persistence strategies, testing, and common pitfalls with solutions.

BackendJavaWorkflow
0 likes · 28 min read
Understanding Finite State Machines and Implementing Spring Statemachine in Java