🐥 YellowDuck.be

🔗 The stack behind There There

2026-06-26T17:00:00Z

What does a modern support application look like? In a revealing piece, Freek shares the technical stack underpinning the beta version of There There, a Laravel app developed by Spatie. Utilizing a mix of proven frameworks and tools, they prioritize stability and maintainability over the latest trends. The choice of Laravel, combined with AI capabilities and a structured code organization by domain, allows for efficient service delivery.

The integration of Inertia and React offers a seamless user experience, while Laravel's ecosystem enriches functionality through custom packages. The article outlines not just the elegant configuration but also the mundane yet crucial infrastructure that supports smooth operations. This stack not only enhances productivity but also ensures reliability in managing customer interactions, bridging the gap between technology and user satisfaction.

Continue reading on there-there.app

#reading-list #development #frontend #laravel #ai

🔗 #[RouteParameter] does not bind your model

2026-06-26T13:00:00Z

If #[RouteParameter] in your Laravel form request receives a string instead of a model, it's often not about failed binding but about the absence of binding altogether. Laravel's #[RouteParameter] attribute enhances type safety but only reads the current route parameter value. It does not perform route model binding, which means if the controller doesn't provide enough information for implicit binding, the form request might get the raw route string instead of an Event model.

This article dives into the nuances of using #[RouteParameter] in form requests and highlights why it's crucial to keep the model in both the controller method signature and the form request constructor. It articulates a vital point: Laravel relies on the controller's method signature to perform implicit route model binding. Without it, the model won't be resolved correctly, potentially leading to errors. Understanding this can save developers from common pitfalls in Laravel's routing and request handling.

Continue reading on dyrynda.com.au

#reading-list #laravel #php #best-practice

🔗 Why enterprise AI projects fail: 5 root causes & fixes

2026-06-26T08:00:00Z

Enterprise AI failure is rarely a modeling problem. Instead, projects stall due to organizational structures that don’t support deployment. A proof-of-concept may clear its demo, but then the initiative can languish for months, with no single role accountable for moving forward. For CTOs and Heads of AI in mid-to-large enterprises, this structural issue is pervasive, as highlighted in the analysis of five key failure modes that hinder AI initiatives from reaching production.

According to industry research, 90% of corporate AI initiatives struggle beyond test stages, often due to organizational priorities favoring technology over strategy, rather than issues with the model itself. The article delves into these failure modes, offering actionable fixes to ensure that AI projects transition smoothly from pilots to production-ready systems. By addressing common pitfalls like pilot purgatory and lack of ownership, organizations can enhance their chances of success.

Continue reading on www.netguru.com

#reading-list #development #best-practice #ai

🔗 What is AI governance?

2026-06-25T17:00:00Z

AI governance is becoming essential as organizations increasingly rely on AI for critical functions. A recent report highlighted that 60% of organizations have AI agents in production, but 40% see security and compliance as the top barrier to scaling. This gap illustrates the urgent need for a governance framework that aligns AI development with ethical, legal, and operational standards.

Effective AI governance addresses risks, ensures compliance, and fosters user trust by instituting clear rules and ongoing monitoring throughout the AI lifecycle. It incorporates principles such as transparency, accountability, and fairness to counter biases in AI models and management of sensitive data.

With regulatory landscapes evolving rapidly—including the EU's AI Act and the NIST AI Risk Management Framework—an established governance strategy becomes even more critical for organizations aiming to harness AI safely and responsibly.

Continue reading on www.docker.com

#reading-list #best-practice #ai #auth

🔗 How Erlang's parser tools saved my DSMR library

2026-06-25T13:00:00Z

Have you ever been buried under a maze of regex and string operations? Robin van der Vleuten shares how he faced this dilemma while working on a DSMR library for smart meter data. Initially relying on chaotic regex patterns, van der Vleuten struggled with parsing errors and maintenance challenges. The breakthrough came when he discovered Erlang's leex and yecc.

These tools allowed him to define clear patterns and grammar rules, transforming the parsing process into a more declarative approach. By separating concerns, enhancing error reporting, and improving performance, these parser tools not only streamlined his library but also reminded him of the value of established solutions in programming.

The library is now open source and effectively handles various DSMR versions and smart meter types, embodying the lesson that sometimes older tools are the best fit for complex tasks.

Continue reading on robinvdvleuten.nl

#reading-list #development #elixir

🔗 AI literacy is not prompt literacy. Ann Handley says it's judgment literacy

2026-06-25T08:00:00Z

Ann Handley argues that true AI literacy extends beyond prompt engineering to encompass judgment literacy. She highlights a critical question often overlooked in AI training: when should we refrain from using AI tools to preserve essential learning? While prompt literacy can be taught quickly, developing judgment literacy takes time and experience, as it involves understanding the value of struggle and learning.

The AI training industry tends to focus on tool usage, ignoring the importance of knowing when not to use them. Handley suggests that fostering a culture of thoughtful AI usage, rather than merely offering courses, is vital for cultivating this necessary judgment.

This insight shifts the emphasis from mere skills acquisition to deeper professional wisdom, stressing that the nuances of human insight remain irreplaceable in many contexts where AI tools might otherwise dominate.

Continue reading on www.searchenginejournal.com

#reading-list #development #best-practice #ai

🔗 Test coverage won't save you

2026-06-24T17:00:00Z

What happens when coding agents take over? In her insightful article, Jenn Cooper highlights a major flaw in relying solely on testing in AI-generated codebases. While high test coverage may seem like a safety net, it primarily locks in existing behaviors, good or bad. This can lead to a creeping architectural drift, where problematic patterns become entrenched without anyone noticing.

To counter this, she advocates for fitness functions that evaluate the overall shape and coherence of the system, not just individual components. By implementing macro-level checks and creating friction during coding, teams can guide agents towards healthier coding practices and ensure a more coherent codebase. The discussion resonates with anyone tasked with maintaining code quality in an era increasingly influenced by AI.

Continue reading on forestwalk.ai

#reading-list #best-practice #ai #testing

🔗 How I use LLMs as a staff engineer in 2026

2026-06-24T13:00:00Z

A year can bring significant changes in technology use. In this article, the author reflects on how they leverage large language models (LLMs) as a staff engineer in 2026, detailing a notable enhancement in efficiency and accuracy. Tasks that once required close supervision, such as writing code changes and debugging, have become more streamlined with current models that can analyze complex problems independently.

The article highlights a shift from skepticism to reliance, with LLMs now effectively handling routine tasks while the engineer focuses on strategic judgment. The author notes routine usage for investigating bugs and generating pull requests, while still emphasizing the importance of human oversight when it comes to critical communications and UI testing. As LLM technology evolves, the balance of delegation and supervision remains a key consideration.

Continue reading on www.seangoedecke.com

#reading-list #development #best-practice #ai

🔗 How to write "garbage code" (by Linus Torvalds)

2026-06-24T08:00:00Z

Linus Torvalds recently criticized a Meta engineer for submitting subpar code late in a merge window, calling it "garbage". He emphasized that good code should minimize cognitive load for all readers, including software engineers and LLMs. By reducing unnecessary abstractions and helper functions, developers can maintain clarity and simplicity in their code. This approach aligns with the PRY principle of repeating oneself to enhance comprehension.

The article underscores that task-switching incurs cognitive costs, suggesting sometimes duplication may actually help rather than hinder understanding. It also highlights that being rude about code failures can discourage contributions, advocating for a more supportive and constructive coding environment.

Continue reading on read.engineerscodex.com

#reading-list #development #best-practice #git

🔗 Build an MCP server with Laravel (and use it to publish this post)

2026-06-23T17:00:00Z

Every MCP server tutorial you'll find is written in Python or TypeScript. If you're a Laravel developer, you've been left out of the conversation — until now. Laravel's official laravel/mcp package lets you build MCP servers that expose your application's functionality directly to AI assistants like Claude. This setup eliminates traditional concerns like REST API design and authentication tokens. In just about 20 minutes, the author created an MCP server to manage this very blog post.

The article dives into the Model Context Protocol (MCP), an open standard that enables AI assistants to perform structured actions with clear inputs and outputs. With Laravel's support for both stdio and HTTP transports, users can effortlessly query, create, update, and publish blog posts, all without navigating a browser. From tools like CreatePostTool to PublishPostTool, each section details simple class implementations, helping developers seamlessly integrate AI interactions with their Laravel applications.

Continue reading on thunk.dev

#reading-list #laravel #php #ai

🔗 Software engineering discipline and posture

2026-06-23T13:00:00Z

There’s something quietly dignified about a clean commit history and well-written documentation. This article by Blain Smith emphasizes that engineering discipline is rooted in respect for teammates. Respect isn't just a thumbs-up emoji; it’s about naming variables wisely and writing comprehensive documentation that doesn’t assume prior knowledge.

Commits serve as ongoing conversations, not merely logs of activity. Each commit message should prioritize clarity, recognizing that it may be read long after its creation. Pull requests are portrayed as invitations for collaboration, requiring context and clarity rather than vague demands. The piece stresses the importance of making improvements every time code is touched, no matter how small. Ultimately, engineering transcends merely shipping features; it’s about enhancing the experience for future developers, thus advocating for a respectful, disciplined approach to software craftsmanship.

Continue reading on blainsmith.com

#reading-list #development #best-practice #git

🔗 Pair-programming is a cheat code

2026-06-23T08:00:00Z

Pair-programming is often called a cheat code for developers and businesses alike. It not only accelerates decision-making but also promotes real-time code reviews and knowledge transfer. Instead of enduring lengthy pull-request reviews, pairs can bounce ideas off one another immediately, reducing the risk of expensive changes late in the development cycle.

Additionally, frequently rotating pairs helps prevent knowledge silos, ensuring that no single developer is solely responsible for critical areas of the codebase. This method also serves as an effective teaching tool for junior developers, allowing them to absorb best practices quickly. In a world increasingly influenced by AI, maintaining this collaborative practice becomes crucial for keeping skills and knowledge current.

Overall, the benefits of pair-programming are clear, encouraging teams to embrace it more fully for long-term success.

Continue reading on www.germanvelasco.com

#reading-list #development #pattern #best-practice

🔗 GenServer state management in Elixir: A production order book

2026-06-22T17:00:00Z

One GenServer manages critical aspects of trading like open positions, pending orders, and strategy state in real-time systems. This article highlights the state struct that powers the RealtimeTrader, which functions as a session-scoped process in a trading pipeline. It breaks down the state management into three essential categories: runtime data comprising orders and account balance, collaborator references for dependency management, and operational flags that control system behavior.

The article emphasizes design choices that allow strategies to maintain state effectively and how important features like trading flags can prevent system errors, ensuring trading activities run smoothly. Furthermore, readers gain access to full source code, enabling them to see production-grade implementations directly in action.

Continue reading on seriousalchemy.com

#reading-list #development #pattern #elixir

🔗 Concurrent reads, serialized writes with GenServer and Registry

2026-06-22T13:00:00Z

GenServer is often a beginner's first encounter with Elixir, but common pitfalls can arise, especially concerning data access patterns. This article highlights an issue when using GenServer.call for reading data as it serializes requests, blocking concurrent access and affecting performance, such as the refresh timer for data.

The solution involves utilizing Registry, which allows registering processes and storing data without the complexities of managing ETS lifecycle. By implementing a via tuple, the GenServer can store its state in Registry, enabling concurrent read access. The article provides a practical example with the FXRates module demonstrating how to effectively use Registry to facilitate concurrent reads while still serializing writes. This approach not only optimizes access patterns but simplifies code management as well.

Continue reading on distantprovince.by

#reading-list #pattern #best-practice #elixir

🔗 The beginning of programming as we’ll know it

2026-06-22T08:00:00Z

In the wake of AI coding assistants like Claude and Codex, many wonder if the role of a computer programmer is coming to an end. While it seems AI can perform tasks in minutes, it is not time to count human programmers out. Currently, human developers are essential for overseeing AI outputs because they infuse wisdom and creativity, which AI lacks.

Although there are many success stories of AI constructing applications from specifications, they often overshadow numerous AI failures that produce unusable code. The reality is that AI-generated code cannot be deemed complete until a human reviews and corrects it. Adopting a healthy skepticism towards AI outputs will help developers maintain quality standards.

As the landscape evolves, those who leverage AI effectively without relinquishing control will likely remain indispensable in their roles. This mantra echoes across all creative professions, reminding us that human oversight is paramount in the face of advancing technology.

Continue reading on bitsplitting.org

#reading-list #development #best-practice #ai

🔗 Rust vs Go: A hands-on comparison

2026-06-21T17:00:00Z

Oh no, not another 'Is Rust better than Go?' article. Seriously, haven't we all had our fill of these comparisons by now? But before you sigh in exasperation, hear us out!

Many comparisons between Go and Rust emphasize their differences in syntax and the initial learning curve. However, ultimately, what matters is the ease of use for non-trivial projects.

Since we are a platform-as-a-service provider, we think that we can contribute the most by showing you how to build a small web service in both languages. We will use the same task and popular libraries for both languages to compare the solutions side-by-side so that you can make up your own mind and get a feel for what it's like to work in each ecosystem.

So, before you dismiss this as 'just another comparison', give it a read. There might be some details that other comparisons have missed before.

Continue reading on www.shuttle.dev

#reading-list #golang #rust #development

🔗 Reading a 200k-line codebase you didn't write: a field guide

2026-06-21T13:00:00Z

Is it really possible to understand a sprawling 200,000-line codebase that someone else authored? Christoph Beck's article presents a practical guide to tackling inherited code through a systematic approach. Starting without diving directly into the files, Beck emphasizes the importance of first interpreting the project's structure, including the directory tree, dependency manifests, CI configuration, and git history.

By pairing human intuition with coding agents, developers can uncover insights about the codebase's history and current state. The article details how to analyze project components efficiently, looking for clues that highlight the team’s practices and any lurking issues. With quick commands and thoughtful interpretation, readers gain a comprehensive understanding of how a legacy codebase functions before they read a single line of code.

Continue reading on bitcrowd.dev

#reading-list #development #best-practice #ai #git

🔗 Claude talk small. Code still big.

2026-06-21T08:00:00Z

AI coding assistants often provide lengthy explanations with every change. But what if they cut down on chatter?

The author shares their experience using the "Caveman" skill, which simplifies AI output to short, effective phrases like "Me fix bug". While this approach saved tokens, the actual savings were less than anticipated.

Most tokens are spent on reading files and generating code, rather than on explanations alone. Despite this, there's merit in the brevity for simple tasks, keeping reviews light-hearted and efficient.

However, for more complex changes, traditional communication is still essential to capture important context.

In conclusion, while the Caveman skill doesn't revolutionize AI coding assistants, it provides a lighter, more amusing way to handle quick tasks.

Continue reading on spatie.be

#reading-list #development #best-practice #ai

🔗 OAuth 2.0 – device flow explained for engineers, especially for backend engineers

2026-06-20T17:00:00Z

A frustrating login experience with long passwords on devices led to the development of OAuth 2.0 device flow. This flow provides a practical solution for scenarios where typing passwords is unfeasible, such as on smart TVs or IoT devices.

The article details how to implement this flow step-by-step using a command-line interface called mycli. It breaks down how to handle the authorization process effectively, manages polling, and explains the various server responses that developers must anticipate.

With real-world examples of how this flow enhances user experience, the piece serves as a guide for backend engineers to streamline authentication processes for users facing input constraints, ultimately urging developers to implement it in their applications.

Continue reading on stackoverflow.blog

#reading-list #development #http #auth

🔗 Laravel MCP: Getting started

2026-06-20T13:00:00Z

Your AI coding agent writes better code when it has real context about your application.

This article examines the Laravel MCP, which provides a structured way to expose your app’s capabilities to AI clients, like ChatGPT and Claude. Without MCP, AI agents can misinterpret your app's architecture, causing them to guess column names and routes. By utilizing the laravel/mcp package, developers can build an MCP server that allows their applications to interact intelligently with AI.

This starts to shine when integrating with non-technical users, simplifying data access without needing knowledge of APIs or CLI calls. The piece also covers practical steps for setting up an MCP server, tools, resources, prompts, and authentication methods, ensuring that readers can effectively harness AI to interact seamlessly with their Laravel applications.

It drives home the importance of structured integration as development scales, particularly in enterprise environments.

Continue reading on laravel.com

#reading-list #laravel #php #ai

🔗 Credence: Elixir semantic linter

2026-06-20T08:00:00Z

A semantic linter for LLM-generated Elixir code.

Elixir's compiler checks syntax. Credo checks style. Credence checks semantics — it mainly catches patterns that compile and pass tests but are non-idiomatic, inefficient, or ported from Python/JavaScript conventions that don't belong in Elixir.

Continue reading on hex.pm

#reading-list #development #tools #elixir

🔗 The tacit dimension: why your best engineers can't tell you what they know

2026-06-19T17:00:00Z

In today's software development landscape, the tacit knowledge held by experienced engineers is undervalued and often overlooked. This article argues that while explicit knowledge is easily documented and processed by AI, the intuitive insights and patterns recognized by seasoned developers are impossible to articulate or transfer effectively to artificial intelligence.

The piece draws on Michael Polanyi's concept of tacit knowledge to illustrate how many crucial understandings in engineering cannot be reduced to written words. As teams increasingly rely on AI for coding tasks, there's a rising danger of losing this invaluable insight, which could leave future engineers ill-equipped to navigate complex codebases.

The author warns that, without intentional mentorship and collaboration, the next generation could experience a decline in critical thinking and problem-solving skills, making the role of experienced engineers more essential than ever.

Continue reading on cekrem.github.io

#reading-list #development #best-practice #ai

🔗 AI’s impact on software engineers in 2026: key trends, Part 2

2026-06-19T13:00:00Z

What if AI tools not only boost productivity but also lead to decreased code quality? In this concluding part of the series, Gergely Orosz and Elin Nilsson delve into the findings from over 900 survey responses regarding AI's effects on software engineers by 2026. They reveal that while AI can reduce the time spent on routine tasks, it introduces new challenges like unrealistic expectations and quality issues.

Many companies struggle with large-scale adoption, finding that effective AI use depends heavily on existing engineering practices. Engineers report a decline in codebase quality, with more bugs sneaking into projects and less experienced programmers grappling with AI-generated code. The piece emphasizes the need for robust guidelines and highlights the complex influence of AI on collaboration, highlighting varying impacts based on individual adaptability and team culture.

Continue reading on newsletter.pragmaticengineer.com

#reading-list #development #best-practice #ai

🔗 High performance Git

2026-06-19T08:00:00Z

Git serves multiple roles beyond just version control; it operates as a content-addressed database, a filesystem cache, and more. This article dives into the different layers of Git, discussing the performance implications of objects, refs, the index, and history traversal. It covers advanced topics like packfiles, maintenance, sparse working trees, and the nuances of partial cloning.

Written specifically for engineers—particularly those in build, CI, and developer experience roles—the content highlights the importance of maintaining speed and efficiency as repositories grow in size and complexity. It offers insights into diagnosis, configuration, and recovery, making it a valuable resource for anyone managing Git at scale.

Continue reading on gitperf.com

#reading-list #development #best-practice #devops #git

🐥 The MySQL null-safe equality operator: <=>

2026-06-18T17:00:00Z

If you've worked with MySQL long enough, you've probably been bitten by NULL comparisons at least once. A query that should return results returns nothing. A WHERE clause that should exclude a row doesn't. The culprit is almost always the three-valued logic of SQL — and the null-safe equality operator <=> is one of the cleanest tools for dealing with it.

The problem with `=` and `NULL`

In SQL, NULL represents the absence of a value — the unknown. Because of this, any comparison involving NULL using the standard = operator yields NULL (not TRUE or FALSE), and NULL is falsy in a WHERE clause.

SELECT NULL = NULL;   -- NULL
SELECT NULL = 1;      -- NULL
SELECT 1 = 1;         -- 1 (TRUE)

This means:

SELECT * FROM users WHERE deleted_at = NULL;  -- returns nothing

The idiomatic fix is IS NULL / IS NOT NULL, but that only works for literal null checks. The moment you're comparing two columns — one or both of which might be NULL — things get awkward fast.

-- This silently drops rows where either column is NULL
SELECT * FROM orders WHERE shipping_address = billing_address;

Enter `<=>`

MySQL's null-safe equality operator <=> behaves exactly like =, except it treats NULL as a comparable value. Two NULLs are considered equal, and a NULL compared to any non-null value is FALSE.

SELECT NULL <=> NULL;   -- 1 (TRUE)
SELECT NULL <=> 1;      -- 0 (FALSE)
SELECT 1 <=> 1;         -- 1 (TRUE)
SELECT 1 <=> 2;         -- 0 (FALSE)

This makes it safe to compare nullable columns directly:

-- Correctly includes rows where both columns are NULL
SELECT * FROM orders WHERE shipping_address <=> billing_address;

A real-world example

Consider a polymorphic subscriptions join table that maps users to subscribable entities (posts, documents, threads, etc.). The goal: return all subscribers excluding the item's author, even when author_id might be NULL.

The naive approach breaks silently:

WHERE subscriptions.user_id != posts.author_id

When author_id is NULL, this evaluates to NULL, so the row is dropped — meaning a user who subscribes to a post with no author would incorrectly disappear from the result.

The null-safe fix:

NOT (subscriptions.user_id <=> (
    SELECT author_id FROM posts WHERE id = subscriptions.item_id
))

This reads as: "keep this row unless the subscriber's user_id exactly matches the author_id, treating NULL as a concrete equal value." When author_id is NULL and user_id is not, the <=> returns FALSE, so NOT FALSE is TRUE — the row is kept. Correct behaviour in all cases.

`<=>` vs. the alternatives

Approach	Handles NULL?	Readable?	Standard SQL?
`col = val`	No	Yes	Yes
`col IS NULL`	Yes (literal only)	Yes	Yes
`COALESCE(col, '') = COALESCE(val, '')`	Yes (with sentinel)	Passable	Yes
`(col = val OR (col IS NULL AND val IS NULL))`	Yes	Verbose	Yes
`col <=> val`	Yes	Yes	No (MySQL/MariaDB)

The COALESCE sentinel approach is fragile — you need to pick a value that can never appear in real data. The verbose OR (IS NULL AND IS NULL) pattern works but is noisy. <=> wins on brevity and correctness, at the cost of portability.

When to use it

<=> is a good fit when:

Comparing two nullable columns directly in a WHERE or JOIN condition.
Negating equality on nullable data (NOT (a <=> b) is cleaner than the alternative).
Upsert / deduplication queries where you need exact matching including null identity.
Generated columns or audit logic where you want to detect whether a value actually changed, including transitions to/from NULL.

Caveats

MySQL and MariaDB only. The <=> operator is not part of the SQL standard and is not available in PostgreSQL, SQLite, or SQL Server. If your codebase runs tests against SQLite (a common Laravel setup), any <=> in a raw query will fail there.

PostgreSQL's equivalent is IS NOT DISTINCT FROM / IS DISTINCT FROM:

-- PostgreSQL equivalent of <=>
col IS NOT DISTINCT FROM val

-- PostgreSQL equivalent of NOT (col <=> val)
col IS DISTINCT FROM val

If cross-database portability matters, abstract the comparison behind a query scope or use the verbose but portable OR (IS NULL AND IS NULL) form.

Summary

The null-safe equality operator <=> is one of those small MySQL features that, once you know it exists, saves you from a whole class of subtle bugs. It's most valuable when you need to compare nullable columns directly — particularly in negated conditions where the standard != would silently swallow NULL rows. Just keep portability in mind: it's a MySQL/MariaDB extension, so make sure your test database matches your production database before reaching for it.

#best-practice #mysql #sql

🐥 YellowDuck.be

🔗 The stack behind There There

🔗 #[RouteParameter] does not bind your model

🔗 Why enterprise AI projects fail: 5 root causes & fixes

🔗 What is AI governance?

🔗 How Erlang's parser tools saved my DSMR library

🔗 AI literacy is not prompt literacy. Ann Handley says it's judgment literacy

🔗 Test coverage won't save you

🔗 How I use LLMs as a staff engineer in 2026

🔗 How to write "garbage code" (by Linus Torvalds)

🔗 Build an MCP server with Laravel (and use it to publish this post)

🔗 Software engineering discipline and posture

🔗 Pair-programming is a cheat code

🔗 GenServer state management in Elixir: A production order book

🔗 Concurrent reads, serialized writes with GenServer and Registry

🔗 The beginning of programming as we’ll know it

🔗 Rust vs Go: A hands-on comparison

🔗 Reading a 200k-line codebase you didn't write: a field guide

🔗 Claude talk small. Code still big.

🔗 OAuth 2.0 – device flow explained for engineers, especially for backend engineers

🔗 Laravel MCP: Getting started

🔗 Credence: Elixir semantic linter

🔗 The tacit dimension: why your best engineers can't tell you what they know

🔗 AI’s impact on software engineers in 2026: key trends, Part 2

🔗 High performance Git

🐥 The MySQL null-safe equality operator: <=>

The problem with = and NULL

Enter <=>

A real-world example

<=> vs. the alternatives

When to use it

Caveats

Summary

The problem with `=` and `NULL`

Enter `<=>`

`<=>` vs. the alternatives