Final notes on Notes

The application people love to hate

Now that I’m no longer working for IBM, I’m saying goodbye to the application formerly known as Lotus Notes, as well as the server known as Domino. Both have been sold off and are now products of an Indian company called HCL Technologies, but they were still in heavy use within IBM.

Mention Notes online and you’ll usually encounter derision, particularly from people who think it’s an e-mail program. It was all too often sold as one, but that was really something it could incidentally handle, not what it was designed for.

To understand what Notes is, and why it is the way it is, you have to know that it was inspired by PLATO Notes in 1973, and development started in 1984. It predates widespread e-mail, the web, home Internet service providers, and every application people disparagingly compare it to.

At the bottom, it’s a database engine which supports any number of distributed document-based key-value databases. Nowadays we’d call it NoSQL, and compare it to something like CouchDB or RocksDB — but Notes shipped in 1988! Each base level set of keys and values in the database is called a note, hence the name of the product.

On top of the database engine is a graphical form designer. It works like a word processor mail merge, giving you a rich text document that you can drop fields into. Each field can have one of a range of basic data types, including string, number, date, and user ID. Fields can also allow multiple values to be entered. When you save using a form, the data is stored in a note, along with information saying which form should be used to display or edit it, when it was saved, who saved it, and so on.

Once you have some documents, you can create one or more views. A view is basically a programmatic “smart group” that fishes a defined set of documents out of the database, and displays values from their key/value fields in table format.

The original Notes offered a spreadsheet-like formula language for scripting. Later on, when Visual BASIC was the new hotness, a VB-like language was added that was more capable. Later still, partial JavaScript support was added.

As well as the data, all of the application design — the forms, views, scripts, and everything else — was itself stored in the database as notes. So Notes was that it handled all kinds of things for you with very little effort:

  • Replicating data and working either online or offline.
  • Fine-grained access control at database, document and individual field level.
  • Authentication via public key cryptography.
  • Document signing
  • Software distribution

Combine this with the ease of creating forms and views, and with a bit of practice you could put together applications for secure distributed multi-user collaboration in an afternoon, and then iterate on it rapidly. The only thing I’ve seen that approaches the development velocity is Ruby on Rails. (And Rails also gets its fair share of robust criticism.)

Of course, Notes applications would rarely have a polished, professional user interface, because they were usually developed in house by large corporations, without much attention paid to design. So like Visual BASIC before it, Notes as a whole got a bad reputation.

There were also some product decisions that were just mistakes. To pick just one example, “folders” in Notes don’t work like real physical folders. When they were implemented, the developers apparently thought it would be more flexible if a single object could be part of any number of folders, rather than limiting it to one and having to copy things to put them in more than one folder. That is indeed great if you’re an information management nerd or a computer scientist, and can understand why deleting something from one folder would make it disappear from every other folder it’s in. Unfortunately ordinary people don’t expect desktop folders or e-mail folders to work like that.

In the mid 90s when the web started to become important, Lotus added a component called Domino that would take your Notes applications and (mostly) manage to serve them up as web sites, as long as they didn’t try to do anything too complicated. Over time this became a core feature of the Notes server, and the entire server became known as Domino.

Under IBM’s ownership, major changes continued. By 2007, basically the entire product had been rebuilt from the bottom up using Java and the Eclipse framework. With that done, it was possible to use Java code in your Domino web applications. In 2008, a framework called XPages was built on top of JSF, and that became the easiest way to produce cutting edge web applications using Domino.

You could build servlets and run them in Domino. You could use JDBC. You could call Java libraries bundled in your application database as jar files. You could script dynamic web form behavior in JavaScript.

At some point, though, IBM’s interest in the product seemed to wane. Notes and Domino 9 were released in 2013, but in 2018 the latest release was still 9.0.1 (fix/feature pack 10). The Domino engine wasn’t improved much, and Notes applications served up as web pages were a mess of nested tables. XPages also languished, as the rest of the Java world moved to JSF 2. The JavaScript engine remained basically the same as at the turn of the century. Overall, it became more and more painful to develop modern web sites with Domino as a foundation. So on the whole, I’m glad to be saying goodbye to Domino.

Now that HCL are developing the product, major updates are happening again. For example, there’s a new client to make it fast and easy to deploy a Notes application to iPads. There have been some tough decisions, though; XPages is probably a dead end, as the work to update it to JSF 2 would be prohibitive, so instead the new thinking is to develop your web application with something else (NodeJS is often suggested) and use Domino as a simple NoSQL database. That’s all very well, but there are a lot of other NoSQL database options, not to mention SQL databases, and if you’re not going to use the Notes and Domino features, why invest in the platform? It’s probably a good strategy for hanging on to existing customers, but it doesn’t seem like a good way to grow the customer base.

Will Notes and Domino remain viable platforms for groupware development? I don’t know. What I do know is that it’s no longer something I personally have to worry about.