This article compiles ten practical code snippets and command patterns—from Go error handling and Git workflows to defensive programming tricks—that Tencent engineers rely on daily, helping developers build muscle memory for common tasks.
Learn how to use Unicode zero‑width characters as hidden watermarks in web content, encode employee IDs into plain text, detect leaks with a simple JavaScript tool, and understand the encoding/decoding process, limitations, and removal methods for this low‑cost defensive technique.
This comprehensive guide explains defensive programming concepts, core principles, practical rules, and advanced techniques—showing how to validate inputs, handle exceptions, manage resources, use immutability, and apply system‑level patterns like circuit breakers and rate limiting to build robust, maintainable Java applications.
This article explains why defensive programming is essential, outlines its core principles, presents common failure scenarios and practical guidelines, and shows how testing and observability can turn inevitable errors into controlled, recoverable events that keep systems stable and maintainable.
This article explains why defensive programming is crucial for production‑grade Spring Boot 3 applications and presents eight concrete patterns—ranging from Optional‑based NPE safety and collection handling to configuration validation, async management, transaction control, testing, exception handling, circuit‑breaker integration, and reactive programming—each illustrated with real‑world code examples and best‑practice recommendations.
This article explains why top tech companies forbid the loose equality operator (==) in JavaScript, detailing its unpredictable implicit type coercion, contrasting it with strict equality (===), and showing common pitfalls and safer alternatives for robust, maintainable code.
A new Java developer caused a production NullPointerException while matching third‑party data, and the article walks through reproducing the bug, analyzing each faulty line, and applying defensive programming techniques such as early returns, Optional, Objects.equals, and collection checks to prevent similar crashes.
A junior Java developer encounters a NullPointerException while integrating third‑party data into a Spring Boot backend, and the article walks through reproducing the bug, analyzing each faulty line, and presenting defensive‑programming, ternary, Optional, and utility‑class solutions plus a SonarLint recommendation.
This article explains defensive programming as a proactive coding paradigm that anticipates and mitigates errors through input validation, error handling, assertions, and continuous testing, and demonstrates its application with detailed Java examples covering pagination, loop safety, exception management, and boundary checks.
This article introduces defensive programming, explains its fundamental concepts and core principles such as risk identification and input validation, and demonstrates practical applications through multiple Java code examples covering pagination, loop prevention, exception handling, boundary checks, and assertions to improve software robustness.
Defensive programming is a proactive coding paradigm that anticipates errors and exceptions, emphasizing input validation, error isolation, assertions, thorough testing, and clear error handling, with practical examples ranging from pagination parameter checks to loop safeguards, illustrating how to enhance software robustness and stability.
This article explains MyBatis dynamic SQL, recounts a first‑hand OOM incident caused by missing backend validation, and shares practical lessons on parameter checking, balancing reusable versus specialized interfaces, and adopting defensive programming to build more reliable backend systems.
The article explains how defensive programming extends beyond simple input checks to include comprehensive data validation, parameter verification, illegal data handling, and collaborative design practices that protect systems from both code errors and external misuse.
This article presents a real-world Java backend case where null pointer exceptions arise during data matching and batch insertion, analyzes the root causes in each code line, and offers defensive programming, ternary, Optional, collection checks, and utility methods to safely handle null values.
This article discusses the proper use of null‑checking in Java, distinguishes between valid and invalid null returns, proposes alternatives such as returning empty collections, using assertions or throwing exceptions, and demonstrates the Null Object pattern with concrete code examples while also noting related community resources.
Java developers constantly battle NullPointerExceptions, a historic flaw introduced by Tony Hoare, but modern JDKs provide clearer messages and defensive techniques—such as explicit null checks, utility methods, avoiding null returns, and using Optional—can dramatically reduce these runtime errors.
The article explores the notorious Java NullPointerException, its historical roots in Tony Hoare's introduction of null, modern JDK 14 diagnostic improvements, and practical defensive programming techniques—including explicit null checks, avoiding null returns, and leveraging Optional—to write safer, more robust code.
This article revisits defensive programming, explores quirky variable‑naming techniques—including single‑character, Chinese, and multilingual identifiers—and humorously breaks down core OOP concepts while stressing the developer’s irreplaceable role in modern software projects.
Tencent’s team successfully took over a 93‑service legacy content architecture, stabilizing it by building comprehensive monitoring, creating detailed code walkthrough documentation, fixing critical bugs, and streamlining R&D processes, which cut daily alerts from 159 to zero, reduced business incidents, and lowered on‑call staffing dramatically.
This article walks through a real Java NPE incident, reproduces the faulty code, analyzes each null‑pointer cause, and presents defensive programming, Optional, and utility‑method solutions, while also recommending the SonarLint plugin for early detection of such bugs.
This article presents a real-world Java backend case where a newly hired developer caused a NullPointerException during data matching and batch insertion, analyzes each line of the problematic code, and offers defensive programming techniques such as null checks, Optional, and utility methods to avoid NPEs.
This article walks through a real‑world NPE incident in a Java SpringBoot service, demonstrates how four lines of code can cause three null‑pointer exceptions, and provides practical defensive‑programming solutions such as early returns, ternary checks, Optional, and utility methods to eliminate these bugs.
This article walks through a real production NPE incident in a Java backend, reproduces the faulty code, analyzes each null‑pointer cause, and presents defensive programming, ternary, Optional, and utility‑library solutions while recommending SonarLint for automatic detection.
The article outlines defensive programming concepts, emphasizing input validation, error handling, resource management, isolation techniques, and design considerations such as thread safety, cache strategies, and interface versioning to build robust and resilient software systems.
This article explains defensive programming for front‑end developers, covering its definition, the three pillars of prevention, correction and direction, common UI and code crisis points, detailed code‑review checklists, CSS defensive rules, and responsive design considerations to build resilient, user‑friendly applications.
This article examines the challenges of repetitive if‑else parameter checks, introduces Hibernate Validator as a JSR‑303 implementation, demonstrates how to build a reusable validation module, and shares best‑practice patterns for integrating elegant, decoupled validation into Java backend systems.
This article explains why excessive null‑checking in Java code is problematic, distinguishes between cases where null is a valid response and where it signals an error, and shows how returning empty collections or applying the Null Object pattern can eliminate redundant checks.
This article explains how to write robust Java code by applying defensive programming techniques such as guard clauses, proper exception handling, validator usage, assertions, and the DRY principle, while illustrating each concept with clear code examples and practical guidelines.
The article explains how defensive programming in Java—using guard clauses, validators, and side‑effect‑free assertions—prevents errors, outlines proper exception handling by distinguishing checked from unchecked exceptions, and reinforces the DRY principle, urging developers to abstract repeated logic after three occurrences.
This article explains how to write robust Java code by applying defensive programming, using guard clauses, proper exception handling, validator patterns, assertions, and the DRY principle, offering concrete code examples and practical advice for building reliable software.
The article explores how adopting a "don't trust" mindset—through rigorous input validation, defensive coding, thorough testing, gradual rollouts, and comprehensive monitoring—helps build resilient, high‑performance systems and avoid common pitfalls in development and operations.
The article explores defensive programming and contract programming, discussing how to handle unexpected JSON data, the role of assertions and exceptions, and the trade‑offs between strict error handling and contractual code design for building robust software.
This article explains defensive programming concepts for PHP developers, illustrating why anticipating failures, never trusting user input, avoiding assumptions, maintaining narrow focus, and keeping consistent syntax can dramatically reduce bugs and improve code reliability.
After two decades of coding, the author shares ten defensive, often‑considered paranoid Java programming practices—such as placing constants on the left side of equals, guarding against NullPointerExceptions, treating -1 as a valid index, using final for methods, variables, and parameters, and handling switch statements—to promote more robust code.
To avoid NullPointerException in Java, use string literals with equals, prefer String.valueOf over toString, employ null‑safe libraries like Apache Commons StringUtils, return empty collections instead of null, annotate with @NotNull/@Nullable, prevent unnecessary autoboxing, define sensible defaults, and use Jackson's path method for safe JSON navigation.
