Tagged articles
distributed
65 articles · Page 1 of 1
AgentScope Java 2.0 launches to solve the “Demo Curse” by adding native distributed deployment, full‑stack multi‑tenant isolation, fine‑grained permission control, a file‑driven Workspace, middleware extensions and robust model fault‑tolerance, turning prototype agents into production‑grade services.
AIAgentFrameworkAgentScope
0 likes · 26 min read

The article provides a comprehensive technical analysis of the AG2 framework, detailing its autonomous coordination multi‑agent paradigm, A2A communication protocol, full‑async Actor kernel, and how it compares to traditional LangChain/Graph approaches for building scalable, enterprise‑grade AI applications.
A2AAG2AI
0 likes · 36 min read

AgentScope Java 2.0 introduces distributed session handling, multi‑tenant isolation, an abstract filesystem, robust model fallback, structured context management, event streaming, a permission system, and middleware hooks, providing a cloud‑native, enterprise‑ready platform for building stable, long‑running AI agents.
AI agentsAgentScopeContext Management
0 likes · 17 min read

This article analytically examines INFINI Pizza, a Rust‑implemented distributed search database, detailing its design philosophy, hierarchical data model, rolling‑partition‑shard architecture, share‑nothing + io_uring I/O stack, true real‑time indexing, in‑place partial updates, AI‑native hybrid search capabilities, ecosystem components, and a point‑by‑point comparison with Elasticsearch.
AI NativeParquetReal-time
0 likes · 20 min read

The article provides a detailed comparison of three Java scheduling solutions—Spring's @Scheduled, Quartz, and XXL‑Job—covering their underlying mechanisms, key features, typical scenarios, common pitfalls, and practical recommendations to help developers select the most suitable option for their projects.
@ScheduledBackendQuartz
0 likes · 18 min read

This guide covers MinIO object storage deployment with ready-to-use automation scripts for both standalone and distributed modes, including environment checks, binary download methods, systemd service configuration, and cluster requirements for production use.
Bash ScriptMinIOObject Storage
0 likes · 38 min read

This article explains the evolution from Pika, a RocksDB‑backed Redis‑compatible KV store, to ZestKV’s serverless, storage‑compute separated architecture, detailing design shortcomings, core components, multi‑tenant support, elastic scaling, performance benchmarks, and future roadmap.
CloudNativeKVdistributed
0 likes · 17 min read

Dromara RuoYi-Vue-Plus is an open‑source, MIT‑licensed backend framework built on Spring Boot 3.4 that targets distributed clusters and multi‑tenant scenarios, offering upgraded features, extensive comparisons to other stacks, and a rich ecosystem of tools, documentation, and community support.
BackendJavaSpring Boot
0 likes · 15 min read

This article explains the principles and implementation details of common rate‑limiting algorithms—token bucket and sliding‑window counting—including their core concepts, key processes, Java code examples, and how to extend them to distributed scenarios with Redis Lua scripts.
Redisdistributedrate limiting
0 likes · 19 min read

This article evaluates five Go in‑memory cache libraries—Ristretto, BigCache, FreeCache, FastCache, and groupcache—detailing their support for large keys, high‑throughput LRU‑like eviction, TPS/QPS benchmarks, core APIs, code examples, and practical selection guidance for backend developers.
CacheConcurrencyLRU
0 likes · 18 min read

This article explores multiple techniques for efficiently deduplicating ten‑hundred‑million QQ identifiers, covering single‑machine bitmap methods, Bloom filter trade‑offs, external sorting, Spark and Redis distributed solutions, and a layered bitmap index that balances memory usage, speed, and accuracy.
Bitmapdeduplicationdistributed
0 likes · 13 min read

This article explains why the KEYS command is unsafe for large Redis keyspaces, introduces the SCAN command and multithreaded scanning techniques, compares performance, and offers alternative counting strategies to reliably count hundreds of millions of keys.
Key CountingRedisSCAN
0 likes · 9 min read

This article explains the concept of rate limiting, introduces common algorithms such as token bucket and leaky bucket, and provides a complete Spring‑Boot implementation using Redis, custom annotations, AOP, and utility classes for distributed request throttling.
annotationdistributedrate limiting
0 likes · 21 min read

This article provides a comprehensive guide to Redis Cluster, covering its background, overall architecture, deployment steps, configuration templates, cluster creation commands, basic key‑value operations, high‑availability testing, and how to manually assign master‑slave relationships for robust distributed caching.
ClusterRedisdatabase
0 likes · 14 min read

The JD App backend hotkey framework provides millisecond‑level detection of bursty hot data, users, and interfaces, pushes the hot keys to all JVMs in the cluster, and dramatically reduces database query pressure while improving overall application performance.
BackendHotKeyJava
0 likes · 8 min read

This step‑by‑step guide shows how to set up a full LNMP stack, compile and configure Zabbix server, proxy, and agents on CentOS 7, covering repository setup, service initialization, database preparation, UI initialization, and host registration for a robust distributed monitoring solution.
CentOSLNMPdistributed
0 likes · 27 min read

JD’s hot‑key detection framework instantly identifies bursty hot requests, pushes the hot keys to a clustered memory layer, and broadcasts them to all JVMs, enabling client‑side caching, user blocking, and circuit breaking, while handling up to 370 000 detections and 800 000 pushes per second and reducing backend query load by over 50 % in large‑scale events.
HotKeyJavadistributed
0 likes · 6 min read

The JD App backend hotkey framework instantly detects bursty hot data, users, and interfaces, pushes the hot keys to all JVMs in the cluster, and dramatically reduces database load while supporting fine‑grained rate limiting and caching across distributed services.
BackendHotKeydistributed
0 likes · 7 min read

This article explains how to enable cross‑server WebSocket communication in a distributed Spring application by using a message queue such as Redis or Kafka, detailing two architectural approaches, concrete code examples, configuration files, and a sample client page.
BackendKafkaMessage Queue
0 likes · 17 min read

This article explains Apache Pulsar’s fast‑growing adoption, its compute‑storage separation architecture, BookKeeper‑based persistence, multi‑tenant support, flexible subscription models, and fault‑tolerant design, providing a comprehensive overview for developers interested in modern distributed messaging middleware.
BookKeeperPulsararchitecture
0 likes · 13 min read

This article provides a step‑by‑step guide on combining Spring Boot with the open‑source XXL‑Job platform, covering its features, comparison with other schedulers, configuration of the admin console and executor, code examples, @XxlJob annotation parameters, and best practices for reliable distributed task management.
JavaSpring BootTask Scheduling
0 likes · 17 min read

This article compares popular Java etcd client libraries, evaluates their features, performance, and suitability, and provides a hands‑on tutorial using jetcd with Maven dependencies, code examples for watching and reading keys, and discusses runtime considerations such as thread handling.
Javadistributedetcd
0 likes · 10 min read

This article walks through the design and Go implementation of a reusable Redis connection pool, covering the pool data structure, object acquisition and release logic, handling of active limits and waiting queues, and an extended per‑IP socket pool for distributed Redis clusters.
BackendConcurrencyConnection Pool
0 likes · 10 min read

On July 19, the openGemini community and Huawei Cloud DTT hosted a live session detailing openGemini’s open-source license, high performance, distributed architecture, and six key capabilities—including streaming aggregation, multi-level downsampling, log search, AI-driven anomaly detection, and a high-cardinality engine—showcasing its suitability for massive telemetry data across cloud-native and IoT scenarios.
cloud-nativedistributedhigh-performance
0 likes · 10 min read

This article explores the challenges of distributed join queries, detailing MySQL sharding‑jdbc join implementation, routing strategies, and code examples, then examines Elasticsearch‑SQL join capabilities, various join algorithms, and practical considerations for using nested types, offering insights for optimizing performance in distributed data environments.
ElasticsearchMySQLdistributed
0 likes · 11 min read

This article demonstrates how to simulate high‑concurrency flash‑sale scenarios using SpringBoot, MySQL, and JMeter, and compares seven approaches—including lock‑based, AOP, pessimistic and optimistic locking, and queue‑based solutions such as BlockingQueue and Disruptor—to prevent overselling and improve performance.
ConcurrencyQueueSpringBoot
0 likes · 19 min read


ITPUBJan 9, 2023 · Databases
The article examines MatrixOne, a cloud‑native hyper‑converged database, detailing its storage‑compute separation, unified file service, resource isolation, HTAP streaming capabilities, and emerging serverless features, while outlining future directions such as CXL memory integration and broader cloud storage support.
HTAPHyper-ConvergedMatrixOne
0 likes · 9 min read

The October 25th PolarDB open‑source summit in Hangzhou gathered Alibaba Cloud executives, ecosystem partners and developers to discuss the daring decision to open‑source the flagship cloud‑native database, its compatibility and openness principles, real‑world case studies, and future trends shaping the next generation of distributed databases.
Alibaba CloudCloud NativePolarDB
0 likes · 20 min read


ITPUBOct 7, 2022 · Databases
This article explains why sharding tables improves read/write speed, then compares three pagination strategies—global query, no‑skip pagination, and two‑phase query—detailing their SQL rewrites, execution steps, performance trade‑offs, and practical examples.
PaginationSQLdistributed
0 likes · 10 min read

This article presents ten performance‑optimization techniques—including indexing, compression, caching, prefetching, throttling, batch processing, resource squeezing, horizontal scaling, sharding, and lock‑free designs—explained through Naruto‑themed analogies and practical guidance for backend systems.
cachingdistributedoptimization
0 likes · 37 min read

This article examines common business scenarios that require timed execution, explains why scheduled tasks are essential, compares single‑node Java scheduling options with distributed frameworks like Quartz, Elastic‑Job, Saturn and XXL‑Job, and provides a detailed feature‑by‑feature analysis to help developers select the most suitable scheduler.
Elastic-JobJavaQuartz
0 likes · 13 min read

This article presents an in‑depth overview of time‑series data concepts and the practical adoption of TimescaleDB built on PostgreSQL at Hytera, covering requirements, core features, hypertable architecture, deployment models, compression, data retention, backup strategies, and performance benchmarks.
CompressionPostgreSQLTime-series
0 likes · 14 min read

The article examines common business scenarios that require timed execution, explains why scheduled tasks are needed, lists single‑machine and distributed Java scheduling frameworks, and provides a detailed feature‑by‑feature comparison between two popular distributed schedulers, X‑Job and Elastic‑Job.
Elastic-JobQuartzScheduling
0 likes · 13 min read

This article provides a comprehensive overview of Kafka's core components—including brokers, topics, partitions, producers, and consumers—explaining their roles, relationships, replication strategies, and how they work together within a Kafka cluster to ensure reliable, scalable message streaming.
ConsumerKafkaTopic
0 likes · 8 min read

Elasticsearch 8.3.0, a distributed full‑text search engine built on Lucene, introduces several known issues, deprecations, performance enhancements across aggregations, authentication, authorization, autoscaling, and adds new geo, health, mapping, SQL, search, and TSDB capabilities.
ElasticsearchJavadistributed
0 likes · 4 min read

This guide walks through installing a Redis cluster with three masters and three slaves using local ports, explains slot allocation, key hashing, gossip communication, failover, node addition, resharding, and best practices for high availability, while providing practical commands and configuration examples.
ClusterFailoverGossip
0 likes · 26 min read

This tutorial walks through the entire lifecycle of using the XXL‑Job distributed scheduling framework—including a brief comparison with ElasticJob, downloading and running the admin console, configuring the MySQL database, setting up a SpringBoot project, adding dependencies, writing Bean‑based and GLUE tasks, registering the executor, and finally creating and monitoring scheduled jobs via the web UI.
JavaSpringBootTask Scheduling
0 likes · 13 min read

This article explains how to solve the problem of non‑serializable WebSocket sessions in a load‑balanced Spring application by using Redis publish/subscribe and spring‑session‑redis to share session data across multiple server instances, providing complete configuration and code examples.
JavaRedisSpring
0 likes · 10 min read

JetBrains Fleet, built on two decades of IDE expertise, offers a lightweight, intelligent, distributed, collaborative, and multi‑language development environment that starts in seconds, runs locally or in the cloud, and integrates essential tools without replacing existing JetBrains products.
CollaborationFleetIDE
0 likes · 7 min read

This article presents a comprehensive design and implementation of a drag‑and‑drop, code‑less workflow orchestration system that abstracts business logic into DAG‑based state machines, detailing architecture, core data structures, Go code examples, and two practical use cases for arithmetic and data‑consumption scenarios.
BackendState MachineWorkflow
0 likes · 18 min read

This article explains the functional purpose, layered and cluster designs, distributed architecture, caching strategies, asynchronous checks, storage heterogeneity, payment solutions, and anti‑bot mechanisms of a cloud‑based shopping cart, highlighting stability, high performance, elasticity, and fault‑tolerance.
BackendShopping Cartarchitecture
0 likes · 5 min read

This article explains Kafka's storage architecture—including topics, partitions, segments, and their naming rules—along with how data is read, and details the system's reliability features such as ISR/OSR replication, leader election, producer acknowledgment levels, and delivery guarantees.
At-Least-OnceLeader ElectionStorage
0 likes · 10 min read

Gorse is an open‑source, Go‑based recommendation system that automates model selection, supports distributed training and real‑time serving via RESTful APIs, stores data in MySQL or MongoDB with Redis caching, and offers a dashboard for monitoring, data import/export, and cluster health.
AIGoRecommendation System
0 likes · 4 min read

This article compares centralized and distributed software architectures, outlining their definitions, pros and cons, core element differences, business support capabilities, and scalability strategies, helping readers understand when each model is most appropriate for modern large‑scale systems.
architecturecentralizeddistributed
0 likes · 8 min read

This article presents a high‑availability Jenkins distributed architecture that leverages master‑slave deployment, label‑based node management, Kubernetes containerization, and LVS load‑balancing to address resource constraints, configuration complexity, and maintenance overhead in large‑scale CI pipelines.
CI/CDCloud NativeDevOps
0 likes · 8 min read

This article walks through ten practical scheduling solutions—from Linux crontab and JDK utilities to Spring Task, Spring Quartz, and distributed frameworks like XXL‑Job and Elastic‑Job—explaining their usage, configuration, code examples, and pros and cons so developers can pick the right tool for any business need.
SchedulingSpringTask
0 likes · 24 min read

This article introduces the concept of software architecture and compares four major styles—monolithic, distributed, microservices, and serverless—detailing their structures, advantages, disadvantages, and typical use cases, helping developers understand how architectural choices affect scalability, maintainability, and operational complexity.
distributedmaintainabilitymonolithic
0 likes · 12 min read

Explore ten practical Java scheduling options—from Linux crontab and JDK Thread/Timer to Spring Task, Quartz, and distributed frameworks like XXL‑Job, Elastic‑Job, Saturn and TBSchedule—detailing setup, code examples, advantages, drawbacks, and best‑fit scenarios for reliable task automation.
QuartzSchedulingSpring
0 likes · 22 min read

This article provides a comprehensive overview of Elasticsearch, covering its distributed architecture, fundamental concepts such as nodes, shards, and indices, as well as practical guidance on index design, bulk writing, query‑fetch workflow, scroll queries, aliases, and basic optimization tips.
Mappingbulkdistributed
0 likes · 7 min read

This article provides a comprehensive overview of core backend engineering topics—including distributed architecture, vertical and horizontal scaling, cache strategies, asynchronous messaging, load‑balancing techniques, microservice design, high‑availability patterns, security mechanisms, and big‑data processing frameworks—aimed at helping fresh graduates and junior developers build interview‑ready knowledge.
cachingdistributedhigh-availability
0 likes · 33 min read

This article explains Elasticsearch’s internal architecture, from cloud clusters and nodes to shards and Lucene’s inverted index, covering indexing, storage structures, query processing, caching, scaling, routing, and real‑world request handling, with detailed diagrams and examples.
LuceneShardsdistributed
0 likes · 13 min read

Elasticsearch provides two search types—query_then_fetch (default) and dfs_query_then_fetch—each involving a multi-step process where the client node distributes queries to relevant shards, shards execute searches using local or global term frequencies, aggregate results, and retrieve full documents, with noted trade‑offs.
ElasticsearchQuery_then_fetchdfs_query_then_fetch
0 likes · 5 min read

This article explores the architecture and implementation of a high‑concurrency ticket‑spike system, covering load‑balancing strategies, Nginx weighted round‑robin configuration, local stock deduction in Go, remote stock control with Redis Lua scripts, and performance testing results.
GoNginxRedis
0 likes · 19 min read

This article analyzes a real‑world incident where duplicate order IDs appeared under high concurrency, critiques the original Java implementation, demonstrates a concurrency test that exposed the flaw, and presents a revised, thread‑safe solution using AtomicInteger, Java 8 date‑time APIs, and IP‑based suffixes to guarantee uniqueness across multiple instances.
ConcurrencyJavaUnique ID
0 likes · 11 min read

This article explains the basic concepts, advantages and disadvantages of four common software architecture patterns—monolithic, distributed, microservices, and serverless—helping developers understand their evolution, trade‑offs, and suitable scenarios for modern application design.
distributedmonolithicserverless
0 likes · 12 min read

This article introduces Elasticsearch as a distributed search and analytics engine, outlines its common application scenarios, provides step‑by‑step installation commands, explains core concepts such as documents and indices, and demonstrates basic indexing, retrieval, bulk processing, and aggregation operations.
ElasticsearchLog Analyticsbulk API
0 likes · 4 min read

The article explains the concept of distributed session consistency, outlines the role and lifecycle of HTTP sessions, describes the challenges of sharing sessions across server clusters, and evaluates several practical solutions including database, cookie, Memcache, and Redis based approaches.
Sessiondistributedmemcache
0 likes · 5 min read

This article explains how to implement order number generation services by first using a simple auto‑increment‑based database table and then a more sophisticated segment‑allocation method that reduces database load, with detailed SQL and Java code examples and transaction‑handling advice.
BackendJavaSequence
0 likes · 8 min read

This article provides practical guidance for Java backend interview preparation, emphasizing solid Java fundamentals, hands‑on framework experience, distributed system knowledge, database performance tuning, core data‑structure and concurrency concepts, Linux log troubleshooting, and how to showcase real project achievements.
InterviewJavaLinux
0 likes · 13 min read


转转QADec 14, 2018 · Frontend Development
This report details the background, objectives, environment, test plan, distributed JMeter setup, server monitoring, results, and analysis of a load‑testing effort aimed at identifying performance bottlenecks and validating reliability of a front‑end Node.js quality‑inspection service under increasing concurrent traffic.
JMeterNodedistributed
0 likes · 8 min read

This article explains how to design and implement a high‑performance, scalable push messaging platform using Netty, covering protocol design, registration/authentication, channel management, message routing, distributed deployment, load balancing, stateful connections, monitoring, and logging to support millions of IoT device connections.
IoTJavaNetty
0 likes · 15 min read

This article explains the fundamentals of database transactions, the ACID properties, implementation details such as transaction logs and concurrency control, and explores distributed transaction solutions including two‑phase and three‑phase commit, XA, Saga patterns, and message‑based approaches.
2PCACIDSaga
0 likes · 17 min read


ITPUBJan 16, 2018 · Databases
A 2017 roundup highlights ten innovative database releases—including a time‑series extension for PostgreSQL, a multi‑model Azure service, Google’s globally distributed Spanner, Amazon’s Neptune graph service, and several open‑source cloud‑native databases—detailing their key features, architectures, and intended use cases.
GraphSQLTime Series
0 likes · 10 min read

This article presents a curated 2017 panorama of cloud computing and distributed system technologies, detailing tools from Selenium and Docker to Hadoop, OpenStack, and front‑end frameworks, offering a holistic view for developers navigating modern infrastructure stacks.
big-datacloudcontainers
0 likes · 14 min read

This article explains how to containerize Locust's distributed load‑testing mode using Docker, detailing image design, environment‑variable configuration, master‑slave networking, and example commands to run a scalable testing setup on Linux systems.
ContainerizationDockerLocust
0 likes · 5 min read
