 |
by
Dick
McCarrick
 
Level: All
Works with: All
Updated: 10/02/2000
Inside this article:
Planning the project and assembling the team
Putting it all together
Ensuring accuracy
Published and available
Related links:
Inside Notes: The Architecture of Notes and the Domino Server
Domino Applications Development Best Practices Guide
The Documentation Library
The architecture of the Domino Web server
Notes: A sustainable platform architecture
Get the PDF:
 (67 KB)
|  |
Ever wonder what's really inside Domino and Notes? Would you like a better understanding of what all the major components are and how they work together? If so, you may want to read Inside Notes, a new book available to download from the Documentation Library on Notes.net.
Inside Notes begins with a thorough overview of Domino and Notes design—"Notes from the 30,000 foot level," according to one of its authors. Even if you're new to Notes, this book will give you the big picture of what the product is about and how it's constructed. Client, server, server tasks, NSF, NIF, programmability—all the important technical components of Notes are described in general terms, including how they interact. Later chapters of Inside Notes then cover each of these components in more detail.
The intended audience for Inside Notes includes all who have to make technical decisions about the product. People who need to evaluate Notes and decide whether to bring it into their company can consult the book to learn what Notes does, how it works, and what it might require in the future. More experienced Notes programmers will also find it a useful reference for expanding their knowledge, exploring alternate ways to do things, and discovering possibilities they hadn't considered.
Responding to requests for details
Inside Notes started out as the brainchild of Jason Dumont, Senior Product Manager in charge of client strategy and iNotes, in response to strong customer demand. According to Jason, "Customers and developers needed insight into what was going on with the product, what is going on internally. They needed this information for troubleshooting and deployment, and for developing Notes applications." To fill this need, Jason envisioned a book along the lines of the Domino Applications Development Best Practices Guide, but geared more towards general Domino and Notes architecture. This way, customers could gain a deeper understanding of Notes and be better equipped to build better applications.
"There are many ways to do things in Notes," says Jason. "It's like building a house—there's a right way to do that, whether it's a log cabin or a Tudor mansion. Our job is to outline the steps for that task. The more diligent we are about providing this kind of information, the more rewards there are to be gained. It's exponential."
Planning the project and assembling the team
Jason's first step towards making Inside Notes a reality was to contact Tim Halvorsen, Chief Technology Officer of Iris. After Jason explained the book's purpose and goals, Tim became an enthusiastic supporter. He agreed to serve as an active participant in the technical review of all material and committed Iris resources to the project. The first and most dedicated of these resources came in the person of George Langlais, a developer on the Notes team. George previously taught Notes Internals training for Iris and Lotus, experience that proved invaluable to the successful completion of Inside Notes.
George and Jason worked closely to design the basic content and structure of Inside Notes. To do this, they drew upon material presented in George's Notes Internals course. They also contacted a number of customers directly to determine what they wanted to see in the book.
Understandably, a book intended to cover so ambitious and broad a topic as Notes architecture requires a team of contributors with the widest possible experience. So to provide content for Inside Notes, Jason contacted a number of groups within Iris, Lotus, and IBM and obtained their participation. These included:
- Iris Development. In addition to Tim and George, a number of Domino and Notes developers served as sources of information for the book. They also reviewed drafts for technical accuracy.
- Lotus Notes Product Management. Jason and other product managers were involved.
- IBM Redbooks. Soren Peter Nielsen assembled a four-person team of Notes programmers/developers to write much of the more technical material.
- Domino/Notes User Assistance. A group of writers led by Kathy Murphy, User Assistance Manager, played an important part in writing content for Inside Notes. They took material found in other parts of the Notes documentation set and condensed it into the book. They also worked closely with development to write a number of new topics.
To ensure this large, multi-functional team stayed coordinated, George and Kathy remained in close communication throughout the project. In addition, Phyllis Sharon, an editor from User Assistance, provided overall editorial support. This helped the book maintain a consistent style and pace across all topics.
Putting it all together
The writing phase of Inside Notes began with George working with the Redbooks team to further develop the general outline. Together they came up with the list of topics and overall organization. Topics were then assigned to individual writers, many of whom were members of the User Assistance team. As Kathy notes, "One difficult part of the process was figuring out how to fit with everyone else's chapters—how much detail to include, for example."
George's biggest writing assignment for Inside Notes was the all-important overview section. This is a 70-page examination of the overall Domino and Notes design. While planning this section, George followed what he calls the "Christmas party conversation" model, "...where someone asks what I do for a living, and I say 'I work for Notes.' They then ask 'What's Notes' and I take 20 minutes or so explaining the basics—collaboration, security, application design. The first section of the book tries for that level of detail." This allows a reader totally unfamiliar with Notes to take an hour or two to gain a high-level idea of what the product is about and how it is assembled. The overview touches upon all the important technical components of Notes and explains how these components interact with each other. In this way, the overview serves as sort of a "super-glossary."
If while reading the Inside Notes overview, readers encounter a topic they want to learn more about, they can find more detailed material on that topic in the second portion of the book. This can serve as a convenient reference. For example, a user may come across a reference to the database catalog. The user can consult this section of Inside Notes and find a description of what it is, how it interfaces with the database indexer, and so on. This material is more technical than what is usually found in the documentation set. For example, it doesn't describe the user interface or give detailed step-by-step instructions about how to do things. Instead, it focuses more on how Notes is put together inside—message queues, caches, semaphores, and so on.
Here are the topics covered in the second part of Inside Notes.
Notes Object Services (NOS)
Notes Object Services (NOS) comprise a large collection of functions that perform all of the basic, portable, thread-safe services that the client and server use. This chapter presents an overview of the NOS services, which fall into the following groups:
- Portability layer is the level at which Notes interacts with the underlying platform and where you find those Notes components that handle all interaction with the underlying system.
- Network services provide a single interface to drivers for different network protocols and support for the Notes Remote Procedure Call (NRPC) mechanism.
- Database services provide access to the contents of Notes database files. Low-level database services provide functionality for tasks such as creating, backing up, deleting, and so on. High-level database services provide functionality for tasks such as full-text indexing, mailing, and scheduling.
- Other NOS services allow you to create and manage ID tables, customize Notes behavior by creating user-written call-back functions, manipulate an in-memory copy of an ACL, and so on.
Notes Storage Facility (NSF)
Notes Storage Facility (NSF) is a key component of NOS. Notes client and Domino server programs use NSF to create and manage Notes databases. This chapter provides a general description of NSF, what it does, and how it works. It then examines the following in detail:
- The database header, which contains key information about the database, such as version numbers, class, ID, and replication settings
- Database notes, including note types such as ACL, Design Collection, and Document
Domino server tasks
Domino server tasks collectively implement all the functions that the Domino server performs. This chapter describes the server tasks that manage and maintain:
- Notes applications (for example Agent Manager, Cataloger, and Domain Indexer)
- Server and administration activities (for example Administration Process, Cluster Administration Process, and Cluster Replicator)
- Mail, calendaring, and scheduling
- Protocols (for example DECS, DIIOP, and HTTP service)
- Server activity (for example Event, ISpy, and Stats)
Domino Web Server
Domino Web Server is built around a series of objects that model elements of the Notes database and document structure, and define the presentation of this data. It is also a runtime environment for the applications, providing methods that implement the necessary conversions and computations that allow a browser (which has little intelligence of its own) to "run" an application. This chapter describes the architecture that Notes uses to provide its services on the Web and discusses how components of the Internet are integrated into the Notes client.
Domino and Notes security
Domino and Notes security provides a robust security model that you can tailor to meet your organization's requirements. This chapter reviews Domino and Notes access control mechanisms that you use to restrict access to:
- Servers and ports
- Databases
- Files
- Design elements such as forms, views, and folders
- Workstation data
- Documents
Directories
This chapter describes in technical detail how Domino creates and uses directories. This includes the three databases from which Domino can look up directory information:
- Domino Directory contains information about users, servers, groups, and other objects that administrators might add to the directory themselves—for example, printers. It is also a tool that administrators use to manage the Domino system. For example, administrators create documents in the Domino Directory to connect servers for replication or mail routing, to register users and servers, to schedule server tasks, and so on.
- Directory catalog combines abbreviated user, group, mail-in database, and resource directory entries from one or more Domino Directories into a single, lightweight, quick-access directory so that users and servers can easily look up names and addresses of people throughout an organization.
- Directory assistance acts as a directory of secondary directories—directories other than a server's primary Domino Directory (names.nsf). Directory assistance can point to secondary Domino Directories, for example Domino Directories from other Notes domains, stored locally or on remote Domino servers. Directory assistance can also point to LDAP directories on remote LDAP servers, for example, third-party LDAP directories.
This chapter also describes the LDAP service in detail, including authentication and access control, lookups, and searches.
Administration Process
Administration Process processes administration requests. This chapter provides a detailed technical discussion of the Administration Process.
Domino cluster
A Domino cluster is a group of two to six servers that you use to provide users with constant access to data, balance the workload between servers, improve server performance, and maintain performance when you increase the size of your enterprise. This chapter describes how clusters and failover work. It lists cluster benefits and requirements, explains the components of clusters, and gives a behind-the-scenes view of the failover process.
Indexer
Indexer is composed of two server tasks: the Update task and the Updall task. These tasks use two sets of NOS services, the Notes Index Facility (NIF) and Full-Text services, to keep database views and full-text indexes up-to-date after documents are added, removed, or modified. This chapter describes both Update and Updall and gives a brief overview of indexing and the Domino Directory.
Replication
Replication is the process of exchanging modifications between replica databases. This chapter provides an inside look on how replication works and lists its benefits. It closely examines the Replicator server task, explaining the purpose and function of replicator commands, settings, and controls. The chapter also suggests tips for avoiding and resolving replication conflicts.
Domino Mail Router
Domino Mail Router, a specialized program on the server, moves a document to a recipient's mail file or transfers the document to another server on the route to the recipient's home server. This chapter details the Mail Router, how it works and interacts with other Domino and Notes components. It reviews the internal processes involved with message delivery and lists housekeeping tasks to help maintain mail performance and efficiency.
Ensuring accuracy
As topics were written, the complex task of technical review began. Iris developers were given 30 review copies; a good number were returned with extensive review comments. According to Kathy, "There was a huge amount of time dedicated to reviewing Inside Notes. The technical review for many individual chapters was conducted independently...The major technical review came late in the schedule...on the entire book." The primary final reviewer for Inside Notes was Tim Halvorsen, who performed a complete section-by-section review.
Published and available
Everyone involved now agrees the final results justified all the effort. Jason feels customers will be very happy to get this information—indeed, some may wonder "why didn't you have this information available sooner?" And even within Iris and Lotus, demand for draft copies of Inside Notes turned out to be strong. "Many people internally have a lot of enthusiasm for this book—asking when can they get a copy, when's the next version of this coming out," notes George. "We didn't expect the internal demand would be quite so high." In fact, many now believe the first thing a new developer should do on joining Iris is read Inside Notes.
As for the future of Inside Notes, the current thinking is to issue an updated version sometime after the next major release of Domino and Notes, especially if customer demand for this information is as strong as anticipated. As Jason sums up, "Any time we give [customers] insight into the tools they use, the more we can reveal, the more it helps them."
You can download a copy of Inside Notes from the Documentation Library on Notes.net.
ABOUT THE AUTHOR
Dick McCarrick is a Documentation Manager in the Domino/Notes User Assistance (documentation) group. Dick has been with the Notes team for ten years. He is currently responsible for overall coordination of the documentation for the next release of Domino and Notes. |