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.
The article explains the Linux kernel's warning against new typedefs, citing Linus Torvalds' preference for struct usage, coding style guidelines, and practical reasons such as readability and maintainability in a large codebase.
This guide explains Python variable naming rules, lists allowed and prohibited characters, shows legal and illegal examples, recommends snake_case style, advises on meaningful names, and outlines constant naming conventions to help you write clear and maintainable code.
This article presents five practical programming style recommendations—meaningful variable names, consistent indentation, clear comments, short line lengths, and concise functions—explaining why they matter, showing poor examples, and providing improved code snippets to help beginners write more readable, maintainable, and efficient code.
This article compiles fifty practical recommendations for Python developers, covering coding style, function design, module organization, error handling, library usage, design patterns, and internal language mechanisms to help beginners and intermediate programmers write cleaner, more efficient, and safer Python code.
This article shares practical Java coding guidelines—including guard clauses, effective use of Stream API, avoiding nested loops, designing APIs with @see/@link, refined logging, exception handling, custom Spring Boot banners, syntax sugar, chain programming, thread pausing, and tuple usage—to help developers write cleaner, more maintainable code.
This article explains why Python, as an interpreted scripting language, does not require a mandatory main function like compiled languages, clarifies common misconceptions about the __name__ == '__main__' guard, and recommends using a simple main.py entry file for clean, idiomatic code.
This guide presents comprehensive Python coding conventions—including indentation, line length, quoting, blank lines, encoding, import ordering, spacing, line‑break handling, comment styles, docstring rules, and naming standards—providing clear examples and best‑practice recommendations for clean, maintainable code.
This article presents a thorough collection of Python best‑practice recommendations, covering coding style, language features, standard library usage, design patterns, testing, performance profiling, and tooling to help developers write clean, efficient, and maintainable Python code.
This article presents a comprehensive overview of Google’s Java style guide, covering terminology, file naming and encoding, whitespace rules, import ordering, brace placement, indentation, line length, naming conventions, annotations, Javadoc formatting, and practical coding tips to help developers write clean, readable, and maintainable Java code.
This article explains the concept of writing Pythonic code—leveraging Python’s language features for clear, concise, and maintainable programs—by contrasting non‑Pythonic examples with idiomatic solutions, illustrating the Zen of Python, and providing practical tips and references for developers.
This article explains what PEP8 is, outlines key Python coding conventions such as indentation, line length, spacing, comments, imports, and naming, and shows how to automatically apply these standards in Jupyter Notebook using the Autopep8 formatter.
This guide explains why adhering to the Linux kernel coding style matters, introduces automatic tools such as checkpatch.pl, Lindent, and astyle for fixing style violations, and details the core conventions for indentation, line length, brace placement, naming, comments, macros, and other critical aspects of kernel C code.
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 article presents Google’s official Java coding style guide, covering terminology, file naming, source‑file structure, formatting rules such as brace placement, indentation, line length, whitespace, naming conventions, Javadoc standards, and practical programming recommendations to help developers write consistent, readable Java code.
This article explains how to write concise, readable Python code by illustrating eleven practical techniques—such as using dictionary defaults, iterating with iteritems, leveraging implicit boolean checks, and applying set operations—while referencing the Zen of Python, PEP 8, and Google style guidelines.
This article compiles comprehensive shell scripting style guidelines—including shebang usage, commenting standards, parameter validation, variable handling, indentation, naming conventions, encoding, permissions, logging, security, line continuation, efficiency tricks, parallel execution, and integration with tools like shellcheck—to help developers write readable, maintainable, and performant scripts.
This article distills the most practical Python coding conventions into clear principles, minimal guidelines, detailed formatting rules, naming standards, writing tips, and commenting practices to help developers write readable, consistent, and maintainable code.
This article presents a collection of practical Pythonic techniques—including variable swapping, efficient looping, string concatenation, file handling, list operations, destructuring assignment, and comprehensions—illustrated with clear before‑and‑after code examples, helping developers write more concise, readable, and memory‑efficient Python code.
This guide presents concise, practical Python coding conventions—including indentation, naming, line length, import ordering, whitespace, and comment practices—to help developers write readable, maintainable code while allowing flexibility when strict rules hinder clarity.
This article presents ten common Pythonic coding techniques—including variable swapping, efficient loops, enumerate, string joining, context-managed file handling, list comprehensions, decorators, appropriate list usage, sequence unpacking, and dictionary iteration—explaining why they are more readable, memory‑efficient, and idiomatic for Python developers.
This article presents a comprehensive collection of 52 Node.js best‑practice recommendations covering project structure, error handling, coding style, testing, and production, each detailed with concise summaries, risk warnings, and in‑depth explanations, guiding developers toward more reliable and maintainable backend applications.
This article summarizes key principles, formatting rules, naming conventions, documentation practices, and coding conventions from the book “The Elements of Java Style,” providing practical guidance for developers who want to write clean, consistent, and maintainable Java code.
This article gathers subtle yet frequent Python anti‑patterns—misusing range, improper list comprehensions, performance traps, variable leakage, global‑scope misuse, and PEP8 violations—explaining why they occur, their drawbacks, and offering clear, Pythonic alternatives to write more readable and bug‑free code.
This article provides a comprehensive guide to writing maintainable JavaScript, covering coding conventions, variable best practices, error handling techniques, object creation methods, prototype and module patterns, and practical examples to help developers build clean, modular, and loosely‑coupled code.
The article humorously explores nine commonly discouraged programming habits—such as using goto, avoiding documentation, cramming code onto one line, omitting type declarations, and redefining operators—explaining why developers sometimes break rules and how these practices can affect code readability, maintainability, and performance.
This comprehensive guide explains Python coding style best practices, covering PEP 8 extensions, flexible line length, naming conventions, docstring standards, functional versus object‑oriented design, testing, standard library usage, third‑party tools, and project structure to produce readable, maintainable code.
This article shares nine practical PHP tips—from security fundamentals like input filtering and output escaping, to efficient coding tricks such as using ternary operators, caching, and modern frameworks—aimed at helping developers write safer, cleaner, and faster backend code.
