BestHub
Sign in
Tagged articles
72 articles
Page 1 of 1
Woodpecker Software Testing
Woodpecker Software Testing
Jan 5, 2026 · Backend Development

Five Core Dimensions of Maintainability Testing for Microservice Systems

This article presents a detailed, step‑by‑step guide to maintainability testing, defining five core dimensions—modularization, reusability, analysability, modifiability, and testability—along with their metrics, a relationship model, a comprehensive microservice e‑shop case study, concrete test scenarios, code examples, and best‑practice recommendations for improving software quality and delivery speed.

DevOpsMicroservicesarchitecture
0 likes · 20 min read
Five Core Dimensions of Maintainability Testing for Microservice Systems
Liangxu Linux
Liangxu Linux
Oct 28, 2025 · Fundamentals

Why the Linux Kernel Discourages Using typedef

The article explains the Linux kernel's warning against new typedefs, citing Linus Torvalds' preference for struct usage, coding style guidelines, and practical reasons such as readability and maintainability in a large codebase.

C programmingLinux kernelcoding style
0 likes · 4 min read
Why the Linux Kernel Discourages Using typedef
JavaScript
JavaScript
Oct 9, 2025 · Frontend Development

Why You Should Rethink Using ‘else’ in JavaScript: Embrace Guard Clauses

Modern JavaScript style guides increasingly recommend avoiding deep if…else chains by using guard clauses and early returns, a practice that flattens code, reduces cognitive load, separates concerns, improves maintainability, and encourages expressive data structures, while still allowing simple cases where if…else remains appropriate.

Early ReturnJavaScriptcode style
0 likes · 7 min read
Why You Should Rethink Using ‘else’ in JavaScript: Embrace Guard Clauses
php Courses
php Courses
Sep 29, 2025 · Backend Development

How to Build Maintainable ThinkPHP Apps: Proven Best Practices

This article outlines essential best‑practice guidelines for developing maintainable ThinkPHP applications, covering framework principles, directory organization, naming standards, error handling, caching, performance tuning, test‑driven development, and effective team collaboration with version control.

Backend DevelopmentPHPThinkPHP
0 likes · 4 min read
How to Build Maintainable ThinkPHP Apps: Proven Best Practices
Liangxu Linux
Liangxu Linux
Jun 15, 2025 · Fundamentals

Functional vs Imperative Programming in Embedded Systems: Which Wins?

This article compares functional and imperative (non‑functional) programming approaches for embedded applications, examining testability, maintainability, performance, and resource usage, and provides concrete C code examples illustrating each paradigm’s trade‑offs, helping developers choose the right style for their constraints.

Cembedded systemsfunctional programming
0 likes · 8 min read
Functional vs Imperative Programming in Embedded Systems: Which Wins?
Continuous Delivery 2.0
Continuous Delivery 2.0
May 21, 2025 · Fundamentals

What Makes Code Good or Bad? Practical Standards for Maintainable Software

The article defines good code as functional and easy to modify, explains why focusing on maintainability and simplicity beats fast but fragile development, lists common signs of bad code, and offers concrete practices like small modules, clear naming, and test‑driven development to boost productivity.

Software EngineeringTDDbest practices
0 likes · 4 min read
What Makes Code Good or Bad? Practical Standards for Maintainable Software
Continuous Delivery 2.0
Continuous Delivery 2.0
May 8, 2025 · Fundamentals

Deep Analysis of Code Health: Standards, Efficiency Impact, Readability, and Practical Practices

This article, based on Dave Farley's video, defines bad code by two fundamental criteria, explains how high‑quality code boosts development speed by 44% according to DORA research, explores deep aspects of readability, and offers concrete practices such as TDD, modular design, clear naming, and complexity control.

Software Engineeringcode qualitymaintainability
0 likes · 4 min read
Deep Analysis of Code Health: Standards, Efficiency Impact, Readability, and Practical Practices
Continuous Delivery 2.0
Continuous Delivery 2.0
May 7, 2025 · Fundamentals

Understanding Code Smells: Module, Function, and Implementation Level Issues

This article explains how Tencent evaluates code quality at module, function, and implementation levels, describing common code smells such as low cohesion, God classes, developer congestion, God functions, DRY violations, nested complexity, and Bumpy Road, and emphasizes the importance of identifying and fixing these issues to improve maintainability and team efficiency.

Software Engineeringbest practicescode quality
0 likes · 5 min read
Understanding Code Smells: Module, Function, and Implementation Level Issues
Liangxu Linux
Liangxu Linux
May 2, 2025 · Fundamentals

5 Essential Coding Style Tips Every Beginner Should Master

This article presents five practical programming style recommendations—meaningful variable names, consistent indentation, clear comments, short line lengths, and concise functions—explaining why they matter, showing poor examples, and providing improved code snippets to help beginners write more readable, maintainable, and efficient code.

best practicescoding stylemaintainability
0 likes · 6 min read
5 Essential Coding Style Tips Every Beginner Should Master
Xiaokun's Architecture Exploration Notes
Xiaokun's Architecture Exploration Notes
Mar 9, 2025 · Fundamentals

Unveiling Complete Data Flow Systems: Architecture, Reliability, and Scalability

This article explains how modern data‑intensive applications are built, detailing a complete data‑flow architecture—from API requests, caching, database queries, change capture, search indexing, and message queues—to core system concerns such as reliability, scalability, and maintainability, offering practical insights for architects.

Data FlowReliabilityScalability
0 likes · 10 min read
Unveiling Complete Data Flow Systems: Architecture, Reliability, and Scalability
Liangxu Linux
Liangxu Linux
Jan 26, 2025 · Fundamentals

Essential C Coding Standards for Clear, Safe, and Maintainable Code

This guide outlines comprehensive C programming conventions—including clear naming, header file rules, function design, variable handling, macro usage, quality assurance, safety, and testing—to help developers write readable, reliable, and maintainable code.

Safetymaintainability
0 likes · 29 min read
Essential C Coding Standards for Clear, Safe, and Maintainable Code
JD Tech Talk
JD Tech Talk
Dec 31, 2024 · R&D Management

Why Code Reviews Fail and How to Master Effective CR Practices

This comprehensive guide explains the importance of thorough code reviews, outlines common pitfalls that make codebases hard to maintain, and provides practical principles, checklists, automation tips, scaling guidelines, clean‑code traits, naming conventions, and solutions to typical challenges such as conflicts, time pressure, and legacy baggage, helping teams improve code quality and development efficiency.

Code reviewSoftware Engineeringbest practices
0 likes · 22 min read
Why Code Reviews Fail and How to Master Effective CR Practices
Full-Stack Cultivation Path
Full-Stack Cultivation Path
Dec 31, 2024 · Fundamentals

Unlocking Code Quality: A 17k‑Word Deep Dive into Code Maintainability

This comprehensive guide explains what code maintainability means, why it matters for long‑term project health, and how to measure and improve it using concrete metrics such as naming conventions, comment density, code volume, logical line count, cyclomatic complexity, similarity, redundancy, and module dependencies, with practical examples and tool recommendations for JavaScript front‑end development.

ESLintJavaScriptcode metrics
0 likes · 50 min read
Unlocking Code Quality: A 17k‑Word Deep Dive into Code Maintainability
Java Tech Enthusiast
Java Tech Enthusiast
Jul 30, 2024 · Fundamentals

Best Practices for Clean Code Naming and Structure

Clean code demands readable, extensible structures and precise, unambiguous naming—each class, method, and variable should convey a single responsibility, avoid duplication, and follow consistent conventions, enabling easy testing, maintenance, and team collaboration while preventing the productivity‑draining chaos of poorly named, tangled code.

Software Engineeringbest practicesclean code
0 likes · 18 min read
Best Practices for Clean Code Naming and Structure
Liangxu Linux
Liangxu Linux
May 2, 2024 · Fundamentals

Why Using Pinyin for Variable Names Hurts Code Readability

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.

Software Engineeringcode readabilitymaintainability
0 likes · 5 min read
Why Using Pinyin for Variable Names Hurts Code Readability
php Courses
php Courses
Nov 25, 2023 · Backend Development

Best Practices for Writing Maintainable ThinkPHP Applications

This article outlines key guidelines for developing maintainable ThinkPHP applications, covering framework design principles, directory structure, naming conventions, error handling, caching, performance optimization, test‑driven development, and effective team collaboration with version control.

BackendThinkPHPcaching
0 likes · 5 min read
Best Practices for Writing Maintainable ThinkPHP Applications
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 17, 2023 · Fundamentals

Common Misconceptions in Architecture Design and Its Real Purpose, Illustrated with a Simple Complexity Analysis Case

The article explains common misconceptions about architecture design, outlines its true goals such as maintainability, scalability, reliability, and security, and demonstrates these principles through a detailed student‑management system case study that highlights complexity analysis and practical design decisions.

ReliabilityScalabilitySecurity
0 likes · 12 min read
Common Misconceptions in Architecture Design and Its Real Purpose, Illustrated with a Simple Complexity Analysis Case
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 16, 2023 · Fundamentals

How to Boost Code Readability: Practical Tips and Refactoring Strategies

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.

Software Engineeringcode readabilitymaintainability
0 likes · 14 min read
How to Boost Code Readability: Practical Tips and Refactoring Strategies
High Availability Architecture
High Availability Architecture
Aug 22, 2023 · Backend Development

Practical Tips for Improving Interface Maintainability in Software Development

This article presents a series of concrete, experience‑driven recommendations—such as embedding documentation links in code comments, publishing source to private repositories, defining constants in parameter classes, handling Map payloads with typed objects, simplifying dependencies, and logging raw request/response data—to enhance the maintainability of backend interfaces throughout the software lifecycle.

API documentationBackend DevelopmentInterface Design
0 likes · 15 min read
Practical Tips for Improving Interface Maintainability in Software Development
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
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
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
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?
Top Architect
Top Architect
Jun 9, 2022 · Fundamentals

How to Write Unmaintainable Code: A Satirical Guide for Developers

This tongue‑in‑cheek article lists a series of deliberately bad coding practices—ranging from confusing naming conventions and deceptive comments to abusive design choices and omitted testing—intended to illustrate how developers can make their software virtually impossible to maintain.

JavaSoftware Engineeringbad practices
0 likes · 14 min read
How to Write Unmaintainable Code: A Satirical Guide for Developers
Programmer DD
Programmer DD
Apr 25, 2022 · Fundamentals

How to Write Code Nobody Can Maintain – A Satirical Anti‑Pattern Guide

This satirical guide enumerates absurd techniques—from confusing naming conventions and deceptive comments to overloaded functions and excessive nesting—that deliberately make code hard to read, test, and maintain, offering a tongue‑in‑cheek look at worst‑case software engineering practices.

Software Engineeringbad practicescode anti-patterns
0 likes · 14 min read
How to Write Code Nobody Can Maintain – A Satirical Anti‑Pattern Guide
Open Source Linux
Open Source Linux
Oct 28, 2021 · Fundamentals

How to Write Code Nobody Can Maintain (And Still Get Away With It)

This tongue‑in‑cheek guide enumerates a series of deliberately bad programming techniques—ranging from confusing naming conventions and deceptive comments to absurd design choices and hidden macros—aimed at making code virtually impossible to understand, maintain, or test.

Software Engineeringbad practicescode obfuscation
0 likes · 17 min read
How to Write Code Nobody Can Maintain (And Still Get Away With It)
21CTO
21CTO
Oct 7, 2021 · Fundamentals

How to Write Code Nobody Can Maintain – A Satirical Guide

This tongue‑in‑cheek article lists a series of deliberately bad programming practices—from confusing variable names and deceptive comments to over‑engineered designs and zero testing—to show how to make code virtually impossible to maintain.

Anti‑PatternSoftware Engineeringcode smell
0 likes · 13 min read
How to Write Code Nobody Can Maintain – A Satirical Guide
ITPUB
ITPUB
Sep 2, 2021 · Fundamentals

How to Write Code Nobody Can Maintain – A Satirical Guide

This tongue‑in‑cheek article enumerates a series of deliberately bad programming practices—from confusing naming conventions and deceptive comments to abusive design choices and anti‑testing habits—showing how to make code virtually impossible for colleagues to understand or maintain.

Software Engineeringbad practicescode anti-patterns
0 likes · 14 min read
How to Write Code Nobody Can Maintain – A Satirical Guide
21CTO
21CTO
Aug 2, 2021 · Fundamentals

Why Most Projects Fail: 4 Code‑Quality Pitfalls and Proven Fixes

The article examines why many software projects become “rotten” by analyzing four common code‑quality problems—over‑large components, low cohesion, tangled high‑level/low‑level logic, and rampant if‑else—then offers concrete refactoring patterns, design‑pattern applications, and practical tooling to restore maintainability and project success.

Design PatternsSoftware Architecturecode quality
0 likes · 38 min read
Why Most Projects Fail: 4 Code‑Quality Pitfalls and Proven Fixes
Java Architect Essentials
Java Architect Essentials
May 16, 2021 · Fundamentals

Code Quality Evaluation Standards and Metrics

The article explains widely used code quality evaluation standards—including coding conventions, readability, maintainability, duplication, and testability—and describes how the @iceworks/doctor tool scores projects across five dimensions to compute an overall quality score.

DuplicationSoftware Engineeringcode quality
0 likes · 7 min read
Code Quality Evaluation Standards and Metrics
Top Architect
Top Architect
May 15, 2021 · Fundamentals

Overview of Software Architecture: Monolithic, Distributed, Microservices, and Serverless

This article introduces the concept of software architecture and compares four major styles—monolithic, distributed, microservices, and serverless—detailing their structures, advantages, disadvantages, and typical use cases, helping developers understand how architectural choices affect scalability, maintainability, and operational complexity.

DistributedScalabilityServerless
0 likes · 12 min read
Overview of Software Architecture: Monolithic, Distributed, Microservices, and Serverless
Selected Java Interview Questions
Selected Java Interview Questions
Apr 28, 2021 · Fundamentals

Why Using Interfaces Improves Software Maintainability

The article explains that employing interfaces in a layered software architecture simplifies future maintenance by allowing changes to be made in a single implementation class, avoiding widespread code modifications across services, DAOs, and actions, and thereby reducing recompilation time and potential errors.

InterfacesJavalayered architecture
0 likes · 5 min read
Why Using Interfaces Improves Software Maintainability
vivo Internet Technology
vivo Internet Technology
Mar 24, 2021 · Backend Development

Componentization vs Serviceization: Definitions, Pros & Cons, and Application Scenarios

The article defines componentization (shared JAR) and serviceization (independent service), compares their performance, cost, maintainability, and resource trade‑offs, outlines ideal use‑cases such as high‑throughput, no‑DB calls versus DB‑access or lower‑concurrency needs, and provides Vivo case studies to guide selection.

Backend ArchitectureComponentizationMicroservices
0 likes · 15 min read
Componentization vs Serviceization: Definitions, Pros & Cons, and Application Scenarios
ITPUB
ITPUB
Mar 24, 2021 · Fundamentals

Why Good Code Comments Are Essential for Every Developer

The article emphasizes that clear, well‑structured comments are vital for code readability, team collaboration, maintenance, and knowledge transfer, illustrating common pitfalls through developer anecdotes and offering practical guidelines such as writing concise explanations, categorizing notes, timing comments, and preserving code history to avoid future confusion.

CollaborationSoftware Engineeringcode comments
0 likes · 10 min read
Why Good Code Comments Are Essential for Every Developer
ITPUB
ITPUB
Mar 24, 2021 · Fundamentals

Mastering Code Review: 12 Principles for Writing Clean, Maintainable Go Code

This article shares a senior engineer's practical philosophy on code review, covering why reviews matter, common pitfalls like duplicated code and premature optimization, and twelve concrete principles—such as simplicity, composition, transparency, and early returns—to help developers write clearer, more maintainable Go programs.

Code reviewGolangSoftware Engineering
0 likes · 41 min read
Mastering Code Review: 12 Principles for Writing Clean, Maintainable Go Code
phodal
phodal
Nov 2, 2020 · Industry Insights

Is Groovy Doomed? Readability, IDE Support, and Team Collaboration Challenges

The article reflects on the pros and cons of JVM languages—especially Groovy—in team projects, examining readability, writability, IDE support, maintainability issues, and why newer alternatives like Kotlin Script may be more suitable for large‑scale development.

GradleGroovyIDE Support
0 likes · 8 min read
Is Groovy Doomed? Readability, IDE Support, and Team Collaboration Challenges
Programmer DD
Programmer DD
Nov 2, 2020 · Fundamentals

How to Evaluate Code Quality: Standards and Metrics for Clean, Maintainable Code

This article explains practical code quality evaluation standards—coding conventions, readability, maintainability, duplication, and testability—and introduces the five dimensions used by Iceworks Doctor to score projects, helping teams adopt consistent, high‑quality coding practices.

Software Engineeringcode qualitycoding standards
0 likes · 6 min read
How to Evaluate Code Quality: Standards and Metrics for Clean, Maintainable Code
dbaplus Community
dbaplus Community
Aug 17, 2020 · Operations

Master Server Troubleshooting: Diagnose, Optimize, and Keep Your Backend Stable

This article shares practical experience on backend troubleshooting, outlining common failure types, a step‑by‑step diagnosis workflow, essential tools, and systematic optimization techniques for performance, stability and maintainability, helping engineers quickly stop losses, pinpoint root causes, and implement robust fixes.

BackendOperationsmaintainability
0 likes · 21 min read
Master Server Troubleshooting: Diagnose, Optimize, and Keep Your Backend Stable
360 Tech Engineering
360 Tech Engineering
Apr 27, 2020 · Frontend Development

Writing Maintainable JavaScript: Principles, Coding Standards, and Best Practices

This article explains why maintainable JavaScript is essential for modern web applications and provides concrete guidelines on coding standards, readability, naming, type transparency, loose coupling, and coding conventions such as respecting object ownership, avoiding globals, and using constants.

best practicescoding standardsfrontend development
0 likes · 25 min read
Writing Maintainable JavaScript: Principles, Coding Standards, and Best Practices
dbaplus Community
dbaplus Community
Apr 16, 2020 · Fundamentals

Why Code Quality Fails Projects and 4 Proven Ways to Fix It

The article examines why many software projects deteriorate due to poor code quality, outlines four common pitfalls such as oversized components, low cohesion, tangled logic, and rampant if‑else statements, and presents concrete refactoring strategies—including inverted‑pyramid design, lib/framework separation, Template Method pattern, and rich enums—to dramatically improve maintainability and project success.

Design PatternsSoftware Engineeringcode quality
0 likes · 37 min read
Why Code Quality Fails Projects and 4 Proven Ways to Fix It
Programmer DD
Programmer DD
Mar 24, 2020 · Fundamentals

How to Write Code Nobody Can Maintain – A Satirical Guide

This tongue‑in‑cheek article enumerates a series of deliberately bad programming practices—from confusing variable names and misleading comments to over‑engineered designs and zero testing—to show how to make code virtually impossible to maintain.

JavaSoftware Engineeringbad practices
0 likes · 12 min read
How to Write Code Nobody Can Maintain – A Satirical Guide
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 25, 2019 · Operations

Understanding Why Microservice Architecture and Service‑Oriented Design Matter

This article explains the motivations behind adopting microservice architecture, outlines the problems it solves such as poor scalability, reliability and maintenance, describes the benefits and new challenges of service‑oriented design, and concludes with a concise summary of its advantages and trade‑offs.

MicroservicesScalabilitymaintainability
0 likes · 8 min read
Understanding Why Microservice Architecture and Service‑Oriented Design Matter
Java Captain
Java Captain
Sep 17, 2019 · Backend Development

Java Function Coding Guidelines: Primitive Types, Parameter Classes, and Refactoring Best Practices

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.

Javabest practicescode readability
0 likes · 19 min read
Java Function Coding Guidelines: Primitive Types, Parameter Classes, and Refactoring Best Practices
Java Backend Technology
Java Backend Technology
Aug 6, 2019 · Fundamentals

How to Write Code Nobody Can Maintain – A Satirical Guide

This tongue‑in‑cheek article enumerates a series of deliberately harmful programming practices—from confusing naming conventions and code obfuscation to misleading documentation, chaotic design choices, and a complete disregard for testing – illustrating how to make software virtually impossible to maintain.

Software Engineeringcode anti-patternsmaintainability
0 likes · 16 min read
How to Write Code Nobody Can Maintain – A Satirical Guide
21CTO
21CTO
Jun 20, 2019 · Fundamentals

Master the Art of Unmaintainable Code: A Satirical Guide for Developers

This tongue‑in‑cheek article lists absurd techniques—from confusing variable names and deceptive comments to overloaded operators and chaotic class designs—that deliberately make software hard to read, test, and maintain, illustrating what not to do when writing clean, maintainable code.

Anti-Patternscodemaintainability
0 likes · 13 min read
Master the Art of Unmaintainable Code: A Satirical Guide for Developers
MaGe Linux Operations
MaGe Linux Operations
May 11, 2018 · Fundamentals

How Massive Can Python Projects Really Get? A Deep Dive into Code Size and Maintainability

This article examines the scale of Python open‑source projects by counting lines of code with cloc, revealing that even multi‑million‑line codebases like OpenStack exist, while highlighting metrics such as average file length, comment‑to‑code ratios, and the variety of ancillary file types across the top projects.

Large-Scale Developmentcode metricsmaintainability
0 likes · 8 min read
How Massive Can Python Projects Really Get? A Deep Dive into Code Size and Maintainability
Architecture Digest
Architecture Digest
Apr 10, 2018 · Fundamentals

Reliability, Scalability, and Maintainability in Distributed System Design

This article examines core distributed system design principles—reliability, scalability, and maintainability—explaining how techniques such as replication, partitioning, consensus algorithms, and transactions address hardware, software, and human failures, and discusses vertical and horizontal scaling strategies to achieve robust, extensible, and maintainable architectures.

ConsensusDistributed SystemsReplication
0 likes · 8 min read
Reliability, Scalability, and Maintainability in Distributed System Design
21CTO
21CTO
Jan 23, 2018 · Fundamentals

How to Write High‑Quality, Maintainable Code: Proven Practices for Developers

This article explores the essential tools, methods, and developer habits needed to produce high‑quality, maintainable code, emphasizing why automation alone isn’t enough and outlining concrete code‑review steps that ensure reliability and alignment with product requirements.

Code reviewbest practicescode quality
0 likes · 8 min read
How to Write High‑Quality, Maintainable Code: Proven Practices for Developers
360 Quality & Efficiency
360 Quality & Efficiency
Jan 4, 2018 · Fundamentals

Code Health: Improving Software Engineering Practices at Google

The article explains Google’s “Code Health” initiative, describing its purpose, organizational structure, and how it promotes better readability, maintainability, stability, and simplicity in software development through best‑practice documentation, tooling, and cultural advocacy.

Engineering CultureGoogleSoftware Engineering
0 likes · 5 min read
Code Health: Improving Software Engineering Practices at Google
21CTO
21CTO
Sep 1, 2017 · Fundamentals

20 Essential Qualities That Distinguish Top Programmers

An informal weekend essay explores how senior programmers differ from junior ones by emphasizing twenty key attributes—reliability, readability, maintainability, testability, extensibility, portability, scalability, usability, availability, reusability, interoperability, manageability, supportability, consistency, security, performance, stability, accuracy, customizability, and robustness—highlighting self‑discipline as the core differentiator.

Software Engineeringcode reliabilitymaintainability
0 likes · 3 min read
20 Essential Qualities That Distinguish Top Programmers
Java Captain
Java Captain
Jul 24, 2017 · Fundamentals

10 Essential Java Programming Best Practices Every Developer Should Follow

These ten essential Java programming commandments—ranging from adding comments and avoiding hard‑coding to proper GUI design, unit testing, and performance‑aware coding—provide developers with practical guidelines to write clearer, more maintainable, and efficient code while preventing common pitfalls.

maintainabilityperformance
0 likes · 12 min read
10 Essential Java Programming Best Practices Every Developer Should Follow
21CTO
21CTO
Jun 12, 2016 · Mobile Development

Key Lessons from Building Android Apps: Architecture, Maintainability, and Security

After transitioning from JavaEE to Android development, the author shares practical insights on designing robust mobile app architecture, covering maintainability, extensibility, security, onboarding ease, documentation, packaging, and the trade‑offs between MVC and MVP, while offering guidance on framework selection and effective encapsulation.

AndroidFrameworkMVC
0 likes · 14 min read
Key Lessons from Building Android Apps: Architecture, Maintainability, and Security
21CTO
21CTO
Mar 1, 2016 · Fundamentals

Why Bad Code Survives and How Refactoring Can Save Your Projects

The article examines why developers often produce low‑quality, hard‑to‑maintain code, outlines common bad‑code patterns, discusses the limited benefits and high costs of refactoring, and offers practical advice for writing better, more maintainable software.

Software Engineeringbad code patternscode quality
0 likes · 12 min read
Why Bad Code Survives and How Refactoring Can Save Your Projects
High Availability Architecture
High Availability Architecture
Jan 29, 2016 · Fundamentals

Evaluating Code Quality: Definitions, Readability, Maintainability and Practical Guidelines

This article explains how to objectively assess code quality by defining good code, discussing readability, documentation, exception handling, concurrency, performance, logging, maintainability, modularization and providing recommended reading, helping developers and reviewers establish consistent evaluation standards.

Software Engineeringbest practicescode quality
0 likes · 21 min read
Evaluating Code Quality: Definitions, Readability, Maintainability and Practical Guidelines
Suning Design
Suning Design
Sep 30, 2015 · Frontend Development

7 Common Frontend Pitfalls When Translating Designs to Code (And How to Fix Them)

This article outlines the typical mistakes designers and front‑end developers make during visual page implementation—such as mimicking native app experiences, ignoring overflow, overlooking font choices, and neglecting maintainability—and offers practical advice to prevent costly rework.

UI Developmentcommon pitfallsdesign implementation
0 likes · 7 min read
7 Common Frontend Pitfalls When Translating Designs to Code (And How to Fix Them)
Qunar Tech Salon
Qunar Tech Salon
Sep 25, 2015 · Fundamentals

Why Maintainability Should Be the Primary Goal of Software Architecture

The article argues that without clear evaluation standards, software architecture should be judged by how well it achieves the architect's design goals, emphasizing maintainability as the key criterion to balance performance, security, scalability, cost, and long‑term evolution.

Software ArchitectureSoftware Engineeringdesign goals
0 likes · 12 min read
Why Maintainability Should Be the Primary Goal of Software Architecture
Qunar Tech Salon
Qunar Tech Salon
Sep 24, 2015 · Fundamentals

Performance vs. Maintainability: Why Maintainability Should Take Precedence

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.

Software Engineeringcachingcode readability
0 likes · 15 min read
Performance vs. Maintainability: Why Maintainability Should Take Precedence
21CTO
21CTO
Sep 8, 2015 · Fundamentals

Why Performance Should Never Sacrifice Maintainability in Code

The article argues that while programmers obsess over performance gains, maintainability is often more critical, illustrating this with C# LINQ vs Single/First debates, database design pitfalls, and the hidden costs of premature optimization, ultimately urging developers to prioritize readable, maintainable code and measure performance before refactoring.

CSoftware Engineeringcode quality
0 likes · 12 min read
Why Performance Should Never Sacrifice Maintainability in Code
21CTO
21CTO
Sep 8, 2015 · Fundamentals

Why Maintainability Should Be the Core Goal of Software Architecture

The article argues that without clear evaluation standards, software architecture debates become subjective, and proposes using the achievement of the architect's design goals—especially maintainability—as the primary metric for judging a good architecture.

Software Architecturecoding standardsdesign goals
0 likes · 13 min read
Why Maintainability Should Be the Core Goal of Software Architecture
21CTO
21CTO
Aug 13, 2015 · Fundamentals

How to Write High‑Quality Code: Readability, Maintainability & Changeability Explained

This article explains how to improve code quality by focusing on three essential attributes—readability, maintainability, and changeability—offering practical advice, design‑pattern examples, and coding conventions that help developers write clearer, more adaptable, and easier‑to‑maintain software.

Design PatternsResponsibility-Driven Designchangeability
0 likes · 34 min read
How to Write High‑Quality Code: Readability, Maintainability & Changeability Explained