BestHub
Sign in
Tagged articles
5000 articles
Page 43 of 50
IT Architects Alliance
IT Architects Alliance
Jun 2, 2021 · Backend Development

Scalable Architecture: DNS, Load Balancing, API Gateways & Microservices

This article outlines a comprehensive technical architecture for internet services, covering DNS resolution (including traditional and HttpDNS), load balancing strategies and algorithms, API gateway functions and configurations, push notification mechanisms, and microservice communication patterns, providing practical references for building scalable, reliable backend systems.

ArchitectureBackendDNS
0 likes · 15 min read
Scalable Architecture: DNS, Load Balancing, API Gateways & Microservices
Su San Talks Tech
Su San Talks Tech
Jun 2, 2021 · Backend Development

Mastering HTTP: When to Use GET vs POST and Their Real Differences

This article presents an interview‑style walkthrough of HTTP request methods, detailing the eight methods defined by HTTP/1.1, focusing on GET and POST, their functional differences, URL length limits, parameter formatting, security considerations, and packet behavior.

BackendHTTPPOST
0 likes · 11 min read
Mastering HTTP: When to Use GET vs POST and Their Real Differences
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 2, 2021 · Backend Development

How Modern Internet Companies Design Scalable Backend Architecture

This article explains the technical architecture of an internet company, covering DNS, load balancing, long connections, API gateways, push notifications, microservices, distributed transactions, and the supporting foundational services, providing a comprehensive reference for learners.

ArchitectureBackendMicroservices
0 likes · 12 min read
How Modern Internet Companies Design Scalable Backend Architecture
Top Architect
Top Architect
Jun 1, 2021 · Backend Development

Zero‑Copy Mechanisms in Operating Systems and Java

This article explains how zero‑copy techniques such as mmap, sendfile, and splice reduce CPU involvement in data transfer by avoiding memory copies between kernel and user spaces, and shows how Java NIO and Netty implement these mechanisms for high‑performance backend I/O.

BackendJava NIOmmap
0 likes · 8 min read
Zero‑Copy Mechanisms in Operating Systems and Java
IT Architects Alliance
IT Architects Alliance
May 31, 2021 · Backend Development

Inside Nginx: Master/Worker Model, Async I/O, and Core Data Structures Explained

This article explains how Nginx runs as a daemon with a master process and multiple worker processes, why it prefers a multi‑process asynchronous non‑blocking architecture over threads, and details the key internal data structures such as connections, requests, arrays, queues, lists, strings, memory pools, hash tables, and red‑black trees that enable its high‑performance HTTP handling.

AsynchronousBackendData Structures
0 likes · 18 min read
Inside Nginx: Master/Worker Model, Async I/O, and Core Data Structures Explained
vivo Internet Technology
vivo Internet Technology
May 31, 2021 · Backend Development

Introduction to Load Balancing and Its Algorithms

The article introduces load balancing as a vital solution for high‑traffic systems, explains vertical and horizontal scaling, classifies balancers by hardware, layer and algorithm, and details common algorithms—random, weighted, round‑robin, least‑active, IP‑hash, and consistent hash—with code examples and usage guidance.

AlgorithmsBackendjava
0 likes · 30 min read
Introduction to Load Balancing and Its Algorithms
Selected Java Interview Questions
Selected Java Interview Questions
May 31, 2021 · Backend Development

Understanding Spring's @Transactional Annotation: AOP‑Based Implementation and Transaction Management Flow

This article explains the purpose of Spring's @Transactional annotation, how it leverages AOP and dynamic proxies to manage transactions, and walks through the core source‑code components—including BeanPostProcessor, advisors, TransactionInterceptor, and the transaction lifecycle—illustrated with concrete code examples.

BackendDynamic Proxyaop
0 likes · 9 min read
Understanding Spring's @Transactional Annotation: AOP‑Based Implementation and Transaction Management Flow
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 31, 2021 · Backend Development

How Zhihu Scales Read Filtering: A Deep Dive into High‑Performance Backend Architecture

This article explains how Zhihu built a highly available, low‑latency read‑filtering service for its homepage, detailing the system’s design goals, architecture components such as proxy, cache and storage, massive data scale, migration from MySQL to TiDB, and performance results after adopting TiDB 3.0.

BackendScalabilityTiDB
0 likes · 21 min read
How Zhihu Scales Read Filtering: A Deep Dive into High‑Performance Backend Architecture
Java Backend Technology
Java Backend Technology
May 31, 2021 · Backend Development

13 Must‑Try Open‑Source Spring Boot Projects for Java Developers

This article curates thirteen high‑quality Spring Boot open‑source projects—ranging from e‑commerce platforms and microservice frameworks to payment systems and HR tools—providing star counts, repository links, brief feature overviews, and demo screenshots to help Java developers choose valuable reference implementations.

BackendMicroservicesOpen-source
0 likes · 11 min read
13 Must‑Try Open‑Source Spring Boot Projects for Java Developers
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 30, 2021 · Backend Development

Master Nginx: Reverse Proxy, Load Balancing, and High‑Availability Guide

This comprehensive guide explains Nginx’s core concepts—including reverse and forward proxy, load balancing, static‑dynamic separation, common commands, configuration blocks, and high‑availability setup with keepalived—providing step‑by‑step examples, diagrams, and practical tips for deploying scalable, high‑performance web services.

Backendconfigurationhigh availability
0 likes · 12 min read
Master Nginx: Reverse Proxy, Load Balancing, and High‑Availability Guide
Top Architect
Top Architect
May 30, 2021 · Backend Development

From Monolith to Unitization: Solving Unlimited Scaling Issues in Backend Services

The article explains why simple sharding and database partitioning cannot achieve unlimited scaling in backend systems, analyzes the problem of excessive RPC‑to‑DB connections, and proposes a unitization approach that limits each service to a single database to enable true horizontal expansion.

BackendScalabilitydatabase connections
0 likes · 7 min read
From Monolith to Unitization: Solving Unlimited Scaling Issues in Backend Services
MaGe Linux Operations
MaGe Linux Operations
May 28, 2021 · Backend Development

How to Reveal the Exact SQL Behind Django ORM Queries

This guide shows three practical ways—using the queryset query attribute, Django's connection object, and the Django Debug Toolbar—to inspect the raw SQL generated by Django ORM, helping developers optimize database performance and troubleshoot queries effectively.

BackendDebug ToolbarDjango
0 likes · 4 min read
How to Reveal the Exact SQL Behind Django ORM Queries
php Courses
php Courses
May 28, 2021 · Backend Development

Resolving the PHP Type‑Hint Error: Argument 1 Must Be an Instance of int

This article explains a confusing PHP error where a method expects an instance of int but receives an integer, analyzes three common causes—including an incorrect use statement, outdated PHP version, and unnecessary type hint—and provides concise solutions for each.

BackendPHPphp7
0 likes · 2 min read
Resolving the PHP Type‑Hint Error: Argument 1 Must Be an Instance of int
Amap Tech
Amap Tech
May 28, 2021 · Cloud Native

Gaode's Serverless/FaaS Platform: Architecture, Implementation, and Business Impact

Gaode’s new serverless/FaaS platform, built on Alibaba Cloud Function Compute with custom C++, Go, and Node.js runtimes, now processes over 100 000 QPS, enabling a unified client‑cloud codebase, rapid feature iteration, automatic scaling and cost savings, while supporting extensive monitoring, Dapr integration, and future edge‑computing enhancements.

BackendCloud NativeFaaS
0 likes · 20 min read
Gaode's Serverless/FaaS Platform: Architecture, Implementation, and Business Impact
IT Architects Alliance
IT Architects Alliance
May 27, 2021 · Backend Development

Can Sharding Alone Scale Your Services? Exploring Unitization for Unlimited Growth

This article analyzes the typical evolution from monolithic to RPC-based services, explains why sharding and database partitioning cannot alone achieve unlimited scaling due to connection limits, and introduces a unitization approach that assigns each application to a specific database shard to overcome those constraints.

BackendScalabilityService Architecture
0 likes · 8 min read
Can Sharding Alone Scale Your Services? Exploring Unitization for Unlimited Growth
Laravel Tech Community
Laravel Tech Community
May 27, 2021 · Backend Development

PHP mcrypt_encrypt Function: Parameters, Usage, and Return Value

mcrypt_encrypt encrypts plaintext using a specified cipher, key, mode, and optional IV, returning the ciphertext as a string or FALSE on failure, with detailed explanations of each parameter—including cipher name, key length requirements, data padding, mode options, and IV usage—provided for PHP developers.

BackendPHPmcrypt
0 likes · 2 min read
PHP mcrypt_encrypt Function: Parameters, Usage, and Return Value
Top Architect
Top Architect
May 27, 2021 · Backend Development

Preventing Order Loss and Duplicate Submissions in Payment Systems: Best Practices

The article explains common causes of order loss and duplicate submissions in payment workflows, distinguishes external and internal loss, and provides concrete backend strategies such as intermediate payment states, timeout queries, idempotent handling, retry mechanisms, and Redis‑based deduplication to ensure reliable order processing.

BackendIdempotencyOrder Management
0 likes · 5 min read
Preventing Order Loss and Duplicate Submissions in Payment Systems: Best Practices
Java Backend Technology
Java Backend Technology
May 27, 2021 · Backend Development

How to Ensure Cache‑Database Consistency: Patterns and Pitfalls Explained

This article explains cache‑database consistency challenges, outlines three classic caching patterns, compares delete‑versus‑update strategies, discusses operation ordering, and presents three practical solutions—including delayed double delete, retry mechanisms, and binlog‑based asynchronous eviction—to help maintain data integrity in distributed systems.

BackendCacheConsistency
0 likes · 11 min read
How to Ensure Cache‑Database Consistency: Patterns and Pitfalls Explained
21CTO
21CTO
May 25, 2021 · Backend Development

Why Sanic Outperforms Flask, Django, and Tornado in Async Python Web Development

This article compares popular Python web frameworks, highlights the speed advantages of async frameworks—especially Sanic—through benchmark data, explains why asynchronous I/O matters, and discusses Sanic's ecosystem, production readiness, documentation, and community support.

AsyncBackendPython
0 likes · 10 min read
Why Sanic Outperforms Flask, Django, and Tornado in Async Python Web Development
Wukong Talks Architecture
Wukong Talks Architecture
May 25, 2021 · Backend Development

Elasticsearch Performance Pitfalls and Optimization Strategies

This article examines common performance pitfalls in Elasticsearch—including slow queries, cluster architecture bottlenecks, and business‑scenario challenges—and provides practical guidance such as caching key fields, data pre‑heating, hot‑cold separation, avoiding joins, and using tribe nodes to improve accuracy and response time.

BackendClusterElasticsearch
0 likes · 9 min read
Elasticsearch Performance Pitfalls and Optimization Strategies
php Courses
php Courses
May 24, 2021 · Backend Development

PHP Interview Questions and Sample Code Answers

This article presents a comprehensive collection of PHP interview questions covering topics such as directory creation, Smarty template features, safe mode restrictions, file handling, regular expressions, MVC concepts, and includes complete code examples for each solution.

BackendPHPcode
0 likes · 27 min read
PHP Interview Questions and Sample Code Answers
FunTester
FunTester
May 24, 2021 · Backend Development

Mastering moco API: Real-Time Request Hit Monitoring and High‑QPS Testing

This guide explains how to extend the moco API with request‑hit monitoring, demonstrates building a lightweight test service, and shows achieving over 50,000 QPS using FunTester, while detailing the available assertion methods and their practical code examples.

API testingBackendMoCo
0 likes · 5 min read
Mastering moco API: Real-Time Request Hit Monitoring and High‑QPS Testing
Programmer DD
Programmer DD
May 24, 2021 · Backend Development

Master Spring Boot 2.5.0 DataSource Initialization: New Configurations Explained

This article walks through Spring Boot 2.5.0's redesigned DataSource script initialization, clarifies deprecated properties, introduces the new SqlInitializationProperties class, and provides a complete example with Maven dependencies, configuration settings, SQL scripts, and best‑practice recommendations for automated database setup.

BackendDataSourceSQL Initialization
0 likes · 10 min read
Master Spring Boot 2.5.0 DataSource Initialization: New Configurations Explained
dbaplus Community
dbaplus Community
May 23, 2021 · Backend Development

Designing Scalable Advertising Systems: Architecture, Challenges, and Solutions

This article explains the fundamentals of online advertising business, outlines its technical challenges such as high concurrency, complex logic, and massive data handling, and then details a practical architecture—including data storage, indexing, retrieval, billing, and reporting—offering actionable insights for building robust ad platforms.

AdvertisingBackendSystem Architecture
0 likes · 16 min read
Designing Scalable Advertising Systems: Architecture, Challenges, and Solutions
php Courses
php Courses
May 21, 2021 · Backend Development

Using Named Parameters and Match Expressions in PHP 8

This article explains PHP 8's named parameters, how they allow flexible argument ordering, skipping defaults, variadic usage, and demonstrates the new match expression with strict typing and constructor property promotion examples.

BackendPHPmatch expression
0 likes · 3 min read
Using Named Parameters and Match Expressions in PHP 8
360 Quality & Efficiency
360 Quality & Efficiency
May 21, 2021 · Backend Development

Choosing Between Zookeeper and Eureka as Service Registry: Principles, Advantages, and Implementation

This article explains the role of a service registry in micro‑service architectures, compares Zookeeper (CP) and Eureka (AP) in terms of design, consistency, and availability, and provides detailed code and configuration examples for deploying both solutions in a high‑availability cluster.

BackendDistributed SystemsZooKeeper
0 likes · 12 min read
Choosing Between Zookeeper and Eureka as Service Registry: Principles, Advantages, and Implementation
Java Architecture Diary
Java Architecture Diary
May 21, 2021 · Backend Development

What’s New in Spring Boot 2.5? Features, Dark Mode & Key Changes

Spring Boot 2.5.0 (alongside 2.4.6 and 2.3.11) introduces Java 16 support, Gradle 7 compatibility, enhanced Docker image building, a new datasource loading mechanism, dark‑mode documentation, and several important configuration and security changes for backend developers.

Backendconfigurationfeatures
0 likes · 3 min read
What’s New in Spring Boot 2.5? Features, Dark Mode & Key Changes
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
May 20, 2021 · Backend Development

Mastering Node.js Multi‑Process: From spawn to cluster for High Concurrency

This article explains process and thread fundamentals, describes Node.js's single‑threaded nature, and provides detailed guidance on using the child_process module (spawn, fork, exec, execFile) and the cluster module to create, manage, and communicate between multiple Node.js processes for scalable, high‑concurrency applications.

BackendClusterNode.js
0 likes · 11 min read
Mastering Node.js Multi‑Process: From spawn to cluster for High Concurrency
Top Architect
Top Architect
May 20, 2021 · Backend Development

Standardizing Log Formats and Using traceId for Efficient Debugging in Backend Services

To improve debugging speed and reduce issue resolution time, the article recommends defining a unified LogObject structure with fields such as eventName, traceId, msg, costTime, request, and response, using JSON serialization, and discusses adding traceId, consolidating request/response logs, and implementation examples in Java.

Backenddebuggingtraceid
0 likes · 8 min read
Standardizing Log Formats and Using traceId for Efficient Debugging in Backend Services
php Courses
php Courses
May 20, 2021 · Backend Development

How to Resolve the ThinkPHP Multi‑App “Index Class Not Found” Error

This guide explains why the ThinkPHP controller Index class may not be found in a multi‑app setup, lists common causes, and provides three step‑by‑step solutions—including installing the think‑multi‑app extension, adjusting configuration files, and using full‑path URLs—along with the necessary code changes.

BackendError HandlingThinkPHP
0 likes · 4 min read
How to Resolve the ThinkPHP Multi‑App “Index Class Not Found” Error
IT Architects Alliance
IT Architects Alliance
May 19, 2021 · Backend Development

Backend Technology Stack Selection for Startup Companies

This article provides a comprehensive guide for startups on choosing and assembling a backend technology stack, covering language choices, core components such as project management, DNS, load balancing, CDN, RPC frameworks, service discovery, databases, NoSQL, messaging, logging, monitoring, configuration, deployment, and operational best‑practice recommendations.

ArchitectureBackendOperations
0 likes · 29 min read
Backend Technology Stack Selection for Startup Companies
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 19, 2021 · Backend Development

How to Build a Scalable Backend Stack for Startups: Languages, Services, and Tools

This guide outlines the essential components of a startup’s backend architecture, covering language choices, middleware, databases, messaging, monitoring, CI/CD, and deployment, and provides practical recommendations for selecting open‑source and cloud services to build a reliable, scalable system from scratch.

ArchitectureBackendTechnology Stack
0 likes · 31 min read
How to Build a Scalable Backend Stack for Startups: Languages, Services, and Tools
Yang Money Pot Technology Team
Yang Money Pot Technology Team
May 18, 2021 · Backend Development

Understanding Hystrix: Resilience Patterns, Execution Flow, and Custom Extensions

This article explains how Hystrix implements resiliency patterns such as bulkhead, circuit breaker, retry, and degradation for microservice calls, details its execution workflow, core components, dynamic configuration, isolation strategies, metrics collection, and practical usage, and discusses future alternatives and extensions.

BackendCircuitBreakerDistributedSystems
0 likes · 33 min read
Understanding Hystrix: Resilience Patterns, Execution Flow, and Custom Extensions
Su San Talks Tech
Su San Talks Tech
May 16, 2021 · Backend Development

Mastering Distributed Locks with Redis: From Bronze to Diamond Solutions

This article examines why local locks fail in distributed systems, introduces Redis‑based distributed locking, and walks through five progressive solutions—from a simple SETNX implementation to atomic Lua scripts—highlighting each approach's drawbacks and how to mitigate them.

Backendredissetnx
0 likes · 16 min read
Mastering Distributed Locks with Redis: From Bronze to Diamond Solutions
Laravel Tech Community
Laravel Tech Community
May 15, 2021 · Backend Development

Key Changes in Tomcat 10.0.5 and Migration from Java EE to Jakarta EE

Tomcat 10.0.x targets Jakarta EE 9, requiring developers to replace the javax package with jakarta, and version 10.0.5 introduces proper JNDIRealm escaping, updated HandlesTypes handling, and a refactored, IoC‑friendly WebSocket creation process to ease migration from earlier Tomcat releases.

BackendJava EETomcat
0 likes · 2 min read
Key Changes in Tomcat 10.0.5 and Migration from Java EE to Jakarta EE
ITPUB
ITPUB
May 15, 2021 · Backend Development

Why GraphQL Is the Better Alternative to REST for Modern APIs

This article explains the limitations of traditional REST APIs, introduces GraphQL as a more flexible and efficient alternative, details its core concepts, execution model, schema design, type system, and provides guidance on server and client implementations, popular services, and tooling.

APIBackendDataFetching
0 likes · 18 min read
Why GraphQL Is the Better Alternative to REST for Modern APIs
Code Ape Tech Column
Code Ape Tech Column
May 14, 2021 · Backend Development

Optimizing ActiveMQ Message Queue Backlog: Removing Synchronization Locks and Tuning queuePrefetch

This article analyzes the causes of data backlog in an ActiveMQ message queue, demonstrates how synchronized locks and default prefetch settings limit throughput, and presents three optimization phases—including removing the lock, adjusting queuePrefetch, and redesigning queue handling—to achieve over 30‑fold performance improvement.

ActiveMQBackendMessage Queue
0 likes · 8 min read
Optimizing ActiveMQ Message Queue Backlog: Removing Synchronization Locks and Tuning queuePrefetch
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 13, 2021 · Backend Development

Spring Framework Core Components, IOC, AOP, Bean Lifecycle and Related Concepts

This article provides a comprehensive overview of the Spring framework, covering its core modules, version compatibility, core concepts such as IoC and AOP, proxy implementations, bean factories, lifecycle management, transaction handling, MVC architecture, Spring Boot, Spring Cloud, and common annotations for Java backend development.

BackendFrameworkIoC
0 likes · 34 min read
Spring Framework Core Components, IOC, AOP, Bean Lifecycle and Related Concepts
Top Architect
Top Architect
May 12, 2021 · Backend Development

Comprehensive Guide to Microservice Architecture: Concepts, Evolution, Comparison with Monolithic, Design Patterns, and Practical Implementation

This article provides an in‑depth overview of microservice architecture, covering its definition, historical development, differences from monolithic and SOA approaches, core characteristics, practical implementation concerns such as API gateways, inter‑service communication, service discovery, fault tolerance, common design patterns, advantages, drawbacks, and a shift in thinking required for successful adoption.

ArchitectureBackendservice discovery
0 likes · 19 min read
Comprehensive Guide to Microservice Architecture: Concepts, Evolution, Comparison with Monolithic, Design Patterns, and Practical Implementation
Top Architect
Top Architect
May 12, 2021 · Backend Development

Evolution of Front‑Back End Separation Architecture: From JSP/Servlet to Node.js Full‑Stack

This article traces the progression of web application architecture from tightly coupled JSP/Servlet MVC models through half‑separated Ajax‑driven approaches to fully separated front‑end/back‑end designs, highlighting how Node.js middle‑layer solutions improve adaptability, performance, and maintainability.

ArchitectureBackendWeb Development
0 likes · 12 min read
Evolution of Front‑Back End Separation Architecture: From JSP/Servlet to Node.js Full‑Stack
php Courses
php Courses
May 12, 2021 · Backend Development

Implementing Direct OSS Upload Signature in PHP

This tutorial explains how to create a lightweight PHP class for generating OSS direct‑upload signatures, describes the advantages of client‑side uploads without server bandwidth, provides the full source code, and highlights common pitfalls such as bucketHost configuration and policy newline handling.

BackendOSSPHP
0 likes · 3 min read
Implementing Direct OSS Upload Signature in PHP
dbaplus Community
dbaplus Community
May 11, 2021 · Backend Development

Essential Safety Checklist for Dangerous Linux Commands

A practical guide warns developers to breathe, verify servers, back up data, and follow strict habits when using risky commands like rm -rf, chmod, dd, and MySQL to prevent catastrophic data loss in production environments.

BackendData SafetyLinux
0 likes · 8 min read
Essential Safety Checklist for Dangerous Linux Commands
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 11, 2021 · Backend Development

Understanding Java Dynamic Proxy: Static vs Dynamic Proxy and Implementations with JDK, CGLIB, Javassist, and ASM

This article explains Java's proxy pattern, compares static and dynamic proxies, and provides detailed examples of JDK dynamic proxy, CGLIB, Javassist, and ASM implementations, highlighting their mechanisms, code samples, and practical considerations for backend development.

ASMBackendDesign Patterns
0 likes · 21 min read
Understanding Java Dynamic Proxy: Static vs Dynamic Proxy and Implementations with JDK, CGLIB, Javassist, and ASM
Laravel Tech Community
Laravel Tech Community
May 10, 2021 · Backend Development

Laravel Performance Optimization: Best Practices and Tuning Techniques

This article presents a comprehensive guide to improving Laravel application performance by covering configuration caching, route caching, class map optimization, autoload optimization, session storage with Memcached, professional cache drivers, database query tuning, dataset caching, JIT compilers, and front‑end asset bundling.

BackendPHPcaching
0 likes · 7 min read
Laravel Performance Optimization: Best Practices and Tuning Techniques
Manbang Technology Team
Manbang Technology Team
May 10, 2021 · Backend Development

Understanding Sentinel Flow Control Rules and FlowSlot Implementation

This article explains Sentinel's flow control rule definition, the attributes of the FlowRule class, and how the FlowSlot, FlowRuleChecker, and related components evaluate and enforce these rules, including code examples and a discussion of different flow control strategies and node types.

BackendFlowControlMicroservices
0 likes · 16 min read
Understanding Sentinel Flow Control Rules and FlowSlot Implementation
Programmer DD
Programmer DD
May 10, 2021 · Backend Development

Mastering Java Dynamic Tracing: Instrumentation, BTrace, and ASM Explained

This article explores how Java's method area stores object behavior, how the java.lang.instrument.Instrumentation API enables runtime class redefinition, and how tools like ASM, BTrace, and Arthas empower developers to inject bytecode, trace methods, and debug production systems without source changes.

BTraceBackendInstrumentation
0 likes · 16 min read
Mastering Java Dynamic Tracing: Instrumentation, BTrace, and ASM Explained
Code Ape Tech Column
Code Ape Tech Column
May 10, 2021 · Backend Development

Mastering CORS in Spring: 5 Ways to Enable Cross‑Origin Requests

This article explains why browsers enforce the same‑origin policy, defines cross‑origin requests, outlines the restrictions of non‑same‑origin interactions, and presents five practical methods—including a global CorsFilter, WebMvcConfigurer, @CrossOrigin annotation, manual header setting, and a custom filter—to implement CORS in Java Spring backends.

BackendCORSCross-Origin
0 likes · 8 min read
Mastering CORS in Spring: 5 Ways to Enable Cross‑Origin Requests
Java Backend Technology
Java Backend Technology
May 9, 2021 · Backend Development

Why kill -9 Can Crash Your Spring Boot Service and How to Shut It Down Gracefully

This article explains the dangers of using the kill -9 command on Java services, illustrates how it can cause data loss, and presents several graceful shutdown techniques for Spring Boot—including SIGTERM, Actuator endpoints, custom Tomcat shutdown hooks, and @PreDestroy backups—complete with code examples and screenshots.

BackendGraceful ShutdownKill Command
0 likes · 19 min read
Why kill -9 Can Crash Your Spring Boot Service and How to Shut It Down Gracefully
Selected Java Interview Questions
Selected Java Interview Questions
May 8, 2021 · Databases

Cache Consistency Strategies for MySQL Using Redis

This article examines why caching is needed for MySQL, discusses consistency challenges, and compares four Redis‑based solutions—including expiration, synchronous updates, Kafka‑mediated async updates, and binlog replication—offering guidance on selecting the appropriate approach based on latency and reliability requirements.

BackendCache ConsistencyDatabase Caching
0 likes · 9 min read
Cache Consistency Strategies for MySQL Using Redis
Top Architect
Top Architect
May 8, 2021 · Backend Development

Distributed Locks: Why They Are Needed, Required Conditions, and Three Implementation Approaches (Database, Redis, Zookeeper)

This article explains the necessity of distributed locks in multi‑node applications, outlines the essential properties a distributed lock must satisfy, and compares three common implementation methods—database‑based exclusive locks, Redis‑based locks, and Zookeeper‑based locks—highlighting their advantages, drawbacks, and usage patterns.

BackendRedis LockZookeeper lock
0 likes · 15 min read
Distributed Locks: Why They Are Needed, Required Conditions, and Three Implementation Approaches (Database, Redis, Zookeeper)
php Courses
php Courses
May 8, 2021 · Backend Development

Efficient CSV Export in PHP for Large Datasets

This article explains how to efficiently export large datasets to CSV files using PHP, describing the CSV format, why a simple streaming approach outperforms PHPExcel, performance expectations for 200,000 rows, and provides a complete PHP function that handles encoding, buffering, and memory‑friendly output.

BackendCSVData Export
0 likes · 3 min read
Efficient CSV Export in PHP for Large Datasets
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 8, 2021 · Backend Development

Graceful Shutdown of RocketMQ Consumer in Spring Applications

The article recounts a production incident caused by an ungraceful RocketMQ consumer shutdown, analyzes the root cause involving Spring's bean destruction order and ShutdownHook behavior, and presents two solutions—using the official Spring‑Boot starter with SmartLifecycle or handling ContextClosedEvent—to achieve orderly termination.

BackendGraceful ShutdownRocketMQ
0 likes · 5 min read
Graceful Shutdown of RocketMQ Consumer in Spring Applications
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 7, 2021 · Databases

Resolving MySQL wait_timeout Issues with Druid Connection Pool Configuration

This article analyzes the root causes of MySQL 'wait_timeout' related exceptions in a backend system using MHA read/write separation, explains how oversized connection pool timeout settings and MySQL wait_timeout lead to idle connections being closed, and provides practical Druid configuration adjustments and alternative solutions to eliminate the errors.

BackendConnection PoolDruid
0 likes · 7 min read
Resolving MySQL wait_timeout Issues with Druid Connection Pool Configuration
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 7, 2021 · Backend Development

12 Essential Java Thread‑Pool Interview Questions and Answers

This article systematically explains why thread pools are needed, how to create them, the types of pools Executors can build, key parameters, underlying principles, rejection policies, blocking queues, core‑thread settings, pool states, thread reuse, the difference between submit() and execute(), and practical usage tips for Java developers.

BackendExecutorServiceThreadPool
0 likes · 13 min read
12 Essential Java Thread‑Pool Interview Questions and Answers
macrozheng
macrozheng
May 7, 2021 · Backend Development

Customizing Spring Boot Error Handling for Non‑Controller Exceptions

This guide explains why Spring Boot’s default @ControllerAdvice cannot catch servlet‑level errors, introduces the ErrorPageFilter mechanism, and shows how to replace the BasicErrorController with a custom ExceptionController that rethrows errors for unified handling across the application.

BackendCustom ErrorControllerError Handling
0 likes · 7 min read
Customizing Spring Boot Error Handling for Non‑Controller Exceptions
Big Data Technology Architecture
Big Data Technology Architecture
May 6, 2021 · Databases

Elasticsearch Pagination: From+size, search_after, and Scroll – Differences, Advantages, and Use Cases

This article explains Elasticsearch’s three pagination methods—From + size, search_after, and Scroll—detailing their definitions, code examples, advantages, disadvantages, and suitable scenarios, while also discussing max_result_window limits, PIT views, and best practices for handling large result sets.

BackendElasticsearchbigdata
0 likes · 13 min read
Elasticsearch Pagination: From+size, search_after, and Scroll – Differences, Advantages, and Use Cases
Python Programming Learning Circle
Python Programming Learning Circle
May 6, 2021 · Backend Development

An Overview of Popular Python Web Frameworks

This article introduces the importance of web development frameworks and provides an overview of several popular Python frameworks—including CherryPy, Tornado, BIK, Flask, and Cuicweb—detailing their key features, advantages, and typical use cases for building efficient backend applications.

BackendCherryPyFlask
0 likes · 6 min read
An Overview of Popular Python Web Frameworks
Top Architect
Top Architect
May 6, 2021 · Backend Development

Unified Multi-Account Login Architecture and Design

This article explains the concept, technical solutions, workflow diagrams, and database schema for implementing unified multi‑account login using username/password, mobile verification, and third‑party OAuth2 integrations, providing practical design guidance without detailed source code.

BackendDatabase designOAuth2
0 likes · 11 min read
Unified Multi-Account Login Architecture and Design
Programmer DD
Programmer DD
May 6, 2021 · Backend Development

Building a Fast Search with Redis: From Complex SQL to Set Operations

This article walks through the challenges of implementing a complex e‑commerce search interface, compares a naïve SQL solution with optimized multi‑query and Redis‑based approaches, and demonstrates how to use Redis sets, sorted sets, and transactions to achieve efficient querying, pagination, and data updates.

BackendSet Operationspagination
0 likes · 9 min read
Building a Fast Search with Redis: From Complex SQL to Set Operations
Code Ape Tech Column
Code Ape Tech Column
May 6, 2021 · Backend Development

Why PageHelper Pagination Breaks with List Operations and How to Fix It

This article explains why PageHelper pagination yields incorrect totals when list operations are performed before or after pagination, analyzes the underlying cause that startPage only affects subsequent SQL, and provides a step‑by‑step solution that processes the list after pagination and returns a correctly populated PageInfo object.

Backendjavamybatis
0 likes · 6 min read
Why PageHelper Pagination Breaks with List Operations and How to Fix It
Efficient Ops
Efficient Ops
May 5, 2021 · Backend Development

Designing a Scalable Backend Stack for Startups: Languages, Tools, and Best Practices

This guide walks through the four‑layer backend architecture—language, components, processes, and systems—and offers practical recommendations for selecting project management, DNS, load balancing, CDN, RPC frameworks, databases, messaging, CI/CD, logging, monitoring, configuration, and deployment tools tailored to early‑stage companies.

ArchitectureBackendTechnology Stack
0 likes · 32 min read
Designing a Scalable Backend Stack for Startups: Languages, Tools, and Best Practices
JavaEdge
JavaEdge
May 5, 2021 · Backend Development

Mastering Java ReadWriteLock: Build Efficient Caches and Avoid Concurrency Pitfalls

This article explains how Java's ReadWriteLock works, compares it with mutex locks, shows caching strategies for high‑concurrency scenarios, illustrates thread‑contention problems, and discusses lock upgrade and downgrade nuances to help developers write safe, performant backend code.

BackendReadWriteLockjava
0 likes · 6 min read
Mastering Java ReadWriteLock: Build Efficient Caches and Avoid Concurrency Pitfalls
ITPUB
ITPUB
May 5, 2021 · Frontend Development

From Static Pages to SSR: A 30‑Year Web Technology Journey

Spanning three decades, this article traces the evolution of web development from Tim Berners‑Lee’s 1991 static page through the rise of HTML, CSS, JavaScript, PHP, AJAX, SPA frameworks, server‑side rendering, Node.js, and emerging trends like React Server Components, illustrating how each breakthrough addressed the limitations of its predecessors.

BackendFrontendJavaScript
0 likes · 18 min read
From Static Pages to SSR: A 30‑Year Web Technology Journey
Liangxu Linux
Liangxu Linux
May 5, 2021 · Operations

Mastering Linux Load Average: How to Read and Interpret top Output

This article explains what the Linux Load Average metric means, how the three numbers are calculated, and walks through each line of the top command output—including CPU, memory, swap, and process details—to help you diagnose server load issues effectively.

BackendLinuxLoad Average
0 likes · 7 min read
Mastering Linux Load Average: How to Read and Interpret top Output
Selected Java Interview Questions
Selected Java Interview Questions
May 4, 2021 · Backend Development

Building a Reusable Backend Base Project with Swagger, CodeGenerator, Pagination, Exception Handling, and Multi‑Environment Configuration

This article explains how to create a reusable backend foundation for new Spring Boot projects by assembling common utilities such as Swagger API documentation, MyBatis‑Plus code generation, unified response objects, pagination helpers, custom exception handling, multi‑environment Maven and Spring profiles, logback configuration, and a Jenkins pipeline.

BackendException Handlingjava
0 likes · 15 min read
Building a Reusable Backend Base Project with Swagger, CodeGenerator, Pagination, Exception Handling, and Multi‑Environment Configuration
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 2, 2021 · Backend Development

Does Spring Boot’s connectionTimeout Limit Request Time? The Real Answer

This article investigates how Spring Boot’s connectionTimeout parameter behaves by conducting three experiments—controller‑side delay, HttpURLConnection requests, and raw socket connections—revealing that the timeout only applies after a client establishes a connection and remains idle, not to the overall request processing time.

BackendTomcatconnectionTimeout
0 likes · 5 min read
Does Spring Boot’s connectionTimeout Limit Request Time? The Real Answer
Architecture Digest
Architecture Digest
May 1, 2021 · Backend Development

Backend Technology Stack Selection for Startup Companies

This article outlines a comprehensive backend technology stack for startup companies, detailing language choices, essential components, processes, system tools, and best‑practice recommendations across areas such as project management, DNS, load balancing, databases, messaging, CI/CD, monitoring, and deployment.

ArchitectureBackendDevOps
0 likes · 30 min read
Backend Technology Stack Selection for Startup Companies
Youzan Coder
Youzan Coder
Apr 30, 2021 · Backend Development

Uncovering Hidden Flaws in a Distributed Lock Implementation: A Structured Code Review

This article examines the business context and collection workflow of a BOS‑integrated service, dissects the distributed lock logic and its execution sequence, and conducts a thorough structured code review that reveals logical, exception, non‑functional, and testability issues while offering concrete improvement recommendations.

BackendCode reviewbest practices
0 likes · 8 min read
Uncovering Hidden Flaws in a Distributed Lock Implementation: A Structured Code Review
360 Smart Cloud
360 Smart Cloud
Apr 30, 2021 · Backend Development

Understanding Rate Limiting: Concepts, Architectures, Algorithms, and a Redis‑Lua Token Bucket Implementation

This article explains what rate limiting is, why it is needed, the typical actions taken when limits are reached, compares single‑node and distributed architectures, reviews four classic limiting algorithms, and provides a practical Redis‑Lua token‑bucket implementation with code examples.

BackendToken Bucketalgorithm
0 likes · 14 min read
Understanding Rate Limiting: Concepts, Architectures, Algorithms, and a Redis‑Lua Token Bucket Implementation
Open Source Linux
Open Source Linux
Apr 30, 2021 · Backend Development

How to Cut Nginx HTTPS Latency by 30% with TLS Tweaks

This article explains why optimizing Nginx HTTPS latency matters for instant search, describes how TLS handshakes add round‑trip delays, and provides step‑by‑step Nginx TLS configuration changes—such as enabling HTTP/2, adjusting ciphers, enabling OCSP stapling, tuning buffer sizes and session cache—that together reduced request latency by about 30% in a real‑world search service.

BackendHTTPSLatency
0 likes · 13 min read
How to Cut Nginx HTTPS Latency by 30% with TLS Tweaks
Wukong Talks Architecture
Wukong Talks Architecture
Apr 29, 2021 · Backend Development

Distributed Lock Implementations with Redis: From Local Locks to Bronze, Silver, Gold, Platinum, and Diamond Solutions

This article explains why local in‑memory locks fail in distributed environments, introduces the concept of distributed locks, and walks through five progressive Redis‑based lock implementations—bronze, silver, gold, platinum, and diamond—detailing their principles, code examples, advantages, and shortcomings.

Backendconcurrencyjava
0 likes · 16 min read
Distributed Lock Implementations with Redis: From Local Locks to Bronze, Silver, Gold, Platinum, and Diamond Solutions
21CTO
21CTO
Apr 28, 2021 · Frontend Development

Why Laravel + Vue.js Is the Power Combo for Modern Web Apps

This article explains how the Laravel PHP framework and the Vue.js progressive JavaScript library complement each other, highlighting their popularity, ease of integration, event‑driven architecture, virtual DOM performance, and faster learning curve, making them an ideal stack for new web projects.

BackendJavaScriptLaravel
0 likes · 5 min read
Why Laravel + Vue.js Is the Power Combo for Modern Web Apps
Alibaba Cloud Native
Alibaba Cloud Native
Apr 28, 2021 · Backend Development

How Seata‑Golang Enables Distributed Transactions in Go Microservices

This article introduces Seata, a high‑performance open‑source distributed transaction solution, explains the Seata‑Golang 1.0.0 release and its demo at a Go meetup, details the core AT‑mode architecture, describes the MySQL driver that integrates Seata‑Golang, and outlines future plans for broader database support.

BackendDistributed TransactionsGo
0 likes · 7 min read
How Seata‑Golang Enables Distributed Transactions in Go Microservices
Programmer DD
Programmer DD
Apr 28, 2021 · Backend Development

How to Gracefully Shut Down a Spring Boot Application: 5 Proven Methods

Learn five practical ways to gracefully shut down a Spring Boot application—including using Actuator’s shutdown endpoint, closing the application context, PID file handling, SpringApplication.exit, and a custom shutdown controller—so unfinished tasks finish, logs flush, and services stop safely without resorting to kill‑9.

ActuatorBackendGraceful Shutdown
0 likes · 9 min read
How to Gracefully Shut Down a Spring Boot Application: 5 Proven Methods
Selected Java Interview Questions
Selected Java Interview Questions
Apr 27, 2021 · Backend Development

Understanding the Spring Bean Instantiation Process

This article explains how the Spring IoC container prepares and creates Bean instances, detailing the two main phases—container startup and Bean instantiation—along with the roles of BeanDefinition, BeanFactoryPostProcessor, BeanWrapper, Aware interfaces, BeanPostProcessor, and custom initialization and destruction logic.

BackendIoCbean
0 likes · 16 min read
Understanding the Spring Bean Instantiation Process
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 27, 2021 · Backend Development

Essential Java Concurrency Interview Topics – 12 Core Questions and Answers

This article presents twelve fundamental Java concurrency interview questions, covering thread creation methods, their pros and cons, thread states, lifecycle, start vs run, termination, thread safety, differences between threads and processes, communication, yield vs sleep, and provides concise answers to help candidates demonstrate solid multithreading knowledge.

BackendThreadconcurrency
0 likes · 11 min read
Essential Java Concurrency Interview Topics – 12 Core Questions and Answers