BestHub
Sign in
Tagged articles

TDD

84 articles · Page 1 of 1
Linyb Geek Road
Linyb Geek Road
Jun 27, 2026 · Artificial Intelligence

How to Build a Real AI Coding Environment with Matt Pocock’s Skills

While many expect AI to instantly double coding speed, the article shows that without a solid engineering feedback loop projects falter; Matt Pocock’s open‑source .skills repository offers a markdown‑driven workflow—clarifying requirements, documenting decisions, applying TDD, diagnosing bugs, and maintaining architecture—guiding developers through a repeatable, context‑aware AI‑assisted development process.

AI programmingClaude CodeOpen-source
0 likes · 14 min read
How to Build a Real AI Coding Environment with Matt Pocock’s Skills
Tech Minimalism
Tech Minimalism
Jun 20, 2026 · Artificial Intelligence

How to Build a Real‑Project AI Coding Environment with Matt Pocock’s Skills

The article explains why AI‑assisted coding fails without a solid engineering feedback loop, introduces Matt Pocock’s open‑source .claude/skills workflow, and provides a step‑by‑step guide—including requirement clarification, PRD generation, vertical task slicing, TDD, debugging and architecture upkeep—to create a reproducible AI programming environment.

AI codingClaude CodeMatt Pocock
0 likes · 15 min read
How to Build a Real‑Project AI Coding Environment with Matt Pocock’s Skills
Frontend AI Walk
Frontend AI Walk
Jun 18, 2026 · Artificial Intelligence

Master AI Coding with a 7‑Step Loop: From Task Cards to Release Checks

This tutorial shows how to replace one‑off prompts with a repeatable Loop Engineering workflow—task cards, clarification, task breakdown, TDD cycles, verification records, progress snapshots, and release checks—so AI‑generated code stays stable, testable, and easy to resume across development sessions.

AI codingLoop engineeringPrompt engineering
0 likes · 17 min read
Master AI Coding with a 7‑Step Loop: From Task Cards to Release Checks
Nightwalker Tech
Nightwalker Tech
May 29, 2026 · Artificial Intelligence

Taming AI Code Generation with PDCA: From Prompt to Reliable Delivery

This article explains how applying the classic PDCA (Plan‑Do‑Check‑Act) loop and a Harness engineering layer can transform probabilistic AI code generators like Codex and Claude Code into deterministic, reliable delivery tools for software development, documentation, and automated testing.

Automation testingHarness EngineeringPDCA
0 likes · 30 min read
Taming AI Code Generation with PDCA: From Prompt to Reliable Delivery
BirdNest Tech Talk
BirdNest Tech Talk
May 18, 2026 · Artificial Intelligence

Taming AI Coding Agents: A Powerful Development Workflow with Engineering Discipline

The article introduces Matt Pocock's open‑source "skills" collection for AI coding agents, shows how it embeds traditional engineering practices such as alignment, domain modeling, TDD, and architecture governance into reusable command sets, and walks through a complete partial‑refund feature implementation using these skills.

AI coding agentsPrompt engineeringTDD
0 likes · 22 min read
Taming AI Coding Agents: A Powerful Development Workflow with Engineering Discipline
Shuge Unlimited
Shuge Unlimited
May 17, 2026 · Frontend Development

Adding Tab Navigation to a Long List: OpenSpec Layout Refactor (Part 4)

In this fourth OpenSpec case study, the author refactors the home page layout by introducing a category‑based tab navigation skeleton that replaces a scrolling long list, detailing the exploration of four design options, the chosen implementation using React, TypeScript and Tailwind, and the full TDD‑driven development, testing, verification and archiving workflow.

Frontend ArchitectureOpenSpecReAct
0 likes · 26 min read
Adding Tab Navigation to a Long List: OpenSpec Layout Refactor (Part 4)
Shuge Unlimited
Shuge Unlimited
May 7, 2026 · Backend Development

Master AI‑Driven TDD in 6 Steps with OpenSpec + Superpowers

This article walks through a three‑iteration, AI‑assisted TDD workflow that combines OpenSpec for spec management and Superpowers for disciplined implementation, detailing a six‑step process, concrete code snippets, performance metrics, known limitations, and practical tips for backend developers.

AI programmingNode.jsOpenSpec
0 likes · 29 min read
Master AI‑Driven TDD in 6 Steps with OpenSpec + Superpowers
Shuge Unlimited
Shuge Unlimited
May 5, 2026 · Artificial Intelligence

Embedding Superpowers TDD with OpenSpec Schema: 3 Injection Points & 4 Layers (Half Effective)

This guide shows how to create a custom OpenSpec schema that injects TDD discipline into an AI‑driven coding workflow using three injection points and a four‑layer overlay, demonstrates that the propose phase works as intended while the apply phase only partially enforces TDD, and provides step‑by‑step setup, code examples, comparisons, troubleshooting and best‑practice recommendations.

AI codingClaude CodeNode.js
0 likes · 25 min read
Embedding Superpowers TDD with OpenSpec Schema: 3 Injection Points & 4 Layers (Half Effective)
Qborfy AI
Qborfy AI
Apr 22, 2026 · R&D Management

Boost Code Quality with a Devil‑Style Review Loop and Spec‑Kit

This article walks through a six‑step, AI‑augmented review‑driven development workflow—using Spec‑Kit commands, devil‑style iterative reviews, and TDD—to turn a simple "user login failure lock" requirement into a robust, well‑tested implementation while catching design flaws early.

SDDSoftware engineeringSpec-Kit
0 likes · 16 min read
Boost Code Quality with a Devil‑Style Review Loop and Spec‑Kit
Shuge Unlimited
Shuge Unlimited
Apr 18, 2026 · Artificial Intelligence

From Legacy Coding to AI‑Assisted Development: A Hands‑On Guide to Using Superpowers and OpenSpec

The article presents a step‑by‑step AI‑enhanced workflow for modernising legacy systems, explaining how OpenSpec’s spec‑driven requirement layer and Superpowers’ strict execution pipeline (brainstorming, isolated worktrees, TDD, code review) together resolve inaccurate demand understanding and uncontrolled code generation, with a concrete flash‑sale implementation and practical pitfalls.

AI codingOpenSpecSpec-Driven Development
0 likes · 20 min read
From Legacy Coding to AI‑Assisted Development: A Hands‑On Guide to Using Superpowers and OpenSpec
Shuge Unlimited
Shuge Unlimited
Apr 13, 2026 · Artificial Intelligence

Superpowers Best Practices: 7‑Step Workflow from Requirements to Production‑Ready Code

This article walks through Superpowers' disciplined 7‑stage workflow—starting with brainstorming, using Git worktrees, writing granular plans, automated sub‑agent development, strict TDD, mandatory code review, and final verification—demonstrated with a coupon‑redeem API implementation.

AI programmingSoftware engineeringSuperpowers
0 likes · 21 min read
Superpowers Best Practices: 7‑Step Workflow from Requirements to Production‑Ready Code
Tech Verticals & Horizontals
Tech Verticals & Horizontals
Apr 10, 2026 · Artificial Intelligence

Superpowers + OpenSpec Skill Library: Enforcing Disciplined AI Development

The Superpowers + OpenSpec Team Skills library provides a set of workflow modules that guide AI‑assisted development through requirement clarification, design confirmation, change specification, implementation planning, TDD, and verification, ensuring disciplined, traceable, and reliable feature delivery for collaborative projects.

OpenSpecSuperpowersTDD
0 likes · 6 min read
Superpowers + OpenSpec Skill Library: Enforcing Disciplined AI Development
AndroidPub
AndroidPub
Mar 30, 2026 · Artificial Intelligence

How Superpowers Transforms AI‑Assisted Development: A Step‑by‑Step Guide

Superpowers introduces a structured, Git‑worktree‑based AI development workflow that tackles plan deviation by combining brainstorming, automated planning, sub‑agent execution, mandatory TDD, and continuous back‑check, offering a practical alternative to simple plan modes and heavyweight frameworks.

AI workflowGit worktreeSuperpowers
0 likes · 13 min read
How Superpowers Transforms AI‑Assisted Development: A Step‑by‑Step Guide
o-ai.tech
o-ai.tech
Mar 26, 2026 · Artificial Intelligence

Why Does Superpowers Insist on Ultra‑Detailed Writing‑Plans?

Superpowers inserts a highly granular "writing‑plans" step between a finished spec and code generation to translate design into narrow, verifiable actions for agents, eliminating ambiguity, enforcing TDD granularity, and externalizing senior engineers' tacit execution knowledge.

AI agentsSoftware engineeringTDD
0 likes · 13 min read
Why Does Superpowers Insist on Ultra‑Detailed Writing‑Plans?
o-ai.tech
o-ai.tech
Mar 26, 2026 · Artificial Intelligence

Understanding Superpowers: Like gstack but a System Enforcing Engineering Discipline for AI Agents

The article analyses the Superpowers repository, contrasting it with gstack and showing how Superpowers tightens AI agents' behavior by embedding classic engineering discipline—step‑by‑step planning, testing, verification and review—into the development pipeline rather than merely expanding the agents' capabilities.

AI agentsSoftware engineeringTDD
0 likes · 12 min read
Understanding Superpowers: Like gstack but a System Enforcing Engineering Discipline for AI Agents
Senior Xiao Ying
Senior Xiao Ying
Jan 27, 2026 · Backend Development

Why Is Your Spring Boot App Lagging? 10 Optimization Tips to Speed It Up

This guide walks through ten practical techniques—startup lazy initialization, scoped component scanning, selective auto‑configuration, async processing, connection‑pool tuning, JPA batch settings, multi‑level caching, multi‑stage Docker builds, JVM container‑aware flags, Tomcat thread tuning, Resilience4j, observability stack, and TDD—to diagnose and eliminate performance bottlenecks in Spring Boot applications.

CachingDockerJava
0 likes · 12 min read
Why Is Your Spring Boot App Lagging? 10 Optimization Tips to Speed It Up
FunTester
FunTester
Aug 27, 2025 · Fundamentals

How Test‑Driven Development Can Boost Code Quality and Team Collaboration

This article explores Test‑Driven Development (TDD) as a quality‑focused methodology, detailing its practical benefits, planning strategies, documentation support, team collaboration gains, and the challenges faced in fast‑paced, high‑change environments, while offering balanced advice for integrating TDD with traditional testing approaches.

Software engineeringTDDcode quality
0 likes · 10 min read
How Test‑Driven Development Can Boost Code Quality and Team Collaboration
Instant Consumer Technology Team
Instant Consumer Technology Team
Aug 20, 2025 · Backend Development

How I Built a Production‑Ready RAG Service in 3 Weeks Using AI Coding Tools

In just three weeks, I single‑handedly created a production‑grade Retrieval‑Augmented Generation (RAG) API with FastAPI, leveraging Cursor and Claude Code to automate coding, testing, and deployment, and I share practical insights on AI‑assisted development, high cohesion‑low coupling design, TDD, git worktree parallelism, and agent orchestration.

AI codingFastAPIGit worktree
0 likes · 19 min read
How I Built a Production‑Ready RAG Service in 3 Weeks Using AI Coding Tools
php Courses
php Courses
Jul 23, 2025 · Backend Development

Beyond Try‑Catch: Advanced PHP Techniques for Safer Code

This article explores modern PHP practices that move error handling from runtime try‑catch blocks to proactive strategies such as static analysis, contract programming, attribute‑based validation, and test‑driven development, showing how to build more reliable and maintainable backend applications.

AttributesContractsPHP
0 likes · 5 min read
Beyond Try‑Catch: Advanced PHP Techniques for Safer Code
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 20, 2025 · Artificial Intelligence

Comparative Review of AI Code Editors: Trae, Cursor, and Augment (2025)

This article reviews and compares three AI code editors—Trae, Cursor, and Augment—detailing personal usage experiences, performance, feature differences, cost, integration with MCP tools, suitable scenarios for solo entrepreneurs versus professional developers, and practical tips for improving workflow with AI assistance.

AI code editorMCPTDD
0 likes · 9 min read
Comparative Review of AI Code Editors: Trae, Cursor, and Augment (2025)
Test Development Learning Exchange
Test Development Learning Exchange
May 18, 2025 · Fundamentals

Guidelines for Testers to Lead Project Testing in Agile Development

This article outlines ten essential practices for testers in agile projects, covering early requirement involvement, test strategy creation, CI/CD integration, collaboration, TDD/BDD adoption, exploratory and performance testing, regression, continuous improvement, and knowledge sharing to ensure high‑quality software delivery.

Agile TestingBDDCI/CD
0 likes · 5 min read
Guidelines for Testers to Lead Project Testing in Agile Development
Continuous Delivery 2.0
Continuous Delivery 2.0
Apr 11, 2025 · Artificial Intelligence

Comparison and Experience Sharing of AI Coding Tools

In this detailed recap of a live session, the author shares personal experiences, compares six AI-powered coding assistants—including Trae, Cursor, and Augment—evaluates their speed, features, costs, and MCP support, and offers practical advice on tool selection, project workflow, and productivity techniques for developers.

AI coding toolsCode AssistantsMCP
0 likes · 12 min read
Comparison and Experience Sharing of AI Coding Tools
Programmer XiaoFu
Programmer XiaoFu
Apr 1, 2025 · Fundamentals

How a 100k‑Bonus Colleague Writes Elegantly Clean Code

The article explains why clean, well‑structured code matters for team productivity, covering naming, class design, function design, SOLID principles, testing practices such as TDD and the FIRST rule, and shows how tools like SonarLint can help maintain code quality.

Naming ConventionsSOLIDTDD
0 likes · 17 min read
How a 100k‑Bonus Colleague Writes Elegantly Clean Code
Test Development Learning Exchange
Test Development Learning Exchange
Jan 24, 2025 · Fundamentals

Understanding the Core Principles, Challenges, and Benefits of Test‑Driven Development (TDD)

The article explains TDD’s core three laws, its rapid feedback loop, common implementation challenges with practical solutions, ways to enhance effectiveness through BDD, CI, and static analysis, and the long‑term benefits of reduced technical debt and improved code quality.

Continuous IntegrationSoftware engineeringTDD
0 likes · 4 min read
Understanding the Core Principles, Challenges, and Benefits of Test‑Driven Development (TDD)
Test Development Learning Exchange
Test Development Learning Exchange
Oct 18, 2024 · Fundamentals

Test‑Driven Development (TDD) and Behavior‑Driven Development (BDD): Definitions, Steps, Pros, Cons, and Choosing the Right Approach

Test‑Driven Development (TDD) and Behavior‑Driven Development (BDD) are software development approaches that start with writing tests or user stories, outlining core steps, advantages, disadvantages, and offering guidance on selecting the appropriate method based on project requirements, team expertise, and business communication needs.

AgileBDDTDD
0 likes · 5 min read
Test‑Driven Development (TDD) and Behavior‑Driven Development (BDD): Definitions, Steps, Pros, Cons, and Choosing the Right Approach
DevOps
DevOps
Aug 4, 2024 · Fundamentals

Understanding Test‑Driven Development (TDD), UTDD, ATDD, and BDD with a Practical Java Example

This article explains the concepts of Test‑Driven Development (TDD), Unit Test‑Driven Development (UTDD), Acceptance Test‑Driven Development (ATDD) and Behavior‑Driven Development (BDD), discusses why TDD is not dead, compares the three approaches, and provides a step‑by‑step Java implementation with code samples, testing workflow, and refactoring guidance.

ATDDBDDJava
0 likes · 14 min read
Understanding Test‑Driven Development (TDD), UTDD, ATDD, and BDD with a Practical Java Example
Continuous Delivery 2.0
Continuous Delivery 2.0
Jul 10, 2024 · Fundamentals

Eighteen Years of Agile: Strange Phenomena and the Quest for Software Engineering Fundamentals in China

The article reviews the history of China's IT industry over the past eighteen years, exposing how government policies, CMM certifications, and superficial agile practices have led to chronic software quality and delivery problems, and argues that only solid fundamentals such as extreme programming, TDD, and deliberate practice can truly improve software development.

AgileCMMContinuous Integration
0 likes · 25 min read
Eighteen Years of Agile: Strange Phenomena and the Quest for Software Engineering Fundamentals in China
Architect
Architect
Jul 8, 2024 · Fundamentals

Master Clean Code: Naming, Classes, Functions, and Testing Best Practices

This guide explains why clean code matters, outlines practical naming conventions, class design principles, function structuring rules, and testing strategies—including TDD, the FIRST criteria, and automated test generation—to help developers write maintainable, readable, and high‑quality software.

Naming ConventionsSOLID principlesTDD
0 likes · 16 min read
Master Clean Code: Naming, Classes, Functions, and Testing Best Practices
MaGe Linux Operations
MaGe Linux Operations
Feb 4, 2024 · Fundamentals

Why TDD and BDD Matter: Master the Red‑Green‑Refactor Cycle

This article explains the core concepts, rhythms, and practical applications of Test‑Driven Development (TDD) and Behavior‑Driven Development (BDD), illustrating how the red‑green‑refactor loop and business‑focused scenarios improve code quality, design, and collaboration between developers and stakeholders.

BDDBehavior Driven DevelopmentTDD
0 likes · 19 min read
Why TDD and BDD Matter: Master the Red‑Green‑Refactor Cycle
HelloTech
HelloTech
Jan 4, 2024 · Frontend Development

Introduction to Front-End Unit Testing with Jest

This guide introduces front‑end unit testing with Jest, explaining TDD and BDD concepts, installation, writing simple and ES6/TypeScript tests, configuring coverage, using common matchers, and employing mock functions, timers, and module mocking to ensure reliable, maintainable code.

JestMockingTDD
0 likes · 14 min read
Introduction to Front-End Unit Testing with Jest
Architect
Architect
Oct 5, 2023 · Fundamentals

Mastering Clean Code: Naming, Classes, Functions, and Tests Explained

This article explains why clean code matters, demonstrates how meaningful naming, single‑responsibility classes, well‑structured functions, and disciplined testing (TDD and the FIRST principles) improve readability, maintainability, and productivity, using concrete Java examples, refactorings, and step‑by‑step guidelines.

Naming ConventionsTDDUnit Testing
0 likes · 17 min read
Mastering Clean Code: Naming, Classes, Functions, and Tests Explained
Java Architect Essentials
Java Architect Essentials
Sep 27, 2023 · Fundamentals

How to Write Clean Code: Naming, Classes, Functions, and Testing Best Practices

This article explains why clean code is essential for productivity and business health, and provides practical guidelines on naming, class design, function design, and testing—including code examples, refactoring techniques, and quality‑checking tools—to help developers produce readable, maintainable, and extensible software.

Naming ConventionsTDDclean code
0 likes · 14 min read
How to Write Clean Code: Naming, Classes, Functions, and Testing Best Practices
DevOps Cloud Academy
DevOps Cloud Academy
Jul 4, 2023 · Fundamentals

Modern Software Engineering: Insights from David Farley on Agile, TDD, and Avoiding Bureaucracy

The article explores David Farley's decades‑long experience in software engineering, highlighting his early automation work, contributions to the Agile Manifesto, the principles of Continuous Delivery, critiques of traditional waterfall methods, and practical guidance on Test‑Driven Development and learning‑oriented development to deliver business value.

AgileDavid FarleySoftware engineering
0 likes · 7 min read
Modern Software Engineering: Insights from David Farley on Agile, TDD, and Avoiding Bureaucracy
FunTester
FunTester
Jun 26, 2023 · Fundamentals

Why Unit Testing Matters: From Test Pyramids to Agile Practices

This article explains the concepts of narrow and broad unit testing, the shift‑left and shift‑right testing strategies, compares Mike Cohn’s and Google’s test pyramids, discusses the limitations of unit testing, and shows how unit testing fits into traditional and agile development models.

AgileTDDUnit Testing
0 likes · 10 min read
Why Unit Testing Matters: From Test Pyramids to Agile Practices
JD Cloud Developers
JD Cloud Developers
Jun 20, 2023 · Backend Development

Mastering Test‑Driven Development: From Red to Green and Beyond

This article explains the fundamentals of Test‑Driven Development (TDD), highlights common misconceptions, guides tool selection, and walks through a complete Java TDD case study—including a strange calculator example, multi‑iteration refactoring, and DDD‑based testing—showing how to improve code quality and maintainability.

DDDJavaMockito
0 likes · 26 min read
Mastering Test‑Driven Development: From Red to Green and Beyond
Architects Research Society
Architects Research Society
Feb 14, 2023 · Fundamentals

Test‑Driven Development (TDD): Concepts, Practices, Tools, and Myths

Test‑Driven Development (TDD) is an incremental, test‑first methodology that emphasizes writing failing tests before code, integrates refactoring, supports both unit and acceptance testing, addresses myths, tools, and its extension with Agile Model‑Driven Development, offering a disciplined approach to improve design and quality.

AgileTDDsoftware testing
0 likes · 21 min read
Test‑Driven Development (TDD): Concepts, Practices, Tools, and Myths
DevOps
DevOps
Jan 4, 2023 · Fundamentals

Understanding Test‑Driven Development: From TDD Mindset to Contract Testing and Standards

The article explains how Test‑Driven Development is fundamentally a mindset that emphasizes predefined standards and expectations, explores related practices such as contract testing, acceptance criteria, and standard‑driven development, and discusses the challenges of defining, maintaining, and motivating adherence to these standards within agile teams.

Acceptance CriteriaAgileTDD
0 likes · 6 min read
Understanding Test‑Driven Development: From TDD Mindset to Contract Testing and Standards
Architecture Breakthrough
Architecture Breakthrough
Dec 14, 2022 · Fundamentals

Why TDD Is the Secret to Simpler, Higher‑Quality Code for Teams

The article explains how Test‑Driven Development (TDD) boosts code quality, embeds domain knowledge, builds reusable automated test suites, and ultimately raises development efficiency, especially for middle‑platform services that must serve multiple business scenarios.

TDDsoftware qualitytest-driven development
0 likes · 5 min read
Why TDD Is the Secret to Simpler, Higher‑Quality Code for Teams
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Oct 10, 2022 · Frontend Development

Front‑end Engineering: A Guide for Team Leaders

This article explains front‑end engineering concepts, common pain points, and a systematic learning path for team leaders, illustrating how to build a component library with Vue, adopt standards, CI/CD, monorepo, and TDD to improve team efficiency.

CI/CDTDDcomponent-library
0 likes · 11 min read
Front‑end Engineering: A Guide for Team Leaders
ELab Team
ELab Team
Jul 13, 2022 · Frontend Development

Mastering Front‑End Testing: From Basics to Building Your Own Test Runner

This article explains software testing fundamentals, classifies test methods, outlines general testing principles, dives into front‑end testing types and popular frameworks, provides code snippets for a minimal test runner, and compares TDD and BDD approaches, offering a comprehensive guide for developers.

BDDFrontend TestingTDD
0 likes · 24 min read
Mastering Front‑End Testing: From Basics to Building Your Own Test Runner
Continuous Delivery 2.0
Continuous Delivery 2.0
Jul 5, 2022 · Fundamentals

Fifteen Rules for Test‑Driven Development (TDD)

This article presents fifteen practical, actionable rules for Test‑Driven Development, explaining how disciplined short cycles, writing tests first, and avoiding production data can make TDD both effective and executable for developers.

TDDbest practicesmethodology
0 likes · 3 min read
Fifteen Rules for Test‑Driven Development (TDD)
Java Interview Crash Guide
Java Interview Crash Guide
May 8, 2021 · Fundamentals

Why Refactoring Matters: Transform Bad Code into Clean, Maintainable Software

This article explains why continuous refactoring is essential for evolving projects, defines refactoring and its scales, lists common code smells and their impact, and presents practical techniques—including SOLID principles, design patterns, naming conventions, layering, and test‑driven development—to turn messy code into high‑quality, maintainable software.

Design PatternsSOLIDSoftware engineering
0 likes · 36 min read
Why Refactoring Matters: Transform Bad Code into Clean, Maintainable Software
Amap Tech
Amap Tech
Jan 8, 2021 · Backend Development

Applying Test‑Driven Development and GTest for Unit Testing in Gaode’s Navigation Service

Gaode’s navigation service adopted test‑driven development using Google’s GTest to replace slow diff‑based checks with fast, lightweight unit tests, enabling incremental refactoring of legacy code, improving quality, handling data‑dependency challenges, and demonstrating that writing tests first clarifies requirements while adding minimal overhead.

Backend DevelopmentC#TDD
0 likes · 9 min read
Applying Test‑Driven Development and GTest for Unit Testing in Gaode’s Navigation Service
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 4, 2021 · Fundamentals

How TDD and GTest Transform Legacy Navigation Systems: A Practical Guide

This article explores how Test‑Driven Development and Google Test can improve quality and enable incremental refactoring of a complex, legacy online navigation system by addressing the shortcomings of traditional diff‑based testing, introducing unit‑testing fundamentals, and sharing practical implementation details and lessons learned.

C#Software engineeringTDD
0 likes · 10 min read
How TDD and GTest Transform Legacy Navigation Systems: A Practical Guide
Architects Research Society
Architects Research Society
Aug 4, 2020 · Fundamentals

Agile Design Practices and Principles for Software Development

This article outlines agile software development design strategies, covering practical agile design activities, underlying design philosophies, and how design fits throughout the entire agile lifecycle, emphasizing iterative modeling, test‑driven development, and the balance between documentation and flexibility.

TDDdesignmethodology
0 likes · 12 min read
Agile Design Practices and Principles for Software Development
DevOps
DevOps
Jul 15, 2020 · Fundamentals

A Philosophical Dialogue on Software Testing and Quality Assurance

The article uses a whimsical conversation between a developer and a testing deity to explore why testing is essential, how it functions as sampling, the limits of defect detection, and practical strategies such as TDD, continuous integration, and requirement control to improve software quality.

Continuous IntegrationTDDquality assurance
0 likes · 16 min read
A Philosophical Dialogue on Software Testing and Quality Assurance
FunTester
FunTester
Jul 12, 2020 · Fundamentals

Why My First Project’s Bugs Vanished Quickly: Code Standards and Testing Insights

The author shares a first‑hand account of a newly launched backend project, explaining how strict coding standards, Groovy‑Java mixed development, and a pragmatic testing strategy—including limited unit testing, interface checks, and annotation‑based validation—enabled rapid bug resolution and a smooth release.

Backend DevelopmentGroovyJava
0 likes · 4 min read
Why My First Project’s Bugs Vanished Quickly: Code Standards and Testing Insights
DevOps
DevOps
Jun 23, 2020 · Fundamentals

Understanding Test‑Driven Development (TDD): Principles, Considerations, Practices, and Challenges

This article explains Test‑Driven Development (TDD) as an agile design methodology, outlines the mindset, requirement analysis, test‑first habits, refactoring and unit‑testing considerations, demonstrates the red‑green‑refactor workflow with examples, and discusses common difficulties and best‑practice tips.

TDDdevelopment practicesrefactoring
0 likes · 8 min read
Understanding Test‑Driven Development (TDD): Principles, Considerations, Practices, and Challenges
Architects Research Society
Architects Research Society
Sep 8, 2019 · Fundamentals

Test‑Driven Development (TDD): Concepts, Practices, Myths, and Tools

This article provides a comprehensive overview of Test‑Driven Development, explaining its principles, workflow, relationship to acceptance testing and traditional testing, its impact on design and documentation, challenges in database development, integration with Agile Model‑Driven Development, common myths, adoption statistics, and a curated list of supporting tools.

AgileSoftware engineeringTDD
0 likes · 20 min read
Test‑Driven Development (TDD): Concepts, Practices, Myths, and Tools
DevOps
DevOps
Jun 24, 2019 · Operations

Why TDD Is Essential for Effective DevOps and Continuous Delivery

The article argues that without Test‑Driven Development (TDD) or its extension ATDD, DevOps initiatives and continuous delivery pipelines lack reliable automated testing, making releases risky despite high code‑coverage metrics.

ATDDCI/CDTDD
0 likes · 6 min read
Why TDD Is Essential for Effective DevOps and Continuous Delivery
HomeTech
HomeTech
May 29, 2019 · R&D Management

APD Agile Improvement Case Study of a User Product Center Team

This case study details how a user product center team applied the APD agile methodology and stream development practices—such as visual value streams, explicit process rules, WIP limits, bug‑board visualization, workflow management, and an evolved TDD approach—to double throughput, cut delivery cycles by 60%, and reduce monthly bugs from 50 to 2, demonstrating measurable R&D efficiency gains.

APDAgileMetrics
0 likes · 7 min read
APD Agile Improvement Case Study of a User Product Center Team
360 Quality & Efficiency
360 Quality & Efficiency
Sep 17, 2018 · Fundamentals

13 Software Testing Antipatterns and How to Avoid Them

This article outlines thirteen common software testing antipatterns—from unstable or slow tests and manual test execution to treating test code as second‑class citizens and misusing TDD—explaining their negative impacts and offering practical guidance on building reliable, automated test suites.

CI/CDTDDantipatterns
0 likes · 14 min read
13 Software Testing Antipatterns and How to Avoid Them
ITPUB
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 engineeringTDDclean code
0 likes · 13 min read
How to Achieve Truly Clean Code: Design, Estimation, and Testing Strategies
21CTO
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
DevOps
DevOps
Oct 22, 2017 · Fundamentals

Agile Is Just a Hammer: Reflections on Misusing Agile Practices

The article uses the hammer metaphor to critique treating agile methods as a one‑size‑fits‑all tool, illustrating common misunderstandings through dialogues about user stories, estimation, TDD, pair programming, Kanban, Scrum, SAFe, and continuous delivery, and urging thoughtful adoption.

AgileTDDmethodology
0 likes · 5 min read
Agile Is Just a Hammer: Reflections on Misusing Agile Practices
Tongcheng Travel Technology Center
Tongcheng Travel Technology Center
Sep 21, 2017 · Frontend Development

Understanding Unit Testing and Jest: Concepts, Types, Tools, and Best Practices

This article explains the fundamentals of unit testing, including its importance, various test types, tool categories, implementation principles, hooks, best‑practice guidelines, and introduces the Jest JavaScript testing framework with installation steps, features, and example test scripts for both synchronous and asynchronous code.

BDDJavaScriptJest
0 likes · 9 min read
Understanding Unit Testing and Jest: Concepts, Types, Tools, and Best Practices
21CTO
21CTO
Sep 3, 2017 · Frontend Development

Why JavaScript Fatigue Happens and How to Overcome It

This article examines why JavaScript developers experience fatigue, explains that software exists to reduce costs and increase revenue, and offers practical strategies—such as mastering fundamentals, selective tool use, and test‑driven development—to help engineers stay productive and focused on solving real business problems.

JS fatigueJavaScriptSoftware engineering
0 likes · 18 min read
Why JavaScript Fatigue Happens and How to Overcome It
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Aug 17, 2017 · Frontend Development

Battling JavaScript Fatigue: Real Reasons and Practical Solutions

This article explores the root causes of JavaScript fatigue, emphasizing that software exists to solve business problems, not to please developers, and offers practical advice on focusing on fundamentals, reducing unnecessary tools, applying TDD, and treating software development like city planning to improve efficiency and value.

Software engineeringTDDtool fatigue
0 likes · 20 min read
Battling JavaScript Fatigue: Real Reasons and Practical Solutions
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Aug 11, 2016 · Frontend Development

Master JavaScript Test Cases: TDD, BDD, Mocha, Should, Nock, Istanbul

This guide explains why test cases are essential, compares TDD and BDD agile approaches, and introduces key frontend testing tools—including Mocha for test suites, Should for assertions, Nock for HTTP mocking, and Istanbul for coverage—while providing code examples and best‑practice recommendations for writing maintainable, high‑quality tests.

BDDJavaScriptTDD
0 likes · 8 min read
Master JavaScript Test Cases: TDD, BDD, Mocha, Should, Nock, Istanbul
21CTO
21CTO
Apr 27, 2016 · Mobile Development

Mastering Android Unit Testing: Practical Tips, Tools, and Real-World Cases

This article shares practical experiences and best practices for Android unit testing, covering why testing matters, simple test structures, mocking with Mockito, dependency injection via Dagger2, using Robolectric, CI integration, common pitfalls, and a detailed checkout flow example.

AndroidCIDagger2
0 likes · 25 min read
Mastering Android Unit Testing: Practical Tips, Tools, and Real-World Cases