What Is Lotus Notes?

by Julian Robichaux
revision 1.1

For as long as I've been working with Lotus Notes, people have asked me, "Just what the heck is Lotus Notes anyway?" That has always been a difficult question to answer, because there are no equivalent products to compare it to. A typical conversation will go something like this:

"Does it do e-mail?"
"So it's like Exchange, right?"
"Only in the sense that it's an e-mail system. It's actually primarily a database system that happens to have built-in e-mail functionality."
"Okay, so it's like SQL or Oracle or something."
"No, it's not a relational database system like those are. It's more of a flattened data structure."
"What's that?"
"Probably nothing you should worry about. It's a database."
"Okay, so how do I manipulate the data? Write an Access front-end or something?"
"No, that's all built-in to the client. It's also got support for several programming languages, and a web server component that allows you to access the data from a web browser."
"Then it's like Exchange, SQL Server, Access, Visual Basic, and IIS all wrapped together?"
"Sort of. But it's packaged so that you don't see all those separate components individually. That's what makes it such a powerful workflow application."
"I don't think I understand..."
"I know. I think I'll have to show you some sample applications."

Often times, these conversations are more heavily biased in one direction or another, and they are usually accompanied by certain amounts of huffing and puffing based on preconceived notions about various things, but that's pretty much it.

This is my attempt to give a slightly more complete description of the Lotus Notes product. I've written two different versions of this description: one for managers, and one for technical people. Everyone will want to customize these descriptions based on their own knowledge, personality, and situation, but maybe it will give you a good starting point for understanding or explaining the application. I know it's not complete, but my intent was to provide a quick overview instead of a description of the entire feature set.

A good overview of the Lotus Notes/Domino product is also available on the IBM website, in a document called "The History of Lotus Notes and Domino". If you want a very technical description of some of the inner workings of Notes, try reading Inside Notes (if you can't find it there, search Google for insidenotes.pdf).

NOTE: in version 1.1 of this document, I also added a short entry at the end: What is a Notes Database?

What is Notes -- the Manager version

Lotus Notes is an application suite that includes the following components:

Unlike other application suites (like Microsoft Office) that split these pieces of functionality into separate products (like Outlook, Access, Front Page, etc.), Lotus Notes presents all of these components using a single front-end.

For many people, Lotus Notes is an e-mail system. While this is not necessarily it's largest strength as a product, e-mail is probably the most recognizable component that it has. It has most or all of the features of the other popular e-mail products on the market, including calendaring and scheduling, and it uses standards-based mail protocols such as POP3 and SMTP. Because Notes has both a client and a server piece, users can use it to read and respond to e-mail, and administrators can use it as an entire e-mail environment.

For all practical purposes though, everything in Notes is a database. Individual users have their own e-mail databases, and different sets of users can share application databases that can display, add, or manipulate information. Besides data, a database can also contain modules of programming code that will perform background, scheduled, or on-demand tasks for a user.

The Lotus Notes client is a desktop application that organizes and displays databases on a user's local workstation. The physical database files can be stored either on the workstation itself or on a server. A typical Notes client "workspace" will have icons for a handful of local databases as well as a number of databases that reside on one or several Notes servers. All of these icons can be grouped together, so that the distinction between local and remote data becomes very trivial.

The databases themselves can be highly customized to present the data that is associated with them. A Lotus Notes developer can design forms to display individual data records, and views to display whole sets of data. In some cases, the data that is displayed doesn't have to come only from the database that you're in -- it can also come from one or more other Notes or non-Notes databases.

Because the programming layer is built-in to the Notes databases, a developer can embed code throughout the database design to automate certain actions or reactions without having to install or configure external programs or processes. This built-in programming layer also makes it possible to create workflow applications that interact very fluidly between both application databases and e-mail.

If all or some of your user base doesn't want to use the Notes client, the capability to automatically display Notes databases on the web is available as well. Since version 4.5, the Notes server software has shipped with a web server component called "Domino", which translates Notes data into web pages and serves them up as a web site. Internet programming technologies such as JavaScript and Java are native to Notes, so these can be easily incorporated into Notes databases and design elements (either on the web or on the client). The Domino web server can also be configured to interact with things such as IIS, Apache, and Java servlets and JSP pages, so you can enhance your Domino website using other (possibly pre-existing) technologies within your environment.

On a slightly more technical level, Notes/Domino provides a very granular security model that allows a developer to "lock down" access to all or parts of a database. In this way, you can combine private and public data within a single database or across a single server. While the security is normally administered through a corporate Notes address book, it can also tie in to the user accounts in an NT domain or any LDAP-aware directory service.

With all of this functionality, it may be hard to envision what Notes can actually do for you. Some examples of typical Notes applications are:

Using the capabilities of Notes to interact with other database systems and other web technologies, you could also use it as a client-based or web-based information portal that ties together a number of different data sources. Lotus Notes can be a stand-alone data repository, a front-end to numerous other data repositories, or many things in-between.

What is Notes -- the Technical version

At its most basic level, Lotus Notes is a database system. In fact, most Notes environments consist of a collection of databases that might interact with each other at some level.

Lotus Notes, however, is not a relational database system. A Notes database is a collection of unstructured data, combined with various design elements that allow you to access and manipulate that data.

Before you allow any pre-conceived notions or biases about relational versus non-relational data to cloud your opinion of Notes, please read through the explanation below.

By walking through the design of a basic Notes database, you can better understand how the data is organized and treated within Notes. Let's say that we want to create a database that tracks information for a car club. To start, we would create a blank Notes database, and within that database we would create a Form to display some fields of data that relate to cars. For example, our Form might have fields called "CarMake" and "CarModel".

A Form allows a user to view or manipulate the data fields of a given record in the database. As such, its format is quite customizable in terms of colors, fonts, and layout. However, the Form does not actually hold the data itself -- it is simply a way to present the data.

Let's say that we've created and saved a Form with the two fields described above. We'll have to name the Form, so we'll call it "Car Data". If you want to imagine a Notes database as having an internal table that holds all of the data records in the database, the internal table for our new database would look something like this:


If we wanted to start populating the internal table, we could actually start doing it now. Every time we opened our Form, entered data, and saved the form, we would be creating new data records in the table. In Notes terminology, a data record is a Document. If we created several new Documents using our "Car Data" Form, our internal table might start to look something like this:

Car DataFordF-150
Car DataHondaCivic
Car DataPorscheBoxster

There are also several internal data fields (like the date the record/Document was created and the user who created it) associated with each Document, but the table above represents the data we can work with and change. As we added new Documents, they would be added to the internal table, and we could also edit or delete the Documents if we had access rights to do so.

Now say we want to add a field to track the color of the cars as well. To add a field to the internal database all we have to do is add a new field to the Form. We would open up the "Car Data" form, add a field called "CarColor", and save the Form. Now our internal table would look like this:

Car DataFordF-150 
Car DataHondaCivic 
Car DataPorscheBoxster 

If we have the proper access to the database, we could even edit the existing Documents to make the table look something like this:

Car DataFordF-150White
Car DataHondaCivicBlue
Car DataPorscheBoxsterRed

As we think more about the database, maybe we'll want to also track information about the members of the car club. We'll make a new Form called "Owner Info", and add two new fields to the Form, "OwnerName" and "OwnerPhone". After we've saved the new Form, the internal table will look like this:

Car DataFordF-150White  
Car DataHondaCivicBlue  
Car DataPorscheBoxsterRed  

Notice how the new fields just get appended on to the end of the internal database. However, if we open the "Car Data" Form back up, we won't see the new fields on the Form. Why? Because even though all the fields for all Forms are stored in a flat database, the individual Forms themselves only display whatever subset of fields that the database designer wants them to display.

If we create a couple of new Documents using the "Owner Info" Form, our internal table might now look similar to this:

Car DataFordF-150White  
Car DataHondaCivicBlue  
Car DataPorscheBoxsterRed  
Owner Info   John555-1212
Owner Info   Steve555-9000

I know that all of the relational database programmers are writhing in pain looking at this table right now, so let's cover a few bases. First of all, the data inside a Notes database isn't structured exactly like this -- notably, there isn't all the white space you're seeing above -- but it's good for the sake of diagramming the data for people who are used to looking at tables. It's also going to help us make sense of some of the other concepts we'll touch on below.

Second, there can be overlap between the fields of various Forms, so there's nothing keeping us from adding an "OwnerName" field to the "Car Data" Form. In fact, you could do this as a way of tying together the "Car Data" information and the "Owner Info" information. The fields on a Form don't just have to be placeholders for fields, they can be programmed as well. For example, your "OwnerName" field on the "Car Data" form could have a formula that simply looks up the owner names and allows the user to choose an existing owner. In SQL terms, this formula would essentially perform the query:

   SELECT DISTINCT OwnerName FROM InternalTable WHERE Form = 'Owner Info';

If we did this, and edited the existing "Car Data" Documents, we'd have an internal table like this:

Car DataFordF-150WhiteSteve 
Car DataHondaCivicBlueJohn 
Car DataPorscheBoxsterRedSteve 
Owner Info   John555-1212
Owner Info   Steve555-9000

Of course, if you had a good relational database background, you'd probably use some sort of numeric OwnerID field instead of the OwnerName, but you get the idea. The point is that records/Documents can be tied together in this manner.

Another interesting aspect of the Notes data store is that the data fields are not strongly typed. In other words, even though you initially set up a field as a numeric field, you can later add text data to that field (if you modify your Form or add data programmatically). In this way the data fields are more like columns in a spreadsheet than columns in a table. In a spreadsheet, you might be able to store dates, numbers, text, and objects all in a single column. Notes is the same way. A field can even hold items such as file attachments or OLE links.

While all of this might seem like a terribly "loose" way to be managing data, it actually makes it much easier to develop and update an application. If you need new fields on a Form, you just add them. If you need a whole new Form with a new set of fields, you can just add that too. If you need to change a numeric field to a text field months after a database has been developed, you can just change it without having to [necessarily] worry about the old data. You don't have to know anything about tables and data normalization and relational database theory, because Notes handles everything internally.

Anyway, now that you've started storing data in the internal table, you'll want to start viewing it as well. In the relational database world, you'd normally write a query to filter and sort your information; in Notes terms, you create a View.

A View is a tabular presentation of a filtered subset of data in the internal table. You define not only the filter that you want to apply (like "all records that were created using the 'Car Data' form"), but also the individual fields that you want to display in columns, and the way that the data is categorized and sorted. You can even add programmatic columns to the View, to display conditional data, totals, sums, or many other manipulated versions of the data in the fields.

If you need to programmatically manipulate the data within the database, Notes provides a number of options for programmatic data access and modification. You can natively use @Functions (a macro language), LotusScript (very similar to Visual Basic or VBA), JavaScript (to a certain extent), and Java. All of these bits of code can be stored either directly on the Form or View design (associated with events, actions, or button clicks) or in modules called Agents or Script Libraries. An Agent is essentially a program inside the database that can be either called by the user or kicked off in an automated fashion. A Script Library is a collection of functions, routines, modules, and/or classes that can be globally modified and shared among various design elements in the database (including Forms, Views, and Agents).

In a lot of ways, a Notes database is similar to a Microsoft Access database. Everything is all in one file. The data is either stored in local tables or accessed from a remote server. You create Forms to display and modify the data. You use Views/Queries to sort and display the data. You can embed LotusScript/VBA within different elements of the database, and call those scripts in a variety of different ways.

You may have heard that Lotus Notes is also an e-mail system. It is. In fact, some people use it only as an e-mail system. However, if you think about what e-mail is, and how it is stored once it arrives on your local machine, e-mail is just a database. Every user has their own individual Notes e-mail database that has been customized for mail activities. Calendar and schedule? Another database. Address Books? Databases. Once you start having a database-centric view of the world, a lot of things can be looked at as being just another type of database, especially when you're thinking in terms of a Notes database, which can hold not only data, but also design elements, programming code, etc.

So how do you access a Notes database? On a local workstation, many people use the Notes client. The client is an application that allows you to manage and work with any number of Notes databases. The databases can be stored either on the local workstation or on a remote server, and most people who use a Notes client have a mix of local and remote databases that they access. On the client, however, the local and remote databases look and act exactly the same.

The various databases on your Notes "workspace" can interact with each other programmatically, which makes it very easy to design workflow applications. For example, you could design an expense tracking database that sends reimbursement requests to an HR group via e-mail (another database), which in turn might tie in to a departmental budget database. Notes databases can also interact with non-Notes databases in various ways (usually via ODBC), which makes it possible to include other systems in your environment as well.

If you don't want to use the Notes client to access a Notes database, you can also access it on a Notes server via a web browser. Since version 4.5, the Notes server software has shipped with a web server component called "Domino", which translates Notes data into web pages and serves them up as a web site. In some cases, no additional programming or design work is necessary for Notes design elements to be viewed as a web page -- all of the conversion is done automatically by the Domino server. In other cases, a Form or View might be modified somewhat for a nicer look on the web, or to provide more of the interactive experience that the Notes client provides. To this end, you can include JavaScript and Java applets directly in your Notes design elements, and you can use DHTML and CSS to provide a more pleasant "look and feel" on the web.

While a Domino server is an HTTP/HTTPS web server unto itself, with no additional software required, you can also connect Domino with other web servers like IIS and Apache. Domino even has its own Java servlet engine and a Java interface to much of the Notes object model, so you can do things like write JSP pages that interact directly with your databases.

If you have multiple Notes/Domino servers, there is a very useful feature called Replication that is built-in to the product. Using Replication, you can keep copies of the same database on multiple servers in sync, so that they automatically update themselves with the latest data and design elements throughout the day. You can even use Replication to make a local copy of a database on your workstation, modify the data offline, and then Replicate your changes back to the server when you reconnect.

Of course, Notes also provides a strong security model to limit the ways in which various users can manipulate or even view the data in a database. Every Notes database has an Access Control List (or ACL) that determines what different users are allowed to do with the data in the database. On a global level, users have access levels such as "Author", "Editor", and "Designer", which indicate what they are allowed to change within the database. On a slightly more specific level, users can be granted or denied access to do things like delete documents or create agents. On a much more granular level, the designer of a database can grant or deny access to views, forms, sections of forms, and even individual documents based on the ACL.

There are certainly many other aspects of Lotus Notes that I haven't even started to touch on here -- LDAP integration, clustering, COM/OLE, CORBA -- but covering all of that would take an entire book (and indeed, there are several good books that attempt to cover it). I haven't even gone very deep into the specifics of the topics that I've mentioned, again for the sake of brevity. However, this overview should be able to give you an initial understanding of the basic architecture of Notes, along with a taste of what can be possible when you take all of these technology ideas and combine them in a single product.

Unfortunately, Lotus Notes is a technology that usually has to be seen to be understood. To help you envision what Notes can actually do in a practical sense, here are some examples of typical Notes applications:

Using the capabilities of Notes to interact with other database systems and other web technologies, you could also use it as a client-based or web-based information portal that ties together a number of different data sources. Lotus Notes can be a stand-alone data repository, a front-end to numerous other data repositories, or many things in-between.

What is a Notes Database

A Lotus Notes database generally has a file extension of ".nsf". Within that file, there can be data, design elements, and programming code. Each database file also has its own security in the form of an Access Control List (ACL). Visually, you can imagine a Notes database file like this:

A brief discussion of the elements of a database is below.

The data inside a Notes database is stored as a set of records -- each record is referred to as a Document. The information in a Document consists of one or more fields, which can be in any number of formats. Text, numbers, and dates are the basic data types, but you can also store things like formatted rich text and file attachments in a field.

A Notes database can also access data from other databases. These databases can be other Notes databases, or any kind of database that is accessible via ODBC. In this way, Notes can act as a front-end to other data sets, even relational databases.

Data is available using any of a number of different design elements that are stored in the database. On a basic level, you use Forms to access, modify, and create records/Documents, and Views to sort and categorize data sets into tabular form. There are also things like Navigators and Outlines, that allow you to create visual interfaces to other design elements and aid in navigation.

Virtually all of the design elements in a database can be viewed using either a Notes client or a web browser. The Notes/Domino server can natively translate these things and present them as web pages, which makes it quite easy to turn a Notes database into a web site. A Notes designer can even add web-specific design enhancements like CSS and DHTML to a Form, View, Navigator, etc.

In order to provide programmatic manipulation of data, a designer can embed many different types of code in a database. Notes has native support for a Formula (macro) language, LotusScript (very similar to Visual Basic), Java, and JavaScript. This code can be placed directly on design elements such as Forms and Views, or it can be placed in modules called Agents.

The code in a database can manipulate data within the database, but it can also interact with the user, the operating system, and external data and processes as well. For example, using LotusScript you can access DLL functions, COM objects, and OLE objects. Using Java, you have a rich set of tools for working with sockets, threads, and GUI components (among other things). Notes even has an exposed API layer that can be accessed via C and C++ libraries.

Wrapped around all of these database elements, Notes provides a strong security layer called an Access Control List (ACL). This allows a database designer or administrator to fine tune what different users are allowed to do within the database. On a global level, users have access types such as "Author", "Editor", and "Designer", which indicate what they are allowed to change within the database. On a slightly more specific level, users can be granted or denied access to do things like delete Documents or create Agents. On a much more granular level, the designer of a database can grant or deny access to Views, Forms, sections of Forms, and even individual Documents based on the ACL.

You are on the nsftools.com website.