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?"
"Yes."
"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
What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm
1 of 11 12/1/2010 3:57 PM
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:
e-mail
calendaring and scheduling
address book
database
web server
programming
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
What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm
2 of 11 12/1/2010 3:57 PM
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:
e-mail (obviously)
discussion forums
document repositories
expense approval systems
web-based request systems
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.
What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm
3 of 11 12/1/2010 3:57 PM
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:
Form CarMake CarModel

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:
Form CarMake CarModel
Car Data Ford F-150
Car Data Honda Civic
Car Data Porsche Boxster
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:
What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm
4 of 11 12/1/2010 3:57 PM
Form CarMake CarModel CarColor
Car Data Ford F-150
Car Data Honda Civic
Car Data Porsche Boxster
If we have the proper access to the database, we could even edit the existing
Documents to make the table look something like this:
Form CarMake CarModel CarColor
Car Data Ford F-150 White
Car Data Honda Civic Blue
Car Data Porsche Boxster Red
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:
Form CarMake CarModel CarColor OwnerName OwnerPhone
Car Data Ford F-150 White
Car Data Honda Civic Blue
Car Data Porsche Boxster Red
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:
Form CarMake CarModel CarColor OwnerName OwnerPhone
Car Data Ford F-150 White
Car Data Honda Civic Blue
Car Data Porsche Boxster Red
Owner Info John 555-1212
Owner Info Steve 555-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
What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm
5 of 11 12/1/2010 3:57 PM
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:
Form CarMake CarModel CarColor OwnerName OwnerPhone
Car Data Ford F-150 White Steve
Car Data Honda Civic Blue John
Car Data Porsche Boxster Red Steve
Owner Info John 555-1212
Owner Info Steve 555-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
What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm
6 of 11 12/1/2010 3:57 PM
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
What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm
7 of 11 12/1/2010 3:57 PM
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
What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm
8 of 11 12/1/2010 3:57 PM
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:
e-mail (obviously)
discussion forums
document repositories
expense approval systems
web-based request systems
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:
What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm
9 of 11 12/1/2010 3:57 PM
A brief discussion of the elements of a database is below.
DATA
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.
DESIGN
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
What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm
10 of 11 12/1/2010 3:57 PM
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.
CODE
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.
SECURITY
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.
http://www.nsftools.com/misc/WhatIsNotes.htm
What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm
11 of 11 12/1/2010 3:57 PM