The term ‘nil’ refers to the absence of value, but we often imbue it with much more meaning than just that. Today, hosts Joël and Stephanie discuss the various ways we tend to project extra semantics onto nil and the implications of this before unpacking potential alternatives and trade-offs.

Joël and Stephanie highlight some of the key ways programmers project additional meaning onto nil (and why), like when it’s used to create a guest session, and how this can lead to bugs, confusion, and poor user experiences. They discuss solutions to this problem, like introducing objects for improved readability, before taking a closer look at the implications of excessive guard clauses in code.

Our hosts also explore the three-state Boolean problem, illustrating the pitfalls of using nullable Booleans, and why you should use default values in your database. Joël then shares insights from the Elm community and how it encourages rigorous checks and structured data modeling to manage nil values effectively.

They advocate for using nil only to represent truly optional data, cautioning against overloading nil with additional meanings that can compromise code clarity and reliability. Joël also shares a fun example of modeling a card deck, explaining why you might be tempted to add extra semantics onto nil, and why the joker always inevitably ends up causing chaos!


Key Points From This Episode

• The project Joël is working on and why he’s concerned about bugs and readability.
• Potential solutions for a confusing constant definition in a nested module.
• A client work update from Stephanie: cleaning up code and removing dead dependencies.
• How she used Figjam to discover dependencies and navigate her work.
• Today’s topic: how programmers project extra semantics onto nil.
• What makes nil really tricky to use, like forcing you to go down a default path.
• How nil sweeps the cases you don’t want to think too hard about under the rug.
• Extra semantics that accompany nil (that you might not know about) like a guest session.
• Examples of how these semantics mean different things in different contexts.
• How these can lead to bugs, hard-to-find knowledge, confusion, and poor user experiences.
• Introducing objects to replace extra nil semantics, improve readability, and other solutions.
• Some of the reasons why programmers tend to project extra semantics onto nil.
• How to notice that nil has additional meanings, and when to model it differently.
• The implications of excessive guard clauses in code.
• An overview of the three-state Boolean problem with nullable Booleans.
• Connecting with the Elm community: how it can help you conduct more rigorous checks.
• Some of the good reasons to have nil as a value in your database.
• The benefits of using nil only to represent truly optional data.

Links Mentioned in Today’s Episode

• Figjam
• Miro
• 'Working Iteratively' blog post
• Mermaid.js
• Draw.io
• Check your return values (web)
• Check your return values (API)
• Primitive obsession
• 'Avoid the Three-state Boolean Problem'
• Elm Community
• 'The Shape of Data': Modeling a deck of cards
• The Bike Shed
• Joël Quenneville on LinkedIn

Support The Bike Shed