Guard Clauses & Bearskin Hats

In the world of software development, writing code that’s both robust and maintainable is essential. Two fantastic techniques to achieve this are using guard clauses and the try-catch pattern. These methods help manage errors gracefully while keeping your code clean and easy to read. I recently presented on this topic at Engage 2024, and in this post, I’ll walk you through how to implement these patterns in FileMaker to make your scripting processes smoother.

This post will focus specifically on guard clauses and single-pass loops (the try-catch pattern). While topics like error handling and transactions are also crucial, they’re covered in other resources. For those interested in a deeper dive, I recommend checking out:

• Barbara Cooney & Alo Torres-Navarro’s Engage 2024 presentation, “Advanced modern Claris FileMaker transactions”
• Robert Naud’s “Error Handling Revisited” talk at DIGFM (October 2023)
• Dan Smith’s overview of FileMaker Error Handling on his Github repository

The beauty of guard clauses is that they let you write more robust code without having to implement additional logging, error handling, or transactions. You can tackle those aspects separately, using various methods that complement the patterns discussed here.

What are Guard Clauses?

Guard clauses are a programming technique used to exit a function or script early if certain conditions aren’t met. This prevents unnecessary code from running if the program may be in an unexpected or invalid state. By placing these checks at the beginning of a script, guard clauses ensure that you only proceed if all necessary parameters and conditions are in place.

Throughout this post, you’ll be able to spot the Guard clauses because of their bearskin hats –. But once you get the hang of them, you’ll be able to spot them in the wild even if they’re out of (emoji) uniform.

Simple Example of Guard Clauses

Imagine you’re writing a script to make a peanut butter and jelly sandwich. You need to check for bread, peanut butter, and jelly before you can start. Without guard clauses, you might write a series of nested if-else statements to check these conditions. With guard clauses, you simply check these conditions at the outset and exit the script if any are not met.

In this example, the script exits immediately if any of the ingredients are missing, saving you from unnecessary steps (and a sad, incomplete sandwich).

Benefits of Guard Clauses

Guard clauses improve code readability by minimizing nested conditional statements—often referred to as the “arrow anti-pattern” due to the shape they form. They also improve performance by avoiding the execution of unnecessary code, conserving computational resources and preventing unexpected behavior.

Let’s compare two versions of an order processing script:

Here’s an example using nested If statements, which results in the arrow anti-pattern:

Notice how the lengthy, nested structure makes it hard to follow, with each If test far from its corresponding error message.

Now, here’s the same script using guard clauses that exit a Single-pass Loop:

This version is not only more compact, but each error check is on the same line as its error message, making it far easier to troubleshoot and maintain.

For readability, your style may vary. You might define the error in its own script step instead of a calculation. The key takeaway is that guard clauses make your code cleaner and more straightforward than deeply nested If statements.

Try-Catch Pattern & Multiple Order Processing with Guard Clauses

These scripts also illustrate the try-catch pattern, a well-known error-handling mechanism in many programming languages. Although FileMaker doesn’t have a built-in try-catch construct (but you can vote for this feature!), we can emulate this pattern using a single-pass loop. This lets us “try” a block of code and “catch” any errors that occur, enabling graceful error handling without unexpected exits or results.

Nesting Try-Catch Blocks

Once you grasp the basics, you can also nest try-catch blocks. This is handy when iterating over a list and you want to handle errors individually rather than aborting the entire process.

Enhancing Your FileMaker Scripting

Mastering different try/catch patterns—simple guard clauses, try/catch blocks, and nested try/catch blocks—can significantly improve your scripting in FileMaker. These techniques enhance code readability, maintainability, and robustness, making debugging easier and your code more dependable.

• Simple guard clauses streamline your code by exiting early if conditions aren’t met, reducing deeply nested conditions.
• Try/catch blocks emulate foundational error-handling, allowing scripts to “try” code and “catch” errors gracefully, even without a built-in construct.
• Nested try/catch blocks provide finer control, especially useful when processing lists and handling errors individually instead of as a batch.

Adopting these practices means writing cleaner, more reliable code, creating a better user experience with fewer errors and less downtime. As a result, users are happier and your business runs more smoothly, with less time spent troubleshooting and more time focusing on your goals.

Level Up Your Team’s Skills!

This post covers the bulk of what was discussed in the presentation, but be sure to check out the “Bearskin Hats” session video from Claris (and other great presentations from Engage 2024) for the full story! And if you want to boost your team’s development skills further, Codence offers training options, including 1-to-1 mentoring and our Apprenticeship program.