Tagged articles

clean code

151 articles · Page 2 of 2

Feb 19, 2021 · Fundamentals

Mastering Code Smells: Identify and Refactor Common Bad Practices

This guide explains the most frequent code smells—Long Method, Large Class, Duplicated Code, Long Parameter List, Shotgun Surgery, Speculative Generality, and excessive comments—detailing why they harm readability and maintainability, and provides concrete refactoring techniques with Java examples to produce cleaner, more modular software.

SOLIDSoftware Designbest practices

0 likes · 14 min read

Mastering Code Smells: Identify and Refactor Common Bad Practices

Selected Java Interview Questions

Jan 30, 2021 · Fundamentals

Fundamental Programming Principles: KISS, YAGNI, Separation of Concerns, SOLID and More

This article presents a comprehensive overview of essential programming principles—including KISS, YAGNI, separation of concerns, DRY, SOLID, inversion of control, and the scout rule—explaining why each matters and offering practical guidance on how to apply them to write clean, maintainable software.

KISSSOLIDSoftware Design

0 likes · 17 min read

Fundamental Programming Principles: KISS, YAGNI, Separation of Concerns, SOLID and More

Top Architect

Jan 27, 2021 · Fundamentals

Five Ways to Replace If‑Else Statements: From Basics to Advanced Examples

This article presents five practical techniques for eliminating or simplifying if‑else constructs—including removing unnecessary else blocks, using early returns, applying guard clauses, converting branches to dictionary look‑ups, and employing the strategy pattern—illustrated with progressively more complex code examples to improve readability, maintainability, and adherence to solid design principles.

Code Refactoringclean codeif-else

0 likes · 6 min read

Five Ways to Replace If‑Else Statements: From Basics to Advanced Examples

Java Interview Crash Guide

Jan 6, 2021 · Fundamentals

Why Clean Code Matters: Naming, Functions, and Testing Secrets Revealed

This article explores the core principles of clean code—from effective naming and expressive functions to purposeful comments and rigorous testing—illustrating how disciplined practices like meaningful identifiers, single‑responsibility functions, and the FIRST testing criteria can dramatically improve code readability, maintainability, and reliability.

NamingSoftware Engineeringclean code

0 likes · 10 min read

Why Clean Code Matters: Naming, Functions, and Testing Secrets Revealed

macrozheng

Dec 30, 2020 · Fundamentals

How to Spot and Eliminate Common Code Smells for Cleaner, More Maintainable Code

This article explores typical code smells such as long methods, God classes, duplicated code, long parameter lists, shotgun surgery, speculative generality, and excessive comments, explaining why they hinder readability and maintainability, and provides practical refactoring techniques and examples to write cleaner, more understandable code.

clean codecode qualitycode smells

0 likes · 13 min read

How to Spot and Eliminate Common Code Smells for Cleaner, More Maintainable Code

Architect's Tech Stack

Dec 21, 2020 · Fundamentals

Refactoring Principles, Code Smells, and Refactoring Techniques

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.

Object-OrientedSoftware Designbest practices

0 likes · 21 min read

Refactoring Principles, Code Smells, and Refactoring Techniques

21CTO

Nov 26, 2020 · Fundamentals

Why Refactoring Matters: A Practical Guide to Cleaner Code

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.

Software Engineeringbest practicesclean code

0 likes · 13 min read

Why Refactoring Matters: A Practical Guide to Cleaner Code

FunTester

Oct 29, 2020 · Fundamentals

How to Name Variables and Methods for Clean, Maintainable Code

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.

Software Engineeringbest practicesclean code

0 likes · 8 min read

How to Name Variables and Methods for Clean, Maintainable Code

Architecture Digest

Sep 25, 2020 · Fundamentals

Refactoring Principles, Code Smells, and Refactoring Techniques

This article explains refactoring as a disciplined way to improve software structure without altering behavior, outlines common code smells, and presents a comprehensive set of refactoring techniques—including extracting functions, moving features, simplifying conditionals, and reorganizing data—illustrated with Java code examples.

Object-Orientedclean codecode smells

0 likes · 23 min read

Alibaba Cloud Native

Aug 14, 2020 · Fundamentals

Why Clean Code Matters: KISS, DRY, Comments, and Unit Tests

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.

DRYKISSSoftware Engineering

0 likes · 12 min read

Why Clean Code Matters: KISS, DRY, Comments, and Unit Tests

Alibaba Cloud Developer

Jul 30, 2020 · Fundamentals

How to Write Clean, Maintainable Code: 6 Essential Practices

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.

DRYKISSSoftware Engineering

0 likes · 11 min read

How to Write Clean, Maintainable Code: 6 Essential Practices

Programmer DD

May 19, 2020 · Backend Development

30+ Java Refactoring Tricks to Write Cleaner, Faster Code

This article presents a comprehensive collection of Java code‑simplification techniques—from ternary operators and enhanced for‑loops to streams, Optional, design patterns, and aggressive dead‑code removal—showing how each shortcut can reduce boilerplate, improve readability, and boost performance in backend development.

Code Refactoringclean codejava

0 likes · 32 min read

30+ Java Refactoring Tricks to Write Cleaner, Faster Code

Python Programming Learning Circle

Mar 28, 2020 · Fundamentals

Writing Clean Code: Naming, Comments, Functions, and Testing Best Practices

The article explains how to write clean, expressive code by defining dirty versus clean code, presenting expert guidelines on naming, commenting, function design, and testing, and illustrating each point with concrete good and bad code examples.

NamingSoftware Engineeringclean code

0 likes · 11 min read

Writing Clean Code: Naming, Comments, Functions, and Testing Best Practices

iQIYI Technical Product Team

Nov 28, 2019 · Fundamentals

What Makes Good Code? Principles, Practices, and Core Qualities for Developers

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.

Code ReviewSoftware Engineeringclean code

0 likes · 10 min read

What Makes Good Code? Principles, Practices, and Core Qualities for Developers

Liangxu Linux

Nov 9, 2019 · Fundamentals

Mastering Clean Code: Naming, Functions, and Testing Best Practices

This article distills key principles from "Clean Code", covering how expressive naming, well‑structured functions, and disciplined testing together raise code readability, maintainability, and reliability, while providing concrete examples and actionable guidelines for everyday programming.

NamingSoftware Engineeringbest practices

0 likes · 11 min read

Mastering Clean Code: Naming, Functions, and Testing Best Practices

Programmer DD

Sep 23, 2019 · Fundamentals

Mastering SOLID: Real‑World Java Examples for Clean Code

This article explains the nine essential SOLID design principles—why design patterns matter, and how the Open/Closed, Dependency Inversion, Single Responsibility, Law of Demeter, Interface Segregation, Liskov Substitution, and Composition principles can be applied in Java with clear code examples.

Design PatternsOOP principlesSOLID

0 likes · 10 min read

Mastering SOLID: Real‑World Java Examples for Clean Code

Java Backend Technology

Sep 14, 2019 · Fundamentals

Master Code Refactoring: Principles, Smells, and Practical Techniques

This article explains what refactoring is, why and when to apply it, lists common code smells with concrete examples, and provides step‑by‑step techniques for reorganizing functions, moving responsibilities, restructuring data, simplifying conditionals, and improving overall software design.

Object-OrientedSoftware Designclean code

0 likes · 27 min read

Master Code Refactoring: Principles, Smells, and Practical Techniques

Alibaba Cloud Developer

Sep 11, 2019 · Fundamentals

What Makes Code Truly Good? Essential Principles and Practices

This article explores the essential characteristics of clean code, emphasizing high cohesion, low coupling, readability, proper naming, formatting, concise classes and functions, effective comments, error handling, and common code smells, while providing practical guidelines and examples for developers.

Software Designclean codecode quality

0 likes · 11 min read

What Makes Code Truly Good? Essential Principles and Practices

Java Captain

Sep 11, 2019 · Backend Development

Java Function Refactoring Guidelines: Utility Functions, Splitting Large Methods, and Reducing Code Levels

The article presents a comprehensive set of Java coding best‑practice guidelines—including the use of common utility functions, systematic splitting of oversized methods, consistent block‑level structuring, encapsulating similar logic, reducing nesting with early returns, and eliminating unnecessary null checks—to improve code readability, maintainability, and overall software quality.

clean codejava

0 likes · 15 min read

Java Function Refactoring Guidelines: Utility Functions, Splitting Large Methods, and Reducing Code Levels

21CTO

Aug 28, 2019 · Fundamentals

6 Proven Techniques to Write Clean, Maintainable Code

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.

Programming Fundamentalsclean codecode readability

0 likes · 11 min read

6 Proven Techniques to Write Clean, Maintainable Code

Amap Tech

Jul 23, 2019 · Fundamentals

Java Function Refactoring Guidelines and Best Practices

The article outlines Java function refactoring guidelines—using utility methods, splitting large functions, keeping consistent block levels, extracting repeated logic, encapsulating parameter retrieval and conditions, parameterizing interfaces, reducing nesting with early returns, and avoiding unnecessary null checks—to improve code readability, maintainability, and performance.

Code Refactoringbest practicesclean code

0 likes · 15 min read

Java Function Refactoring Guidelines and Best Practices

Java Backend Technology

Mar 10, 2019 · Fundamentals

Mastering Code Refactoring: Principles, Smells, and Practical Techniques

Refactoring transforms messy code into clean, maintainable structures without altering observable behavior, covering principles, common code smells, and step‑by‑step techniques such as extracting functions, moving methods, simplifying conditionals, and reorganizing data, empowering developers to improve design, reduce bugs, and accelerate development.

Software Designbest practicesclean code

0 likes · 26 min read

Mastering Code Refactoring: Principles, Smells, and Practical Techniques

Java Captain

Feb 18, 2019 · Fundamentals

How to Refactor Badly Written Code: Principles, Code Smells, and Refactoring Techniques

This article explains the purpose and principles of refactoring, enumerates common code smells, and provides concrete refactoring techniques—including extracting functions, inlining, moving features, reorganizing data, simplifying conditionals and calls—illustrated with Java code examples.

Software Designclean codecode smells

0 likes · 22 min read

How to Refactor Badly Written Code: Principles, Code Smells, and Refactoring Techniques

Java High-Performance Architecture

Jan 18, 2019 · Fundamentals

Four Simple Clean‑Code Rules That Boost Team Productivity

This article presents four practical clean‑code guidelines—testing every change, keeping functions small, avoiding side effects, and using clear naming—illustrated with JavaScript examples, to help developers write more maintainable, testable, and understandable code.

Software Engineeringbest practicesclean code

0 likes · 7 min read

Four Simple Clean‑Code Rules That Boost Team Productivity

Java Captain

Jul 22, 2018 · Fundamentals

Best Practices for Writing Clean and Maintainable Code

This article summarizes essential clean‑code practices—including commenting, naming, method design, exception handling, concurrency, unit testing, and overall code structure—to help engineers write elegant, readable, and maintainable software.

Code styleSoftware Engineeringclean code

0 likes · 10 min read

Best Practices for Writing Clean and Maintainable Code

21CTO

Jul 18, 2018 · Fundamentals

How to Master Clean Code: Design, Estimation, and Testing Strategies

This article explains how treating software projects as disciplined design processes—using shared language, realistic estimation, systematic system modeling, and test‑first development—helps create clean, maintainable code while avoiding the pitfalls of over‑engineering and rushed delivery.

Software Designclean codeestimation

0 likes · 13 min read

How to Master Clean Code: Design, Estimation, and Testing Strategies

ITPUB

Jul 18, 2018 · Fundamentals

How to Achieve Truly Clean Code: Design, Estimation, and Testing Strategies

This article explores the philosophy of clean code, emphasizing disciplined design, clear domain language, realistic estimation, collaborative system modeling, and test‑first development to produce maintainable, efficient software that meets client needs while avoiding unnecessary complexity.

Software DesignSoftware EngineeringTDD

0 likes · 13 min read

How to Achieve Truly Clean Code: Design, Estimation, and Testing Strategies

Java Backend Technology

Jul 12, 2018 · Fundamentals

How to Write Clean, Readable Code: Practical Tips from the Classics

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.

Software Engineeringbest practicesclean code

0 likes · 13 min read

How to Write Clean, Readable Code: Practical Tips from the Classics

21CTO

Jul 5, 2018 · Fundamentals

When Clean Code Becomes a Burden: Balancing Principles with Humanity

This reflective essay examines how strict adherence to clean‑code principles, TDD, and SOLID can clash with personal well‑being and team dynamics, urging developers to consider empathy, context, and real‑world constraints when applying coding standards.

TDDclean codesoftware craftsmanship

0 likes · 6 min read

When Clean Code Becomes a Burden: Balancing Principles with Humanity

Java Backend Technology

Jun 19, 2018 · Fundamentals

Mastering SOLID and OOP Principles: A Practical Guide for Clean Code

This article summarizes the core object‑oriented design principles—including SOLID, the Law of Demeter, and composition/aggregation reuse—explaining their definitions, analyses, advantages, and real‑world examples to help developers write more maintainable and extensible software.

Design PrinciplesOOPSOLID

0 likes · 19 min read

Mastering SOLID and OOP Principles: A Practical Guide for Clean Code

Qunar Tech Salon

Apr 20, 2018 · Fundamentals

Clean Code Practices and Guidelines for Java Development

This article explains the concept of clean code, why clean code awareness is essential for developers, illustrates common bad‑code patterns with real Java examples, and provides practical guidelines—including formatting, development standards, code‑review rules, Maven conventions, Lombok usage, and refactoring strategies—to help teams write maintainable, readable, and efficient code.

Software Engineeringbest practicesclean code

0 likes · 13 min read

Clean Code Practices and Guidelines for Java Development

ITPUB

Mar 30, 2018 · Fundamentals

5 Simple Principles for Writing Clean, Maintainable Code

The article presents five practical concepts—avoiding overly clever tricks, modularizing with divide‑and‑conquer, keeping code IDE‑friendly, ensuring readability through clear architecture and naming, and minimizing branching—to help developers write clean, maintainable code and boost productivity.

clean codecode qualitymodularization

0 likes · 9 min read

5 Simple Principles for Writing Clean, Maintainable Code

ITFLY8 Architecture Home

Feb 5, 2018 · Fundamentals

How to Eliminate 22 Common Code Smells with Refactoring Techniques

This article enumerates twenty‑two typical code smells—from duplicated code and long methods to speculative generality—and provides concrete refactoring tactics such as Extract Method, Pull Up Method, Introduce Parameter Object, and Move Method to improve design, readability, and maintainability of object‑oriented software.

Object-OrientedSoftware Designclean code

0 likes · 24 min read

How to Eliminate 22 Common Code Smells with Refactoring Techniques

Tencent IMWeb Frontend Team

Dec 16, 2017 · Frontend Development

Master Clean JavaScript: Essential Practices for Modern Frontend Development

This article presents a comprehensive guide to writing clean, maintainable JavaScript by avoiding legacy pitfalls, applying Clean Code principles, leveraging ES6/ES7 features, and using tools like Babel, ESLint, and Prettier to improve code quality and development efficiency.

BabelESLintFunctional Programming

0 likes · 10 min read

Master Clean JavaScript: Essential Practices for Modern Frontend Development

Architecture Digest

Jul 26, 2017 · Fundamentals

11 Tips for Writing Clear and Readable Code

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.

Software Engineeringclean codecode readability

0 likes · 9 min read

11 Tips for Writing Clear and Readable Code

21CTO

Jun 25, 2017 · Fundamentals

Why Refactoring Matters: A Practical Guide to Cleaner Code

This article explains why refactoring is essential for maintaining legacy systems, defines refactoring, outlines when to start and stop, describes the step‑by‑step process, discusses code smells and techniques, and offers resources for mastering clean, maintainable software.

Software Designclean codecode quality

0 likes · 13 min read

Architecture Digest

Jun 25, 2017 · Fundamentals

Why and How to Refactor Code: Principles, Process, and Best Practices

The article explains why refactoring is essential for maintaining and evolving legacy code, defines refactoring, outlines when to start and stop, lists prerequisites, describes a step‑by‑step process with testing and version control, and connects refactoring to design principles and large‑scale systems.

Software DesignSoftware Engineeringclean code

0 likes · 13 min read

Why and How to Refactor Code: Principles, Process, and Best Practices

21CTO

Jun 5, 2017 · Frontend Development

How Classic Writing Rules Can Sharpen Your JavaScript Code Style

This article adapts William Strunk Jr.'s timeless seven writing principles to JavaScript development, showing how functions that do one thing, minimal code, active voice, logical grouping, avoiding spaghetti, feature‑based file organization, and true‑value naming can produce cleaner, more maintainable front‑end code.

Code styleFunctional Programmingbest practices

0 likes · 16 min read

How Classic Writing Rules Can Sharpen Your JavaScript Code Style

ITPUB

Apr 26, 2017 · Fundamentals

How to Write Self‑Descriptive Code: Naming Practices for Clean Code

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.

Software Engineeringbest practicesclean code

0 likes · 9 min read

How to Write Self‑Descriptive Code: Naming Practices for Clean Code

21CTO

Apr 10, 2017 · Fundamentals

When Are Code Comments Truly Necessary? A Deep Dive into Clean Code Practices

This article examines the role of comments in source code, argues that well‑written, transparent code can often eliminate the need for comments, outlines four levels of code quality, provides concrete refactoring examples, and shares practical clean‑code guidelines such as avoiding magic numbers, reducing parameters, and using contract‑style preconditions.

Software Engineeringbest practicesclean code

0 likes · 9 min read

When Are Code Comments Truly Necessary? A Deep Dive into Clean Code Practices

ITPUB

Mar 20, 2017 · Fundamentals

5 Simple Principles to Write Clean, High‑Performance Code

The article presents five practical concepts—avoiding unnecessary uniqueness, modularizing code, separating concerns, enhancing readability, and choosing clear naming—to help developers write bug‑free, efficient, and easily maintainable code that reduces cognitive load and boosts productivity.

Cognitive LoadSoftware Engineeringbest practices

0 likes · 10 min read

5 Simple Principles to Write Clean, High‑Performance Code

Tencent IMWeb Frontend Team

Feb 17, 2017 · Frontend Development

Master Clean JavaScript: Variable & Function Best Practices for Readable Code

This article presents practical JavaScript guidelines for naming variables, structuring functions, and avoiding common pitfalls, illustrating each bad pattern with concise code examples and showing the improved, more readable alternatives to help developers write cleaner, maintainable code.

JavaScriptclean codecoding standards

0 likes · 13 min read

Master Clean JavaScript: Variable & Function Best Practices for Readable Code

Node Underground

Jan 20, 2017 · Frontend Development

Master Clean Code: JavaScript Best Practices for Readable, Maintainable Code

This article presents practical JavaScript clean‑code guidelines—including intention‑revealing naming, single‑purpose functions, pure functions, proper async handling, and linting standards—to help developers write more readable, maintainable, and error‑free code.

JavaScriptNamingbest practices

0 likes · 11 min read

Master Clean Code: JavaScript Best Practices for Readable, Maintainable Code

Meituan Technology Team

Jan 19, 2017 · Fundamentals

Clean Code Practices for Object‑Oriented Development

Clean code for object‑oriented development means writing readable, self‑describing, maintainable software by applying principles such as single responsibility, clear naming, small methods, composition over inheritance, regular code reviews, refactoring, static analysis, and learning from open‑source, ensuring simplicity and collaborative excellence.

Code ReviewDesign PatternsObject-Oriented

0 likes · 20 min read

Clean Code Practices for Object‑Oriented Development

Huawei Cloud Developer Alliance

Sep 13, 2016 · Fundamentals

Four Simple Principles to Write High‑Quality Code Every Time

This article identifies why most code remains low‑quality despite many guidelines and presents four practical principles—single abstraction level, minimized indentation, clear expressions, and effective use of helper classes—that dramatically improve a team's coding standards.

Software Designbest practicesclean code

0 likes · 5 min read

Four Simple Principles to Write High‑Quality Code Every Time

ITPUB

Aug 1, 2016 · Fundamentals

Write Clear, Concise Variable and Method Names: Practical Naming Rules

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

Write Clear, Concise Variable and Method Names: Practical Naming Rules

Architecture Digest

Jul 25, 2016 · Fundamentals

Why Comments Can Be Harmful and How to Adopt a Zero‑Comment Policy

The article argues that comments often degrade code readability, identifies two common comment‑related problems—poor naming and overly long methods—and proposes a zero‑comment approach that relies on accurate naming, short methods, and self‑describing code, illustrated with C# examples.

clean codecode commentscoding standards

0 likes · 7 min read

Why Comments Can Be Harmful and How to Adopt a Zero‑Comment Policy

21CTO

Dec 14, 2015 · Fundamentals

Mastering Clean Code: Practical Tips for Writing Elegant and Maintainable Software

This article shares practical programming philosophy and concrete techniques—such as iterative code refinement, modular design, readable naming, avoiding unnecessary language features, and clear control flow—to help developers consistently produce elegant, maintainable, and bug‑free code.

Code RefactoringModular DesignSoftware Engineering

0 likes · 27 min read

Mastering Clean Code: Practical Tips for Writing Elegant and Maintainable Software

21CTO

Nov 14, 2015 · Fundamentals

How to Write Self‑Describing Code: Naming Best Practices for Clean Code

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.

Software Engineeringbest practicesclean code

0 likes · 8 min read

How to Write Self‑Describing Code: Naming Best Practices for Clean Code

21CTO

Nov 13, 2015 · Fundamentals

How to Write Self‑Describing Code: Naming Best Practices for Clean Code

This article explains why clear, self‑describing naming is essential for professional programmers, illustrates common pitfalls with bad examples, and provides concrete guidelines on intent‑revealing, unambiguous, appropriately‑sized, convention‑compliant, domain‑aware names to improve code readability and collaboration.

Software Engineeringbest practicesclean code

0 likes · 9 min read

21CTO

Oct 19, 2015 · Fundamentals

18 Essential Programming Principles Every Developer Should Follow

This article presents eighteen core programming principles—from DRY and KISS to the Open/Closed and Law of Demeter—that help developers write cleaner, more maintainable code, reduce bugs, and adapt to change effectively.

Software DesignSoftware Engineeringbest practices

0 likes · 8 min read

18 Essential Programming Principles Every Developer Should Follow