Notes @Formula

Notes @Formula — usually written simply as the Formula language — is the domain-specific programming language at the heart of Lotus Notes (later IBM Notes, now HCL Notes/Domino). Created by Ray Ozzie during the development of Notes and shipped with Release 1.0 in December 1989, it is a functional, list-oriented language designed not for crunching numbers but for manipulating strings, lists, and documents. Its most recognizable trait is that nearly every built-in function and action begins with an @ character — @If, @Today, @DbLookup, @Trim — which is why developers affectionately call it @Formula.

Rather than being a general-purpose language you compile into standalone programs, @Formula lives inside a Notes application. It is the language you write into a view’s selection criteria, a column’s value, a computed field on a form, a validation rule, or an agent that sweeps across thousands of documents. In each of these places, a short formula evaluates against the current document and produces a result. This tight binding between language and document database is what gives @Formula its character.

History & Origins

The story begins in 1984, when Ray Ozzie founded Iris Associates to build a collaborative platform under a development agreement with Lotus Development Corporation. Ozzie and his team — many of them veterans of the PLATO networked-learning system — set out to create software that combined a document database, email, workflow, and replication into a single product. That product became Lotus Notes, and it shipped as Release 1.0 in December 1989.

Notes needed a way for application designers to express logic — which documents belong in a view, what a field should default to, whether input is valid — without writing full programs. For this, Ozzie created the Formula language. Pragmatically, he borrowed the compiler and decompiler from the Lotus 1-2-3 spreadsheet, but the language he built on top had a different purpose. Where 1-2-3 formulas were about numerical calculation across cells, Notes formulas were about string and list processing across documents. The design drew on Ozzie’s prior experience with Icon and Lisp, languages known for elegant text handling and list manipulation — influences visible in @Formula’s treatment of multi-value fields as first-class lists.

Design Philosophy

@Formula was shaped by a few clear principles, all flowing from its role inside a document database:

• Functional, not procedural (originally). In its classic form, a formula was an expression that evaluated to a value, with no loops and no mutable state. You described what the result should be, and the engine computed it. This made formulas easy to reason about in the context of a single document.
• Lists are everywhere. Notes fields can hold multiple values, and @Formula treats these as lists by default. Operators and functions are list-aware: applying an operation to two lists pairs their elements, and many @functions map naturally over every element. This list-orientation is the language’s most distinctive feature.
• String and text first. Reflecting its purpose, the language is rich in text functions — extracting, trimming, replacing, and reformatting strings — rather than heavy numerical machinery.
• Embedded and event-driven. A formula never runs in isolation; it runs in a context — a view refresh, a field recalculation, an agent execution — always with reference to a current document and environment.

The result is a language that feels less like C or Pascal and more like a sophisticated spreadsheet formula crossed with a list-processing dialect.

Key Features

@Formula is built from two complementary kinds of building blocks:

• @Functions perform calculations and logic: @If for branching, @DbLookup and @DbColumn for pulling values from other databases, @Today and @Now for dates, @Trim, @LeftBack, @Word for string surgery, and many more.
• @Commands perform actions in the user interface — opening a document, switching views, composing a new memo, saving, or closing — typically attached to buttons, action bars, and the Notes client UI.

Other characteristic elements include:

• Field references and temporary variables. Formulas read document fields by name and can create temporary variables for intermediate results.
• List operators. Pairwise and permuted list operators let a single short formula transform whole columns of multi-value data.
• Selection and column formulas. A view is defined partly by a selection formula (SELECT ...) that decides membership, and partly by column formulas that compute what each column shows.
• Hide-when formulas. UI elements carry boolean formulas that determine when they are shown or hidden, enabling dynamic, role-aware forms without procedural code.

A simple formula that greets the world looks like this:

1

"Hello, World!"

A more representative example uses @functions, a field reference, and conditional logic:

1
2

FullName := @Trim(FirstName + " " + LastName);
@If(FullName = ""; "Anonymous"; FullName)

And a typical view selection formula restricts a view to a category of documents:

1

SELECT Form = "Order" & Status != "Cancelled"

Evolution

For over a decade @Formula remained a purely expression-based, loop-free language — deliberately simple, and well suited to the per-document evaluations it was built for. As Notes applications grew more ambitious, two things happened.

First, in 1996, LotusScript — a BASIC-style, object-oriented scripting language — was added to Notes, giving developers a fully procedural option with a rich class library (the back-end and front-end Notes object models) for logic too complex to express as a single formula. @Formula and LotusScript came to coexist, each suited to different jobs: formulas for view/column/field logic, LotusScript for elaborate workflow and integration code.

Second, with Notes/Domino 6 in 2002, the Formula engine was rewritten by Damien Katz (who would later go on to create CouchDB). This rewrite extended the language beyond its purely functional roots, adding looping, variable assignment, and dynamic evaluation of formula text at runtime (via functions such as @Eval), along with reported performance improvements. The language thus gained limited imperative capabilities while keeping its formula-centric identity.

Through the IBM era — IBM acquired Lotus in 1995 — and after HCL Technologies completed its acquisition of the Notes and Domino products in 2019, @Formula has remained a supported, first-class language. It continues to ship in modern releases, including HCL Notes/Domino 14 (released December 7, 2023) and subsequent updates.

Current Relevance

Today @Formula occupies a stable, specialized niche. It is not a language anyone reaches for to build new web services or mobile apps — but within the vast installed base of Notes/Domino applications that still run business processes at enterprises, banks, insurers, and government agencies around the world, it remains indispensable. Every view that filters documents, every form that computes a default, every agent that sweeps a database for matching records, leans on @Formula.

Because so many of these applications were built over the past three decades and continue to be maintained, knowledge of @Formula remains a valued, if increasingly specialized, skill. HCL’s continued investment in the Notes/Domino platform — with regular releases and modernization efforts such as web and low-code front ends — means the language is actively maintained rather than merely legacy, even as newer development on the platform often layers JavaScript, Java, and REST APIs on top.

Why It Matters

@Formula matters as a foundational example of a domain-specific language done well. By giving application designers a compact, functional, list-oriented vocabulary tightly bound to a document database, Lotus Notes let non-programmers and developers alike build sophisticated collaborative and workflow applications years before such tools were common — and decades before the term low-code entered the vocabulary.

It also represents an important thread in computing history: Notes was one of the most influential groupware products ever made, and @Formula was the language through which its applications came to life. The language’s blend of spreadsheet-style immediacy and Lisp/Icon-inspired list processing produced something genuinely distinctive — a reminder that a small, focused language, carefully matched to its problem domain, can outlive far more general tools. More than 35 years after it first shipped, @Formula is still running in production, which is its own quiet testament to that design.

Sources include the Wikipedia article on the Formula language, the Wikipedia article on HCL Notes, the HCL Domino Designer documentation on the Notes Formula Language, and the FOLDOC entry on the Lotus Notes Formula Language.