LOTUS NOTES APPLICATION PROGRAMMING INTERFACE (API)

This document is based on the speaker notes from a talk that I gave at Lotus in December 1995 on the Lotus Notes API, with emphasis on using the MacOS version of Notes verion 4.

INTRODUCTION

Overview of APIs There are a few alternative methods for developing applications for the Notes environment. In other presentations you have already heard about database development, which includes navigators and agents. You have also heard about LotusScript. Later you'll be hearing about InterNotes, and developing solutions that integrate Notes with the Internet. The API is the only Notes development technology that enables you to implement Notes applications in the C programming language, giving you the all of the power and pain of C. There are three APIs that we'll be discussing - the C API, the HiTest C API, and the HiTest C++API. We'll also be discussing Vendor Independent Messaging.

C API Most of this talk will concentrate on the C API, since both of the HiTest APIs are built on top of the C API.

HiTest C API The HiTest C API is a higher level API that is built on top of the C API. It is object oriented, but not C++.

HiTest C++ API Like the HiTest C API, the HiTest C++ API is a high level API that is built on top of the C API. It isobject oriented, and is C++.

VIM The Vendor Independent Messaging API enables programmers to write email-enabled applications thatcommunicate with Notes and ccMail, as well as with applications from other companies that conformto the VIM standards.

Leveraging Apple Technologies Part of my mission here at Lotus is to help differentiate the MacOS version of Notes from the otherversions. I'll be talking about how Notes developers can work with Apple technologies such as OpenDoc, AppleScript, and the Newton.

MacOS Development Environment Since we have just released the fourth beta of the MacOS Notes C API, I'll briefly discuss what it takes to start developing C applications that communicate and collaborate with Notes.

OVERVIEW OF APIS

What is the Notes API? The Notes API provides a platform and version independent method of accessing Notes data andservices. For example, Lotus does not publish the Notes file format, yet via the API both version 3 and version 4 databases can be accessed without regard for file format. The API provides a logical file format that hides the physical format.

Multi-Platform
MacOS (68k and PPC, System 7.1 and greater), OS/2 (32 bit only), Windows (3.1,WFW, NT, 95), NetWare, UNIX (five versions, including Sun Solaris 2.4, HP-UX (10.01), AIX). Soon to include Dec Alpha platform. All Notes code that you write is 100% platform independent. Obviously, you may need to or may want to include additional platform specific code. You can create an application that is 100% platform independent by combining the Notes API with a 3rd party application development package, for example, to handle the u/i, while the Notes API is usedto handle the database and network management.

Why is there a Notes API?
The API enables programmers to automate repetitive tasks, such as registration of users.

You might also want to create an API application if you want your own u/i, rather than usingthe Notes client application u/i.

The API does not require the Notes client application to be running, reducing the RAM requirement for your application. In contrast, developing applications using LotusScript, andof course using Notes database tools, requires that the Notes client be running.

The scope of the task may not be possible to accomplish using the tools available within theNotes client.

The application may need to tightly integrate with an in-house development environmentother than Notes, or may need to integrate with off-the-shelf code libraries.

The Industry Newswire subscription service is implemented as a C API program. This service takes articles from a variety of publications and redistributes them to subscribers. The subscribers specify what type of articles they want. For example, Lotus gets computer related articles, plus any article that mentions Lotus. The Industry Newswire uses an API application to gather and process the data, which is distributed to the end-user, who then uses the Notes client to view the data.

API Capabilities
(1) Create, delete, and copy Notes databases
(2) Read, write, and modify Notes documents
(3) Search, sort, and index documents in Notes databases
(4) Send mail messages and documents
(5) Read, write, and modify the design of a Notes database
(6) Read, write, and evaluate formulas
(7) System Administration (replication, modify the ACL, user log access)

API Limitations (1) Can't drive Notes u/i. Example: can't pop open a document on the screen.
(2) Can't access Notes Desktop: Example: can't get list of icons that user has added to Notes Workspace.

Should use LotusScript for the above examples.

(3) Can't run API program if Notes not installed. May be possible to run the API program with many Notes components removed, but that's getting risky.

WHY MORE THAN ONE API?

One can think of Notes as an application, but in the context of programmability is more appropriate to think of Notes as a database, a network transport, or even a layer on top of the operating system.

As with programming languages that interact directly with an operating system it makes sense to have varied languages that each offer different advantages, since all have some drawbacks. Just as no one would question why there is a need for assembly language, C, Basic, and high level database languages, it also makes sense to have more than one way to program Notes, so Lotus provides the Notes C API, HiTest C API, HiTest C++ API, as well as higher level languages such as LotusScript. Each offers advantages that the others can not provide.

NOTES ARCHITECTURE AND THE APIS

The Notes C API is Notes. The API is just a group of Notes functions that have been exposed for third party developers to use. This is important to you because it means that the API is as important to Lotus as it is to the 3rd party developers.

Some client and server tasks bypass the API and call directly into the Notes Core. We discussed examples of these "API Limitations" on a previous slide. For this reason it would not be possible, for example, for a 3rd party developer to create an alternative to the Notes client that was compatible withthe Notes desktop database. The Notes client determines what databases the user has added to their workspace by calling directly into the Core. Your C API application can generally be as efficient as the Client and Server itself, and can have the same capabilities. Since the HiTest C and HiTest C++ environments are built on top of the C API, your HiTest C and HiTest C++ applications have an extra layer between them and the Notes Core.

STRUCTURE OF A DATABASE

When talking about Notes programmability, it may be useful to forget that the client application even exists, and think in terms of Notes as an API to a database engine. In this paradigm, everything is adatabase. Even your email can be accessed via database calls. Remember that we are not talking about file formats here. All of these structures are logical structures, and not necessarily physical structures. Even I don't know where or how they are stored in the file.

Header
The header contains the database title, categories, access control list, replication history, and the useractivity log.

Note (or Document)
A Note, which is more commonly called a document, contains its own header followed by any number of items, which are the actual data fields. The terms items and fields are sometimes used interchangeably.

Notes Canonical Format
Internally, all Notes data is stored in Intel byte ordering with no pad bytes. Generally, Notes insulates API programs from the details of conversion. For certain data types, the programmer is responsible for the conversion. The Notes C API User's Guide documents this issue, and the sample programs in the Toolkit demonstrate how and when to do the conversion. In the future, the Notes HiTest C++ API will do all the conversion automatically, and byte ordering and alignment will cease to be an issue.

NOTES C API

What is the C API?
The Notes C API is used to build standalone applications that run independently of the Notes application, yet have access to Notes services. The API is implemented as a library of over 1000 C language functions, data structures, and symbolic constants to access Notes databases, network services, and administration services. The number of exposed function from Notes v3 to v4 has increased by more than 50%, while maintaining compatibility with source code written for v3 API programs. Some of the tasks that can be accomplished through the API can not be accomplished through the Notes client application's user interface.The API is supported on every platform that supports a Notes client or Notes server.

When should you use the C API?
The Notes C API is best suited to low-level Notes functionality, such as extending support to importing and exporting new file formats and data sources.

Overview of C API Toolkit
The C API is implemented as a shared library. The API Toolkit includes the API header files, libraries, a large number of sample programs, and documentation.

The purpose of the sample programs is to provide examples of how to use the API functions. A representative selection of the functions are used in the samples. The purpose of the samples is not to provide a template for application development, but rather to educate you on the API. The sample programs are sorted into a number of directories by functionality - such as Views, RichText, Database, Mail, and Newton.

The Toolkit includes documentation in the form of two Notes databases. The first is a User's Guide,which introduces the concepts and functionality of the C API, as well as specific details on application development on the various supported platforms. The second is a Reference Guide, which explains every function, data structure, and symbolic constant used in the C API.

Lastly, a number of databases are included that are specific to the API sample programs.

C API Application Development
C API applications for MacOS are developed natively on a Macintosh. The development environmentis MPW using the Symantec C compilers for 68k and PowerPC. All development tools are included on the Essential Tools and Objects (ETO) cd, which is published by APDA. Make files are included for all samples, as are MPW build scripts that automate the usage of the makefiles. "Read Me" files for each supported platform, plus one for each sample, in addition to the User's Guide and Reference Guide are included in the Toolkit. We'll be discussing the development environment in detail later in this talk. We'll also be discussing future plans to support the Symantec and Metrowerks project environments.

NOTES C API DATA TYPES

Each Notes server can support one or more databases. Each database can contain one or more notes. Each note can contain one or more items. Each item is composed of a distinct data type. Those data types fall into two categories: simple and the composite (structured) data types.

Simple Data Types

Text and Text List
e.g. subject field of a mail memo

Number and Number List
e.g. part number or order number

Time/Date and Time/Date Range or List
e.g. date field

Composite Data Types

Rich Text - e.g. styled text
The functionality provided by Lotus Notes Rich Text is actually a superset of the industry standard Rich Text (Microsoft RTF). However, the data structures used in Lotus Rich Text are different than those used in Microsoft Rich Text. The C API Toolkit contains sample programs and source code to help you to create and manipulate Rich Text, and to call the import and export libraries to convert between Microsoft Rich Text and Lotus Rich Text. Lotus Rich Text may also contain bitmaps and hyperlinks (also called doclinks) to other documents.

Object - e.g. embedded OLE object, file attachment

Tables

User Data
Programmers can define their own data types which are not interpreted by Notes, but are simply stored as a stream of binary data.

NOTES C API - SEARCHING A DATABASE

Using the C API there are four ways to search a Notes database.

Linear
Scans all notes in a database, applying search criteria. Use this type of search when the search criteria is not known until runtime. The linear search is accomplished using a C API function that takes as an argument a pointer to a function that you define, called an "action routine". The action routine is called for each note that matches the search criteria. Linear is an inefficient search method.

Indexed
Uses views to sort and categorize notes. Use this type of search when the order of matched items isimportant. You create the view to specify the hierarchy.

Full Text
Use if search keywords might be in rich text fields.

Direct Access
Not a search, but if you know the Notes ID of the note, or you know the name of an item within a note, you can access it directly.

NOTES C API - SECURITY

Security is important!
Security is obviously important. Users want to know that their workstations are secure, and IS departments want to know that their servers and networks are secure. With all of the talk about the Internet and the perception of low security, you should know that Notes is secure.

Notes provides user identification, access control lists, and password protection as well as encryption. We'll talk here about how that security impacts API applications, and how you can take advantage of the features of Notes security.

Enforced on server
At first, it may seem that enforcing security only on the server and not on the workstation is a problem. However, you must realize that there are only two ways for something to get on the workstation. The first is that the user entered it, so obviously should have access to it. The second is that the user had access to copy it from somewhere else, so should have automatic access now that it is local. Notes v4 adds an additional level of security over what v3 had by offering encryption on the workstation.

Security in the Notes u/i vs. the Notes API
Security that is supported in the Notes user interface for the most part is also supported in API. We'll discuss the exceptions (forms and sections) on the next slide. This is important because you don't want a hacker to write an API program that cracks the Notes client application's security. Some developers have had problems with this, since it can sometimes restrict functionality. For example, an API program can only use one user's Note ID at a time.

Access Control Lists (ACL)
An Access Control List is a list of users and specifies what level of access each user has to a database. Each entry in the ACL contains a user name, access level, flags, and roles. Each database must contain one ACL, and may not contain more than one.

NOTES C API - LEVELS OF SECURITY

Server-level security
User must have access to the server - an API program can not open a database that the user could not have opened through the Notes user interface.

Database-level security
Database-level security is controlled by the Access Control List (ACL), which defines who can use a database, and what operations they are permitted in that database.

View-level security
If the view has a read access list, then it is enforced in the API. If the user does not have access to theview, the error message will indicate that the view does not exist. One might think that the error message should be that the user does not have access, but this is not the case. In the u/i, users can't even see the views that they don't have access to. So it stands to reason that the API should not be able to see those views either.

Form-level security
If the form has a read access list, then it is enforced in the API. In the Notes user interface, documents automatically inherit the access list of the form that created it. In the API, this inheritance is notautomatic. The API program must implement the document's read access list. In addition to the read access list, a form may contain a compose access list. Even though this is enforced by the user interface, the API ignores the compose access list for forms. When an API program creates adocument, there is no internal mechanism that checks the new doc with the form associated with it.

Document-level security
The document read, editor, and author access control lists are enforced by the API. For example, if the user does not have read access to a document, NSFNoteOpen() will fail, and NSFSearch() will not find the document. This second example is important. Rather than NSFSearch() returning documents that can not be opened, it does not find those documents. If a user has read access but not author access, then NSFNoteOpen() will succeed, but NSFNoteUpdate() will fail and will return the error ERR_NOT_AUTHOR. In the Notes u/i, if the users don't have author access to a document, they won't beable to get into edit mode. In the API, there will be no error until you try to save the document.

Section-level security
A form may contain one or more sections. A section is a field that contains a list specifying who can edit the fields that follow the section field. Sections are not a real security feature. In the u/i, if a user cannot edit a field because they are not in the section list, they may be able to switch to a different form that does not have that field as part of a section. An API program can write to or append to any field in a document.

Field-level security
Fields may be encrypted, and it is the responsibility of the API application to decrypt the field.

NOTES C API - ENCRYPTION

Public vs. Personal Key
Every Notes user is automatically assigned a public encryption key, which is included as part of their Notes ID. Usually, the public key is used for sending encrypted email. The personal key is used to encrypt documents that you will be keeping to yourself, or distributing to people to whom you have given your personal key. When you distribute a document, you will usually encrypt it with the public key.

Domestic vs. International
Notes uses RSA encryption, which, as you may know, has been classified by the US Government as a military technology, and thus the North American version can not be exported in its most secure form. Using the Domestic North American English version of Notes, you get the most secure version of encryption. If you need to send an encrypted email or document outside of the US or Canada, then you must use the International English version of Notes, which has a slightly less but still very secure level of encryption.

Field-level Encryption
Documents are not encrypted. Fields are encrypted. If you want to encrypt an entire document, it is better to think of the document as a collection of a number of items, all of which have been set up as encryption items.

This concludes the Notes C API portion of this session.

HITEST C API

What is the HiTest C API?
The Lotus Notes HiTest C API is an alternative higher level C interface to the Notes C API. Program development is significantly faster and requires less code than with the standard C API. HiTest C is object based, but not C++. It is currently released only for Windows and OS/2, but work is in progress for MacOS and Unix.

History
HiTest C was originally developed by Edge Research, which is now a wholly owned subsidiary of Lotus. It was developed as a step towards the implementation of HiTest Tools for Visual Basic, which enables Windows programmers to build Notes applications in a graphical programming environment.

Developer Benefits
(1) High Level - Compared to the C API, the HiTest C API has fewer functions, is easier to learn, and has a more consistent API. The C API has about 500 functions. HiTest C has less than 200 functions.

(2) Input validation and error handling. Better than the C API, but less than the HiTest C++ API.

(3) Simple browsing functions for everything from servers and databases through attachments and items.

(4) Simple data transfer.

(5) Automatic data conversion when reading or writing data.

(6) Simple high-level creation, access, and manipulation of composite data.

(7) Integrated single-function support for agent execution and full text search.

Limitations
(1) Built on top of C API, so there is a performance penalty.

(2) Not currently available on as many platforms as C API.

(3) Does not provide all of the functionality of the C API.

HITEST C++ API

What is the HiTest C++ API?
The HiTest C++ API is built on top of the C API (not on top of the HiTest C API). It provides true OOP, with all of the benefits of C++. HiTest C has a noticeable performance overhead. An implementation goal of HiTest C++ was to minimize the performance overhead. HiTest C++ is single chain, not multiple inheritance.

Status of Availability (as of December 1995)
Not yet in beta.

Developer Benefits
(1) Reduced application code size. Much of the code that the C and HiTest C leaves to the individual developer is handled by the C++ classes in its high level functions and data abstractions.

(2) Reduced application debugging and maintenance time, as well as more readable code. Since it is C++, there is type checking done at compile-time. The C++ classes implement run-time exception handling.

(3) Sophisticated memory management. If an object allocates memory, it is responsible for freeing it. If the programmer allocates memory, then the programmer is responsible for freeing it. If the programmer allocates and object but forgets to free it, it is automatically freed when the object goes out of scope.

(4) Easier for the programmer to learn the C++ classes than it is to learn the hundreds of C API functions or the HiTest C objects.

(5) Rapid development and deployment.

(6) Multi-platform support - when released will support every platform that the Notes C API supports.

Error Handling
(1) "Failable" functions return status codes. Used both as informational and to indicate an error situation.

(2) Run-time exception handling is supported via "catch" and "throw".

NOTES HITEST C++ API - SEARCHING A DATABASE

Search Methods
Like the C API , using the C++ API you can search by Formula (Linear), Key (Indexed), and Full Text.

All of the capabilities of searching in the C API, plus more.

Navigation supported via:

Iterators (class maintains the state)
ACLEntry = ACLEntryIterator->GetNextEntry();

Arrays (indexed access to data)
Doc = (*Documents)[i];

Named data can be directly accessed
Status = Database->GetForm("Discussion Topic", &Form;);

VENDOR INDEPENDENT MESSAGING (VIM)

We've now ended our discussion of the three Notes APIs, and will now look at Vendor Independent Messaging.

I've been told that yesterday one of the speakers said that VIM is dead but not yet buried. I'm reminded of something that Mark Twain once said. "Rumors of my demise are greatly exaggerated". VIM has been enhanced, and will continue to be supported by Lotus for Notes and ccMail. Perhaps the greatest reason for the enhancements has been requests by third party developers.

VIM is a useful API, and support for VIM is not in any danger of being dropped.

What is VIM?
The Vendor-Independent Messaging (VIM) Interface is an industry-standard and platform independent application programming interface specification for messaging systems. This API lets you write applications that link the functionality of messaging systems to the functions provided by end-user applications. With VIM, these resulting mail-enabled or mail-aware applications can be developed over a wide range of platforms. VIM provides a single interface that allows programmers to combine theservices of various messaging systems into one application.

What can you do with VIM?
(1) Compose and send messages with file attachments.
(2) Receive, store, and process delivered messages with the VIM API.
(3) Search and modify address books.

Why would you want to mail-enable an application?
Using the VIM API functions, you can design a number of specialized mail-enabled applications.For example, you could develop an application designed to analyze stock information sends email when a particular stock reaches or drops to a certain price.

VIM Compliant
The Lotus VIM implementation is VIM compliant. The process of converting a VIM application from another messaging system to Notes is very easy, as long as the application did not make use of optional or extension functions that are not implemented under Notes. (Certain VIM functions do not make sense in the context of Notes.) Actually, such an application may not even need to be recompiled. It is possible for the same VIM compliant application to run on any VIM compliant system. ccMail is also VIM compliant. The samples in the VIM Toolkit will work with both ccMail and Notes without needing to recompile them.

The VIM Toolkit
The Lotus VIM Developer's Toolkit enables developers to add electronic mail capabilities to their standalone applications. The Toolkit provides header files, libraries, documentation, and sample programs, and is compatible with both Notes-based and ccMail-based electronic mail.

Status of MacOS Availability (as of December 1995)
The VIM code libraries have been ported to the MacOS, and the testing/debugging cycle is continuing. Porting of the sample programs is also being done.

MACOS DEVELOPMENT ENVIRONMENT

Now
For a long time, Apple did not provide a shared library technology for developers to use. This is the main reason why Notes version 3 did not have a developer accessible API.Then Apple implemented the Apple Shared Library Manager (ASLM) for 68k Macintosh models, followed by the Code Fragment Manager (CFM) for PowerPC Macintosh models. When the Notes version 4 project began, there was no choice but to implement the 68k version with ASLM and the PPC version with CFM. Until relatively recently, ASLM was only available for 68k and CFM was onlyavailable for PowerPC. Today, both ASLM and CFM are available on both platforms, but it is too late to do anything for Notes v4. While this has no impact on the users of Notes and has no impact on the code that Notes API developers must write, it does have an impact on what linkers can be used to develop a Notes API application. When one begins to restrict the linker choices, one also begins to restrict the compiler choices, and lastly the development environment choices.

The current beta release (called Test Build 4) for MacOS requires the use of MPW with the Symantec compilers for 68k and PowerPC. It is possible to use the Metrowerks compiler for PowerPC, but not the Metrowerks compiler for 68k, since Metrowerks does not support linking ASLM shared libraries. According to their tech support, Metrowerks does not plan to support ASLM in the future. That means that it will never be possible to use Metrowerks to build 68k Notes API applications. The C API toolkit includes an MPW UserStartup file and a number of script files and make files to ease development of the sample applications, and to provide a foundation for developing your own projects.

The Future
One of the tasks on our schedule is to look at the Symantec Project Manager environment for building Notes API applications. For PowerPC applications, that is, I think, an achievable goal. Unfortunately, using Symantec Think C for building 68k Notes API applications is extremely difficult, and is not something that I am looking into further at this time. We should expect, or at least hope, that at sometime soon Symantec will provide a way to build 68k applications within their PowerPC Project Manager environment. If they retain support for ASLM 68k applications, then the needs of Notes API developers will have been met. I'd also like to see support of the Symantec Project Manager when theNotes HiTest C++ API toolkit is ready, since that will enable developers to use the Symantec class browser as well as ease the integration with the Think Class Library (TCL).

Update (January 1996)
Notes C API PowerPC applications can now be built using the Symantec Project Manager version 8, and also the Metrowerks version 7 development environment. It is actually possible that the Metrowerks environment can be used to build 68k Notes applications, if the Metrowerks restriction on ASLM is building, rather than using ASLM libraries.

Investigative work in this area is ongoing. New information will be posted here as it becomes available.

LEVERAGING APPLE TECHNOLOGIES

Newton

When version 2.0 of the Newton OS was released at Comdex in November 1995, Apple and Lotus made a joint announcement in the form of a press release. I'd like to read part of that press release to you, and for the first time, publicly say what it means to Notes API developers and to Newton and Notes users.

"Enterprise customers manage a broad range of business-critical information in Lotus Notes. As they deploy PDA technologies like Newton 2.0 into their IT environment, integration of Notes-based information adds great value. Developers can easily create a connection between Notes and Newton PDAs, thereby providing a compelling enterprise integration solution.

You might be asking yourself, "how can I easily create a connection between Notes and the Newton"?

MakeBook sample API program
The C API toolkit currently contains one Newton sample called MakeBook, and will soon have more. The current sample program, which of course includes full source code, implements a program to export the Notes C API User's Guide database into a form that can be transferred to the Newton, and is readable by the Newton built-in Newton Book browser. This sample program requires that you use an Apple supplied Newton Book "compiler" as well as a program to do the actual file transfer.

The key point here is that this is the foundation of a technology integration between Notes, which is a managed and distributed information system, and the Newton which is more personal than any personal computer. A few people around Lotus have been using the Newton Book that I created using the MakeBook program, and find it tantalizing. In fact, browsing the Notes C API User's Guide on the Newton is actually faster than browsing it using Notes v4 on a PowerPC or a Pentium based machine, even if the database is stored locally on that machine.To keep this in context, MakeBook is not a general purpose Notes database export tool for use by end-users. It is a sample program, a technology demonstration, or a template for third party developers to use in creating their own products. Remember that in the Notes API group, we do not create products. It is our Charter to create tools and provide sample source code to help other developers to create Notes applications, in this case Notes and Newton integration applications.

DILs
Apple has recently released the Newton Desktop Integration Libraries (DILs) to enable developers to write MacOS and Windows applications that exchange data with the Newton. In the very near future, the Notes API group will be releasing sample programs (again including full source code) that show how to leverage the DILs in Newton/Notes applications. Remember that the MakeBook sample requires the use of another program to transfer the datato the Newton from the Mac or Windows machine. Functions in the DILs could handle that task.

What's Next
Newton/Notes Connectivity is a priority for both Apple and Lotus, and that the Notes API group is one placewhere you'll see some action.

OpenDoc
OpenDoc has the potential be a key Notes development tool, since OpenDoc's concept of Containers and Parts is somewhat analogous to the Note paradigm of the Notes client application and runtime services implemented by databases, LotusScript, and API programs.The Notes API group is looking at OpenDoc for ways to integrate the Notes API into it so that we can provide sample OpenDoc parts in the Lotus Toolkit. Nothing has been planned at this time (as of December 1995), although you should keep in mind that the Windows and OS/2 versions of OpenDoc are being developed by IBM, which recently acquired Lotus.

System 7 Finder Features
Many Notes API programs are implemented in a 100% platform independent manner. However, sometimes it makes sense to write a MacOS specific program. I was approached by a third party Notes developer for help in designing a Mac-specific Notes add-inthat will add Notes functionality to other applications. This developer wanted to add a menu to themenu bar of other applications. The items on that additional menu would add Notes functionality to those applications. I told them that it seemed needlessly difficult to add a menu to the application's menu bar. My idea was to add a folder into the Apple Menu Items folder that contained aliases to their Notes API applications. The resulting user interface is a hierarchical menu on the Apple menu with the names oftheir API applications. When the user selects that menu item, the API application is run. Those API applications use AppleScript to communicate with the frontmost application, and use the Notes API to communicate with Notes. This design exploits a feature of the Apple menu, and made new menu items available to all applications. If an application is AppleScript savvy, then the Notes API application would be able to communicate with it.

AppleScript
AppleScript has many uses. It can be used to make an application programmable by end users, and can be used to implement programmability between applications. Although the Notes client application is not AppleScript aware, it is possible to create an AppleScript aware application that provides an interface between AppleScript and the Notes API. This is very different that scripting the Notes client, which is a task that should be done using LotusScript. An AppleScript/Notes API application could have many uses. For example, imagine implementing the AppleScript database suite, or some variation of it, which uses Notes as its database, as implemented via the Notes API. Another idea would be to use AppleScript to implement a layer on top of VIM, to make it easier for developers to mail-enable their applications.

SUMMARY

Lotus has made a real commitment in providing a true Macintosh user experience and a true Macintosh developer Toolkit with Notes version 4. Within the Notes API group our goal has been to provide cross platform compatibility with all of the implementations of Notes, in order that the MacOS version is an equal peer to the other versions. In addition to providing a toolkit that is on par with the others, we have tried to provide ways for developers to take advantage of Apple and industry standard technologies that highlight the MacOS platform. I hope that this talk has been helpful to you as an overview of Notes C programmability, and of the development options available to the cross platform and the MacOS developer. You can look forward to continued support and enhancements to the Toolkit, and I hope that Lotus can look forward to feedback and support from the developer community.

For information on becoming a Notes developer and joining the Lotus Business Partner program, call one of the following numbers.

USA: 1-800-START-SMart
Canada: 1-800-565-0878
Outside USA and Canada: 617-693-1992