Lotus Notes Insufficient Memory Too Many Design Elements

Lotus Training Overview

LotusScript is a BASIC derivative that uses many of the same statements and function names, so most developers will find it easy to understand and use without too much relearning. While this course teaches the basics of LotusScript, its primary emphasis is not on the language itself, but rather on how to use it to operate on Notes database, view, document, field, and ACL objects. With this knowledge, you will be able to develop powerful custom applications and extend the standard templates such as Mail or Discussion.
Lotus Training Course goals

The design specification for a kernel memory allocator is similar, but not identical, to the design criteria for a user-level memory allocator. One criterion for a memory allocator is that it make good use of the physical memory. Use of memory is measured by the amount of memory needed to hold a set of allocations at any point in time. Error 500 HTTP Web Server: Lotus Notes Exception - Formula or value requires too much memory This error normally occurs when the return value of a @DbLookup or @DbColumn exceeds the memory limit.

In this course, you will learn how to: This course will teach you how to:

use fundamental LotusScript language elements as you program and debug applications using Domino Designer
use LotusScript in various Notes events to operate on objects in the Domino Object Model
configure client, server, database, and document security mechanisms to allow LotusScript to operate
reconcile LotusScript and Notes data types and validate user input
design error handling routines to gracefully recover from runtime errors
operate on new and existing documents as well as on collections of documents
use messaging to send email, documents, and newsletters
operate on the database ACL and develop an alternative user interface so users can more easily administer database security
interact with users with both the primitive LotusScript and sophisticated Notes dialog boxes
use Profile documents to store application and user-specific configuration settings
develop custom procedures and classes and use Script Libraries to store and share commonly used procedures across design elements and applications
develop server-based Agents that use LotusScript and Notes objects to process documents
debug Agents using the Remote LotusScript Debugger, report errors to a log file, profile Agent performance, and work with your server administrator to develop application probes to monitor ongoing Agent performance
operate on file system based text files
generate MIME content that can be used to send formatted emails with intact HTML
parse XML files to extract element data and attributes
run procedures stored in Windows, Notes, and other product DLLs
instantiate objects from other products such as Office applications, Windows Script Host, and Windows Management Instrumentation via COM to use their properties and methods.

HCL Notes is a client-server cross-platform application runtime environment that provides an interface to the HCL Notes and Domino software. clarification needed It can be used as an email client without an HCL Domino server, for example, as an IMAP client.HCL Notes and Domino provide email, calendars, instant messaging (with additional HCL software voice- and video-conferencing. Lotus Notes Insufficient Memory Local Heap Is Full Lotus Notes Insufficient Memory Too Many Design Elements There are recognized websites on the internet and you have to find them to ensure reliability. Archive rarely used documents and delete old Lotus Notes attributes: There are documents which are rarely used but are important in some or the other way. So, create archive for such emails and remove them from the main database. Also, remove old calendar entries, to do lists, notes, appointments etc. And generate space for new elements.

Lotus Training Audience

This course is designed for Notes programmers well versed in using Domino Designer 8. It assumes that you have:

extensive experience using Notes 8
thorough knowledge of the Domino Designer 8 development environment, including Form and View design
mastered the concepts covered in the Domino Designer 8: Basic Notes Applications course.

The course does not review any aspects of the non-LotusScript specific development environment such as how to design forms or views.
Though not required, experience in any event-driven or structured programming language is helpful in understanding LotusScript. If you have used LotusScript in other Lotus applications or have built applications using Microsoft® Visual Basic™, you will find that this course won't be repetitive as it focuses mostly on Notes objects.
This course is part of a series of Domino Designer 8 training courses. Follow these paths to master all aspects of developing applications using Domino Designer:

Lotus Notes Insufficient Memory Too Many Design Elements Formed

Domino Designer 8: Basic Notes Applications provides the base knowledge for this additional training:
Client Track

Configure Domino to use DB2 as a database engine and build applications that access relational data, DB2 for Domino 8 Administrators and Developers.
Specialize in programming Notes applications to respond to built-in user interface features, Domino Designer 8: Special Notes Features.
Convert an application written for Notes clients to be used in browsers, Domino Designer 8: Basic Browser Applications.
Provide data to cutting-edge Web applications, Domino Designer 8: Web Agents and Web Services.

Lotus Notes Insufficient Memory Too Many Design Elements

Language Track. These languages apply to both Notes and browser clients:

Learn sophisticated application techniques that fully exploit the formula language in Domino Designer 8: Formula Language.
Develop sophisticated applications and Agents with LotusScript in Domino Designer 8: LotusScript.
Add powerful client-side scripting to browser applications in Domino Designer 8: JavaScript.

Course design

Lotus Notes Insufficient Memory Too Many Design Elements Pdf

Lotus Notes Insufficient Memory Too Many Design Elements Desk Design Pool

This is a lecture/lab course in which you will closely examine demonstration code and create additional code. You will immediately apply the concepts and techniques as you work in your own project database.
This is not an introductory programming course. Its emphasis is on how to use LotusScript to manipulate Notes objects. All major concepts are reinforced with examples and exercises, during which you will code and debug LotusScript. From this experience you will have the necessary skills to build sophisticated applications.
All code fragments are labeled to make talking about them and reusing them in exercises easier. The intent in labeling them is also to help build a sense of modularity, purpose, and a way of 'thinking' about LotusScript.
Lotus Training Course duration

Ibm Lotus Notes Insufficient Memory Too Many Design Elements

4 days
Lotus Training Course outline

Topic 1: LotusScript in Notes and Domino

What is LotusScript?

Advantages of LotusScript for Notes/Domino

When to use LotusScript

Where the code runs

LotusScript respects security

What LotusScript cannot do

Limits and performance

Other resources

Topic 2: Lotus Notes Events

Event-driven language

Enter LotusScript code

Automatic code completion

Programmers Pane properties

Print code

Syntax errors

Compile and test the code

Exercise: Create button event script

What is the sequence of events?

Exercise: Experience the event model

What happened? Create document events

Query what? Post what?

Recalculate document event

Save document event

Close document event

Switch modes events

Read document events

Agent events

Database events

View events

Field events

Topic 3: Debugging

Script errors

Remark code

Script Debugger

Find errors

Debugger Buttons

Debugger tabs

Exercise: Use the Debugger

Exercise: Break points

Persistent breakpoints

Debugging with Msgbox and Print

Topic 4: Language Fundamentals

Basic language rules

MessageBox parameters and return values

InputBox

Variables

Declare variables

Advantages of explicit declaration

Global variables

Exercise: Global variables

Constants

User-defined data type

Statements and functions

Exercise: Experience LotusScript functions

String functions

Math functions

Date functions

Data type conversion

Boolean operators

How Designer Help helps

Platform considerations

Topic 5: Program Control Structures

Program structure

Experience control structures

Branching structures

Exercise: Branching structures

Looping structures

Looping performance

Code benchmarking

Exercise: Looping

How to exit a structure

Break out of an endless loop

Exercise: Exit a structure

Topic 6: User Input Validation and Error Handling

Check for empty variable

Failure to exit loop

Check data type

Other data type tests

Exercise: User input validation

Error handler

Resume after error

Goto after error

Resume 0

Specific error number handling

Reverse engineer Err codes

Error cases

Exercise: Error handling

Multiple error handlers

Error handlers and the Debugger

Topic 7: Domino Object Model

What is an object?

Object class properties and methods

Domino Object Model

Back-end vs. Front-end classes

Back-end object classes

Front-end object classes

How Designer Help helps

Topic 8: Notes Object Instantiation

Object instantiation steps

How to instantiate an object

Container objects

Object reference variables

Best practice: Use generic object names

Access current database using back-end methods

Best practice: Use constants

Use Domino Designer 8 Help

Exercise: Object containers

Access other databases using back-end methods

Access other database on server

Exercise: Instantiate object in another database

Best practice: Public declarations of Notes objects

Notes object properties

Read object property

Set object property

Chain/pipe references

'With' statement

Notes object methods

Run Notes object methods

Three types of methods

Exercise: Open method

LotusScript is not a keystroke macro language

Interact with users via front-end methods

Exercise: Open database for user

Delete object reference

Topic 9: NotesSession Object Operations

Session properties

NotesName object class

NOTES.INI access

Data type assignment from environment

Exercise: Set environment

Topic 10: NotesDatabase Object Operations

Paths to instantiate NotesDatabase

Select and open database

Ways to create a new NotesDatabase object

Is the database really open?

Open database on servers

Exercise: Database Info

Iterate data to look for a database

NotesReplication class

Exercise: NotesReplication class

Open database for user in UI

Open a database by property

Error handling when opening databases

Exercise: Find database

Create non-replica database copy

Who can create a database?

Copy documents to new database

Exercise: Database Copy

Error handler review

Create replica copy

New database from template

ACL of new database from using template

Delete database

Case Study

Topic 11: New Document Object Operations

New document (back-end)

Security issues with back-end methods

Document properties

Exercise: Create Document (back-end)

New document using Form (front-end)

Security issues with front-end methods

Exercise: Create NotesUIDocument object

Topic 12: NotesItem Object Operations

Create a new item Option 1: Extended class syntax

Data type of a new item

Create a new item Option 2: NotesItem object New method

Item properties you can set

Create a new item Option 3: Document object method

Create a new item Option 4: AppendItemValue method

Read item values Option 1: Extended class syntax

Read item values Option 2: NotesItem object Values property

Read item values Option 3: Use GetItemValue method

Modify existing item values

Best practice: Be sure an item exists before using it

Access system fields

Read all items

Remove item

Exercise: Manipulate NotesItem objects

Challenge Exercise I: System Inventory

Objects required for Challenge Exercise

Pseudocode for Challenge Exercise

Topic 13: UI Object Classes

NotesUIWorkspace object

Close method

NotesUIDocument object

Instantiating the current UI document object

Front-end UI methods

Back-end to front-end interaction

Example of back-end to front-end interaction

NotesUIDocument limitations

Using the 'Source' object reference variable

Instantiating container object

Exercise: Flip-Flop via back-end methods

Exercise: Flip-Flop via front-end methods

NotesUIView object

Refresh a View

Topic 14: Notes Data Validation

Form translation and validation

Check empty object

Example: Check empty object

Check for empty item (Field)

Example: Check for empty item (Field entry)

Accessing fields in a Form

Field focus

Simple Field validation

Exercise: Item validation

Compute with Form

Continue variable

Example setting Continue I: Stop a Form from closing

Example setting Continue II: Require Action Button clicks

Stop users from deleting documents in folders

Stop users from pasting documents

Topic 15: Multi-Value Items and Arrays

Array basics

How to declare an array

Assign values to an array

Split

Join/Implode

Read single array element value

Iteratively read array elements

Examples of object properties returning an array of values

Find an array element

Replace values in an array

Replace

Determine the number of elements in an array

Remove blank elements

ArrayUnique

Dynamically sized array

Create copy of an array

Erase array values

Exercise: Dynamic array

Append one array to another array

Multi- dimension arrays

Items and multi-value Fields

Variable assignment

Testing equivalence

Read an array of strings or array of objects?

Get multi-value Field in current document

Set multi-value Field in current document

Append to existing multi-value Field

Exercise: Translate a multi-value Field

Other collections of document objects

Sort a collection

Collections and performance

Topic 19: View-Based Document Object Collections

NotesView object

Exercise: Loop through NotesView

Solution: Loop through NotesView

NotesDocument object ColumnValues property

Primary key and View concerns

Get a document or document collection by View key

Example: Build a collection by View key

Process descendent documents

Iterate all levels of a document hierarchy

Sibling documents

Access a documents parent document

View.EntryCount property

NotesViewEntryCollection object

NotesViewEntry and NotesDocument objects

Exercise: Status summary

Solution: Status summary

NotesViewNavigator object

Topic 20: Search-Based Document Collections

Collection from GetModifiedDocuments method

Collection by Full Text Search

The query

Search items using [FIELD]

Search on special items

Full Text Search options

Use the results

About the accuracy of Full Text Search

Refine an existing collection

Exercise: FTSearch Summary

Solution: FTSearch summary

Collection by ordinary Search

Change a View Selection Formula

Exercise: Search summary

Solution: Search summary

Search method performance

Switch search methods on-the-fly

Domain Search

Code the FTDomainSearch method

Topic 21: Unprocessed, Selected, Unread Documents

Unprocessed documents

Unprocessed documents and user interaction

Efficient processing by Agents

Unprocessed flag and Agents

Unprocessed search accuracy

Exercise: Unprocessed documents

Documents highlighted and/or selected in a View

Unread documents

Topic 22: Existing Document Object Operations

Make a copy of the current document

Delete a document

Security issues

Exercise: Archive selected documents

Delete open document

Test for locked document

Lock document

Does the document really need to be saved?

IsDeleted and soft deletes

IsValid document? IsDeleted document?

Is document open in the UI?

Open user-selected document

Put document in Folder (back-end)

Put document in Folder (front-end)

Exercise: Put document(s) in Folder

Remove document(s) from Folder

Remove all Folders

Remove only personal Folders

Make Response document

Topic 23: Newsletter Object

NotesNewsletter object

Create newsletter object

Exercise: Newsletter report

Case study: Custom search Form

Optional exercise: Order report

FormatDocument method

Topic 24: Messaging

Send document

Example Agent

Send method parameters

Source database

Read the Directory for user mail information

Change the apparent sender name from Notes

Change the apparent sender name from an Agent

Prevent Agent mail 'ping-pong'

Exercise: Send message

Optional properties and Fields

Exercise: Status Checker Agent

Solution: Status Checker Agent

Challenge Exercise IV: System inventory

Programmatically send Sametime instant messages

Topic 25: Evaluate @Functions

Which @Functions cannot be used?

Why evaluate @Functions in LotusScript?

Evaluate syntax

Sum two Fields

String functions

Uppercase Field

@Functions outside of object context

Sum an array

Lookups

Exercise: Using @Functions

Performance implications

Topic 26: Dialog Boxes

OpenFileDialog

SaveFileDialog

Prompt

Choose Database dialog box

PickListCollection

PickListStrings

Exercise: PickListStrings

Free Time dialogs

Folder dialog

DialogBox

From where you can call the DialogBox method

Status information

Case study: Bring the data here

Topic 27: Database Access Control List

Minimum access requirements

Best practices

Find a known ACL entry level

Name storage in the ACL

ACL level constants

Iterate ACL entries

Other ACL permissions

Resolve group or Organization wildcard name

Why control the ACL with LotusScript?

Add an ACL entry

When to save ACL changes

-Default- special handling

Exercise: Set ACL

Change the level of an entry

Rename an entry

Delete an entry

Exercise: ACL control

Set permissions

Set entry type

Add a Role

Associate an entry with a Role

Role resolution

Disassociate entry from Role

Rename Role

Remove a Role

ACL and replication

ACL, your Domino administrator, and company policy

Topic 28: Profile Documents

What Profile documents are used for

The nature of Profile documents

Profile document security and replication

Create Profile document

Back-end method to access Profile document

Read profile Fields

List Profile documents

Delete Profile document

Topic 29: Procedures and Script Libraries

Advantages of using procedures

How/where to define procedures

Function procedures

Call a function

Single function argument

Pass an array as an argument

Multiple function arguments

Example: ConvertTemp function

Example: ReplaceSubstring function

Exercise: Value translation

Exit a procedure

Sub procedures

Example: Sub procedure

Pass argument by reference

Pass argument by value

Script Libraries

Use 'LibraryName' statement in Options

Exercise: Use a Script Library

Resource strings

Script Library tips

Recursion example: Process all child documents

Recursion example: Find root parent document

Recompile all LotusScript

%Include LSS file

Topic 30: Custom Classes

Custom classes

Derived classes (inheritance)

Memory management

Example: Custom helper class

Advantages of object-oriented programming

Learn more about custom classes

.LSO files

.LSX files

Topic 31: Server-Based Agents

Create new Agent

Trigger

Target

Document selection 'event'

Unprocessed documents

Before New Mail Arrives trigger

Agent security

Handling UI method errors in Agents

DelayUpdates property for Agents

Pass arguments at run time

Work queue architecture

Usage guidelines

Topic 32: Agent Logging, Profiling, and Debugging

Domino Server Log

Private Agent log

Custom Agent Log

Agent performance and Agent Profiling

DDM Application Probes

Remote LotusScript Debugger

Topic 33: Text File Operations

Write to a text file (Output)

Read lines from a text file (Input)

Read performance

Delete a file

Example: List Databases to File

Exercise: Append to text file

Export records to text file

Easy comma delimited export

Import records from text file

NotesStream class

Open, write to, and close NotesStream object

List databases example

MIME in email messages

Agents and MIME/HTML

Topic 34: XML Processing

What wont be covered

NotesDOMParser and NotesDOMDocumentNode classes

Example XML file

Walk DOM Tree

Exercise: Correlate XML file to walkTree report

Create Notes documents from XML

Open a NotesStream to a URL

Topic 35: Call DLL Procedures

Declare DLL procedure

Call the DLL Procedure

Caveats and tips

Win API: GetFolderName

Win API: Read/Write INI file

Win API: Get registry value

Notes API: Close any Notes window

Notes API: Run file from Notes

Other DLL examples

Resources

Topic 36: Use Other Product Objects

Component Object Model (COM)

Instantiate Excel objects

Start and stop an application

Product object hierarchy

Access the object methods and properties

Where to find object data files

Example 1: Create Excel object from file

Example 2: Create new Excel object and set formula

Example 3: Create new Excel chart object

Example 4: Export View to Excel

Example 5: Create new Word object

Example 6: Create new Word object (labels)

Compound Document Container

Example 7: Work with embedded object

Notes and OLE

Example 8: Create OLE object in PostOpen event

Troubleshoot OLE problems

Example 9: Operate on attachment

Windows Script Host (WSH)

Windows Management Instrumentation (WMI)

COM access to Notes objects

Buy versus build

Lotus Symphony