Tagged articles
517 articles
Page 3 of 6
Sohu Tech Products
Sohu Tech Products
Aug 2, 2023 · Mobile Development

Recommended Android Studio Plugins for Efficient Development

This article introduces six essential Android Studio plugins—including ADB Idea, ECTranslation, Key Promoter X, Alibaba Java Coding Guidelines, QAPLug, and Save Action—detailing their installation, key features, and how they boost development efficiency, code quality, and debugging for Android developers.

Android StudioMobile DevelopmentPlugins
0 likes · 9 min read
Recommended Android Studio Plugins for Efficient Development
Kuaishou E-commerce Frontend Team
Kuaishou E-commerce Frontend Team
Jul 28, 2023 · Frontend Development

How to Write High‑Quality Front‑End Code: Best Practices and Standards

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.

Securitybest practicescode quality
0 likes · 23 min read
How to Write High‑Quality Front‑End Code: Best Practices and Standards
Su San Talks Tech
Su San Talks Tech
Jul 19, 2023 · Backend Development

25 Essential Tips Every Junior Backend Engineer Should Follow

This article compiles 25 practical recommendations—from writing clear comments and unit tests to handling transactions, optimizing SQL, managing concurrency, and maintaining code quality—to help junior developers avoid common pitfalls and accelerate their growth in backend engineering.

JavaSoftware Engineeringbest practices
0 likes · 22 min read
25 Essential Tips Every Junior Backend Engineer Should Follow
FunTester
FunTester
Jul 18, 2023 · Fundamentals

9 Common Code Smells and How to Fix Them for Cleaner, Safer Software

This article examines nine frequent coding pitfalls—from inconsistent naming and missing comments to poor error handling, hard‑coded values, inadequate testing, over‑optimization, security oversights, and weak version‑control practices—offering concrete refactoring examples and best‑practice recommendations to improve readability, maintainability, and reliability.

SecuritySoftware EngineeringVersion Control
0 likes · 18 min read
9 Common Code Smells and How to Fix Them for Cleaner, Safer Software
Ctrip Technology
Ctrip Technology
Jul 13, 2023 · Backend Development

Refactoring Practices and Strategies for Large‑Scale Microservice Systems

This article outlines the definition, motivations, impact levels, planning, communication, layered design, gray‑release techniques, quality improvement measures, and observability considerations for large‑scale backend refactoring in microservice architectures, drawing on practical experience from Ctrip's end‑to‑end refactoring project.

Software Architecturecode qualityrefactoring
0 likes · 11 min read
Refactoring Practices and Strategies for Large‑Scale Microservice Systems
Top Architect
Top Architect
Jul 10, 2023 · Backend Development

Comprehensive Code Quality Management Practices for Development Teams

This article presents a systematic approach to improving code quality across the software development lifecycle, covering traceability between tasks and commits, early static analysis, efficient code review, disciplined branching strategies, commit‑message enforcement, and fostering a collaborative technical culture.

Code reviewcode qualitycontinuous integration
0 likes · 14 min read
Comprehensive Code Quality Management Practices for Development Teams
Yunxuetang Frontend Team
Yunxuetang Frontend Team
Jun 25, 2023 · Frontend Development

Front‑End Mastery: ChatGPT Pair‑Programming, Clean JavaScript, and UI Metrics

This article curates recent front‑end engineering insights, including a ChatGPT‑driven pair‑programming approach using the driver‑observer model, a rapid 200‑line Vue‑like framework built with AI assistance, practical JavaScript code‑cleanliness techniques, strategies for optimistic UI design, and a lightweight method for measuring user‑experience metrics.

ChatGPTJavaScriptUI design
0 likes · 4 min read
Front‑End Mastery: ChatGPT Pair‑Programming, Clean JavaScript, and UI Metrics
Baidu Intelligent Testing
Baidu Intelligent Testing
Jun 2, 2023 · Fundamentals

Code‑Level Quality Techniques: Architecture, Understanding, Probes, and Applications

This article introduces code‑level quality technologies, covering their background, architectural layers, code understanding methods, probe techniques, coverage metrics, smart unit testing, static analysis, and isolated‑function detection, and explains how these practices improve software robustness and defect‑recall efficiency.

Software EngineeringSoftware Testingcode coverage
0 likes · 16 min read
Code‑Level Quality Techniques: Architecture, Understanding, Probes, and Applications
DaTaobao Tech
DaTaobao Tech
May 31, 2023 · Mobile Development

From Intern to Senior Engineer: Lessons on Writing Quality Android Code

This article shares a senior engineer’s journey from internships to three years at Taobao, offering practical advice on writing readable, high‑performance Android code, mastering design principles, handling performance metrics, and maintaining a growth mindset while contributing to a mobile‑focused tech team.

APMAndroidCareer Growth
0 likes · 13 min read
From Intern to Senior Engineer: Lessons on Writing Quality Android Code
Baidu Tech Salon
Baidu Tech Salon
May 30, 2023 · Fundamentals

Code-Level Quality Techniques: Architecture, Code Understanding, Probes, and Applications

The article outlines a two‑layer architecture for code‑level quality techniques—CodeC for deep code understanding via static analyses and Codeπ for applications such as quality assessment, probes, health monitoring, and defect location—detailing methods like AST parsing, coverage metrics, intelligent unit testing, static analysis, and orphan‑function detection to enhance software robustness.

Software EngineeringSoftware Testingcode instrumentation
0 likes · 16 min read
Code-Level Quality Techniques: Architecture, Code Understanding, Probes, and Applications
Baidu Geek Talk
Baidu Geek Talk
May 30, 2023 · Fundamentals

Unlocking Code‑Level Quality: From Static Analysis to Intelligent Testing

This article introduces code‑level quality technology, outlining its background, a two‑layer architecture for code comprehension and instrumentation, key techniques such as static and dynamic analysis, coverage metrics, intelligent unit testing, rule‑based scanning, and orphan function detection, while previewing deeper future explorations.

Dynamic analysisSoftware Engineeringcode coverage
0 likes · 16 min read
Unlocking Code‑Level Quality: From Static Analysis to Intelligent Testing
Programmer DD
Programmer DD
May 29, 2023 · Fundamentals

Why Mastering Computer Fundamentals Is the Best Investment for Programmers

The author reflects on the enduring value of deep computer fundamentals, emphasizing that solid foundational knowledge—spanning binary arithmetic, memory organization, CPU architecture, and low‑level programming—remains the most rewarding investment for developers seeking to avoid code degradation and excel in their careers.

Learning ResourcesSoftware Engineeringcode quality
0 likes · 4 min read
Why Mastering Computer Fundamentals Is the Best Investment for Programmers
Continuous Delivery 2.0
Continuous Delivery 2.0
May 22, 2023 · Fundamentals

Improving Code Quality: Five Practical Refactoring Techniques for Better Software

This article outlines five practical strategies for improving code quality—including appropriate commenting, limiting function parameter length, avoiding overly long functions, simplifying nested conditionals, and applying design patterns—while emphasizing the importance of refactoring to enhance readability, maintainability, and testability of software.

Design Patternscode qualityrefactoring
0 likes · 10 min read
Improving Code Quality: Five Practical Refactoring Techniques for Better Software
php Courses
php Courses
May 19, 2023 · Backend Development

Eliminating Duplicate and Redundant Code in PHP: Refactoring Techniques

This article explains how to remove duplicate and redundant PHP code by applying refactoring principles such as the DRY rule, using functions and classes, adopting naming conventions, simplifying conditionals, and externalizing configuration, thereby improving readability, maintainability, and performance.

Backend DevelopmentDRYPHP
0 likes · 7 min read
Eliminating Duplicate and Redundant Code in PHP: Refactoring Techniques
Test Development Learning Exchange
Test Development Learning Exchange
May 12, 2023 · Fundamentals

Ten Benefits of Software Testers Writing Code

Writing code empowers software testers by automating test execution, reducing costs, expanding coverage, improving code quality, enhancing skill sets, increasing test case accuracy, shortening test cycles, boosting result reliability, streamlining test management, and accelerating data comparison, ultimately making testing more efficient and reliable.

Software Testingcode qualityefficiency
0 likes · 3 min read
Ten Benefits of Software Testers Writing Code
Alibaba Cloud Developer
Alibaba Cloud Developer
May 8, 2023 · Fundamentals

Transform Spaghetti Code into Clean Architecture with 3 Powerful Patterns

This article redefines what constitutes good code by using a star‑chart analogy, exposing typical spaghetti‑code pitfalls, and introducing three design patterns—Value Object, Side‑Effect‑Free Function, and Intention‑Revealing Interface—to help developers refactor and write maintainable software.

Value Objectcode qualityintention-revealing
0 likes · 13 min read
Transform Spaghetti Code into Clean Architecture with 3 Powerful Patterns
21CTO
21CTO
Apr 16, 2023 · Fundamentals

How to Write High‑Quality Code: From Learning to Refactoring

This article explores how developers can master code quality by adopting a learning mindset, studying exemplary code, applying core programming principles, analyzing real‑world examples such as RocketMQ file‑warming, and finally refactoring code to improve maintainability and performance.

Software Engineeringcode qualitylearning
0 likes · 17 min read
How to Write High‑Quality Code: From Learning to Refactoring
Java Architect Essentials
Java Architect Essentials
Apr 4, 2023 · Backend Development

14 Essential Java Backend Development Practices for Clean and Maintainable Code

This article shares fourteen practical Java backend development habits—including using @ConfigurationProperties, replacing @Autowired with @RequiredArgsConstructor, modularizing code, throwing exceptions instead of returning error flags, minimizing unnecessary database calls, avoiding null returns, reducing if‑else chains, and leveraging IDE features—to help developers write cleaner, more robust, and easier‑to‑maintain code.

Configurationbest practicescode quality
0 likes · 8 min read
14 Essential Java Backend Development Practices for Clean and Maintainable Code
JD Tech
JD Tech
Mar 23, 2023 · Operations

Implementing CI/CD Pipelines: Concepts, Scenarios, and Project Practices

This article explains the author's understanding of CI/CD, outlines several practical scenarios for its implementation—including compilation and deployment, unit testing, code scanning, and full‑link testing—details key steps, benefits, and real‑world applications using tools such as Bamboo, SonarQube, JUnit, and Python‑based automation.

AutomationDevOpsci/cd
0 likes · 13 min read
Implementing CI/CD Pipelines: Concepts, Scenarios, and Project Practices
Continuous Delivery 2.0
Continuous Delivery 2.0
Mar 23, 2023 · Fundamentals

Practical Guidelines for Effective Unit Testing

This article offers pragmatic, engineering‑focused advice on why unit testing matters, what makes a good test, when to write or skip tests, who should write them, and how to structure tests using the classic arrange‑act‑assert pattern.

Software Testingcode qualitytest‑driven development
0 likes · 7 min read
Practical Guidelines for Effective Unit Testing
Python Programming Learning Circle
Python Programming Learning Circle
Mar 22, 2023 · Fundamentals

Characteristics of Good Code and How to Produce It

This article outlines ten essential characteristics of high‑quality code—robustness, efficiency, simplicity, brevity, testability, reusability, portability, observability, operational readiness, and scalability—illustrates common bad‑code examples, and explains how thorough requirement analysis, design, testing, and continuous iteration produce maintainable, reliable software.

Software Engineeringbest practicescode quality
0 likes · 14 min read
Characteristics of Good Code and How to Produce It
IT Services Circle
IT Services Circle
Mar 21, 2023 · Fundamentals

20 Counterproductive Coding Practices (Satirical Guide)

The article humorously lists twenty counterproductive coding “tips” – from using single‑letter variables and omitting comments to writing one‑line code, ignoring errors, creating unused variables, deep nesting, and skipping tests – claiming these practices boost productivity despite harming readability and reliability.

Anti-PatternsJavaScriptcode quality
0 likes · 7 min read
20 Counterproductive Coding Practices (Satirical Guide)
php Courses
php Courses
Mar 14, 2023 · Backend Development

PHP Refactoring Techniques: Naming, Extraction, Early Return, Collections, and Consistency

This article demonstrates practical PHP refactoring techniques—including expressive naming, method extraction, early returns, leveraging Laravel collections, and maintaining code consistency—by showing before-and-after code examples that improve readability, reduce duplication, and simplify logic for backend developers.

Backend DevelopmentLaravelPHP
0 likes · 13 min read
PHP Refactoring Techniques: Naming, Extraction, Early Return, Collections, and Consistency
High Availability Architecture
High Availability Architecture
Mar 14, 2023 · Fundamentals

Refactoring Practices: Improving Code Readability, Reducing Duplication, and Enhancing Maintainability

The article explains the definition of refactoring, why it is essential for development efficiency and risk reduction, and presents concrete refactoring techniques such as removing duplicate code, adding meaningful comments, simplifying complex conditions, extracting methods, and semanticizing fixed rules, all illustrated with real Java code examples.

Software Engineeringbest practicescode quality
0 likes · 15 min read
Refactoring Practices: Improving Code Readability, Reducing Duplication, and Enhancing Maintainability
DataFunSummit
DataFunSummit
Feb 26, 2023 · Backend Development

Common Code Smells and Optimization Practices in Backend Development

This article examines typical code quality issues such as meaningless naming, overly long methods, inefficient batch operations, improper dependency handling, excessive parameters, duplicated logic, and offers concrete refactoring examples and best‑practice guidelines to improve maintainability and performance of backend Java code.

Javabest practicescode quality
0 likes · 14 min read
Common Code Smells and Optimization Practices in Backend Development
Alibaba Cloud Developer
Alibaba Cloud Developer
Feb 23, 2023 · Fundamentals

Why Refactoring Matters: Lessons from "Refactoring" for New Engineers

The article reviews the book “Refactoring: Improving the Design of Existing Code”, explains what refactoring is, why it is essential for maintainability and efficiency, and presents practical techniques—such as removing duplicate code, improving naming, simplifying conditions, and using enums—to help engineers with one‑year experience write cleaner, more maintainable Java code.

JavaSoftware Engineeringclean code
0 likes · 17 min read
Why Refactoring Matters: Lessons from "Refactoring" for New Engineers
Code Ape Tech Column
Code Ape Tech Column
Feb 17, 2023 · Backend Development

45 Essential Java Code Quality Tips and Best Practices

This article presents 45 practical Java coding guidelines covering naming conventions, formatting, commenting, method extraction, error handling, thread safety, design patterns, database access, and many other best‑practice techniques to help developers write cleaner, more maintainable backend code.

best practicescode qualitycoding standards
0 likes · 27 min read
45 Essential Java Code Quality Tips and Best Practices
21CTO
21CTO
Jan 17, 2023 · Fundamentals

Mastering Code Review: Proven Practices to Boost Code Quality and Team Collaboration

This guide explains why code review is essential, outlines practical guidelines for reviewers and submitters, shares real‑world practices from leading companies, and highlights common code smells such as DRY, primitive obsession, lock misuse, and pagination problems, helping teams improve code quality and maintainability.

Code reviewcode qualityrefactoring
0 likes · 20 min read
Mastering Code Review: Proven Practices to Boost Code Quality and Team Collaboration
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 3, 2023 · Fundamentals

Mastering Code Review: Proven Practices to Boost Code Quality and Team Collaboration

This comprehensive guide explains why code review matters, shares real‑world practices from leading companies, outlines concrete steps for submitters and reviewers, warns against common pitfalls like DRY violations and poor pagination, and offers actionable tips to make reviews effective and sustainable.

Code reviewSoftware Engineeringcode quality
0 likes · 19 min read
Mastering Code Review: Proven Practices to Boost Code Quality and Team Collaboration
政采云技术
政采云技术
Dec 22, 2022 · Fundamentals

Understanding Refactoring: Motivation, Standards, and a Practical Java Example

This article explains why refactoring is essential for maintainable code, outlines quality standards such as readability and extensibility, and walks through a concrete Java example that evolves from a monolithic statement method to a clean, modular design using extract method, move method, and replace‑temp‑with‑query techniques.

Javaclean codecode quality
0 likes · 16 min read
Understanding Refactoring: Motivation, Standards, and a Practical Java Example
37 Interactive Technology Team
37 Interactive Technology Team
Dec 2, 2022 · Backend Development

Why Avoid Go’s init() Function? Risks, Testing Issues, and Better Alternatives

This article explains why using Go's init() function is discouraged due to readability, testing complications, and error‑handling limitations, and it offers practical alternatives such as direct variable initialization, custom init functions with sync.Once, and controlled error‑aware initialization patterns.

BackendError HandlingGo
0 likes · 8 min read
Why Avoid Go’s init() Function? Risks, Testing Issues, and Better Alternatives
Ctrip Technology
Ctrip Technology
Nov 29, 2022 · Backend Development

Introducing the Alchemy Code Quality Analysis Platform for Backend Development

The article presents Alchemy, a comprehensive code quality analysis platform that integrates static analysis, unit‑test rule scanning, duplicate‑code detection, custom rule checks, and code search into GitLab CI/CD pipelines, addressing common DevOps challenges and improving backend development efficiency.

Backend DevelopmentDevOpsci/cd
0 likes · 11 min read
Introducing the Alchemy Code Quality Analysis Platform for Backend Development
21CTO
21CTO
Nov 22, 2022 · Fundamentals

How to Define and Evaluate Good Code: Practical Standards for Developers

This article explores what constitutes good code, presenting objective and subjective criteria—from logical clarity and minimal dependencies to readability, documentation, testing, concurrency handling, performance, and maintainability—while offering concrete guidelines and recommended reading for developers seeking to improve code quality.

code qualitymaintainabilityreadability
0 likes · 21 min read
How to Define and Evaluate Good Code: Practical Standards for Developers
政采云技术
政采云技术
Nov 22, 2022 · Operations

How to Automate Code Quality with GitLab CI/CD and SonarQube

This guide explains how to integrate GitLab CI/CD with SonarQube, configure runners, set up SonarQube projects, define quality gates, and embed the pipeline into the development workflow to enforce code‑quality standards automatically.

AutomationDevOpsGitLab CI
0 likes · 11 min read
How to Automate Code Quality with GitLab CI/CD and SonarQube
Programmer DD
Programmer DD
Nov 8, 2022 · Fundamentals

Java Code Quality: Alibaba Guidelines, CheckStyle, PMD, FindBugs, SonarLint

To maintain stable, high‑quality Java services as projects grow, this guide introduces five essential static‑analysis tools—Alibaba Java Coding Guidelines, CheckStyle, PMD, FindBugs, and SonarLint—detailing their installation, core features, usage steps, and how they collectively reduce bugs and improve code standards.

Alibaba guidelinesJavacheckstyle
0 likes · 12 min read
Java Code Quality: Alibaba Guidelines, CheckStyle, PMD, FindBugs, SonarLint
21CTO
21CTO
Nov 6, 2022 · Fundamentals

Why Code Line Count Is a Misleading Metric for Engineer Performance

The article critiques Elon Musk's use of code line counts to measure Twitter engineers, explains why this metric fails to capture true engineering value, and offers practical advice for developers facing layoffs and focusing on high‑impact, low‑code work.

Engineering managementLayoffscode quality
0 likes · 6 min read
Why Code Line Count Is a Misleading Metric for Engineer Performance
Programmer DD
Programmer DD
Oct 27, 2022 · Backend Development

Do Frameworks Really Damage Software Maintainability?

This article examines how adopting software frameworks—especially web frameworks—can undermine long‑term maintainability through control inversion, mismatched goals, design trade‑offs, and hidden costs, while also showing how a decoupled approach can retain benefits without the drawbacks.

BackendSoftware Architecturecode quality
0 likes · 19 min read
Do Frameworks Really Damage Software Maintainability?
Su San Talks Tech
Su San Talks Tech
Oct 25, 2022 · Fundamentals

45 Proven Tips to Write Clean, Maintainable Java Code

This article shares 45 practical techniques—from naming conventions and formatting rules to exception handling, thread safety, and design‑pattern usage—that help developers write clearer, more robust Java code, reduce technical debt, and improve overall software quality.

Software Engineeringbest practicescode quality
0 likes · 30 min read
45 Proven Tips to Write Clean, Maintainable Java Code
Efficient Ops
Efficient Ops
Sep 27, 2022 · Operations

How a Bank’s DevOps Team Boosted Code Quality with Unit Testing and Automation

The article details how China Construction Bank's software development center enhanced code quality and accelerated delivery by integrating unit testing, test‑driven development, mutation testing, automated test code generation, code‑style scanning, and shared template mechanisms within a mature DevOps pipeline.

AutomationCode ScanningDevOps
0 likes · 8 min read
How a Bank’s DevOps Team Boosted Code Quality with Unit Testing and Automation
Xianyu Technology
Xianyu Technology
Sep 6, 2022 · Fundamentals

Effective Unit Testing: Principles, Practices, and Design Guidelines

Effective unit testing—fast, readable, isolated, deterministic, and focused on a single behavior—relies on disciplined design, proper use of test doubles, the test‑pyramid hierarchy, meaningful assertions, continuous code‑review feedback, and mindful coverage, enabling safe refactoring, reduced maintenance cost, and higher confidence in software changes.

Software Testingcode qualitytest automation
0 likes · 15 min read
Effective Unit Testing: Principles, Practices, and Design Guidelines
Qunhe Technology Quality Tech
Qunhe Technology Quality Tech
Aug 25, 2022 · Operations

How We Scaled Litmus CI: From 100 to 2,000 Daily Tasks

This article details how the Litmus code‑quality platform was integrated into a CI pipeline, the performance bottlenecks encountered with Jenkins and Sonar, the systematic optimizations applied—including server redesign, script refactoring, parallel testing, and JVM tuning—and the resulting dramatic reduction in task duration and increase in throughput.

CIDevOpsJenkins
0 likes · 9 min read
How We Scaled Litmus CI: From 100 to 2,000 Daily Tasks
ITPUB
ITPUB
Aug 10, 2022 · Fundamentals

16 Essential Coding Habits Every Developer Should Master

This article compiles sixteen practical coding habits—from self‑testing changes and validating method parameters to handling concurrency, resource cleanup, and cache consistency—providing concrete examples, code snippets, and clear guidelines that help developers avoid common bugs and improve overall software quality.

code qualitycoding habitssoftware development
0 likes · 12 min read
16 Essential Coding Habits Every Developer Should Master
Architecture Breakthrough
Architecture Breakthrough
Jul 18, 2022 · R&D Management

Simplify Your Team’s Work: Practical Code Quality Assurance Strategies

This article explains why technical leaders must establish robust code quality assurance mechanisms—covering static analysis, unit testing, code reviews, defect tracking, automation, and release checks—to reduce manual effort, prevent production issues, and ultimately accelerate delivery while fostering developer growth.

AutomationCode reviewcode quality
0 likes · 8 min read
Simplify Your Team’s Work: Practical Code Quality Assurance Strategies
macrozheng
macrozheng
Jul 8, 2022 · Fundamentals

Why Bad Code Thrives: Lessons from the Trenches

The article reflects on how rushed schedules, misguided management tools, inexperienced developers, and ego‑driven customizations create and perpetuate low‑quality code, urging developers to recognize technical debt, avoid reckless refactoring, and seek realistic project timelines and proper team practices.

Software EngineeringTechnical Debtcode quality
0 likes · 8 min read
Why Bad Code Thrives: Lessons from the Trenches
DaTaobao Tech
DaTaobao Tech
Jul 5, 2022 · Fundamentals

The Art of Cleanliness: Professional Ethics for Software Developers

The article outlines ten ethical principles for software developers—drawn from Robert C. Martin’s *The Art of Cleanliness*—that stress integrity, high-quality code, teamwork, continuous integration, frequent small releases, rigorous testing, proactive maintenance, and lifelong learning to prevent harmful failures in critical systems.

Software Engineeringcode qualitycontinuous integration
0 likes · 13 min read
The Art of Cleanliness: Professional Ethics for Software Developers
ELab Team
ELab Team
Jun 18, 2022 · Frontend Development

Deep Dive into ESLint: How Rules, CLI, and AST Processing Work

This article explains why ESLint is essential for frontend development, details how its rule configuration works, walks through the CLI execution flow, and reveals the internal call stack that parses code into an AST, applies custom rules, and performs auto‑fixes.

ASTCLICustom Rules
0 likes · 15 min read
Deep Dive into ESLint: How Rules, CLI, and AST Processing Work
Python Programming Learning Circle
Python Programming Learning Circle
Jun 5, 2022 · Fundamentals

Ten Essential Characteristics of Good Code and How to Achieve Them

The article outlines ten key traits of high‑quality code—robustness, efficiency, maintainability, brevity, testability, reusability, portability, observability, operational readiness, and scalability—explains why many engineers overlook these standards, provides examples of bad code, and emphasizes the importance of thorough requirement analysis, design, testing, and documentation throughout the software development lifecycle.

best practicescode qualitytesting
0 likes · 14 min read
Ten Essential Characteristics of Good Code and How to Achieve Them
360 Quality & Efficiency
360 Quality & Efficiency
Jun 2, 2022 · Fundamentals

Understanding and Improving Software Testability

The article explains the concept of software testability, outlines controllability and observability factors, discusses cohesion and coupling, suggests practices such as TDD and design patterns, and introduces tools like testability‑explorer and Sonar for measuring and enhancing testability.

CohesionCouplingSoftware Testing
0 likes · 8 min read
Understanding and Improving Software Testability
FunTester
FunTester
May 24, 2022 · Fundamentals

Why Abstract Thinking Is the Key to Scalable Software Design

The article explains how abstract thinking—extracting common traits, ignoring irrelevant details, and managing hierarchical levels—empowers programmers to write more reusable, maintainable code, illustrated with philosophical analogies, OOP examples, and concrete refactoring of type‑casting logic.

abstractioncode qualityobject‑oriented programming
0 likes · 10 min read
Why Abstract Thinking Is the Key to Scalable Software Design
Python Programming Learning Circle
Python Programming Learning Circle
May 21, 2022 · Fundamentals

Best Practices for Writing Conditional Branches in Python

This article explains how to write clear, maintainable conditional branches in Python by avoiding deep nesting, using early returns, encapsulating complex logic, applying De Morgan's law, leveraging custom boolean methods, and employing built‑in functions like all(), any() and else clauses in loops and try statements.

best-practicescode qualityconditional branching
0 likes · 13 min read
Best Practices for Writing Conditional Branches in Python
FunTester
FunTester
May 10, 2022 · Fundamentals

From Code Monkey to Craftsman: Embracing the Engineer’s Craftsmanship Mindset

The article urges seasoned software developers to shift from a productivity‑vs‑quality mindset toward a craftsman approach, emphasizing disciplined code, professional ethics, and societal responsibility as the path to lasting fulfillment and impact beyond the mid‑career crisis.

Career Developmentcode qualityengineering discipline
0 likes · 8 min read
From Code Monkey to Craftsman: Embracing the Engineer’s Craftsmanship Mindset
21CTO
21CTO
Apr 26, 2022 · Fundamentals

Why Software Complexity Grows and How to Tame It: From Tactical Tornadoes to Strategic Design

This article explores the nature of software complexity, its rational and sensory definitions, common symptoms such as change amplification, cognitive load and unknown unknowns, and contrasts tactical programming practices with strategic design approaches to help engineers manage and reduce complexity over time.

architectural patternscode qualitysoftware complexity
0 likes · 21 min read
Why Software Complexity Grows and How to Tame It: From Tactical Tornadoes to Strategic Design
21CTO
21CTO
Apr 25, 2022 · Fundamentals

Why Design Patterns Still Matter: Overcoming Real‑World Code‑Quality Pain Points

The article reflects on a developer's sharing session about design patterns, examines why they are often ignored in complex business scenarios, discusses performance and class‑explosion concerns, team and agile constraints, and offers practical steps to sustain code standards and pattern usage.

Agile DevelopmentDesign PatternsSoftware Engineering
0 likes · 9 min read
Why Design Patterns Still Matter: Overcoming Real‑World Code‑Quality Pain Points
Liangxu Linux
Liangxu Linux
Apr 10, 2022 · Fundamentals

What Makes Code Truly Good? 10 Essential Characteristics Every Engineer Should Master

This article outlines ten key attributes of high‑quality code—robustness, efficiency, simplicity, brevity, testability, reusability, portability, observability, operational readiness, and scalability—while contrasting them with common bad‑code patterns and explaining how solid requirement analysis, system design, testing, and continuous iteration produce truly good software.

Software Engineeringbest practicescode quality
0 likes · 15 min read
What Makes Code Truly Good? 10 Essential Characteristics Every Engineer Should Master
IT Services Circle
IT Services Circle
Apr 9, 2022 · Fundamentals

Using Cppcheck for Static Code Analysis in C/C++ Projects

This article explains why static analysis is essential for C/C++ development, compares compiler warnings with dedicated tools, introduces cppcheck, shows how to install and use it on sample programs, and demonstrates its ability to uncover bugs that compilers often miss.

C++bug detectioncode quality
0 likes · 8 min read
Using Cppcheck for Static Code Analysis in C/C++ Projects
IT Services Circle
IT Services Circle
Mar 27, 2022 · Fundamentals

Understanding Bad Code: Causes, Characteristics, Risks, and Solutions

This article examines why developers produce low‑quality code, describes typical symptoms such as unreadability and excessive nesting, outlines the long‑term costs and risks of bad code, and presents expert‑recommended practices—including code reviews, design documentation, technical debt repayment, and disciplined development processes—to improve code quality.

Code reviewSoftware EngineeringTechnical Debt
0 likes · 12 min read
Understanding Bad Code: Causes, Characteristics, Risks, and Solutions
Wukong Talks Architecture
Wukong Talks Architecture
Mar 25, 2022 · Fundamentals

Good Code Characteristics and How to Achieve High‑Quality Software

The article outlines ten essential characteristics of good code, contrasts them with common bad‑code patterns, and explains how thorough requirement analysis, system design, testing, and operational practices together produce high‑quality software, while also promoting a related book giveaway.

code qualitysoftware designtesting
0 likes · 13 min read
Good Code Characteristics and How to Achieve High‑Quality Software
Programmer DD
Programmer DD
Mar 22, 2022 · Fundamentals

What Makes Code Truly Good? 10 Essential Traits Every Engineer Should Master

The article outlines ten key characteristics of high‑quality code—robustness, efficiency, simplicity, brevity, testability, reusability, portability, observability, operability, and scalability—while contrasting them with common bad‑code examples and emphasizing the importance of thorough analysis, design, testing, and continuous improvement throughout the software development lifecycle.

Software Engineeringcode qualitysoftware design
0 likes · 14 min read
What Makes Code Truly Good? 10 Essential Traits Every Engineer Should Master
MaGe Linux Operations
MaGe Linux Operations
Mar 15, 2022 · Backend Development

How DODB Improved Development Efficiency with Code Metrics & Refactoring

This article presents a detailed case study of the DODB digital operations platform, comparing historical and current code metrics, identifying code, project‑management and developer issues, and outlining standards, tools and refactoring practices that significantly boosted development efficiency.

DevOpsProject Managementcode quality
0 likes · 17 min read
How DODB Improved Development Efficiency with Code Metrics & Refactoring
Alibaba Terminal Technology
Alibaba Terminal Technology
Mar 14, 2022 · Mobile Development

How to Fight Android Engineering Decay: Strategies for Code, Resources, and Modules

This article examines the root causes of engineering decay in large Android apps, breaks down the problem into configuration, manifest, Java code, resources, and native libraries, and presents a comprehensive governance framework that combines people‑centric practices, process‑driven gates, and tooling to detect and remediate decay across modules.

AndroidBuild ProcessEngineering Decay
0 likes · 22 min read
How to Fight Android Engineering Decay: Strategies for Code, Resources, and Modules
DevOps
DevOps
Mar 8, 2022 · Fundamentals

Understanding Technical Debt: Classification, Impact, and Mitigation Strategies

The article explains the origins and four quadrants of technical debt, outlines its detrimental effects on software quality and maintainability, and offers practical approaches—including daily debt management, clear technical standards, continuous technology monitoring, visualization, and sustained investment—to identify, prioritize, and reduce technical debt in development teams.

Software ArchitectureTechnical Debtcode quality
0 likes · 10 min read
Understanding Technical Debt: Classification, Impact, and Mitigation Strategies
21CTO
21CTO
Mar 7, 2022 · Fundamentals

10 Must‑Have JetBrains IDE Extensions to Tackle Technical Debt

Discover ten JetBrains IDE extensions that help developers reduce technical debt by improving code refactoring, issue tracking, static analysis, security scanning, and overall code quality across Java, Kotlin, and many other languages.

IDE ExtensionsJetBrainsTechnical Debt
0 likes · 7 min read
10 Must‑Have JetBrains IDE Extensions to Tackle Technical Debt
Taobao Frontend Technology
Taobao Frontend Technology
Mar 1, 2022 · Frontend Development

How Taobao Transformed Its Store Builder with TypeScript: Lessons & Best Practices

This article details Taobao's front‑end engineer Lin Weixuan's experience migrating the massive store‑decoration codebase to TypeScript, establishing development and engineering standards, optimizing compiler performance, and exploring advanced type programming and tooling to improve code quality and stability.

Utility Typescode qualitycompiler api
0 likes · 40 min read
How Taobao Transformed Its Store Builder with TypeScript: Lessons & Best Practices
Java Interview Crash Guide
Java Interview Crash Guide
Feb 17, 2022 · Backend Development

Boost Your Java Backend: Practical Coding Habits and Best Practices

This article shares a collection of practical Java backend coding habits—from using @ConfigurationProperties and @RequiredArgsConstructor, to modularizing code, handling exceptions, minimizing database queries, managing thread pools, naming caches, applying design patterns, and leveraging asynchronous tasks—to improve code quality and performance.

Javacode qualitythread pool
0 likes · 11 min read
Boost Your Java Backend: Practical Coding Habits and Best Practices
Selected Java Interview Questions
Selected Java Interview Questions
Feb 16, 2022 · Backend Development

Java Backend Development Best Practices and Tips

This article presents a collection of practical Java backend development guidelines, covering configuration management with @ConfigurationProperties, constructor injection via @RequiredArgsConstructor, code modularization, exception handling, database query reduction, null avoidance, strategic use of design patterns, IDE assistance, source code reading, and fundamental coding techniques such as map traversal and collection choice.

Configurationbest practicescode quality
0 likes · 7 min read
Java Backend Development Best Practices and Tips
Architecture Digest
Architecture Digest
Feb 15, 2022 · Fundamentals

Principles of Clean Code: Naming, Functions, and Testing

This article distills key lessons from the book "Clean Code", covering expressive naming, purposeful functions, minimal and meaningful comments, and rigorous testing practices, illustrated with concrete code examples to help developers write more readable and maintainable software.

clean codecode qualityfunctions
0 likes · 10 min read
Principles of Clean Code: Naming, Functions, and Testing
IT Services Circle
IT Services Circle
Feb 14, 2022 · Backend Development

20 Common Coding Pitfalls and How to Avoid Them

This article lists twenty typical coding mistakes that developers often encounter, such as poor formatting, unclear naming, duplicated code, long methods, excessive nesting, hard‑coded values, improper logging, and missing tests, and provides practical refactoring techniques and best‑practice recommendations to improve code quality and maintainability.

Javacode qualitycoding best practices
0 likes · 32 min read
20 Common Coding Pitfalls and How to Avoid Them
Su San Talks Tech
Su San Talks Tech
Feb 8, 2022 · Fundamentals

20 Code Smells That Drive Developers Crazy (And How to Fix Them)

This article explores twenty common coding pitfalls—from poor formatting and meaningless naming to deep nesting, hard‑coding, and missing unit tests—offering practical refactoring tips, design‑pattern solutions, and best‑practice guidelines to improve code readability, maintainability, and performance.

JavaSoftware Engineeringbest practices
0 likes · 38 min read
20 Code Smells That Drive Developers Crazy (And How to Fix Them)
dbaplus Community
dbaplus Community
Feb 4, 2022 · Fundamentals

20 Bad Programmer Habits to Avoid for a Stronger Career

This article outlines twenty common bad habits of programmers—from inconsistent terminology and poor documentation to neglecting official docs and inadequate testing—explaining why they hinder growth and offering concrete advice on how to develop professional coding, communication, and teamwork skills.

Software Engineeringcode qualitycommunication
0 likes · 10 min read
20 Bad Programmer Habits to Avoid for a Stronger Career
Tencent Cloud Developer
Tencent Cloud Developer
Jan 18, 2022 · Frontend Development

Writing Reusable Code: Principles and Practices for Front-End Development

Writing reusable front‑end code means identifying and extracting repeatable UI components, centralized API request/response handling, common business‑flow logic, shared state management, and utility functions into separate, modular files or libraries, which reduces duplication, eases maintenance, and improves scalability across similar scenarios.

ReactVuecode quality
0 likes · 7 min read
Writing Reusable Code: Principles and Practices for Front-End Development
Java Backend Technology
Java Backend Technology
Jan 16, 2022 · Backend Development

Write Maintainable, High‑Performance Backend Code: Standards, Design Patterns & Optimization Tips

This article presents a comprehensive guide to building maintainable, extensible backend systems by covering coding conventions, branch naming, commit messages, comment standards, result‑wrapping patterns, database normalization, algorithmic improvements, concurrency handling, service layering, and practical code examples.

BackendDatabase designcode quality
0 likes · 20 min read
Write Maintainable, High‑Performance Backend Code: Standards, Design Patterns & Optimization Tips
Java High-Performance Architecture
Java High-Performance Architecture
Jan 14, 2022 · Fundamentals

30 Hilariously Bad Code Snippets Every Developer Should Avoid

The article humorously showcases a collection of the worst code snippets ever written, illustrating common pitfalls such as reinventing the wheel, magic numbers, unreadable variable names, misuse of booleans, and overly complex switch statements, while reminding developers that everyone writes imperfect code at times.

bad codecode qualitycoding mistakes
0 likes · 5 min read
30 Hilariously Bad Code Snippets Every Developer Should Avoid
Architecture Digest
Architecture Digest
Jan 6, 2022 · Fundamentals

A Collection of the Worst Code Snippets: Lessons from Bad Code

This article humorously showcases a curated collection of notoriously bad code snippets, illustrating common pitfalls such as misuse of boolean logic, magic numbers, poorly named variables, and overly complex switch statements, while encouraging developers to reflect on and improve their coding practices.

bad codecode qualitycoding fundamentals
0 likes · 8 min read
A Collection of the Worst Code Snippets: Lessons from Bad Code
Java Backend Technology
Java Backend Technology
Jan 6, 2022 · Backend Development

Boost Your Java Productivity: 15 Must-Have IntelliJ IDEA Plugins

This guide presents fifteen essential IntelliJ IDEA plugins—from code completion and shortcut hints to code quality checks and live templates—that dramatically streamline Java development, improve code readability, enforce standards, and boost overall productivity for developers.

IDE pluginsIntelliJ IDEAJava
0 likes · 6 min read
Boost Your Java Productivity: 15 Must-Have IntelliJ IDEA Plugins
dbaplus Community
dbaplus Community
Jan 1, 2022 · Fundamentals

10 Essential Habits Every Programmer Should Adopt

This article outlines ten practical habits for developers, from relying on official documentation and thorough testing before delivery to effective logging, mastering Git, prioritizing functional implementation over premature optimization, managing requirements, proactively solving project issues, allocating buffer time, hands‑on learning, and improving English for technical growth.

Gitcode qualityprogramming habits
0 likes · 8 min read
10 Essential Habits Every Programmer Should Adopt
Tencent Cloud Developer
Tencent Cloud Developer
Dec 30, 2021 · Frontend Development

How to Write Robust Front-End Code: Practices and Techniques

Writing robust front‑end code involves systematic exception handling, thorough input validation, disciplined code‑style practices such as default cases and optional chaining, careful selection of mature third‑party libraries, and proactive robustness testing like monkey testing to ensure the UI remains functional under unexpected conditions.

JavaScriptRobustnessbest practices
0 likes · 8 min read
How to Write Robust Front-End Code: Practices and Techniques
Efficient Ops
Efficient Ops
Dec 16, 2021 · Operations

Essential Shell Script Coding Standards for Reliable Maintenance

This guide outlines comprehensive shell scripting standards—including why they matter, core principles, file naming, encoding, line length, indentation, naming conventions, comment rules, error handling, and best‑practice patterns—to improve readability, maintainability, and consistency across Bash scripts in production environments.

BashShell scriptingcode quality
0 likes · 25 min read
Essential Shell Script Coding Standards for Reliable Maintenance
Tencent Cloud Developer
Tencent Cloud Developer
Dec 6, 2021 · Fundamentals

Improving Code Quality: Methods, Priorities, and Stages

The article explains why high‑quality code boosts product and developer success, lists practical practices such as style standards, meaningful naming, testing, CI, reviews and pair programming, and recommends tackling improvements in three stages—first delivering business functionality, then enhancing readability, and finally reducing complexity.

Code reviewSoftware Engineeringbest practices
0 likes · 5 min read
Improving Code Quality: Methods, Priorities, and Stages
Selected Java Interview Questions
Selected Java Interview Questions
Nov 25, 2021 · Frontend Development

Refactoring Examples for Common Business Scenarios: From Callback Hell to Promise.all and Pure Functions

This article demonstrates how to refactor tangled asynchronous request chains and complex if‑else logic in JavaScript by replacing callback hell with Promise.all and async/await, extracting pure helper functions, and applying best‑practice principles to improve readability, testability, and maintainability.

JavaScriptPromisePure Functions
0 likes · 11 min read
Refactoring Examples for Common Business Scenarios: From Callback Hell to Promise.all and Pure Functions
macrozheng
macrozheng
Oct 31, 2021 · Fundamentals

20 Bad Programmer Habits to Avoid for a Successful Career

This article lists twenty common bad habits of programmers—from inconsistent terminology and poor documentation to neglecting testing and teamwork—explaining why each harms productivity and offering concrete advice on how to develop professional coding practices.

Career DevelopmentSoftware Engineeringcode quality
0 likes · 8 min read
20 Bad Programmer Habits to Avoid for a Successful Career
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 30, 2021 · Fundamentals

20 Bad Habits of Programmers and How to Overcome Them

The article outlines twenty common bad habits of programmers—from inconsistent terminology and poor documentation to neglecting official resources and teamwork—explaining why each is detrimental and offering practical advice for cultivating professional competence and collaborative success.

Software Engineeringcode qualityprofessional development
0 likes · 10 min read
20 Bad Habits of Programmers and How to Overcome Them
Baidu App Technology
Baidu App Technology
Oct 25, 2021 · Fundamentals

Becoming a True Software Engineer: Reflections on China's Software Industry Development

Reflecting on China’s Programmer’s Day, the author argues that moving from mere developers to true software engineers—by mastering engineering principles, design, project management, and open‑source culture—is essential for upgrading the nation’s 4 million‑strong software workforce and overcoming low‑quality, involutionary development.

China software industryProject ManagementSoftware Engineering
0 likes · 5 min read
Becoming a True Software Engineer: Reflections on China's Software Industry Development
Selected Java Interview Questions
Selected Java Interview Questions
Oct 10, 2021 · Fundamentals

Using SonarLint and SonarQube for Java Code Quality Analysis

This guide introduces SonarLint and SonarQube, explains how to install and configure them for Java projects, demonstrates scanning with Maven, and provides additional resources such as Alibaba Java coding conventions and documentation links, helping developers improve code quality and maintainability.

JavaSonarQubecode quality
0 likes · 5 min read
Using SonarLint and SonarQube for Java Code Quality Analysis
21CTO
21CTO
Sep 26, 2021 · Fundamentals

10 Red Flags That Reveal a Senior Developer Who’s Not Worth Your Time

This article shares ten common behaviors that indicate a seasoned programmer may lack real skill, explains why these habits hurt teams, and offers practical advice on how to recognize and help such developers become more effective contributors.

career advicecode qualityprogrammer habits
0 likes · 11 min read
10 Red Flags That Reveal a Senior Developer Who’s Not Worth Your Time
Java Architect Essentials
Java Architect Essentials
Sep 25, 2021 · Fundamentals

Why Long Classes Are Problematic and How to Refactor Them

The article explains why excessively long classes violate design principles, cause readability and maintenance issues, and provides step‑by‑step refactoring techniques using IntelliJ IDEA to extract methods, move members, and split responsibilities for cleaner, more maintainable code.

IDEAcode qualityrefactoring
0 likes · 9 min read
Why Long Classes Are Problematic and How to Refactor Them
Java Architect Essentials
Java Architect Essentials
Sep 21, 2021 · Fundamentals

Coding Standards and Best Practices for Robust Software Development

This article presents a set of coding "military rules" covering topics such as avoiding magic numbers, limiting method parameters, proper resource release, specific exception handling, and precise arithmetic, followed by practical development efficiency tips and resource links for further learning.

Exception HandlingResource ManagementSoftware Engineering
0 likes · 9 min read
Coding Standards and Best Practices for Robust Software Development