What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.

htm

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
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?

1 von 10 26.01.2007 13:10

What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm

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
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

2 von 10 26.01.2007 13:10

What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm

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.

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

3 von 10 26.01.2007 13:10

What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm

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:

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

4 von 10 26.01.2007 13:10

What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm

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 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:

5 von 10 26.01.2007 13:10

What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm

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 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).

6 von 10 26.01.2007 13:10

What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm

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

7 von 10 26.01.2007 13:10

What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm

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:

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:

8 von 10 26.01.2007 13:10

What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm

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
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.

9 von 10 26.01.2007 13:10

What Is Lotus Notes? http://www.nsftools.com/misc/WhatIsNotes.htm

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

10 von 10 26.01.2007 13:10