The article explains that a leading underscore in Python names signals a non‑public or internal use convention defined by PEP 8, describes its practical effects on imports and IDE hints, and outlines other underscore naming patterns such as name mangling, trailing underscores, magic methods, and throwaway variables.
The article explores how developers inherit poorly written, uncommented code from departing colleagues, illustrates the pain with real Java examples, and offers a step‑by‑step guide to understand, refactor, and prevent such code‑base sabotage.
This note explains Java identifiers—allowed characters, first‑character rules, valid and invalid examples—lists all language keywords that cannot be reused as names, and outlines practical naming conventions for classes, methods, constants, and packages to improve code readability.
This guide presents a comprehensive set of mandatory and recommended conventions for MySQL database objects—including table, column, and index naming, field design rules, index selection principles, and best‑practice development tips—to help engineers build maintainable, high‑performance schemas.
This guide explains the purpose of Python identifiers, outlines the character and naming rules—including case sensitivity and keyword restrictions—provides common naming patterns such as boolean prefixes and collection naming, and offers best‑practice recommendations for clear, maintainable code.
This article explains Alibaba’s Java development guidelines for layered domain models, detailing the purpose and naming rules of DO, DTO, BO, AO, VO, and Query objects, and clarifies the roles of PO, VO, DAO, BO, DTO, and POJO in clean backend architecture.
In the era of digital transformation, chaotic data warehouse naming wastes resources, while a well‑defined naming convention improves maintainability, collaboration, and business value, as demonstrated by real‑world cases showing three‑fold query speed gains and up to 60% reduction in cross‑team effort.
This guide presents a complete database development specification—covering naming, design, data types, index, and SQL rules—with mandatory, recommended, and reference levels to ensure consistent, high‑performance, and maintainable database schemas.
This guide outlines comprehensive API interface design best practices, covering design principles, naming conventions, parameter structures, return code standards, security measures, and a reusable documentation template to ensure flexible, efficient, and secure service development.
Explore a comprehensive data governance guide covering naming conventions, data lifecycle classifications, layered architecture standards, inter-layer calling rules, and model design principles, providing practical standards and best practices for building robust, maintainable data warehouses and analytics platforms.
This guide presents a comprehensive PHP naming convention handbook, covering universal principles, variable and function styles, class/interface naming, constant rules, pitfalls to avoid, and the PSR standards, offering practical code examples to help developers write clearer, more maintainable backend code.
This article explains why clean code is crucial for projects and developers, covering the importance of readable naming, single‑responsibility classes, well‑structured functions, and effective testing practices to boost productivity and reduce technical debt.
This article shares practical guidelines for designing database schemas with meaningful table and column names, covering prefixes, English naming, boolean and timestamp conventions, foreign‑key suffixes, appropriate redundancy, and concrete examples of good and bad designs to help teams build readable and maintainable databases.
This guide explains how to design clear and maintainable database schemas by using meaningful prefixes, full English names, consistent suffixes for booleans, timestamps, and foreign keys, and by applying best‑practice naming conventions, redundancy strategies, and relationship modeling to improve readability and performance.
This guide explains what variables are in C++, covers declaration and initialization, details fundamental data types such as int, float, double, char, and bool, outlines naming conventions, and demonstrates both implicit and explicit type conversions with clear code examples.
This guide explains the key component, page, window, and mouse pointer properties in UI design, covering scroll settings, opacity handling, naming conventions for objects and attributes, and best practices for consistent, case‑insensitive usage across dynamic panels.
This article outlines seven practical unit‑test naming patterns, explains their structure with real‑world code examples, compares their advantages and drawbacks, and offers guidance on selecting the most suitable convention for different project sizes and team workflows.
This guide outlines practical C coding standards covering clear and concise code, consistent naming conventions for variables, functions, constants, enums, macros, and files, proper header protection, include ordering, inline function usage, and effective commenting to improve readability and maintainability.
This article explains why clean code is essential for productivity and team collaboration, outlines concrete guidelines for meaningful naming, single‑responsibility classes, concise functions, and effective testing, and shows how tools and refactoring can help maintain high code quality.
This article explains the importance of clean code in team development and walks through practical guidelines for naming, class design, function design, and testing, illustrating each principle with concrete Java examples, refactorings, and best‑practice recommendations.
This article explains why clean code is essential for team development and provides practical guidelines on naming, class design, function composition, and testing—including SOLID principles, meaningful identifiers, single‑responsibility classes, short functions, and test‑driven development—to improve readability, extensibility, and overall software quality.
This article explains the meaning and conventions of single and double leading, trailing, and surrounding underscores in Python identifiers, shows how name mangling works, and provides practical code examples illustrating their effects on classes, modules, and REPL usage.
Effective naming in Go requires consistency, brevity, and precision, with guidelines covering variable and function names, camel‑case conventions, short local variables, descriptive parameters, return values, method receivers, package naming, interface naming, and error types, illustrated by numerous code examples from the standard library.
This article presents a comprehensive, step‑by‑step analysis of Go naming conventions, explaining why each rule matters, illustrating each point with concrete code snippets and real‑world examples, and showing how to apply the guidelines to variables, functions, packages, structs, interfaces, errors, constants, enums and comments for truly clean Go code.
Improving code reviews hinges on clear, domain-specific naming, concise guiding comments that explain why code behaves as it does, and respectful, issue-focused communication that adapts to reviewers’ experience, collectively boosting code quality, team cohesion, and overall software reliability.
This article shares a developer’s journey from tangled, hard‑to‑read code to clean, maintainable software, illustrating how meaningful naming, PEP 8 compliance, static typing, small functions, avoiding magic numbers, and the DRY principle can dramatically improve code quality.
This article presents comprehensive Vue.js and Element‑plus coding standards, covering enum naming, directory and file naming conventions, component file structure, attribute and directive usage, boolean, function, class, constant, and enum naming rules, emphasizing consistency to improve readability and maintainability.
These guidelines detail C++ client-side naming conventions using Hungarian notation, modular and component-based development principles, and comprehensive coding style rules—including variable prefixes, class naming, indentation, brace placement, macro safety, and interface design—to promote readable, maintainable, and robust software.
Clean code demands readable, extensible structures and precise, unambiguous naming—each class, method, and variable should convey a single responsibility, avoid duplication, and follow consistent conventions, enabling easy testing, maintenance, and team collaboration while preventing the productivity‑draining chaos of poorly named, tangled code.
This article explains why maintaining clean, well‑structured code is essential for productivity and team collaboration, covering naming conventions, class design principles, function responsibilities, testing strategies, and tools like SonarLint, while providing concrete Java code examples for each concept.
This article presents Alibaba's concise 10‑point MySQL schema standard, covering boolean field naming, lowercase identifiers, singular table names, reserved word avoidance, index naming conventions, decimal usage, fixed‑length char, variable‑length varchar/text, mandatory audit fields, and the prohibition of physical deletions, offering practical guidance for clean database design.
This guide explains why clean code matters, outlines practical naming conventions, class design principles, function structuring rules, and testing strategies—including TDD, the FIRST criteria, and automated test generation—to help developers write maintainable, readable, and high‑quality software.
This article explains why clean, well‑named code is essential for productivity, outlines practical naming rules—such as avoiding ambiguity, preventing misleading names, making meaningful distinctions, and keeping identifiers searchable—and provides concrete Java examples and patterns to help developers write maintainable, testable software.
This article explains how the underscore character in Python can be leveraged for quick console result reuse, selective tuple unpacking, protected and private attribute naming, and numeric readability, providing practical code examples that illustrate each technique for more efficient and readable code.
This article explores Go naming conventions, covering directory, package, and file naming rules, practical examples, community consensus, and personal recommendations to help developers create clear, maintainable project structures.
Effective clean‑code practices require precise, unambiguous naming for variables, methods, classes, and packages, because clear identifiers convey purpose, avoid confusion, simplify maintenance, reduce bugs, and support readability, extensibility, and testability, ultimately preventing technical debt and improving team productivity.
This article presents a comprehensive guide to MySQL table design, covering naming conventions, appropriate data types, primary key strategies, field length choices, logical deletion, common fields, indexing rules, normalization trade‑offs, storage engine selection, time type recommendations, and SQL optimization tips.
This article explains why clean code is essential for productivity and project health, and provides practical guidance on naming, class design, function design, and testing—including SOLID principles, parameter handling, exception use, and test‑driven development—to help developers write maintainable, high‑quality software.
This article explains why clean code matters for productivity and project health, and provides practical guidelines on naming, class design, function design, SOLID principles, testing strategies, and tooling to help developers write maintainable, readable software.
This article explains how to choose consistent, short, and precise names in Go, covering general naming principles, the first rule about declaration‑use distance, CamelCase style, local variables, parameters, return values, receivers, exported identifiers, interface naming, error naming, package naming, import paths, and useful standard‑library examples.
This article explains why clean code is essential for productivity and project health, covering naming conventions, class design, SOLID principles, function design, parameter handling, testing strategies like TDD and the FIRST principles, and tools such as SonarLint to maintain code quality.
Using pinyin in code reduces readability, maintainability, and international collaboration, leading to ambiguity, bugs, and higher maintenance costs, so developers are advised to follow standard naming conventions like meaningful English identifiers, camelCase, and snake_case.
The article explains why maintaining clean code is essential, covering naming conventions, class design, function principles, and testing strategies, and provides concrete Java examples and refactoring techniques to help developers write readable, maintainable, and high‑quality software.
This article explores Go's naming conventions, focusing on the logical use of the “er” and “able” suffixes in interfaces and types, and explains how following these guidelines improves code readability, consistency, and expressive power.
This article provides a comprehensive guide to Java development fundamentals, covering naming conventions, comment quality, class and method definitions, object design patterns, and performance considerations such as immutable types, sealed classes, and the Valhalla project, with practical code examples and best‑practice recommendations.
This guide explains why case‑sensitivity issues arise in databases, how naming conventions can prevent them, and compares the behavior of Snowflake, Databend, MySQL, and PostgreSQL for database, table, column names and string literals, complete with practical examples and a concise checklist.
This article explores the trade‑offs between efficiency, readability and maintainability in software development, presents common naming conventions and best‑practice guidelines for Java, discusses proper use of comments, and introduces advanced language constructs such as records, sealed classes and the upcoming Valhalla project.
This comprehensive guide explains why clean code is crucial for productivity and company health, and provides actionable advice on writing clean code through proper naming, class design, function structuring, and testing practices, illustrated with Java examples and refactoring patterns.
This article explains why maintaining clean, readable code is crucial for team productivity, covering the impact of messy code, practical guidelines for naming, class design, function structure, and testing practices such as TDD and the FIRST principles, all illustrated with real code examples.
This article explains why clean code matters, demonstrates how meaningful naming, single‑responsibility classes, well‑structured functions, and disciplined testing (TDD and the FIRST principles) improve readability, maintainability, and productivity, using concrete Java examples, refactorings, and step‑by‑step guidelines.
This comprehensive guide explores Java naming standards, comment strategies, class and method design, and practical patterns—covering everything from basic conventions to advanced features like sealed classes, value types, and immutable objects—to help developers write more readable, maintainable, and scalable code.
This article explains why clean code is essential for productivity and team collaboration, and provides practical guidelines on naming, class design, function design, and testing—including principles like single responsibility, SOLID, meaningful naming, minimal parameters, and test‑driven development—to help developers produce readable, extensible, and reliable software.
This article explains why clean code is essential for productivity and business health, and provides practical guidelines on naming, class design, function design, and testing—including code examples, refactoring techniques, and quality‑checking tools—to help developers produce readable, maintainable, and extensible software.
This guide outlines a comprehensive data model architecture for data warehouses, detailing layer definitions (ODS, CDM, DWD, DWS, ADS), naming conventions, data type standards, partitioning strategies, redundancy rules, and lifecycle management policies to ensure consistency, performance, and maintainability across big‑data environments.
This article explores essential Java class‑naming conventions, categorizing common suffixes such as Manager, Factory, Provider, and more, providing concrete examples from popular open‑source projects and explaining why consistent naming improves code readability, maintainability, and developer productivity.
This guide walks backend developers through fifteen practical best‑practice tips covering table and column naming, data types, field lengths, primary keys, storage engines, null constraints, foreign keys, indexes, time and monetary fields, character sets, collations, and handling large columns to reduce maintenance costs and avoid common pitfalls.
This article explains why high‑quality front‑end code matters, defines its key attributes such as readability, maintainability, robustness and performance, and provides concrete guidelines on naming, comments, code organization, security, tooling, and e‑commerce front‑end standards to help developers write clean, efficient, and scalable code.
This guide explains why and how to establish a systematic project file and naming convention for design assets, detailing folder hierarchy, naming rules for iterations, slices, components, and other documents, and showing the resulting improvements in collaboration, version control, and hand‑off efficiency.
This article explains that an engineer's primary responsibility is to solve business problems, explores the challenges across a product's lifecycle, outlines software complexity dimensions, and demonstrates how Domain‑Driven Design, strategic and tactical patterns, and modern architectural styles like Hexagonal and CQRS can effectively manage that complexity.
This article explains why clean code is essential for Java projects, covering naming conventions, class design, function responsibilities, testing practices, and tools, and provides concrete examples and refactorings to improve readability, maintainability, and team efficiency.
This article explains why clean code matters and provides practical guidelines on naming, class design, function decomposition, SOLID principles, testing strategies such as TDD and FIRST, as well as tooling like SonarLint to improve code quality and maintainability.
This article explains why clean, well‑structured code is essential for productivity, outlines best practices for naming, class design, function implementation, and testing, and provides concrete examples and refactoring techniques to help developers write maintainable software.
The article explains that naming code elements with pinyin reduces readability, conflicts with established coding conventions, and hampers collaboration, illustrating the drawbacks with examples and summarizing Python's PEP naming guidelines to promote clearer, more maintainable code.
The article explains the importance of clear SQL naming conventions, table and index creation rules, and general syntax guidelines in database DevOps, highlighting developer resistance to audits, the rationale behind each rule, and how tools like Bytebase with VCS integration improve the review experience.
This comprehensive guide outlines front‑end development standards—including naming conventions, technology‑stack choices, programming rules, Git workflow, BFF design, front‑back collaboration, IDE settings, testing strategies, and documentation—to improve code maintainability, team efficiency, and project quality.
Learn how to write readable, maintainable, and reusable methods by applying core design principles such as Single Responsibility, KISS, and DRY, along with practical naming conventions, parameter handling, method size guidelines, and code structuring techniques illustrated with Java examples.
This guide presents comprehensive MySQL naming standards covering database objects, schemas, tables, columns, indexes, views, stored procedures, functions, triggers, constraints, and users, along with design principles for storage engines, character sets, table structures, and SQL query best practices.
This article explains the various meanings of single and double underscores in Python, outlines the five common underscore naming patterns, demonstrates how name mangling works for double‑leading underscores, and shows practical uses of the underscore as a throwaway variable and REPL placeholder.
A developer discovers a nearly 2 GB Java WAR file packed with an old JDK and a game, learns how a careless SVN commit caused deployment nightmares, and later confronts poor coding practices and naming conventions that highlight the need for proper environment setup and rigorous code reviews.
This article introduces Python variables, describing their three components—name, assignment operator, and value—while covering naming rules, common naming conventions such as snake_case, camelCase, and uppercase constants, and explaining the id, type, and value properties with examples.
This comprehensive guide explains data‑warehouse construction standards, covering model architecture principles, public development rules, layer‑by‑layer design specifications, and systematic naming conventions for tables, dimensions, and metrics to ensure consistency, scalability, and reliable data governance.
This article outlines nine practical Python coding habits—including early design, thorough documentation, consistent naming, code aesthetics, comprehensive README, modularization, version control, regular backups, and consulting official documentation—to help developers write clean, readable, and maintainable software.
Choosing the correct boolean property name in JavaBeans—using `success` rather than `isSuccess`—ensures consistent getter/setter generation and avoids mismatched JSON serialization across frameworks like fastjson, Gson, and Jackson, preventing subtle bugs in production environments.
The article explains why readable code matters, shows a messy JavaScript example, lists common readability problems, and provides concrete guidelines—consistent style, meaningful naming, proper comments, small files, shallow nesting—along with tooling tips such as ESLint, Standard Style, husky and lint‑staged to enforce them.
This comprehensive guide explains data‑warehouse construction standards, covering model architecture principles, layered design (ODS, DWD, DWM, DWS, APP), domain division, data‑model design rules, type and naming conventions, table lifecycle management, and practical implementation examples.
Chinese tech giants like Tencent, Alibaba and ByteDance replace titles and real names with English names, nicknames, or “classmate” formats to flatten hierarchy, foster egalitarian communication, boost creativity, and attract talent, reflecting cultural power‑distance dynamics and offering practical naming recommendations for modern management.
This comprehensive guide explains Java naming standards for packages, classes, interfaces, abstract classes, exceptions, methods, variables, constants, enums, generics, and test code, providing clear rules, examples, and best‑practice code snippets to help developers write clean, maintainable code.
The article examines how varied naming conventions and outdated coding practices in Java backend projects cause confusion, illustrates the problem with real code examples, and provides concrete refactoring steps—such as adopting Java 8 date‑time APIs and enforcing consistent service naming—to improve maintainability and team cohesion.
The article explains why naming Boolean fields with the isXXX pattern in Java is discouraged, illustrates correct and incorrect getter/setter conventions with code examples, discusses JavaBeans specifications and RPC serialization issues, and recommends using wrapper types for POJOs while keeping primitives for local variables.
This article provides a comprehensive guide to Java naming conventions, covering package naming, class and interface naming, abstract and exception classes, method and variable naming, constant and enum standards, as well as best‑practice examples and code snippets for each rule.
This article compiles practical guidelines and personal experiences on writing clean, maintainable code, covering principles such as eliminating duplication, separating concerns, unifying abstraction levels, function design, naming, unit testing, and broader software‑engineering concepts to reduce mental load and improve code quality.
This article presents a comprehensive guide to data model architecture, detailing layered data store definitions, classification structures, processing flow, naming conventions, and core design principles to help engineers build scalable, maintainable data warehouses.
This article outlines a comprehensive data model architecture, detailing layered data stores, classification structures, naming conventions, and core modeling principles to guide effective data warehouse design and implementation.
This article provides a comprehensive guide to data model architecture, detailing layered data storage concepts, classification structures, naming conventions, and design principles to help practitioners build consistent, maintainable, and performant data warehouses and analytics platforms.
This article explains typical software version naming schemes, detailing the major.minor.patch.date_stage format, the meaning of each segment, various release stage labels such as Alpha, Beta, RC, and Release, and provides examples of alternative naming practices used by different tools.
This article explains what variables are, why they’re essential in programming, how to define them in Python, the components of a variable, naming conventions, common pitfalls, and demonstrates both camelCase and snake_case styles with code examples, plus a brief note on constants.
This article explains the Java naming conventions for boolean and Boolean fields, why using the isXXX prefix can cause serialization issues in RPC frameworks, and recommends using wrapper types for POJO properties while keeping primitives for local variables.
This article shares Laiye Technology's practical experience with Protobuf and gRPC, covering performance benefits, common pitfalls such as naming and compatibility issues, and the engineering solutions they implemented—including naming conventions, review processes, unified CI compilation, automatic client generation, version tagging, and Swagger documentation—to streamline large‑scale microservice development.
This article explores Python's preference for snake_case naming, comparing it with other conventions, outlining readability and typing advantages, and tracing its historical roots and the language's unique affinity for the underscore character.
This article explains the five underscore naming patterns in Python—single leading, single trailing, double leading, double leading and trailing, and a solitary underscore—detailing their conventions, the name‑mangling mechanism, and how they affect class attributes and imports.
This guide outlines comprehensive MySQL best practices covering naming conventions, table engine and charset choices, field type selection, index design principles, common index column recommendations, ordering of composite indexes, avoidance of redundant and foreign‑key constraints, SQL development rules, and operational guidelines for large‑scale data handling.
This article, translated from Google's testing blog, offers practical guidelines on avoiding overly long identifiers, writing clear and precise commit messages, and linking code changes to defect reports to improve code readability and maintainability across software projects.
This guide presents comprehensive MySQL best‑practice standards covering object naming, basic schema design, field definitions, index design, common index column recommendations, covering indexes, SET usage, SQL development rules, and safe operational behaviors to improve performance, maintainability, and security.
This article presents practical guidelines on avoiding overly long or vague identifiers, writing clear and contextual commit messages, and associating code changes with defect reports to improve code readability, traceability, and overall software development efficiency.
This tutorial explains how to read user input into a variable, print it, handle type conversion for arithmetic, check variable types, convert between types, and follow proper naming rules for Python variables.
This comprehensive guide outlines MySQL database naming conventions, basic design rules, field specifications, index design principles, common index recommendations, and best practices for SQL development and operational behavior to ensure performance, maintainability, and security.
This guide presents comprehensive MySQL best‑practice rules covering object naming conventions, fundamental schema design, field type selection, index creation strategies, and SQL development habits to improve performance, maintainability, and reliability of production databases.
This article presents comprehensive Java coding standards—including naming conventions, Javadoc documentation, and the use of CheckStyle for automated style checking—along with a list of practical development habits to improve code quality, maintainability, and productivity.
The article shares practical clean‑code guidelines for Java developers, covering how code serves as team communication, the importance of clear naming, keeping methods short, reducing nested if/else, extracting try/catch blocks, encapsulating many parameters, and leveraging Lombok and Apache Commons utilities.
The article outlines comprehensive MySQL database standards covering naming conventions, table and column design, index strategies, SQL development practices, and operational guidelines to improve performance, maintainability, and security, including recommendations on data types, character sets, reserved fields, binary data storage, and safe query patterns.
