Tagged articles
Code Readability
94 articles · Page 1 of 1
This article explains the four types of Java method references (static, bound instance, arbitrary instance, constructor), their equivalent lambdas, compiler overload resolution, readability trade-offs, and practical examples showing when method references improve clarity versus when lambdas remain preferable.
Best PracticesCode ReadabilityCompiler Overload Resolution
0 likes · 21 min read

The article shows how interleaving multiple data-flow chains in a method forces readers to context-switch, and demonstrates that simply reordering lines to follow each chain sequentially — without changing logic or extracting methods — dramatically improves readability, while explaining why method extraction can backfire when variables are shared across chains.
Clean CodeCode Readabilitycode organization
0 likes · 8 min read

The article argues that using full‑pinyin identifiers for Chinese platform names and domain concepts improves code readability, searchability, and consistency, especially when no standard English term exists, and it illustrates the point with concrete naming examples and snippets.
Chinese platformsCode Readabilitypinyin naming
0 likes · 4 min read

Using clear prefixes like is, has, can, and should for boolean variables improves code readability, while pitfalls such as mixed prefixes, negative naming, vague names like flag, and boolean traps in method parameters can cause confusion; the article offers concrete examples and practical refactoring strategies.
Best PracticesCode Readabilityboolean naming
0 likes · 8 min read

The article analyzes practical technical drawbacks of Chinese identifiers—pinyin ambiguity, input‑method interruptions, encoding issues, and poor ecosystem support—while distinguishing that Chinese comments are acceptable, concluding that English identifiers remain the most efficient communication method for global collaboration.
Chinese identifiersCode Readabilityinternational collaboration
0 likes · 6 min read

This article examines Java's var local‑variable type inference introduced in Java 10, detailing its benefits such as reduced boilerplate, improved readability, and easier refactoring, while also highlighting drawbacks like potential readability loss, ambiguous types, and strict usage constraints that can lead to bugs if misused.
Best PracticesCode ReadabilityJava
0 likes · 26 min read

The article explains how the Composed Method Pattern (CMP) and the Single Level of Abstraction Principle (SLAP) can keep AI‑generated code readable, maintainable, and team‑friendly by structuring entry methods as narratives and ensuring each method stays at a single abstraction level.
AI code generationCMPClean Code
0 likes · 16 min read

A senior architect recounts twelve common coding habits—like over‑splitting services, endless method length, deep nesting, misleading comments, and missing logs—that dramatically reduce code readability and increase maintenance difficulty, illustrating each with vivid examples from a fictional developer.
Code ReadabilityCoding Best Practicesbackend development
0 likes · 13 min read

The article explains that, unlike Python, JavaScript, C, and C++, Go does not support the ternary ?: operator because its designers consider it prone to creating unreadable, complex expressions, preferring the clearer if‑else construct, and it discusses alternatives, pros, cons, and a discouraged custom implementation.
Code ReadabilityGoconditional expression
0 likes · 7 min read

This article explains the importance of comments in Python, describing how they improve code readability for collaborators and future maintenance, and outlines the two comment styles—single‑line with # and multi‑line with triple quotes—along with practical examples.
Code ReadabilityPythoncomments
0 likes · 3 min read

This article explains how named (keyword) arguments improve code readability, eliminate order‑dependency bugs, and work seamlessly with optional parameters, providing clear examples in Python, JavaScript, and C# while comparing them to traditional positional arguments.
Code ReadabilityFunction Parametersnamed arguments
0 likes · 7 min read

This article explains Kotlin's type alias feature, introduces the new nested type alias support in Kotlin 2.2, discusses its benefits, limitations, practical examples, and how to enable it in Gradle or Maven projects, helping developers write more readable and maintainable code.
Code ReadabilityKotlinKotlin 2.2
0 likes · 16 min read

The article humorously chronicles twelve common anti‑patterns—such as over‑splitting microservices, writing massive methods, deep nesting, random naming, misleading comments, copy‑pasting code, ignoring design docs, and avoiding logging—that severely hurt code readability and maintainability, and explains why they should be avoided.
Code Readabilitybad coding practicesrefactoring
0 likes · 10 min read

The author reflects on a paid tutoring session that revealed university C‑language exam questions focused on obscure syntax tricks, argues that such puzzles hinder real programming skill development, and calls for a shift toward readability, problem‑solving, and practical relevance in computer science education.
Code Readabilityc-programmingexam critique
0 likes · 4 min read

This article examines PHP 8.0's named parameters feature, outlining how passing arguments by name improves readability and flexibility, while also discussing potential drawbacks such as learning curve, verbosity, and IDE dependence, and offers practical recommendations for when to adopt this syntax.
API EvolutionBackendBest Practices
0 likes · 6 min read

This article examines why developers often over‑nest and misuse conditional statements, then presents proven techniques—early returns, lookup objects, optional chaining, guard clauses, and state machines—to simplify, improve readability, and make conditional logic more maintainable and scalable.
Code ReadabilityConditional LogicJavaScript
0 likes · 8 min read

Discover the most subtle Python anti‑patterns—from using is for value comparison to overusing map and filter—explaining why they harm readability, performance, or correctness, and learn clear, idiomatic alternatives that make your code cleaner, faster, and more maintainable.
Code ReadabilityPythonanti-patterns
0 likes · 10 min read

This article explains how overusing nested if‑else statements harms code readability and maintainability, and demonstrates how replacing them with early return statements and guard clauses can flatten the structure, reduce cognitive load, and improve testability and future modifications.
Code Readabilityif-elserefactoring
0 likes · 4 min read

This article explains why thoughtful object naming—avoiding generic “er”/“or” suffixes and vague Service/Helper classes—improves code readability, maintainability, and AI‑assisted development, and demonstrates better designs with concrete C# examples that model real‑world business roles and adaptive behavior.
AI-assisted programmingClean CodeCode Readability
0 likes · 12 min read

This article explains why large codebases like Facebook restrict JavaScript arrow functions, detailing issues with this binding, prototype methods, constructor usage, missing arguments object, and readability, and offers practical guidelines for when to use or avoid them.
Arrow FunctionsBest PracticesCode Readability
0 likes · 3 min read

The article argues that mastering code reading—through historical examples, production‑level analysis, and practices like Hungarian notation and readability programming—is essential for developers to thrive in an AI‑driven software era.
AI coding assistantsCode Readabilityprogramming fundamentals
0 likes · 8 min read

This guide explores the versatile underscore '_' in Python, showing how to discard unwanted variables, simplify loops, improve numeric readability, leverage REPL shortcuts, and why using it as a regular variable is discouraged.
Code ReadabilityREPLunderscore
0 likes · 5 min read

Early return is a programming technique that lets functions exit as soon as an invalid condition is found, reducing nested if‑statements, improving readability, maintainability, and performance, as illustrated by comparing a nested‑condition order‑processing function with an early‑return version.
Code ReadabilityEarly Returnfunction design
0 likes · 4 min read

The JavaScript pipeline operator replaces cumbersome temporary variables, nested calls, and limited method chaining by letting developers chain regular, async, or generator functions directly, improving readability and maintainability, while Babel’s proposal‑hack plugin can be installed and configured now to start using it.
BabelCode ReadabilityFrontend Development
0 likes · 3 min read

This document defines comprehensive C language coding standards covering clarity, simplicity, testability, safety, efficiency, and portability, offering concrete principles, rules, and suggestions to guide developers in writing maintainable, reliable, and high‑performance code.
Code Readabilityc-programmingcoding standards
0 likes · 19 min read

This guide introduces three popular monospaced programming fonts—Fira Code, Cascadia Code, and Source Code Pro—explaining their design features, ligature support, visual clarity benefits, and providing download links and GitHub star counts for developers seeking clearer code.
Cascadia CodeCode ReadabilityFira Code
0 likes · 4 min read

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.
Clean CodeCode Readabilitynaming conventions
0 likes · 18 min read


21CTOJun 10, 2024 · Frontend Development
This article explains why choosing a clear, monospaced programming font matters, outlines key selection principles and considerations, and introduces ten free fonts—each with distinctive features and download links—to help developers improve readability and coding efficiency.
Code Readabilityeditor customizationfree fonts
0 likes · 8 min read

Choosing a clear, aesthetically pleasing programming font is essential for developers, and this guide reviews popular monospaced fonts—Monaco, Consolas, Source Code Pro, JetBrains Mono, Fira Code, Cascadia Code, Inconsolata, and Ubuntu Mono—highlighting their readability features and providing download links.
Cascadia CodeCode ReadabilityConsolas
0 likes · 6 min read

The article explains why the Go language deliberately omits the ternary (?:) operator, compares its usage in Python, JavaScript, and C/C++, shows how to rewrite complex ternary expressions with clear if‑else statements, and presents a functional workaround while outlining the pros and cons of ternary syntax.
Code ReadabilityGo Languageconditional expression
0 likes · 7 min read

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.
Code Readabilitymaintainabilitynaming conventions
0 likes · 5 min read

This article explains Python type hints, covering their syntax, benefits for readability and debugging, advanced usage with the typing module, and practical code examples that help developers write more robust and maintainable Python applications.
Code ReadabilityPythonmypy
0 likes · 5 min read

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.
Code ReadabilityGointerface design
0 likes · 4 min read

This article explains why the ternary (?:) operator is missing in Go, compares its usage in other languages, shows how to replace it with if‑else statements or helper functions, and discusses the readability trade‑offs of ternary expressions.
Code Readabilityconditional expressionlanguage design
0 likes · 7 min read

Developers often struggle with Go's standard library because its high abstraction, performance tricks, compatibility concerns, Go's programming paradigm, reliance on documentation, and individual experience levels combine to make the code less intuitive and harder to grasp.
Code ReadabilityGoprogramming
0 likes · 5 min read

The article lists twelve common anti‑patterns—such as splitting microservices per table, writing overly long methods, nesting deep conditionals, random variable names, misleading comments, copy‑pasting code, ignoring logs, and over‑engineering solutions—that dramatically reduce code readability and make maintenance a nightmare.
Code Readabilitybad practicesmicroservices
0 likes · 11 min read

This article compares Java 8 Streams with traditional for‑loops through concrete code examples, benchmark results, parallel‑stream speedups, and discusses scenarios where Streams excel or fall short, helping developers decide when to prefer Streams over loops.
Code ReadabilityJavaParallelStream
0 likes · 10 min read

The article lists twelve common coding anti‑patterns—such as over‑splitting microservices, writing excessively long methods, deep nesting, misleading comments, copying code, ignoring logs, and building unnecessary frameworks—that hurt readability and increase maintenance difficulty.
Best PracticesCode Readabilityrefactoring
0 likes · 11 min read

This article explores the importance of code readability, comparing simple versus layered implementations, and offers concrete strategies—such as using clear intent, hierarchical structure, concise methods, pure conditions, and minimal comments—to improve maintainability and reduce side effects in everyday software development.
Best PracticesClean CodeCode Readability
0 likes · 14 min read

This article explores why code readability matters, compares two implementation styles, outlines three key readability dimensions—plain expression, clear intent, and hierarchical structure—and provides actionable refactoring tips, code‑generation insights, and best‑practice recommendations for developers seeking maintainable, easy‑to‑understand software.
Code Readabilitymaintainabilityrefactoring
0 likes · 14 min read

This article explains PHP7's strong typing features—including parameter, return, and nullable type declarations—through clear code examples, demonstrating how they enhance readability, reduce errors, and improve maintainability for developers working on server-side applications.
Code ReadabilityType Declarationsnullable types
0 likes · 5 min read


21CTOJun 13, 2023 · Fundamentals
This article explains why clear naming is crucial for maintainable software, identifies common pitfalls such as lack of intent, poor thinking, and bad habits, and provides concrete guidelines, examples, and refactorings—especially for Java—to help developers choose expressive, searchable, and consistent identifiers.
Best PracticesCode ReadabilityJava
0 likes · 17 min read


21CTOMay 16, 2023 · Fundamentals
Discover a curated list of seven attractive terminal fonts that enhance visual appeal, improve readability, reduce eye strain, and provide a more enjoyable coding experience for programmers, system administrators, and Linux enthusiasts alike.
CascadiaCode ReadabilityFira Code
0 likes · 5 min read

The article explains why most programming languages forbid variable names that begin with digits, covering the definition of variables, Python's naming rules, human and computer confusion caused by such names, and the impact on code readability and maintainability.
Best PracticesCode Readabilitylexical analysis
0 likes · 4 min read

This article surveys modern front-end engineering topics, covering plugin-based design, AST-driven compilation, sandbox performance tricks, techniques to reduce complex if‑else structures, a single‑div CSS football field demo, and essential insights into automated testing for developers.
ASTCode Readabilityfrontend
0 likes · 4 min read

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.
Best PracticesCode ReadabilityPEP
0 likes · 4 min read

This article explains why Python developers should avoid explicit for loops, demonstrating how list comprehensions, generator expressions, map/reduce, itertools, and function extraction can produce more concise, readable, and maintainable code while reducing indentation and improving structure.
Code ReadabilityPythonfor loop
0 likes · 6 min read

This article explains how avoiding explicit for‑loops in Python encourages the use of advanced, idiomatic constructs such as list comprehensions, generator expressions, functional tools like map and reduce, and the itertools module, resulting in shorter, more readable, and flatter code.
Code Readabilityfunctional programminggenerator
0 likes · 7 min read

The article explores the origin and purpose of the infamous deadbeef constant and other so‑called magic numbers in C/C++ code, explains why they appear, shows real examples, and advises developers to replace them with named constants for clearer, safer code.
C++Code Readabilitymagic numbers
0 likes · 4 min read

This article explains why deeply nested if‑else statements hurt readability and maintenance, then presents five practical techniques—including method extraction, early returns, enums, functional interfaces, and design patterns—along with complete Java code examples to transform messy business logic into clean, modular code.
Code ReadabilityJavadesign patterns
0 likes · 19 min read

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.
Code ReadabilityCoding Best Practicesmodularity
0 likes · 8 min read

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.
Code ReadabilityESLintJavaScript
0 likes · 10 min read

Effective naming in software development, illustrated with real code examples and visual metaphors, transforms ambiguous code into clear, self‑documenting logic, improves readability, reduces errors, and aligns with best practices such as modeling, meaningful differentiation, and consistent style, ultimately enhancing maintainability.
Best PracticesCode Readabilitynaming
0 likes · 17 min read

This article presents practical Python best‑practice guidelines, including avoiding hard‑coded numeric literals by using enums, limiting raw string manipulation in favor of object‑oriented query building, keeping literal expressions readable, and applying useful tips such as treating booleans as numbers, handling long strings, using infinity constants, and understanding thread‑safety and string‑concatenation performance.
Best PracticesCode ReadabilityEnum
0 likes · 16 min read

This article explains the async/await syntax, compares it with traditional Promise chains, and outlines six practical advantages—including conciseness, unified error handling, clearer conditional logic, easier intermediate value handling, better stack traces, and simpler debugging—illustrated with real JavaScript code examples.
Async/AwaitCode ReadabilityDebugging
0 likes · 9 min read

Discover how IntelliJ IDEA’s Font Ligatures feature can transform the standard ‘!=’ operator into the mathematical ‘≠’ symbol, how to toggle this setting via Reader Mode, and why disabling it may improve code readability, with visual examples and a Java code demo.
Code ReadabilityFont LigaturesIDE settings
0 likes · 5 min read


ByteFEJun 24, 2021 · Fundamentals
This article explains practical JavaScript naming conventions—covering camelCase, constant capitalization, acronym handling, meaningful and expressive names, verb consistency, boolean naming, and class naming—while providing numerous code examples to illustrate good and bad practices for clearer, maintainable code.
Code ReadabilityJavaScriptconventions
0 likes · 7 min read

This article explores the core concepts of clean code for JavaScript, covering code smells, technical debt, refactoring, readability, writing code in English, and team collaboration techniques, while providing practical examples and tooling tips for maintaining high‑quality code.
Clean CodeCode Readabilityrefactoring
0 likes · 11 min read

This article discusses common pitfalls in Java code such as string and numeric matching, explains why using raw literals can cause bugs, and demonstrates how to improve readability and maintainability by employing enums, value conversion, and state‑machine patterns for backend development.
BackendBest PracticesCode Readability
0 likes · 8 min read

This article explains the purpose of Python's pass statement, showing how it acts as a null operation for the interpreter while providing developers a convenient placeholder for unfinished code, and why the language includes it unlike many other programming languages.
Code ReadabilityPythonpass statement
0 likes · 8 min read

Effective naming is a critical yet often overlooked aspect of software development that boosts code readability, facilitates communication, reduces cognitive load, and even influences design decisions, as illustrated by real-world examples from Alibaba to POJO, along with practical guidelines for variables, functions, classes, packages, and modules.
Code Readabilityself‑documenting codesoftware design
0 likes · 20 min read

The article explains the concept of syntactic sugar in programming, its benefits for readability and efficiency, describes how Java implements and desugars such features—including the switch‑on‑String transformation—and illustrates the process with code examples and decompiled output.
Code ReadabilityCompilerJava
0 likes · 6 min read

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.
Best PracticesCode ReadabilityES6
0 likes · 7 min read

The article argues that code should primarily be written for human readers, emphasizing principles like KISS and DRY, thoughtful commenting, avoiding TODOs, and the necessity of unit tests, while acknowledging trade‑offs and offering practical guidance for producing maintainable, elegant software.
Clean CodeCode ReadabilityDRY
0 likes · 12 min read

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.
Code Readabilitycommit messagesdefect tracking
0 likes · 6 min read

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.
Best PracticesCode Readabilityinterface design
0 likes · 9 min read

This article explains the four most common misuses of Python lambda functions—replacing built‑in functions, assigning lambdas to variables, improper use of higher‑order functions, and overly complex expressions—and offers best‑practice recommendations to improve code readability and maintainability.
Code Readabilityfunctional programminglambda
0 likes · 9 min read


ITPUBMar 3, 2020 · Fundamentals
The article explains how limiting functions to roughly 24 lines and keeping each line under 80 characters improves code readability, aligns with human memory limits, and works across languages, while offering practical tips, examples, and tooling advice for developers.
80/24 ruleC#Code Readability
0 likes · 6 min read

Good code follows principles of readability, scalability, high cohesion and low coupling, supported by habits like thorough code reviews, purposeful comments, and learning from quality open‑source projects, while developers cultivate abstraction thinking, curiosity, and teamwork to produce reliable, maintainable, and easily extensible software.
Clean CodeCode Readabilitycode review
0 likes · 10 min read

The article outlines essential coding guidelines that emphasize optimizing code for readers rather than authors, keeping rules concise, valuing standards without fanaticism, ensuring consistency, providing clear cues for rare cases, and avoiding clever but hard‑to‑maintain constructs.
Best PracticesCode Readabilitycoding standards
0 likes · 2 min read

This article presents a series of Java function coding guidelines—including using primitive types for parameters and return values, avoiding null arrays or lists, encapsulating many parameters into objects, replacing anonymous inner classes with functions, simplifying control flow, and employing temporary variables—to improve code readability, maintainability, and robustness.
Best PracticesCode ReadabilityJava
0 likes · 19 min read


21CTOAug 28, 2019 · Fundamentals
This article explains why clean code matters—reducing reading time, easing project continuation, speeding up new‑developer onboarding, and supporting consistent coding patterns—and provides six practical tips, from readable formatting to regular code reviews, to help developers produce cleaner, more maintainable software.
Clean CodeCode ReadabilityCoding Best Practices
0 likes · 11 min read

This article distills essential clean‑code practices—covering comments, naming, method design, error handling, concurrency, unit testing, structure, and design—drawn from classic books and real‑world engineering experience to help developers produce elegant, maintainable software.
Best PracticesClean CodeCode Readability
0 likes · 13 min read

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.
Code ReadabilityPythoncoding style
0 likes · 9 min read


21CTODec 5, 2017 · Fundamentals
Learn ten practical techniques—from effective commenting and consistent indentation to avoiding redundant comments, grouping code, naming conventions, applying the DRY principle, limiting nesting and line length, and organizing files—to dramatically improve the readability and maintainability of your code in any project.
Best PracticesCode Readabilitycoding standards
0 likes · 9 min read

This article presents eleven practical tips for writing clear, readable code, covering short methods, single-purpose variables, descriptive naming, proximity of declarations, avoiding magic numbers, respecting language idioms, following conventions, steering clear of premature optimization, refactoring after testing, and using patterns wisely.
Clean CodeCode Readabilityprogramming best practices
0 likes · 9 min read

This article outlines ten crucial Java programming best‑practice rules—ranging from adding comments and avoiding hard‑coding to proper GUI design and unit testing—to help developers write more readable, maintainable, and high‑performance code.
Best PracticesCode Readabilitycoding standards
0 likes · 11 min read


ITPUBApr 26, 2017 · Fundamentals
This article explains why clear, self‑descriptive naming is essential for maintainable code, compares bad and clean naming examples, and offers concrete guidelines on intent‑revealing names, appropriate length, consistent terminology, domain relevance, and contextual clarity.
Best PracticesClean CodeCode Readability
0 likes · 9 min read

This article explains why readable code matters for developers, then offers practical guidelines on naming variables and functions, structuring conditional branches, keeping functions single‑purpose, handling errors, avoiding side‑effects, and organizing class methods to improve maintainability in modern JavaScript projects.
Best PracticesCode ReadabilityJavaScript
0 likes · 24 min read


ITPUBAug 1, 2016 · Fundamentals
This article shares practical guidelines for naming variables, methods, and classes—showing why overly long identifiers hurt readability, how to eliminate redundant words, and offering concrete before‑and‑after code examples to help developers adopt concise, expressive names.
Clean CodeCode Readabilitymethod naming
0 likes · 9 min read


21CTOMar 10, 2016 · Fundamentals
This article explains practical techniques for writing high‑quality functions, covering consistent naming conventions, descriptive function names, optimal parameter handling, clean function bodies, reduced nesting, and other best‑practice tips to improve readability and testability.
Best PracticesCode Readabilityfunction design
0 likes · 13 min read


21CTOFeb 11, 2016 · Fundamentals
The author recounts how strict coding standards at Google transformed his view, showing that uniform indentation, naming, and comment styles dramatically improve code readability, speed up understanding across teams, and outweigh common objections about creativity, flexibility, or perceived waste of time.
Best PracticesCode ReadabilityGoogle
0 likes · 7 min read

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.
Best PracticesCode Readabilitycoding style
0 likes · 22 min read

A developer survey of 4,500 programmers reveals that naming variables, classes, and functions is perceived as the biggest programming challenge, highlighting its impact on code readability, design quality, and maintenance, and underscoring the art and difficulty of choosing concise, meaningful identifiers.
Code ReadabilityDeveloper Surveynaming
0 likes · 6 min read

The article presents a comprehensive philosophy on software development, emphasizing the importance of repeatedly refining code, structuring it elegantly, modularizing with clear functions, avoiding unnecessary comments, and adopting simple, intuitive practices to improve readability and maintainability across any programming language.
Best PracticesCode ReadabilityProgramming Philosophy
0 likes · 27 min read


21CTONov 14, 2015 · Fundamentals
This article explains why clear, self‑describing naming and adherence to coding conventions are essential for readable, maintainable software, illustrating common pitfalls with bad examples and showing improved alternatives that convey intent without relying on comments.
Best PracticesClean CodeCode Readability
0 likes · 8 min read


21CTOOct 19, 2015 · Fundamentals
This guide explains why good naming is essential for maintainable C++ code, presents eight concrete principles—such as being true to the name, avoiding misleading terms, using searchable identifiers, and leveraging meaningful context—and shows bad versus good examples for variables, functions, classes, and constants.
Best PracticesC++Code Readability
0 likes · 8 min read


21CTOOct 16, 2015 · Fundamentals
This article explains the Extract Method refactoring technique, its definition, benefits, and step‑by‑step PHP examples that show how to split a long method into smaller, well‑named methods, improving readability, reusability, and adherence to the Single Responsibility Principle.
Code Readabilityextract-methodrefactoring
0 likes · 10 min read

Formatting SQL statements doesn't speed up execution, but it dramatically enhances readability, maintenance, and development efficiency, making testing easier and reducing errors through clear alias usage, leading commas, and line‑by‑line JOIN placement, as illustrated by practical examples.
Code ReadabilityFormattingSQL
0 likes · 2 min read

The article argues that while performance is important, maintainability is more critical for sustainable software development, illustrating this with anecdotes, common misconceptions about optimization, and practical advice on balancing code readability, caching, and hardware considerations.
CachingCode Readabilitymaintainability
0 likes · 15 min read


21CTOAug 24, 2015 · Fundamentals
This article explains five common types of programming comments that hinder readability—such as self‑promoting tags, outdated code blocks, redundant explanations, irrelevant stories, and lingering TODOs—and offers practical advice on how to avoid them.
Best PracticesCode Readabilitycode comments
0 likes · 7 min read


ITPUBJun 14, 2015 · Fundamentals
A humorous story about a graduate student’s unreadable code illustrates why naming is the toughest programming challenge, and the article then outlines six clear principles—avoiding metaphors, keeping names short, shortening expressions, using active voice, steering clear of jargon, and breaking rules when necessary—to improve code readability and maintainability.
Best PracticesCode Readabilitynaming conventions
0 likes · 4 min read

While C++ enables writing highly performant code, developers should avoid sacrificing code readability and simplicity for marginal speed gains, distinguishing performance from efficiency, focusing optimization on critical sections, and leveraging tools and proper data layout to achieve optimal results without unnecessary complexity.
Code Readabilitysimplicity
0 likes · 6 min read

The article explains how over‑complex mental models, poor translation of semantic ideas into code, inadequate naming, missing design chunks, unclear usage patterns, and lack of smooth model transitions cause code to decay, and offers practical principles such as DDD, SRP, good naming, testing, and reusing existing algorithms to maintain readability.
Code ReadabilityMental ModelsSingle Responsibility Principle
0 likes · 10 min read
