Beginner LotusScript for Notes and Domino 9
Units: 12
Duration: 3 classroom equivalent days
Discussion Access: 12 months

Summary Description
TLCC’s Beginner LotusScript for Notes Domino 9 course will teach you the basics of the LotusScript language and the Domino object model. This course is designed for both the programmer who has never worked with object oriented programming languages before and the experienced coder who wants to learn the Domino Object Interface. Get started with the LotusScript programming language and some basic functions. Next, learn to use the basic building blocks of LotusScript including the different data types and when to use them. Discover how to work with strings and text and to control the flow of your program and LotusScript looping structures. Harness the power of arrays and lists to store your data. Explore object oriented programming and how to use LotusScript and the Domino Object Interface to access and operate on Notes and Domino objects. Learn how to work with both back-end and front-end Domino document objects. This course has many real life demonstrations and examples. You will learn LotusScript by actually writing real code, not a simulation, at your own pace and at your place! This course is the first of a series of TLCC Notes Domino 9 LotusScript courses.

Audience and Prerequisites
The recommended prerequisites are:
  • TLCC's Notes Domino 9 Application Development 1 course or equivalent experience
  • TLCC's Notes Domino 9 Application Development 2 course or equivalent experience

System Requirements
A single Notes 9 and Domino Designer 9 client. Access to the Internet is required to get instructor support.

Course Modules

Module 1 - Introduction to the LotusScript Language
This module introduces the LotusScript programming language.
  • Describe the LotusScript programming language
  • Compare LotusScript with the Notes Formula Language
  • Understand and use the object-event programming model in Notes
  • Use the Inputbox and Messagebox functions
  • Use the features of the "classic" LotusScript Editor, and introduce the new LotusScript Editor in Eclipse (LSEE)
  • Use the LotusScript Debugger

Module 2 - Script Building Blocks
When you build a script, you can include several LotusScript building blocks, which are described in this module.
  • Use each of the script building blocks:
  • Identifiers
  • Keywords
  • Literals
  • Constants
  • Operators
  • Expressions
  • Statements
  • Comments
  • Learn about labels and their use
  • List the special characters in the LotusScript Language
  • Use the predefined constants in the LSCONST.LSS file
  • Learn about LotusScript functions and statements
  • Use the user dialog functions
  • Use the status bar functions and techniques
  • Learn about user-defined functions, subroutines, Script Libraries, and the advantage of using these larger script building blocks
  • List the LotusScript statement construction rules

Module 3 - Using Variables
This module outlines the basic steps for declaring, assigning, and processing variables. The scalar and variant data types are described and demonstrated. LotusScript offers many built-in functions and statements for working with variables. This module also describes and demonstrates many of the most useful functions and statements.
  • Learn the three basic steps that are at the core of most scripts: declaring, assigning, and processing variables
  • Understand explicit and implicit declaration
  • Use each of the scalar data types: String, Fixed String, Integer, Long, Byte, Single, Double, Currency and Boolean
  • List the data type suffixes
  • Use numeric functions and techniques
  • Understand the memory allocation for the various data types
  • Learn about the variant variable -- the chameleon data type
  • Understand how date/time values are stored as numbers
  • Use variant variables for date/time processing
  • Use date functions and techniques
  • Learn about implicit and explicit data type conversion
  • Use the Option Declare statement as a compile-time Spell Checker
  • Learn techniques for formatting numbers, strings, and dates

Module 4 - Manipulating Strings
This module describes functions and techniques to manipulate string values.
  • Use several case conversion techniques
  • Remove extra spaces from strings
  • Learn techniques for adding, removing and replacing characters in a string
  • Use character code page manipulation techniques
  • Use string conversion and string concatenation techniques
  • Use the string comparison techniques
  • Use of the Option Compare statement
  • Use string pattern matching techniques

Module 5 - Controlling Program Flow
The LotusScript Language contains a rich set of program flow control tools, including several looping structures. In this module, you learn about these LotusScript flow control tools:
  • GoTo
  • If...GoTo
  • If...Then...Else
  • If...Then...ElseIf
  • Select Case
  • Do...Loop
  • While...Wend
  • End
  • Exit

Module 6 - Working with Arrays and Lists
Array variables are aggregate data storage structures that can hold multiple values. They are an important data structure because field item values are stored in arrays and many properties and methods in the Domino Object Interface return values in array structures. This module covers the basics of array creation, composition, and manipulation. This module also covers the basics for creating and using list data structures. Like arrays, lists are aggregate data storage structures that can hold multiple values. Unlike arrays, you assign and access data in lists using descriptive list tags.
  • Understand the definition and structure of arrays
  • Learn the steps for declaring arrays, setting the bounds of an array, assigning values in an array, and accessing values in an array
  • Use the Option Base statement for setting the default lower boundary for arrays
  • Use the LBound and UBound array boundary functions
  • Learn array looping techniques using the Do, For, and ForAll block structures
  • Use the REDIM statement to re-dimension a dynamic array
  • Use the REDIM statement to expand and contract an array
  • Learn the list data structure
  • Learn the steps to declaring a list, assigning values in a list, and access values in a list
  • Use the ListTag, IsList, and ListElement functions

Module 7 - Understanding the Domino Object Interface
This module introduces event-driven object-oriented programming and describes how to use LotusScript to gain access to the Domino Object Interface. This module also introduces a 3-step procedure to access Domino objects. The pseudo-code diagram methodology is introduced and used to solve problems using LotusScript and the Domino Object Interface.
  • Understand what an event-driven object-oriented programming language is
  • Understand the meaning of the terms: Classes, Objects, Properties, Methods and Events
  • Use the object model in Notes
  • Learn the classes in the Domino Object Interface
  • Understand the difference between the front-end and back-end classes
  • Learn a 3-step procedure to access Domino objects
  • Learn the Domino object containment model
  • Use the pseudo-code diagram methodology to solve problems using LotusScript and the Domino Object Interface
  • Use the NotesSession class to access environment information
  • Access the current database and any stored database
  • Access and use the NotesView class

Module 8 - Working with Documents
This module introduces the NotesDocument class and how to access and work with documents in a database. This module also introduces techniques to work with multiple documents.
  • Use the NotesDocument class
  • Learn different ways to access a document
  • Access and change the field values in a document
  • Create and save documents using LotusScript
  • Loop through the documents in a view
  • Loop through the documents in a database

Module 9 - Working with the Current Document
This document currently on the screen is the Front-end or User Interface (UI) document. This module describes how to access and manipulate the front-end document.
  • Use the NotesUIWorkspace and NotesUIDocument classes
  • Navigate the front-end document
  • Access and change field values in the front-end document
  • Use the NotesUIDocument class to print, save, and close the current document
  • Access the back-end document through the front-end document