BestHub
Sign in
Tagged articles

state machine

164 articles · Page 1 of 2
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.

automated rollbackcanary deploymentchange management
0 likes · 37 min read
Why Auto-Rollback Fails at 10M QPS: The Missing Control Loop
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 ScriptsQR Code LoginRedis
0 likes · 28 min read
Spring Boot QR Code Login: State Machines, SSE Push, and Replay Protection for Production
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 agentsCI/CDLaravel
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.

MCPModel Context ProtocolObservability
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 agentsAutonomous DevelopmentEvidence-Based Development
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 architectureAgent FrameworkAgent Loop
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 agentsDurable ExecutionObservability
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.

ConcurrencyKafkaMySQL
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.

JavaMicroservicesSAGA
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.

APITokendatabase
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 AILLMTool Calling
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.

declarative programmingimperative programmingsoftware design
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.

High ConcurrencyOptimistic LockRedis Persistence
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 DiagramSystem Design
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.

AlipayHigh ConcurrencyJava
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 agentsKubernetesObservability
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.

ChoreographyMicroservicesSAGA
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.

Agent LoopCI pipelineObservability
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.

High ConcurrencyObservabilitySpringBoot
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.

AlipayBackend DevelopmentObservability
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.

Backend DevelopmentCache invalidationfailure classification
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 AgentObservabilitymemory 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.

Batch ProcessingKubernetesObservability
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.

Optimistic LockRabbitMQRedis SETNX
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.

High ConcurrencyRabbitMQSpring Boot
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 Designdatabase lockingdistributed systems
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.

Agent ArchitectureBusiness AgentLLM
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.

MicroservicesPlatform Architecturelogistics fulfillment
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.

AgentDistributed CoordinationEvent Sourcing
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++callbackscommand dispatch
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.

JavaRedisRocketMQ
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.

ClaudeLLMPydantic
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.

Backend DevelopmentCompressionFeat framework
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.

JavaMessageProcessorasynchronous
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.

embedded systemsfirmwaremessage queue
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.

AnimationAsynchronous LoadingLottie
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.

JavaOptimizationSpring
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 orchestrationPlatform Architecturelogistics
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 ProductionOGVWorkflow Automation
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.

Design PatternsSpringproduct onboarding
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.

AOPJavaPersistence
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 PatternDomain-Driven DesignFinite State Machine
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.

AOPJavaPersistence
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.

BackendJavaPersistence
0 likes · 28 min read
Understanding Finite State Machines and Implementing Spring Statemachine in Java
Shepherd Advanced Notes
Shepherd Advanced Notes
Sep 1, 2023 · Big Data

Visual Guide to Kafka’s Architecture and Core Principles

This article explains Kafka’s architecture in depth, covering components such as producers, consumers, topics, partitions, replication, Zookeeper coordination, the Controller’s election and responsibilities, state machines, and the NIO‑based network model, using clear diagrams and analogies.

ControllerKafkaNetwork Model
0 likes · 14 min read
Visual Guide to Kafka’s Architecture and Core Principles
JD Cloud Developers
JD Cloud Developers
Aug 3, 2023 · Backend Development

Mastering State Machines: From Theory to Spring and COLA Implementations

This article introduces the fundamentals of state machines, explains the four core concepts, explores domain‑specific languages (DSL) and their classifications, and provides practical Java examples using Spring Statemachine and the COLA framework, ending with a comparison and adoption guidance.

BackendCOLADSL
0 likes · 18 min read
Mastering State Machines: From Theory to Spring and COLA Implementations
Liangxu Linux
Liangxu Linux
Jul 30, 2023 · Fundamentals

How Event‑Driven State Machines Power Embedded Systems: From ISR to Message Queues

This article explains the principles of event‑driven programming and state‑machine design for microcontrollers, compares them with interrupt handling, introduces a message‑based architecture with concrete data structures and APIs, and shows how to build a reusable framework that solves ordering and loss problems in embedded applications.

ISRembedded systemsevent-driven
0 likes · 33 min read
How Event‑Driven State Machines Power Embedded Systems: From ISR to Message Queues
Zhuanzhuan Tech
Zhuanzhuan Tech
Jun 28, 2023 · Backend Development

Extracting Business System Knowledge through FSM‑X Visualization: A Practical Exploration

This article describes a practical approach to automatically extract and visualize business system knowledge from code by abstracting workflow control logic into a generalized design pattern using the FSM‑X state‑machine framework, discussing its background, methodology, implementation details, and current limitations.

BackendDomain-Driven DesignKnowledge Extraction
0 likes · 10 min read
Extracting Business System Knowledge through FSM‑X Visualization: A Practical Exploration
21CTO
21CTO
Jun 20, 2023 · Backend Development

Mastering Spring State Machine: Build Robust Order Workflows with Persistence

This article introduces the fundamentals of finite state machines, explains their four core concepts, demonstrates how to model order workflows with state diagrams, and provides a comprehensive guide to implementing, configuring, persisting, and testing Spring Statemachine in a Java backend, including solutions for exception handling and AOP enhancements.

AOPPersistenceSpring
0 likes · 23 min read
Mastering Spring State Machine: Build Robust Order Workflows with Persistence
Java Interview Crash Guide
Java Interview Crash Guide
Jun 15, 2023 · Backend Development

Mastering Spring Statemachine: Build Robust Order Workflows with Persistent State

This guide explains the fundamentals of state machines, introduces the four core concepts, shows how to model order transitions with diagrams, and provides a complete Spring Statemachine implementation—including database schema, enums, configuration, persistence, controller, service, listeners, testing, and advanced error‑handling techniques—so developers can create reliable, persisted workflows in Java.

Finite State MachinePersistenceSpring StateMachine
0 likes · 30 min read
Mastering Spring Statemachine: Build Robust Order Workflows with Persistent State
DeWu Technology
DeWu Technology
Jun 7, 2023 · Backend Development

Ensuring Data Consistency Across Microservices: Strategies and Design Principles

This article examines why data consistency between microservices is critical, defines key terminology, and presents two practical approaches—business‑side final consistency and platform‑side final consistency—detailing their core ideas, design principles, workflow diagrams, and real‑world implementation considerations such as idempotency, storage choices, latency tolerance, state‑machine design, concurrency control, and observability.

ConcurrencyData ConsistencyMicroservices
0 likes · 17 min read
Ensuring Data Consistency Across Microservices: Strategies and Design Principles
Architecture Digest
Architecture Digest
May 31, 2023 · Backend Development

Understanding State Machines and Implementing Spring Statemachine for Order Processing

This article explains the fundamentals of finite state machines, introduces the four core concepts of state, event, action, and transition, and provides a detailed guide on using Spring Statemachine with Java—including configuration, persistence, service and controller implementations, testing, and advanced troubleshooting techniques.

state machineworkflow
0 likes · 24 min read
Understanding State Machines and Implementing Spring Statemachine for Order Processing
Top Architect
Top Architect
May 29, 2023 · Backend Development

Understanding Finite State Machines and Spring Statemachine for Order Processing in Java

This article explains the fundamentals of finite state machines, introduces the four core concepts of state, event, action, and transition, demonstrates how to model an order lifecycle with a state‑machine diagram, and provides a complete Spring Statemachine implementation—including enums, configuration, persistence (memory and Redis), listeners, testing, and solutions to common exception‑handling issues—complete with runnable Java code examples.

AOPPersistenceorder processing
0 likes · 26 min read
Understanding Finite State Machines and Spring Statemachine for Order Processing in Java
Code Ape Tech Column
Code Ape Tech Column
May 23, 2023 · Backend Development

Message Notification Architecture and Design in Microservices

This article explains the principles, process management, sequence, and structural design of a message notification system within microservice architectures, highlighting production‑consumption patterns, task handling, state transitions, channel integration, and practical considerations for effective backend implementation.

Message Notificationbackend architecturemessage center
0 likes · 9 min read
Message Notification Architecture and Design in Microservices
Sohu Tech Products
Sohu Tech Products
Apr 26, 2023 · Fundamentals

Understanding JavaScript Generators: Basics, Syntax, and Advanced Usage

JavaScript Generators, introduced in ES6, allow functions to pause and resume execution, yielding multiple values; this article explains their syntax, basic usage, advanced features like yield* and data exchange, and demonstrates practical scenarios such as asynchronous flow control, memory-efficient data processing, and state machine implementation.

@AsyncJavaScriptdata processing
0 likes · 11 min read
Understanding JavaScript Generators: Basics, Syntax, and Advanced Usage
Architecture Digest
Architecture Digest
Apr 25, 2023 · Backend Development

Design and Implementation of a Scalable Transaction Platform for Vivo Global Mall

This article details the design principles, architecture, multi‑tenant sharding strategy, state‑machine workflow, distributed transaction handling, and high‑availability measures of Vivo's transaction platform, illustrating how a micro‑service‑based e‑commerce system achieves low cost, extensibility, and robust performance.

e-commercestate machinetransaction
0 likes · 12 min read
Design and Implementation of a Scalable Transaction Platform for Vivo Global Mall
Architecture Digest
Architecture Digest
Apr 14, 2023 · Backend Development

Design and Architecture of a Scalable Transaction Platform for Vivo Global Mall

This article presents the design philosophy, overall architecture, multi‑tenant sharding strategy, state‑machine workflow, distributed transaction handling, and high‑availability measures of Vivo’s global e‑commerce transaction platform, sharing practical challenges and solutions encountered during its development and ongoing evolution.

distributed transactionse-commercestate machine
0 likes · 14 min read
Design and Architecture of a Scalable Transaction Platform for Vivo Global Mall