Ipinapakita ko ang tungkol sa mga problema ng NULL, ngunit araw-araw ang mga news ay nag-iisip sa akin: ang NULL ay mahirap at bumalik. 
 
 TL;DR: Pumunta sa mga NULL references na nagiging sanhi ng runtime crashes sa pamamagitan ng paggamit ng parehong validation at null-safe patterns TL;DR: Pumunta sa mga NULL references na nagiging sanhi ng runtime crashes sa pamamagitan ng paggamit ng parehong validation at null-safe patterns ang problema 
 
 
 
 
 
 
 
 Tungkol sa Crash Mga pangunahing incidents at disruptions Unpredictable ang behavior Tungkol sa Debugging ang frustration ng user Instabilidad ng sistema Malaki ang reliability sa ang case: Ang Google Cloud 
 
 
 
 
 
 Bad error handling: Ang code crashed sa halip ng gracefully handling null data Walang mga feature flags: Ang bagong code ay hindi palagi-palagi na inilabas sa mga seguridad controls Instant Global Replication: Bad data ay lumalabas sa buong mundo ngayong tulad ng sa Crowdstrike Incident Walang randomized backoff: Recovery na nangangahulugan ng infrastructure overload Inadequate testing: Ang error scenario ay hindi na tested sa panahon ng pag-implementasyon Mga Solusyon 
 
 
 
 
 
 
 Huwag ng mga zero Gamitin ang null checks kung ang nulls ay higit sa iyong kontrol ( halimbawa, isang external API) I-initialize ang default values Paggamit ng mga custody clauses Paggamit ng Null Object Huwag gamitin ang optional Ipinanganak ang mga ito ️ https://hackernoon.com/code-refactoring-tips-no-015-remove-null ang konteksto Noong Hunyo 12, 2025, a Nagsimula ang mga ito sa Google Cloud Platform. Pagkakaiba ng Stop Ang mga ito ay nakakaapekto sa duties ng mga serbisyo ng Google Cloud at Google Workspace sa buong mundo mula sa halos 10:49 AM hanggang 1:49 PM PDT (3 oras sa kabuuan), na may ilang mga serbisyo na nangangailangan ng higit pa upang mai-recover ang lahat. Ang pag-uugali ay nangangahulugan sa isang cascading error sa Google's API management system: 
 
 ang trigger: Noong Mayo 29, 2025, inilapat ng Google ang isang bagong code sa "Service Control" (ang kanilang sistema ng pag-management ng API) na idinagdag ng karagdagang mga check ng politika ng quota. Ang code na ito ay may isang kritikal na defect. Ito ay hindi nagkakahalaga Wala siyang proteksiyon sa . Mga error Ang mga flag 
 
 Ang mga Failure: Noong Hunyo 12, isang pagbabago ng politika na naglalaman ng blank/ Pagkatapos ng pagsubok ng Service Control upang pagproseso ang mga empty fields, natagpuan ang isang null pointer sa unprotected code path, kung saan ang binary crashed sa isang infinite loop. ang zero 
 
 Ang global impact ay: Dahil ang pag-management ng quota ay global, ang mga corrupt na data na ito ay replicated sa buong mundo sa loob ng ilang segundo, nangangahulugang ang Service Control sa pag-crash sa lahat ng rehiyon. Ang Null pointer exception ay dumating kapag nagtatrabaho sa pag-access ng mga methods o properties sa mga objekto na hindi kasalukuyang. Ito ay nangyayari kapag ang mga variable ay naglalaman ng null references sa halip ng valid na instances ng object. Ang problemang ito ay magiging karaniwan sa produksyon na mga environment kung saan ang mga exception ay maaaring tumagal ang iyong application at frustrate ang mga gumagamit. Ang mga wika tulad ng Java, C#, at JavaScript ay karamihan sa mga problema na ito, kahit na ang mga modernong mga tampok at pattern ng wika ay maaaring makatulong sa iyo upang maiwasan ang mga crashes na ito sa lahat. Ang Nulls ay isang pangunahing problema sa industriya ng software para sa mga dekada, ngunit ang mga engineer ng software ay patuloy nangangahulugan ang mga ito maliban sa mga admonitions ng kanilang tagapagtatag. https://hackernoon.com/null-the-billion-dollar-mistake-8t5z32d6?embedable=true Sample code Malapit na ang public class ServiceControlPolicy {
  private SpannerDatabase spannerDB;
  private QuotaManager quotaManager;
    
  public void applyPolicyChange(PolicyChange change) {
      // NULL POINTER: change can be null
      Policy policy = spannerDB.getPolicy(change.getPolicyId());
      // NULL POINTER: policy can be null from the database
      String quotaField = policy.getQuotaField();
      // NULL POINTER: quotaField can be null (blank field)
      quotaManager.updateQuota(quotaField, change.getValue());
  }
    
  public void exerciseQuotaChecks(String region) {
      // NULL POINTER: policies list can be null
      List<Policy> policies = spannerDB.getPoliciesForRegion(region);
      for (Policy policy : policies) {
          // NULL POINTER: individual policy can be null
          String quotaValue = policy.getQuotaField();
          // NULL POINTER: quotaValue can be null before trim()
          quotaManager.checkQuota(quotaValue.trim());
      }
  }
    
  public boolean validatePolicyData(Policy policy) {
      // NULL POINTER: policy parameter can be null
      String quotaField = policy.getQuotaField();
      // NULL POINTER: quotaField can be null before length()
      return quotaField.length() > 0 && 
             !quotaField.equals("null");
  }
    
  public void replicateGlobally(PolicyChange change) {
      List<String> regions = getGlobalRegions();
      for (String region : regions) {
          // NULL POINTER: change.getPolicy() can return null
          spannerDB.insertPolicy(region, change.getPolicy());
      }
  }
}
 ang right public class ServiceControlPolicy {
  private SpannerDatabase spannerDB;
  private QuotaManager quotaManager;
    
  public void applyPolicyChange(PolicyChange change) {
      if (change == null) {
          // Assuming it comes from an external API
          // Beyond your control
          change = new NullPolicyChange();
      }
      
      Policy policy = findPolicyOrNull(change.policyId());
      String quotaField = policy.quotaField();
      if (!quotaField.isEmpty()) {
          quotaManager.updateQuota(quotaField, change.value());
      }
  }
    
  public void exerciseQuotaChecks(String region) {
      if (region == null || region.isEmpty()) {
          // Assuming it comes from an external API
          // Beyond your control
          return;
      }
      
      List<Policy> policies = policiesOrEmpty(region);
      
      for (Policy policy : policies) {
          String quotaValue = policy.quotaField();
          if (!quotaValue.isEmpty()) {
              quotaManager.checkQuota(quotaValue.trim());
          }
      }
  }
    
  public boolean validatePolicyData(Policy policy) {
      if (policy == null) {
          // Assuming it comes from an external API
          // Beyond your control
          // From now on, you wrap it
          policy = new NullPolicy();
      }
      
      String quotaField = policy.quotaField();
      return quotaField.length() > 0;
  }
    
  public void replicateGlobally(PolicyChange change) {
      if (change == null) {
          // Assuming it comes from an external API
          // Beyond your control
          // From now on, you wrap it
          change = new NullPolicyChange();
      }
        
      Policy policy = change.policy();
      if (policy == null) {
          // Assuming it comes from an external API
          // Beyond your control
          // From now on, you wrap it
          policy = new NullPolicy();
      }
        
      List<String> regions = globalRegions();
      for (String region : regions) {
          spannerDB.insertPolicy(region, policy);
      }
  }
    
  private Policy findPolicyOrNull(String policyId) {
      Policy policy = spannerDB.policy(policyId);
      return policy != null ? policy : new NullPolicy();
  }
    
  private List<Policy> policiesOrEmpty(String region) {
      List<Policy> policies = spannerDB.policiesForRegion(region);
      if (policies == null) {
          // This is a good NullObject
          return Collections.emptyList();
      }
      
      return policies.stream()
              .map(p -> p != null ? p : new NullPolicy())
              .collect(Collectors.toList());
  }
}

class NullPolicy extends Policy {
  @Override
  public String quotaField() { return ""; }
    
  @Override
  public String policyId() { return "unknown-policy"; }
    
  @Override
  public Map<String, String> metadata() { 
      return Collections.emptyMap(); 
  }
}

class NullPolicyChange extends PolicyChange {
  @Override
  public String policyId() { return ""; }
    
  @Override
  public String value() { return ""; }
    
  @Override
  public Policy policy() { return new NullPolicy(); }
}
 Mga Deteksiyon 
 
 [x] Ang mga halimbawa ay Maaari mong i-detect potential null pointer exceptions sa pamamagitan ng pag-review ng code para sa direct method calls sa mga objekto nang walang null checks. Ang mga linters ay maaaring i-examine ang return values mula sa mga paraan na maaaring i-return , paghahanap para sa uninitialized object fields, at gumagamit ng static analysis tools na flag potensyal null dereferences. ang zero Ang mga modernong mga ideya ay karaniwang nag-aalok ng mga problema na ito sa pamamagitan ng mga warning. Mga araw ️ 
 
 ang zero ang level 
 
 [x] Ang mga sumusunod Bakit importante ang pagbabago ️ sa mga Ang mga bagay ay mayroon o hindi. ang real world Kapag bumalik na ako sa UP, i'll start building a new me. sa pagitan ng reality at code. Mga Correspondence I-break ang bijection na ito sa pamamagitan ng pagganap ng null references ay lumikha ng phantom na mga objekto na ginagamit sa iyong code ngunit hindi sa real world, na nangangahulugan sa mga crashes kapag nagtatrabaho sa pag-interact sa mga inexistent na entities. Kung nag-aalok mo ang pangalan ng iyong license plate "NULL", makakuha ka ng maraming parking ticket Ikaw ang Generation Ang mga generator ng AI ay karaniwang lumikha ng code na may zero pointer vulnerabilities dahil nag-focus sa happy path scenarios. Ang mga ito ay karaniwang lumikha ng mga call ng methode nang hindi nila tinanggap ang mga kaso ng edge kung saan ang mga objekto ay maaaring maging , lalo na sa mga kompleksong hierarchy ng object o kapag nagtatrabaho sa mga eksternal na source ng data. ang zero Mga Deteksiyon Ang mga tool ng AI ay maaaring i-detect at i-fix ang mga problema ng null pointer kapag ibinigay mo ang mga katangian tungkol sa defensive programming practices. Tapos na ang klase. 🙂 🙂 Tandaan: Ang mga assistant ng AI ay gumagawa ng maraming mga error 
 
 Suggested Prompt: I-remove ang lahat ng Null References Suggested Prompt: I-remove ang lahat ng Null References 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Without Proper Instructions 
 With Specific Instructions 
 
 
 
 ChatGPT 
 ChatGPT 
 
 
 
 Claude 
 Claude 
 
 
 
 Perplexity 
 Perplexity 
 
 
 
 Copilot 
 Copilot 
 
 
 
 Gemini 
 Gemini 
 
 
 
 DeepSeek 
 DeepSeek 
 
 
 
 Meta AI 
 Meta AI 
 
 
 
 Grok 
 Grok 
 
 
 
 Qwen 
 Qwen ang chat ang chat si Claude si Claude ang perplexity ang perplexity Mga Pilot Mga Pilot Mga Gemini Mga Gemini Mga pahinang Mga pahinang Ang meta ay Meta AI ang guro ang guro ang kwento ang kwento Mga Konklusyon Null pointer exceptions represent one of the most common runtime errors in programming. Maaari mong i-remove ang karamihan ng mga crash na ito sa pamamagitan ng pag-implementasyon ng parehong null checks, gamit ang Null Object design pattern, at paggamit ng defensive programming practices. Ang maliit na overhead ng code ng pag-validation ay magkakaroon ng malaking pagbabago sa application stability at user experience. https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iii-t7h3zkv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xliii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxix https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xlii https://hackernoon.com/code-smell-252-nullcustomer?embedable=true https://hackernoon.com/code-smell-260-crowdstrike-null?embedable=true Higit pang impormasyon https://status.cloud.google.com/incidents/ow5i3PPK96RduMcb1SsW?embedable=true https://www.wired.com/story/null-license-plate-landed-one-hacker-ticket-hell/?embedable=true https://www.forbes.com/sites/zakdoffman/2019/08/14/hacker-gets-12000-in-parking-tickets-after-null-license-plate-trick-backfires/?embedable=true Disclaimer Code Smells ay ang aking . opinyon 
 
 I call it my billion-dollar mistake. Ito ay ang invention ng null reference noong 1965. I call it my billion-dollar mistake. Ito ay ang invention ng null reference noong 1965. Si Tony ay https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true Ang artikulong ito ay bahagi ng CodeSmell Series. https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-i-xqz3evd?embedable=true

Winner of Noonies 2020 for the award Hacker Noon Contributor of the Year - REFACTORING.

2020 - Hacker Noon Contributor of the Year in REFACTORING

2022 - HackerNoon Contributor of the Year - Clean Code

2022 - HackerNoon Contributor of the Year - Debugging

2022 - HackerNoon Contributor of the Year - Github

2022 - HackerNoon Contributor of the Year - Machine Learning

2022 - HackerNoon Contributor of the Year - Quality Assurance

2022 - HackerNoon Contributor of the Year - Refactoring

2022 - HackerNoon Contributor of the Year - Software Architecture

2022 - the Greatest Storyteller

Buy My Book

Share your ideas with me!

Read My Stories

Buy Me a Coffee

Software Engineer and Book Author

Ang audio na ito ay ginawa sa orihinal na wika ng kuwento!

Masyadong mahaba; Upang basahin

Code Smell 304: Ang Null Pointer Exception - Paano Pumunta sa NULL References na Nagkakaroon ng Runtime Crashes

Code Smell 304: Ang Null Pointer Exception - Paano Pumunta sa NULL References na Nagkakaroon ng Runtime Crashes

About Author

MGA KOMENTO

HANG TAGS

ANG ARTIKULONG ITO AY IPINAKITA SA

Related Stories

State of the Noonion: The Year of Profitability and Product Renaissance

Getting intimate with Ethereum tokens

Encrypted Instant Messaging Recommendations January 2017

COVID-19: We Need More Than Data, We Need Insights!

State of the Noonion: The Year of Profitability and Product Renaissance

Getting intimate with Ethereum tokens

Encrypted Instant Messaging Recommendations January 2017

COVID-19: We Need More Than Data, We Need Insights!

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps