This article lists and explains ten of the most common errors Java developers make—from misusing Arrays.asList and raw types to incorrect loop deletions, mutable versus immutable objects, and constructor pitfalls—providing correct code examples and best‑practice recommendations.
This article explains Python's flexible import system, covering regular imports, from‑statement imports, relative imports, optional imports, local imports, and common pitfalls such as circular and shadowed imports, while providing clear code examples and best‑practice recommendations.
This article gathers subtle yet frequent anti‑patterns that new Python developers encounter—misusing range, avoiding list comprehensions, overlooking set/dict look‑ups, variable‑scope surprises, and PEP8 style rules—and offers clear, practical alternatives to write cleaner, faster, and more maintainable code.
This article provides a comprehensive checklist for designing Java APIs, covering package organization, naming conventions, type, method, exception, constructor, and documentation best practices, using clear directives such as “must”, “should”, “consider”, and “avoid” to help developers create clean, maintainable, and robust APIs.
This article compiles 75 concise Python coding recommendations covering style, idioms, core language features, standard libraries, design patterns, internal mechanisms, tooling, and performance optimization to help developers write cleaner, more maintainable, and efficient Python code.
This guide walks beginner Python developers through frequent anti‑patterns—misusing range, overlooking list comprehensions, inefficient membership checks, variable‑scope surprises, and PEP 8 style rules—offering clear alternatives and best‑practice tips to write cleaner, more reliable code.
This article explains why and how to use Go's context cancellation feature, covering listening for cancel events, emitting cancellations, time‑based timeouts, practical code examples, and important pitfalls to write faster and more robust backend services.
Learn seven practical Python optimization techniques—from using local variables and reducing function calls to leveraging generators and pre-compiling code—that can noticeably improve execution speed, lower memory usage, and make your scripts more efficient.
This article, the fifth in a static code scanning series, explains six special scenarios—custom close utilities, methods returning resources, streams that need not be closed, nested stream closures, JDBC statement/result set relationships, and socket streams—that complicate determining whether Java resources have been properly closed.
This article compiles a curated list of practical Python tricks—from chained comparisons and enumerate usage to generators, dictionary comprehensions, decorators, and context managers—providing clear examples and explanations that help developers write more concise, efficient, and readable code.
This article presents a comprehensive set of Java performance optimization techniques, covering proper use of singletons, avoiding static variables, minimizing object creation, leveraging final modifiers, using local variables, selecting appropriate data structures, reducing synchronization, and employing efficient coding patterns such as System.arraycopy and bit‑shift operations.
This article shares VIPShop's extensive production experience with Redis Cluster, covering use cases, storage architecture evolution, detailed best‑practice guidelines, common pitfalls, operational automation, monitoring strategies, and useful open‑source tools for large‑scale deployments.
This article explains how to use jQuery’s chaining and .end() method, correctly employ HTML5 data‑* attributes, improve selector performance by caching and preferring native loops, understand the CSS box model and box‑sizing, apply efficient float and absolute positioning techniques, and follow best‑practice CSS formatting and feature detection.
This article explains how Java exceptions provide a consistent mechanism for identifying and responding to errors, and outlines three key principles—specificity, early throwing, and delayed catching—illustrated with a fictional JCheckbook class to demonstrate robust, user‑friendly debugging practices.
This article shares practical lessons and common pitfalls encountered while developing numerous Go‑based microservices for Teamwork Desk, covering topics such as framework choices, panic handling, request body reuse, SQL handling, pointer usage, naked returns, variable shadowing, concurrent map access, and vendoring best practices.
