The 2020 NordPass survey reveals that simple numeric passwords like "123456" remain the most common weak passwords, highlighting new risky entries and offering practical advice for creating stronger, more secure credentials.
This article explains why software design documents are essential, outlines the key sections they should contain, offers concrete writing tips, and provides a step‑by‑step process for creating, reviewing, and iterating on design specs to improve project outcomes and reduce risk.
This article explains why exception handling in Java is challenging and presents ten practical best‑practice guidelines—including using finally or try‑with‑resources, declaring specific exceptions, documenting throws, providing clear messages, catching specific exceptions first, avoiding Throwable, logging properly, and preserving original causes—to write more robust and maintainable code.
This article presents a concise set of Laravel best‑practice recommendations—including environment configuration, avoiding core modifications, using migrations, seeding, Artisan commands, proper naming, validation requests, Carbon for dates, staying up‑to‑date, and asset compilation—to help PHP developers write clean, maintainable backend code.
This article presents practical refactoring techniques for PHP developers, emphasizing unit testing, bottom‑up restructuring, eliminating magic numbers, using braces, meaningful naming, and leveraging language features, illustrated with real‑world hotel management code examples and concise best‑practice tips.
This guide explains why comments are essential for code readability, outlines various comment styles for C/C++—including file, function, variable, spelling, and TODO comments—and provides concrete examples and best‑practice recommendations to help developers write clear, maintainable code.
This article presents a comprehensive Spring Boot project template for backend development, detailing README guidelines, one‑click local build scripts, business‑oriented package structure, automated test classifications, logging, exception handling, distributed locks, code style, static analysis, health checks, API documentation, database migration, multi‑environment setup, CORS configuration, and recommended third‑party libraries.
This article explains why Chinese characters are rarely allowed in passwords—due to historical, technical, and usability reasons—and provides practical tips for creating stronger, more secure passwords using letters, numbers, and symbols.
This article shares practical insights and principles—from the importance of code review to concrete guidelines like KISS, composition, and transparency—helping developers write higher‑quality, easier‑to‑maintain software while avoiding common pitfalls such as duplication, premature optimization, and over‑engineered designs.
This article explores the essential reasons why engineers and leaders must practice code review, outlines common pitfalls such as duplicated code and premature optimization, and presents concrete design principles, model‑driven thinking, and Unix‑inspired guidelines to improve code quality and maintainability in large‑scale backend systems.
The article examines common problematic comment styles—such as embedding contact info, design details, "how" instead of "why", usage instructions, and algorithm explanations—and suggests modern Git‑based practices to keep code clean and maintainable.
This article explains the fundamentals of software architecture diagrams, outlines the purpose and classification of different diagram types, describes common pitfalls, and provides a step‑by‑step guide to using the C4 model—including system context, container, component, and class diagrams—plus a real‑world case study.
This article presents ten concrete Java refactoring techniques—from extracting duplicate code and splitting long methods to optimizing nested conditionals and removing temporary variables—each illustrated with clear before‑and‑after code examples and practical advice for improving code readability and maintainability.
Code Review, a crucial yet often overlooked development practice, enhances code quality, promotes team knowledge sharing, enforces consistent standards, and improves maintainability, while the article outlines its benefits, practical guidelines, timing, formats, and specific expectations for reviewers and reviewees to foster effective adoption.
This article presents a comprehensive set of mandatory and recommended conventions for MySQL table creation, SQL writing, and index design, aiming to improve backend development efficiency, reduce erroneous DDL and queries, and enhance overall database performance.
This article explains five common issues caused by NULL values in MySQL columns—data loss with COUNT, DISTINCT, and inequality queries, NULL‑induced NULL results in SUM leading to NPE, increased query complexity, and index behavior—while providing practical SQL solutions and best‑practice recommendations.
The article explains how adding a new enum constant in a downstream library can cause IllegalArgumentException during RPC deserialization, analyzes the underlying JSON serialization mechanism, and recommends avoiding enums in RPC parameters and return values by using strings with documented constraints.
A developer recounts how blindly copying code snippets from sites like CSDN and StackOverflow led to bugs, explains the hidden risks of reusing code without understanding, and offers practical advice on testing and comprehending third‑party code to avoid security and functionality issues.
This article explains the multiple benefits of code review—from knowledge sharing and improving code quality to enforcing team standards—and provides practical steps, cultural tips, tool recommendations, and workflow guidelines to help development teams adopt effective code review practices.
This guide introduces a minimal, safe Bash script template, explains why Bash is still essential for backend tasks, and walks through best‑practice features such as strict error handling, portable shebang, colorized messaging, parameter parsing, cleanup traps, and portability across macOS and various Linux distributions.
This article explores why and when to refactor legacy projects, outlines common pitfalls such as missing functionality and inadequate testing, and offers practical guidance on assessment, testing, branching, feature toggles, and A/B testing to ensure a successful rewrite.
This guide explains how to structure Git branches—including master, develop, feature, release, and hotfix—provides command sequences for common tasks, and details a comprehensive commit‑message format based on the Angular convention to improve code review, release notes, and long‑term maintainability.
This article outlines 13 practical code review standards—ranging from improving system health and rapid feedback to fostering education, respecting guidelines, handling conflicts, ensuring testing, and encouraging constructive communication—aimed at helping developers conduct effective reviews and maintain high-quality, maintainable codebases.
This article compiles core programming principles such as KISS, YAGNI, Separation of Concerns, DRY, Inversion of Control and the SOLID rules, explaining why each matters, how to apply them, and providing reference links for deeper study.
This article explains the concept of refactoring, its motivations and timing, enumerates common code smells, and provides detailed refactoring techniques—including extracting methods, moving functions, encapsulating data, simplifying conditionals, and handling inheritance—to improve software design and maintainability.
The article introduces the widely‑starred GitHub project “Node.js Best Practices,” highlighting its multilingual documentation, comprehensive coverage of project structure, error handling, coding standards, testing, production, security, and performance, and encourages readers to visit the repository for detailed guidance.
This article explains the functional differences, recommended usage scenarios, and IDE warnings for Spring's @Autowired and @Resource annotations, showing how constructor, setter, and field injection affect code quality, testability, and framework portability.
This article distills key recommendations from Effective Java, covering static factory methods, builder patterns, singleton safety, utility class design, object creation, memory management, garbage‑collection, equals/hashCode contracts, immutability, generics, enums, collections, exception handling, and performance‑aware coding practices for robust Java development.
This article introduces static code analysis, outlines its advantages and disadvantages, presents eight typical scanning rule categories, and demonstrates common pitfalls such as null‑pointer dereferences, logic errors, uninitialized variables, and potential overflow issues with concrete code examples.
This article lists ten common "toxic" Java code patterns—ranging from offensive method names and misleading sorting to hidden performance traps—and explains why they are harmful, how they affect maintainability and runtime, and what clean, efficient alternatives should be used.
This article presents 13 Google-inspired code review standards that aim to improve software quality, ensure error‑free and well‑styled code, accelerate merges, foster learning, maintain testing, and promote respectful, thorough, and holistic review practices for developers.
The article presents a comprehensive guide on why developers and leaders must perform code reviews, identifies common pitfalls such as duplicated code, premature optimization and over‑engineered OOP, and offers concrete principles, model‑design advice, and Golang examples to improve code quality and maintainability.
This document identifies common JavaScript code pitfalls, such as inefficient array methods and complex conditionals, and provides best practices for improving code readability and maintainability through modern JavaScript techniques and tools.
This guide outlines comprehensive MySQL best‑practice standards covering naming conventions, storage engine selection, charset usage, table and column comments, size limits, partitioning, hot‑cold data separation, index design, SQL coding rules, and operational safeguards to ensure performant, maintainable, and secure database systems.
The article analyzes a runtime IllegalArgumentException caused by an enum constant added in a downstream library, explains how JSON‑based RPC deserialization fails when the receiving service lacks the new enum value, and recommends using strings instead of enums for RPC interfaces to improve compatibility and maintainability.
This article outlines nine practical Kubernetes pod‑level security configurations—including security contexts, privilege escalation, non‑root users, resource limits, service account tokens, seccomp profiles, capabilities, and read‑only filesystems—to help you harden containers against attacks and improve cluster stability.
This guide details the core PEP‑8 conventions for Python code, covering comments, indentation, line length, imports, whitespace, naming, and input/output practices, with clear examples and practical tips to improve readability and maintainability.
This guide shares seven practical habits for Linux beginners, covering safe root usage, sensible file naming, separating the home directory, effective disaster recovery, experimental learning, command‑line mastery, and preparing a portable Linux environment to boost confidence and productivity.
This article presents sixteen practical Java coding best‑practice guidelines—including avoiding ‘where 1=1’ in MyBatis, using entrySet for map iteration, preferring Collection.isEmpty(), pre‑sizing collections, employing StringBuilder, leveraging Set for contains checks, static initialization blocks, and other tips—to improve performance, readability, and safety of backend applications.
This article explains why refactoring is essential for maintaining legacy systems, defines refactoring as a controlled code‑restructuring technique that preserves observable behavior, and provides a step‑by‑step process—including when to start, when to stop, prerequisites, and practical tactics—to improve code quality and reduce technical debt.
The 3rd Cloud Native Technology Practice Summit gathered over 10,000 IT professionals worldwide, showcased six comprehensive cloud‑native forums, presented award‑winning industry and container‑application cases, and highlighted how leading banks and solution providers are leveraging cloud‑native platforms for digital transformation.
This article presents thirteen practical code review standards—ranging from rapid feedback and thorough testing to respectful communication and UI demonstration—that aim to improve overall software quality while keeping developers motivated and productive.
This article distills key recommendations from Joshua Bloch’s Effective Java, covering static factory methods, builder patterns, singleton protection, memory management, and API design conventions, providing concise examples and practical guidance to help Java developers write clearer, more efficient, and safer code.
This article presents a comprehensive set of guidelines for writing clean, maintainable, and efficient Bash/Shell scripts, covering shebang usage, comments, parameter validation, variable handling, indentation, naming, encoding, permissions, logging, security, parallel execution, and tooling such as ShellCheck.
This article presents forty concise, actionable tips ranging from breaking code into functions and applying YAGNI and KISS principles to using version control, testing, and continuous learning, all aimed at helping developers enhance their coding efficiency and professional growth.
The article outlines practical guidelines for naming variables and methods—emphasizing clear intent, avoiding misleading or abbreviated names, leveraging IDE autocomplete, ensuring searchability, and maintaining consistent conventions—to improve code readability, maintainability, and overall software quality.
The article presents a comprehensive set of fifteen universal software architecture principles—ranging from redundancy and rollback to automation and non‑intrusive design—along with essential design guidelines such as separation of concerns, single responsibility, and low coupling to help architects build scalable, reliable, and maintainable systems.
This guide consolidates practical conventions for writing clean, maintainable shell scripts, covering shebang usage, commenting, parameter validation, variable handling, indentation, naming, encoding, efficiency tricks, and static analysis with ShellCheck.
The article explains Java’s try‑with‑resources feature as syntactic sugar that the compiler rewrites into a try‑finally structure with sophisticated exception handling, demonstrates the generated bytecode, clarifies AutoCloseable versus Closeable, and offers best‑practice guidelines for reliable resource management.
This article compares Spring's programmatic and declarative transaction management, explains how each works with code examples, outlines the benefits and limitations of declarative transactions—including granularity and failure scenarios—and argues why developers should consider programmatic transactions for clearer control and fewer hidden bugs.
This article outlines a comprehensive DevOps operations framework, tracing its evolution from traditional ops to modern automation, detailing business standards, work policies, system integration, and best‑practice norms to achieve high SLA, low cost, and a one‑stop operational platform.
Becoming a full‑stack engineer requires mastering core web fundamentals, continuously learning diverse languages, frameworks, and infrastructure, practicing rigorous design and code quality, and bridging front‑end, back‑end, and operations knowledge to boost development efficiency, solve problems quickly, and earn peer trust across the tech stack.
These Java performance optimization guidelines cover best practices such as appropriate use of singletons, minimizing static variables, reducing object creation, leveraging final modifiers, preferring local variables, efficient handling of collections, avoiding costly operations like synchronized blocks and split, and proper resource management to improve application efficiency.
This guide explains Google’s DevOps solution built on DORA research, outlines the four DevOps capability categories, and provides detailed steps, best practices, common pitfalls, improvement methods, and measurement techniques for implementing reliable, automated software deployments.
This article outlines ten practical code‑review guidelines—from logging standards and IDE warnings to unit testing, branch policies, hidden requirements, exception handling, and SQL performance—helping developers write clean, maintainable, and production‑ready code.
This article provides a comprehensive overview of Apache RocketMQ, covering its core concepts, architecture, various message types, reasons for adoption such as asynchronous decoupling and peak‑shaving, as well as best practices and local transaction patterns for reliable distributed messaging.
This guide explains how to identify suitable test scenarios for Selenium automation, select the right tools and team structure, eliminate flaky tests, and ensure ongoing effectiveness by aligning automation choices with business goals and technical constraints.
This article presents practical Selenium automation best practices—including early and frequent testing, BDD adoption, proper wait strategies, reporting, PageObject usage, automatic screenshots, test design, and mindful tool reliance—to help engineers achieve stable, efficient web test suites.
This article shares ten practical Python‑focused machine‑learning engineering tips—from writing abstract classes and fixing random seeds to tracking progress, speeding up pandas, managing cloud costs, and building robust FastAPI services—helping developers write cleaner, more reproducible, and production‑ready code.
This article presents a comprehensive guide for Java developers on improving code quality by introducing common utility functions, splitting oversized methods, ensuring consistent block levels, encapsulating repeated logic, reducing nesting depth, and eliminating unnecessary null‑checks, each illustrated with concrete code examples and clear recommendations.
This article presents a collection of common Java coding pitfalls—such as using 'where 1=1' in MyBatis, inefficient Map iteration, improper collection checks, and suboptimal string handling—and provides concise, performance‑oriented best‑practice alternatives with code examples.
This article outlines 13 practical code‑review standards that help improve software health, ensure quality, foster collaboration, and keep development teams satisfied by focusing on incremental improvements, timely feedback, education, and respectful communication.
This article introduces Python type annotations, explains why they improve code consistency and readability in collaborative projects, demonstrates simple and advanced usage with code examples and screenshots, and encourages developers to adopt static typing for better maintenance and fewer runtime errors.
This article explains why daily stand‑up meetings are essential for agile teams, analyzes common problems, describes the correct way to run them, and provides an 18‑key checklist of best‑practice tips—including facilitator roles, timeboxing, visual tools, and burn‑down chart usage—to help teams achieve better collaboration, transparency, and sprint outcomes.
This article explains the complexities of exception handling across various backend scenarios—such as message queues, RPC services, mobile and PC clients—offering practical guidelines on when to catch, rethrow, use error codes, or employ alternatives like Java Optional to improve code clarity and system reliability.
This article outlines twelve essential cybersecurity best practices for 2019, covering biometric security, tiered policies, risk‑based approaches, data backup, IoT protection, multi‑factor authentication, password management, least‑privilege principles, privileged‑user monitoring, third‑party access control, phishing defense, and employee awareness to safeguard sensitive data.
This article outlines frequent Kubernetes operational mistakes—such as misconfigured resource requests, missing probes, improper load‑balancer exposure, naïve autoscaling, IAM/RBAC misuse, lack of anti‑affinity, absent PodDisruptionBudgets, multi‑tenant pitfalls, and suboptimal externalTrafficPolicy—providing concrete remediation steps and best‑practice code examples.
This article outlines nine practical Python skills—ranging from problem‑solving mindset and avoiding XY problems to mastering strings, lists, loops, functions, OOP, and PEP‑8 conventions—that help beginners transition into confident intermediate developers.
This guide outlines eight practical steps—including defining scope, forming a planning team, setting clear objectives, designing realistic scenarios, creating evaluation checklists, assigning roles, conducting pre‑drill briefings, and performing post‑drill reviews—to help organizations execute effective, repeatable disaster recovery exercises that strengthen business continuity.
The article explains how the vague term “user” leads to design flaws and security vulnerabilities across systems like ticket‑booking platforms, Unix, and SaaS, and argues that precise terminology and early conceptual planning can prevent costly rework.
This article explores why clean, readable code matters, explains key principles such as KISS and DRY, discusses the role of comments, unit tests, and avoiding TODOs, and offers practical advice for developers to improve code quality and long‑term maintainability.
This article examines common pitfalls in API design, argues that the consumer of an interface should drive its design, and presents concrete examples and best‑practice recommendations for structuring endpoints, meta data, and choosing appropriate communication protocols.
Refactoring improves code understandability and reduces maintenance costs by reorganizing internal structure without changing behavior, and this guide explains its purpose, timing, principles, common code smells, measurement metrics, and practical techniques across data, statement, subroutine, class, and system levels.
This article outlines essential RESTful API design principles, covering clear URL structures, proper use of HTTP verbs, precise status codes, appropriate response formats, and the inclusion of hypermedia links to create intuitive, maintainable, and standards‑compliant web services.
This article examines the DevOps standard, highlights common pitfalls through two case studies, and offers practical implementation paths and guiding principles to help organizations successfully adopt DevOps across development, testing, and operations teams.
This comprehensive guide covers Git fundamentals, including workspace concepts, configuration, common commands for adding, committing, branching, merging, rebasing, stashing, submodules, hook setup, branch management strategies, and solutions to frequent Git issues, providing developers with a complete reference for effective version control.
This article introduces Java's enum type introduced in JDK 1.5, explains seven practical usage patterns—including constants, switch statements, adding methods, overriding methods, implementing interfaces, organizing enums in interfaces, and using EnumSet/EnumMap—while providing code examples, best‑practice guidelines, and comparisons with legacy int or String constants.
This article explores the importance of code review for engineers and leaders, examines common pitfalls such as duplicated code and premature optimization, presents core software design principles like KISS and composition, and offers practical guidelines and Golang examples to improve code quality and maintainability.
This comprehensive guide explains why Kubernetes has become the standard container platform, covering its application‑centric architecture, migration challenges, networking and CNI design, control‑plane components, storage solutions including CSI and FlexVolume, image distribution strategies, upgrade and backup procedures, operator patterns, and practical containerization best practices for large‑scale deployments.
This article explains the true purpose of code review beyond bug hunting, explores its cultural and quality benefits, and offers seven actionable recommendations—including small batch reviews, frequent cycles, choosing the right reviewers, rapid feedback, modern tools, pair programming, and blending online with offline sessions—to make code reviews more effective.
This article presents thirty practical Python best‑practice tips covering version checks, IPython usage, list comprehensions, memory inspection, multiple return values, data classes, variable swapping, dictionary merging, string manipulation, ternary operators, counters, comparison chaining, color output, date parsing, integer division, character‑set detection and more, each illustrated with concise code examples.
The article explains how adopting a concise, shared checklist for code reviews can reduce subjectivity, improve team trust, and ensure critical quality and documentation standards are met across software projects.
This article explains the DRY (Do Not Repeat Yourself) principle, demonstrates how duplicated PHP code in a Report class can be refactored by extracting shared logic into reusable methods, and shows the final clean implementation that improves readability and maintainability.
The author recounts a massive SAP cloud application that suffered severe slowness due to a forgotten 20‑second wait statement, and shares a comprehensive, ten‑step guide on when and how to safely optimize code, emphasizing analysis, clear goals, and disciplined review.
This article outlines ten essential steps to strengthen JumpServer security, including upgrading the operating system and JumpServer software, updating dependencies, avoiding weak passwords, enabling OS security components, minimizing open ports, securing public access, configuring SSL, enforcing strong passwords, and enabling multi‑factor authentication.
The article outlines best practices for remote software teams to keep pull requests small, fast, and well‑communicated, emphasizing frequent reviews, clear labeling, context provision, reviewer support, CI automation, and a collaborative, non‑authoritative culture to improve code quality and team productivity.
This article explains Prometheus data collection by describing metric syntax, label usage, time‑series concepts, the four logical metric types (Counter, Gauge, Histogram, Summary), and provides practical naming, labeling, and selection guidelines for effective monitoring.
iQIYI’s mobile component library was built by first auditing 400+ pages to define design specs and business needs, then creating reusable “block‑card” components with a scalable granularity, a backend management platform, and a Sketch plugin, achieving 43% page coverage, 40% workflow efficiency gain and 25% UI consistency improvement while maintaining design flexibility.
This article presents comprehensive Java code optimization techniques, emphasizing error avoidance, reduced code size, and improved execution efficiency through practices such as using final modifiers, object reuse, local variables, proper resource handling, appropriate data structures, bitwise operations, and careful use of collections and concurrency utilities.
This article presents common error patterns and proper techniques for handling Java exceptions, illustrating why returning null, catching generic exceptions, swallowing Throwables, and misusing finally blocks are problematic, and provides clear, correct examples to improve exception management in Java applications.
The article explains why Java developers often litter code with null‑checks, distinguishes when null is a valid response versus an error, and proposes using assertions, exceptions, empty collections, or the Null Object pattern to write cleaner, safer code.
This article explains why overusing null‑check statements and try‑catch blocks makes Java code messy, distinguishes valid and invalid null returns, and offers practical techniques such as assertions, exceptions, empty collections, and the Null Object pattern to write safer, more concise code.
This guide presents ten practical Redis best‑practice tips—including avoiding KEYS *, using SCAN, analyzing command stats, leveraging hashes, setting expirations, choosing eviction policies, handling errors, scaling with clusters, understanding threading limits, and configuring Sentinel for high availability—to help you run Redis efficiently and safely.
The article outlines Google’s philosophy on code health, emphasizing readable, maintainable, stable, and simple code, and provides practical guidance on writing understandable code, designing robust interfaces, and avoiding primitive obsession to improve developer productivity and software quality.
This article explains why maintainable JavaScript is essential for modern web applications and provides concrete guidelines on coding standards, readability, naming, type transparency, loose coupling, and coding conventions such as respecting object ownership, avoiding globals, and using constants.
This article introduces the highlights of the latest (Taishan) edition of Alibaba’s Java Development Manual, outlines new OOP, date‑time, collection, SQL, error‑code and security conventions, and provides a one‑click download link for the complete collection of all seven historic versions.
This article examines why overusing if‑else statements makes Java code hard to read and presents nine practical techniques—including early returns, maps, ternary operators, combined conditions, enums, Optional, streamlined logic, polymorphism, and switch statements—to refactor and simplify conditional logic for cleaner, more maintainable code.
This article explains essential RESTful API design details—including URL conventions, HTTP verb usage, status‑code precision, proper JSON responses, and HATEOAS linking—to help developers create clear, consistent, and user‑friendly web APIs.
This article reveals common Java pitfalls—from using Objects.equals versus ==, ternary operator type conversion, generic type mismatches, Set deduplication, BeanUtils property copying, to CGLIB proxy quirks—and provides concrete analysis and practical avoidance techniques for each case.
This article provides a comprehensive overview of Java exception handling, covering the exception hierarchy, key keywords, common interview questions, code examples, and best‑practice guidelines for declaring, throwing, and catching exceptions effectively in Java applications.
