Figure 1: Language/API interaction -- @Formulas are "closer to the iron."

Why use @Formulas?

One of the questions I hear all the time is: "Why should I use @Formulas? What can they give me that LotusScript and/or Java doesn't?" There are a few reasons why @Formulas are desirable in Domino 5x:

@Formulas can be coded more quickly for many tasks -- Try coding the equivalent functionality of what @DbLookup does. That would require many, many lines of code, and by the time you figure out all the what-if scenarios for error trapping, etc. you could have finished the rest of your coding. Instead, use the proper tool, such as @DbLookup.

@Formulas are supported all the way back to Notes 2x -- Sure, there are newer @Functions that have been added since 2x, but if you're worried about legacy compatibility, @Functions go farther back than LotusScript.

@Formulas are truly cross platform -- @Formulas are fully supported on every platform Domino supports. LotusScript and Java are also supported, but much of LotusScript's functionality is unavailable outside of the Win32 platforms -- items involving COM, OLE, etc. to name a few.

Given like tasks, @Formulas are always faster than LotusScript -- If there is a way to do a particular task in both LotusScript and the @Formula language, the @Formula version will always be faster. Why? Because @Formulas are closer to the API functionality itself. All the languages available in Notes/Domino 5x are children of the same API. But each of them interact with the API differently. LotusScript and Java are "higher-level" programming languages, which means they provide a higher level of flexibility and power, but those benefits come at the cost of some speed. LotusScript and Java also must run through a byte code interpreter. @Formulas, on the other hand, access the API through the @Formula engine, which is "closer to the iron" -- that is, it's closer to the native API level than the higher-level programming languages, as shown in figure 1.

So, now you know why you should use @Formulas. The next question is "When?"

When to use @Formulas

As stated earlier, @Formulas can often provide a quicker way to accomplish the same task, so you don't waste your time reinventing the wheel. For instance, if you are creating a button that simply saves and closes a document, why would you write all the lines of LotusScript required to accomplish this when a simple @Command([FileSave]) and @Command([FileCloseWindow]) would work?

@DbColumn and @DbLookup are very quick at retrieving data, especially from views. Coding these in LotusScript or Java would be a daunting task, so this is an obvious time to use @Formulas.

If the job you're attempting is fairly simple, and doesn't require complex looping or branching, look for an @Formula solution first. You could save yourself quite a bit of coding effort by coding a few lines of @Formulas over many lines of LotusScript or Java.

All this comes down to a simple rule: Take a moment before writing your code to analyze what you are trying to accomplish. Compare this to the simple guidelines mentioned above, and see if @Formulas are the better tool for the job. Am I saying @Formulas can solve the world's problems? Hardly. There are many situations where @Formulas are not a good fit.

When not to use @Formulas

There are many situations when @Formulas aren't a good fit however, and you should use one of the higher-level languages such as LotusScript or Java:

• @Formulas have no looping capability (at least none you would want to use), so anything requiring looping or branching is not a place for @Formulas. However, with Notes/Domino 6, @Formulas have looping capabilities, so this reason applies only to earlier versions.
• If your task requires a solution that is exceptionally complex, use the higher languages of LotusScript or Java.
• @Formulas have no ability to interact with COM or OLE objects, so if you have to access these items, LotusScript is obviously the tool of choice.
• If you have to perform complex searches, use Java or LotusScript.