Error Handling and Evaluation in Formula: @IfError, @Eval, and Where a Formula Runs

Series finale. The first six parts covered what formula can do; this one covers two things you hit no matter what you write: what happens when a formula errors, and where and when a formula actually runs. Catch errors with @IfError and a fallback, test with @IsError — but remember @IfError hides the real error message, so drop it while debugging. @Eval runs a string as a formula at runtime. And 'which context a formula runs in' is the root of half the series' gotchas (@DbLookup not allowed in column formulas...). Part seven (final) of the Formula @function series.

Control Flow and Variables in Formula: :=, @If, @Do, @For/@While

A real formula branches, holds intermediate values, and occasionally loops. This piece covers structuring formulas: temp variables x := ... are the modern backbone (semicolon-separated, the last statement is the return value); @If chains up to 99 condition/action pairs — formula's switch; @Do evaluates in sequence and returns the last; and real loops @For/@While/@DoWhile exist but, because formula is list-oriented, are rarely needed. Part six of the Formula @function series.

Date Arithmetic in Formula: @Adjust to Add/Subtract, @Now/@Today for Now, and @Modified's Two Versions

Date math in formula isn't a big date library — it's a few @functions. Add or subtract with @Adjust (seven positions for year/month/day/hour/minute/second, positive or negative); get now with @Now (full timestamp) or @Today (date only); get document times with @Created/@Modified. This piece also flags two traps: @Now re-evaluates every run and hurts efficiency in column/selection formulas, and @Modified (modified initially) vs @ModifiedInThisFile (last modified in this file) differ once you have replicas. Part five of the Formula @function series.

@Name Is the Swiss Army Knife for Notes Names: Three Formats, Any Component

In formula you constantly handle Notes names — comparing, displaying, extracting the OU. @Name is the Swiss army knife: [ABBREVIATE]/[CANONICALIZE]/[CN] convert among canonical/abbreviated/common, and [O]/[OU1]/[S] extract any part. Get the current user with @UserName (canonical) or @V3UserName (abbreviated) — but there's a trap: inside a server agent the 'current user' is the signer, and it isn't a security mechanism. Part four of the Formula @function series.

String Functions in Formula: @Left/@Right/@Middle, @Word, @ReplaceSubstring

Cutting strings in formula: many people only know @Left(s; 3), the count form — but @Left/@Right/@Middle also take a delimiter string: @Left(email; "@") is everything before the @. @Middle has four signatures, so 'grab what's between X and Y' is one line. This piece covers formula's string tools: @Middle's four forms, @Left/@Right's dual form, @Word to grab the nth piece by separator (-1 for the last, for surnames), and @ReplaceSubstring with parallel lists for multiple replacements. Part three of the Formula @function series.

Why You Barely Write Loops to Process a List in Formula

Coming from LotusScript/Java, you'd loop over a list. But formula has almost no loops — because one formula already operates on a whole list at once. This piece treats formula as a functional list language: an operation on a multi-value field runs element-wise (implicit map), @Transform is the explicit map (with @Nothing for filter, a returned list for flatMap), @Explode/@Implode split and join, and @Sort sorts (with [CUSTOMSORT] using $A/$B). What's a ten-line loop elsewhere is often one line of formula. Part two of the Formula @function series.

Reading Values Across Views and Databases in Formula: @DbColumn and @DbLookup

To read another view or another database from formula, two functions do ninety percent of the work: @DbColumn grabs a whole column (keyword lists, dropdowns), @DbLookup finds a value by key (resolve a code to a label, pull a related field). This piece covers both signatures, the cache keyword (""/NoCache/ReCache), and the rules you must know — the first column must be sorted, equality-only matching, the 64KB cap, and where they can't be used. Part one of the Formula @function series.

The Domino REST API Before Go-Live: the Security Model, One-Way Rich Text, CORS, and Admin Ports

Series finale. You can authenticate, expose a scope, CRUD, and query; before handing it to real users, a Domino developer must be sure of two things: does it bypass my Readers-field security, and what will bite in production? The answers: DRAPI is layered security (JWT + scope + Domino's own ACL/Readers underneath), so it doesn't leak — but there are real limits (rich text is one-way out, unconfigured fields are unreachable, same-name forms/views are ambiguous), plus CORS and the admin ports to close before going live. Part six (final) of the DRAPI series.

Your DQL Is Correct but Returns Nothing? The Form Is Missing a dql Mode

Last part fetched a single document by unid. What you usually want is 'the batch that matches' — all incomplete todos, all customers in a region. DRAPI gives two paths: GET /lists/{view} to read a view/folder, or POST /query to run DQL. DQL even supports parameterized queries (?VAR + variables, injection-safe). But there's a trap that follows from the last part's modes: a form without a dql mode is completely invisible to DQL. This part covers both query paths, pagination, the mode trap, and DQL access control. Part five of the DRAPI series.