IBM Lotus Domino: Classic Web Application Development Techniques - Richard G Ellis - E-Book

IBM Lotus Domino: Classic Web Application Development Techniques E-Book

Richard G Ellis

0,0
47,99 €

-100%
Sammeln Sie Punkte in unserem Gutscheinprogramm und kaufen Sie E-Books und Hörbücher mit bis zu 100% Rabatt.

Mehr erfahren.
Beschreibung

Domino is an application server that can be used as a standalone web server. As part of the Domino suite, it provides a powerful collaborative platform for the development of customized business applications. It provides enterprise-grade e-mail, messaging, and scheduling capabilities.

There are many novice and moderately experienced developers who would like to enhance a Web-enabled Domino application, but to do so they need to learn the fundamentals of HTML, CSS, and JavaScript, and also how to use those technologies in the context of a Domino application. Information about how to do this is available on the Web, but the sheer volume of that information makes it very difficult for the newbie to get started.

Topics and techniques presented in this book provide a comprehensive overview of all major design strategies used to Web-enable traditional Domino applications. Illustrations provide clear working examples of how HTML, CSS, and JavaScript can be incorporated into existing applications to improve both look and performance.

Early chapters provide suggestions for working with users and for managing your development time and effort. Later chapters focus in detail on forms and pages, views, navigation, agents, security, performance, and troubleshooting. Examples demonstrate clearly how to incorporate HTML, CSS, and JavaScript into Domino designs. By the end of this book you will have learned what you need to know to quickly and competently tackle web application enhancement tasks.

Beyond providing a good understanding, this book will continue to serve as a valuable source of ideas and techniques. This book brings together essential classic strategies and techniques used to deploy Domino applications to the Web. Chapters cover all major design elements, with a special emphasis on how to craft these elements to work well with web browsers. Many topics include alternative techniques for solving particular problems. Illustrations and examples can be used where appropriate, or they can serve as jumping off points for your own solutions.

Das E-Book können Sie in Legimi-Apps oder einer beliebigen App lesen, die das folgende Format unterstützen:

EPUB
MOBI

Seitenzahl: 414

Veröffentlichungsjahr: 2011

Bewertungen
0,0
0
0
0
0
0
Mehr Informationen
Mehr Informationen
Legimi prüft nicht, ob Rezensionen von Nutzern stammen, die den betreffenden Titel tatsächlich gekauft oder gelesen/gehört haben. Wir entfernen aber gefälschte Rezensionen.



Table of Contents

IBM Lotus Domino: Classic Web Application Development Techniques
Credits
About the Author
About the Reviewers
www.PacktPub.com
Support files, eBooks, discount offers and more
Why Subscribe?
Free Access for Packt account holders
Instant Updates on New Packt Books
Preface
Getting started
What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
Downloading the example code
Errata
Piracy
Questions
1. Preparation and Habits
Preparing yourself as a developer
Gather a list of public websites that use Domino
Get certified in Lotus Notes / Domino application development
Use Domino Help
Consider using external editors and development tools
Create sandbox applications
Create a personal cookbook
Create a personal document library
Create a website
Adopt new language and terms
Pay attention to web programming developments and practices
Standardizing applications
Abide by your organization's web development guidelines
Usability
Style
Mechanics and process
Create libraries of common resources
Planning your work
Take notes
Use to-do lists
Keep a list of all active projects and tasks
Report your progress
Working the project
Work with users, not against them
Identify the champion and other players
Don't start without clear requirements
Understand the budget and timeline; provide an estimate
Avoid scope creep
Assume that all Notes applications will be web-enabled in the future
Familiarize yourself with an unknown design
Assess an existing application for web enablement
Think like a user
Think like a developer
Write a report
Keep an issues log
Improve the application under the covers
Enhance performance wherever possible
Add error trapping
Add diagnostic and repair aids
Provide the customer with a summary of changes
Documenting your applications
Add comments to the code
Create internal developer notes
Add release notes to the About document
Include external documentation in the design as file resources
Create user-oriented help pages
Summary
2. Design and Development Strategies
Planning the design
Understand the scope of the project
Annotate the requirements document
Understand the workflow
Determine the need to access external databases
Decide on one database or several
Review existing designs
Copy the design of an existing application
Evaluate the security needs of the application
Using consistent naming conventions
Name databases so that URLs are easy to remember
Use standard versioning for design templates
Use standard versioning for major design elements
Use unique names for all major design elements
Name design elements sensibly
Name form fields consistently and appropriately
Create different versions of design elements for Notes and the Web
Name Domino groups and roles appropriately
Use Domino groups and roles appropriately
Name roles consistent with other applications
Attending to human factor issues
Create clean and flexible designs
Design for specific display characteristics
Design for accessibility
Add titles to pages, forms, and framesets
Optimize the use of images
Use image resources instead of pasted images
Using appropriate design elements and techniques
Consider alternate design strategies
Learn the Properties dialog box
Use hide-when formulas
Avoid using the Java applets
Avoid server refresh round trips
Conform to HTML standards
Avoid using non-standard, deprecated, and invalid HTML tags
Avoid using HTML formatting tags
Use configuration documents
Developer testing
Add diagnostic and repair tools
Set up test IDs
Test with browsers used by your users
Clear the browser cache
Promoting the design from testing to production
Use a staging server for user acceptance testing
Segregate administrative and developer duties
Request that templates be signed by an authorized signing ID
Understand how templates are applied to production applications
Reviewing other sources of help
Read the Notes and Domino release notes
Summary
3. Forms and Pages
Setting properties appropriately
Set the content type (MIME) property
Take full control with content type HTML
Leave the "Use JavaScript when generating pages" option enabled
Generate HTML for all fields
Opening forms and pages directly
Viewing the source in a browser to investigate anomalies
Composing and saving documents
Create documents
Edit documents
Save documents
Save documents using $$Return to specify the next page
Save documents using a WebQuerySave agent to specify the next page
Improving the layout of design elements
Identify all HTML tags
Use view template forms to display views
Use framesets for layout
Use <div> tags to replace framesets
Align fields
Use tables to align fields
Use <div> and <label> tags to align fields
Use <fieldset> and <legend> tags to group related fields
Using computed text
Display a customized title bar
Display customized messages
Using hidden computed fields
Add fields to provide access to key document attributes
Access CGI variables
Improve @DbLookup and @DbColumn formulas
Using HTML to add value to a form or page
Use special fields
Convert between Notes and HTML
Creating pseudo Action Bars for the Web
Summary
4. Navigation
General precautions
Do not hardcode URLs, filenames, or UNIDs
Use @WebDbName
Use $Ref
Use a "go forward" navigational strategy on the Web
Avoid generating complex dynamic pages
Application launch options
Launch the About document
Launch a specific homepage
Launch a frameset
Launch a view
Launch a form
Launch a graphical navigator
Launch documents in context using Auto Frame
Creating a custom application login form
Creating menus
Create Hotspots
Create menus with outlines
Create menus with tables
Create menus with HTML and CSS
Create dynamic menus with views
Displaying a design element after exiting a document
Use $$Return to select a design element
Display the previous view
Display the parent document
Using response forms for interim workflow steps
Coding default error pages
Providing directions and help
Add meaningful labels and guidance text
Add titles to design elements
Link to the About and Using documents
Add customized help pages
Opening another application in a separate window or tab
Summary
5. Cascading Style Sheets
Using CSS for styling design elements on the Web
Learn basic CSS coding
Associate CSS rules with design elements
Locating style rules in applications
Use a page design element
Use Style Sheet Resources
Add style (sparingly) to Properties
Minimize the use of internal and inline styling
Use common style sheets
Use a Domino application as a style sheet repository
Use the HTML directory on the server
Developing CSS rules
Work with an application rather than a template while writing CSS
Make sure you have control over the style of an element
Clear the browser cache
Remove HTML formatting
Remove conflicting inline and internal CSS rules
Use fully qualified CSS selectors
Accommodate different browsers
Adding style to form and page elements
Use color effectively
Style text
Style headings and labels
Underline links in text but not in menus
Style fields
Highlight required fields
Style buttons
Replace the default Action Bar buttons with hotspot buttons
Style the default Action Bar buttons
Style borders and margins
Work with images
Style menus
Style printed pages
Add more than one class to an element
Summary
6. JavaScript
Using JavaScript in web applications
Keep it simple, comment the complex
Be alert for disabled JavaScript and other options in browsers
Be alert for inconsistent JavaScript behavior in different browsers
Use browser object detection
Use browser detection only when really necessary
Locating JavaScript in applications
Place functions in JavaScript libraries
Add JavaScript in the JS Header
Add JavaScript to web events
Use a page for JavaScript
Use a subform for JavaScript
Consolidate and co-locate JavaScript
Developing and debugging scripts
Use browser debugging tools
Validate JavaScripts
Using JavaScript to enhance forms and pages
Run JavaScript on load
Access CGI variables
Validating fields
Validate number fields
Use a date picker for date fields
Warn users before leaving an un-submitted form
Use Ajax calls to avoid server round trips
Summary
7. Views
General guidelines
Create some diagnostic views
Display documents in a hierarchy
Display Replication or Save conflict documents
Specify a default view
Use view templates
Use the same view template for several views
Compute the view title
Exploring view options for the Web
Understand view Action buttons
Use Domino-generated default views
Include HTML tags to enhance views
Use the "Treat view contents as HTML" option
Structure HTML views as tables
Code links to open documents
Structure HTML views as lists
Set the view line count
Create Notes versions of HTML views
Use the View Applet (with caution)
Creating Action buttons
Provide view navigation buttons
Code next and previous navigation buttons
Code first and last buttons
Let users specify a line count
Code expand and collapse buttons for categorized views
Co-locate and define all Action buttons
Create your own Action buttons
Adding style to views
Style Domino default views
Style HTML views
Opening documents in a separate window
Adding view scrollbars dynamically
Summary
8. Agents
General LotusScript agent guidelines
Give agents meaningful names and aliases
Structure and document agents
Use agent subroutines and LotusScript libraries
Harvest ideas from Designer Help
Setting agent attributes
Set who can view and run an agent
Set an agent's runtime context
Set an agent's runtime privileges
Hide unused agents
Developing agents
Use web safe @formulas and LotusScript
Include a basic error trap
Write messages to the browser as a web page
Write messages to the browser with a JavaScript alert
Write messages to an agent log file
Working with documents
Use WebQuerySave
Access a document from an agent
Access a document open in the browser
Access a document not open in the browser
Detect the type of client invoking the agent
Detect whether a document is in Read or Edit mode
Prevent a document from being saved
Redirect the browser to the next page
Process selected documents in a view
Writing special purpose agents
Send e-mail notifications
Export data to a spreadsheet on the Web
Summary
9. Security and Performance
Security
General guidelines
Plan your security
Manage Domino groups
Specify anonymous access
Set the maximum Internet access level
Manage the application ACL
Enable SSL
Prevent opening an application in a browser
Hiding is not securing Use element access lists
Understand application backup and restore procedures
Add security to forms and documents
Understand the "Generate HTML for all fields" attribute
Prevent users from reading existing documents
Prevent users from editing existing documents
Prevent users from editing selected fields using a Controlled Access Section
Prevent users from editing selected fields using hide-when formulas
Do not use field encryption
Track document changes
Make a form available to anonymous users
Control navigation options
Code an explicit logoff
Manage agent security
Performance
General guidelines
Listen to your users
Design for ease of use
Archive or delete old documents
Remove obsolete code and design elements
Clean up and optimize code
Use tools to assess response time
Improve forms
Limit the use of images
Use Ajax calls to retrieve data
Use simpler hide-when formulas
Validate fields with JavaScript
Improve views
Remove unused or redundant views from the design
Limit the data displayed in views
Remove unnecessary view column sorting
Minimize the use of view column formulas
Avoid time-based view column formulas
Create views as an alternative to common searches
Modify database properties
Investigate Domino server options
Summary
10. Testing and Debugging
Testing
Test with different browsers
Test with different user privileges
Craft the staging environment to resemble the production environment
Engage other people for testing
Test every feature if possible
Test responsiveness
Create a written test plan
Track defects
Create detailed user documentation while testing
Require user sign-off
Monitor the application after Go Live
Debugging
General guidelines
Reproduce the problem
Isolate the failure
Code a $$ReturnGeneralError form
Check the Domino Log
Use the Web
Use Design Synopsis
Troubleshoot forms
Dynamically display hidden fields on the Web
Expire the cache
Debug CSS
Use browser-based debugging tools
Troubleshoot agents
Incorporate dynamic debugging messages
Create troubleshooting tools display scheduled agent information
Troubleshoot problems with data
View field values in Document Properties
Create diagnostic views
Write document repair agents
Document problems and solutions
Keep a personal problem solving journal
Report back to the user
Summary
Index

IBM Lotus Domino: Classic Web Application Development Techniques

IBM Lotus Domino: Classic Web Application Development Techniques

Copyright © 2011 Packt Publishing

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

First published: March 2011

Production Reference: 1180311

Published by Packt Publishing Ltd. 32 Lincoln Road Olton Birmingham, B27 6PA, UK.

ISBN 978-1-849682-40-4

www.packtpub.com

Cover Image by Artie Ng (<[email protected]>)

Credits

Author

Richard G. Ellis

Reviewers

Karen Hobert

Mark Vincenzes

Development Editor

Rukhsana Khambatta

Technical Editors

Sakina Kaydawala

Pallavi Kachare

Manasi Poonthottam

Indexer

Rekha Nair

Editorial Team Leader

Mithun Sehgal

Project Team Leader

Lata Basantani

Project Coordinator

Leena Purkait

Proofreader

Stephen Swaney

Production Coordinator

Arvindkumar Gupta

Cover Work

Arvindkumar Gupta

About the Author

Richard G. Ellis currently works as a Domino developer supporting several hundred classically crafted, web-enabled applications. He has held positions as a programmer, systems administrator, technical manager, and IT director in major commercial and university settings. He has taught undergraduate and graduate level courses as well as numerous workshops on programming languages and other computer-related subjects. He also provides quality assurance testing and technical writing services for major commercial and educational institutions. Mr. Ellis is certified both as a Domino developer and administrator.

I very much appreciate the people at Packt Publishing for their support and guidance, and the folks at IBM for building Lotus Notes and Domino. I would also like to thank Anne Agee, Kevin Chick, Jeff Clark, Adrienne Connolly, Al Cote, Eric Forte, Corey Kimball, Debbie Magoon, Fred Sollars, and Kevin Suares for their support, insight, and encouragement. Most of all I would like to thank my long-time friend and mentor Mac Toedt for the many opportunities and solid guidance he has given me over the years.

About the Reviewers

Karen Hobert is an IT market research analyst and strategy consultant with deep practical and market expertise in collaboration, communications, content management, and social software technologies. Karen has over twenty years of communication, collaboration, and social software platform expertise that she uses to help organizations design and deploy shared information systems. She has an extensive working knowledge of communication, collaboration, and social technologies including technologies from Microsoft, IBM, Google, and other best-of-breed vendors. Additional areas of expertise include collaborative application design and web development platforms. Karen is a contributor on numerous technical articles and is the author of courses and workshops on programming and deploying web-based business process applications.

Karen is a technical reviewer for the IBM Lotus Notes 8.5 User Guide published by Packt.

Mark Vincenzes is a software engineer at IBM, where he works on web application servers. Over the past 30 years, Mark has contributed to projects such as custom I/O and networking subsystems, database management systems, object request brokers, and source control systems. Mark's past employers include Burroughs, Xerox, Apollo, and Hewlett-Packard.

www.PacktPub.com

Support files, eBooks, discount offers and more

You might want to visit www.PacktPub.com for support files and downloads related to your book.

Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.PacktPub.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at <[email protected]> for more details.

At www.PacktPub.com, you can also read a collection of free technical articles, sign up for a range of free newsletters, and receive exclusive discounts and offers on Packt books and eBooks.

http://PacktLib.PacktPub.com

Do you need instant solutions to your IT questions? PacktLib is Packt's online digital book library. Here, you can access, read and search across Packt's entire library of books.

Why Subscribe?

Fully searchable across every book published by PacktCopy and paste, print and bookmark contentOn demand and accessible via web browser

Free Access for Packt account holders

If you have an account with Packt at www.PacktPub.com, you can use this to access PacktLib today and view nine entirely free books. Simply use your login credentials for immediate access.

Instant Updates on New Packt Books

Get notified! Find out when new books are published by following @PacktEnterprise on Twitter, or the Packt Enterprise Facebook page.

Dedication

I dedicate this book to Doreen, my wife and dearest friend for several decades now, and to my children and grandchildren: Jeffrey, Derrick, Caroline, Carrie, Owen, Eileen, and the new grandson on the way.

Preface

Boss: I need some web pages up as soon as you can.

Developer: No problem. I'll get you something before lunch.

Creating web pages was fairly straight-forward in the early 1990's. Today, there are many, often competing technologies available for creating a web experience. Remarkably, all these differing technologies and strategies interoperate in a relatively seamless way to serve the billions of people who use the World Wide Web and the Internet.

IBM's Lotus Notes and Domino product set the subject of this book is a feature-rich, application development technology that has been used to create web-enabled applications since the late 1990's. Since then, it has evolved substantially through several major software versions, and it will continue to advance into the foreseeable future, adapting to the changing web landscape and incorporating new technologies and methods as appropriate.

One of the delightful aspects of Domino is its backwards compatibility. With few or no changes, applications written with previous versions of the software, untouched for a decade or more, will run as expected on the newest Domino server.

It is also important to understand that useful applications can be crafted and deployed on a wide range of platforms with relatively little work. A simple application can be cobbled together and rolled out in less than an hour. It would not be a complex application, of course, but it might suffice for basic data collection or an informational website. After that first version rolls to production, providing immediate benefit to users, features and improvements could be added incrementally with little or no downtime.

Quickly-crafted applications are probably not polished applications in terms of look-and-feel or function. This author has worked with a number of these earlier, rapidly-developed applications; they are still functional, but by contemporary web standards, they are not pretty.

Improving an existing, web-enabled application comes with a number of challenges. How can the design be upgraded without impacting users or disturbing the data?

It was in facing the challenge of working with some of these older applications that I first began making notes which led to this publication.

Getting started

If you are a developer new to Lotus Notes and Domino, you face a substantial learning curve. If you are already a Domino developer, but are new to working with Domino applications on the Web, then the learning curve is not so steep.

As a Domino developer, you must master the Notes and Designer clients, and you must achieve some level of coding competence with Formula Language, LotusScript, HTML, CSS, JavaScript, and possibly Java. In addition, you must embrace the Domino way of doing things. You must understand its security features, design templates, replication, workflow, and so on. In a web application, all of these elements work together to achieve some desirable business purpose.

What this book covers

Topics in these chapters offer tips, suggestions, and code snippets to help you understand and resolve specific problems you may encounter when working with Domino applications for the Web. You will likely encounter problems not covered within these pages, but the tips provided here should save you some puzzlement, aggravation, and research time.

Many techniques covered in these pages are now referred to by the Domino community as "classic" or "traditional" web development techniques. Not covered here are XPages and other development strategies that were introduced in Domino 8.5 and later. If you need such information, you must seek it elsewhere.

My overarching intent was to bring together in one place some useful tips and techniques that are otherwise scattered across the Web. Ideas offered here derive from experience, mine and others. Code samples are for illustration only and should not be interpreted as a guarantee of performance or suitability for a specific situation. Everything covered should be useful for versions of Domino 6.5 and later. Domino Designer 8.0 was used to develop and verify all the sample code.

Keep in mind that there are often several ways to create a feature or to solve a problem. While classic techniques work with current and older versions of Domino, the preferred way to create new applications is to use the latest techniques such as XPages. However, even in an up-to-date Domino environment, it may not be practical to redesign an existing application to take advantage of them. If you cannot take advantage of those newer techniques for whatever reason, then certainly use techniques catalogued in this volume. Use what makes sense to you and what works for you. Test thoroughly.

Chapter 1, Preparation and Habits, provides suggestions for developers seeking to improve their knowledge, skill, and productivity. Issues related to executing development projects are discussed.

Chapter 2, Design and Development Strategies, provides recommendations for planning development projects and for developing applications.

Chapter 3, Form and Pages, illustrates selected design choices related to forms and pages, including properties, composing and saving documents, improving layout, using view templates, incorporating HTML tags, and using hidden fields and computed text.

Chapter 4, Navigation, illustrates selected navigational strategies, including application launch options, custom login forms, menus, default error pages, and providing direction and help.

Chapter 5, Cascading Style Sheets, illustrates how CSS rules can be incorporated into applications to style forms and pages for the Web.

Chapter 6, JavaScript, illustrates how client-side JavaScript can be incorporated into applications for such purposes as validating fields, changing element style, enabling a date picker, providing a warning before leaving a form if changed data has not been saved, and retrieving data with Ajax.

Chapter 7, Views, illustrates design choices for displaying views on the Web.

Chapter 8, Agents, illustrates how to incorporate agents in web applications, including setting properties and security, adding error traps, accessing documents, processing selected documents in a view, sending e-mail notifications, and extracting data to a spreadsheet.

Chapter 9, Security and Performance, discusses security planning, implementing security features, tracking document changes, and designing for good performance.

Chapter 10, Testing and Debugging, discusses testing strategies, test plans, tracking issues, and selected debugging techniques.

What you need for this book

To explore the techniques discussed and illustrated in this book, readers should have access to Lotus Notes, Domino Designer, and a web browser. Ideally, readers are able to save sandbox applications to a Domino server for experimentation and testing.

Who this book is for

This book is for novice to moderately experienced Domino developers who are new to the task of web-enabling traditional Domino applications. Readers should be familiar with using Domino Designer to develop applications for the Lotus Notes client. It is also assumed that readers have, or can acquire, at least rudimentary knowledge of HTML, CSS, and JavaScript.

Reader feedback

Feedback from our readers is always welcome. Let us know what you think about this book what you liked or may have disliked. Reader feedback is important for us to develop titles that you really get the most out of.

To send us general feedback, simply send an e-mail to <[email protected]>, and mention the book title via the subject of your message.

If there is a book that you need and would like to see us publish, please send us a note in the SUGGEST A TITLE form on www.packtpub.com or e-mail <[email protected]>.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide on www.packtpub.com/authors.

Customer support

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.

Downloading the example code

You can download the example code files for all Packt books you have purchased from your account at http://www.PacktPub.com. If you purchased this book elsewhere, you can visit http://www.PacktPub.com/support and register to have the files e-mailed directly to you.

Errata

Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our books maybe a mistake in the text or the code we would be grateful if you would report this to us. By doing so, you can save other readers from frustration and help us improve subsequent versions of this book. If you find any errata, please report them by visiting http://www.packtpub.com/support, selecting your book, clicking on the errata submission form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded on our website, or added to any list of existing errata, under the Errata section of that title. Any existing errata can be viewed by selecting your title from http://www.packtpub.com/support.

Piracy

Piracy of copyright material on the Internet is an ongoing problem across all media. At Packt, we take the protection of our copyright and licenses very seriously. If you come across any illegal copies of our works, in any form, on the Internet, please provide us with the location address or website name immediately so that we can pursue a remedy.

Please contact us at <[email protected]> with a link to the suspected pirated material.

We appreciate your help in protecting our authors, and our ability to bring you valuable content.

Questions

You can contact us at <[email protected]> if you are having a problem with any aspect of the book, and we will do our best to address it.

Chapter 1. Preparation and Habits

A fresh start is invigorating, a chance to look forward with high expectations and new resolve. It's a time to put into practice all the lessons you have learned and to put behind you the issues and problems which previously bogged you down. Take advantage of every fresh start. Look forward to and accept every new challenge and opportunity.

Especially when starting a new job, it is important to take stock of your skills, both technical and non-technical. If you succeeded wildly at your last job or project, then hooray for you! Do it again! But if you fell short in some ways, resolve to do better.

The topics in this chapter address the human and organizational context within which you will develop your Domino applications. Most of these suggestions are relatively non-technical, as they deal with how you might organize yourself and your time and how you might work more effectively with your customers. Topics focus on these key issues:

Preparing yourself as a Domino developerThe importance of using standards and guidelinesPlanning your workHandling a development projectDocumenting your design

Preparing yourself as a developer

A craftsman is only as good as his tools, and in a very real sense, you are your tools. To remain capable and versatile, you should commit to the life-long task of continually acquiring knowledge and skills people-skills as well as technical skills.

As you begin your work on a new project, keep in mind the larger picture. This new project will be followed by others. One polished application will lead to another. One happy and satisfied customer will spread the word about how good you are.

Gather a list of public websites that use Domino

While you browse the Web, gather ideas about what makes web pages look good. Great websites should inspire you. Inspect the layout, the use of images and color, and the navigational strategies. If you see an interesting control, peek under the covers and take notes about how it was coded. But be sensitive to intellectual property and copyright laws not everything published on the Web is free.

In particular, collect links to public websites that use Domino and show it to good advantage. Relatively speaking, only a smaller number of public-facing websites are served by Domino. But browse around; you will find hundreds of them in short order. This collection of websites can become a marketing and public relations tool for you as you sell your ideas to your customers.

Too often Domino web applications crafted in the past were functional, but not pretty. That might have been okay ten years ago, but no longer. Today's customers expect the same kind of functionality from your applications that they see elsewhere on the Web. And there really is no reason why you can't provide it to them.

Take some time and build yourself a small application to hold the links. Eventually, roll this application to the Web so that the links can be shared readily with customers and others who are interested.

In this sample Domino Websites application, details about each website are stored in a separate document. The blue hotspots link to views which display lists of Commercial, Consultants, Government, and Other Sites. With sufficient privileges to the database, a user can add, edit, and delete these documents with the Notes client or with a browser.

Get certified in Lotus Notes / Domino application development

Honing your skills by doing is essential. The more applications you build and the more time you spend on this work, the better you should become at it. Experience is a great teacher.

But you do not have time to figure everything out yourself. So you must read and study what others have done, which is especially easy today with a fast connection to the Internet. Set aside some time every week (or each day if you can swing it) and graze the web landscape.

Commit yourself to preparing for, taking, and passing certification exams in Lotus Notes / Domino application development. If possible work through the Administrator exams as well. Effortful and extensive preparation should make it easier to pass the exams the first time. More importantly, preparation for the exams will broaden your understanding of Domino and teach you about features and techniques that you might not otherwise stumble upon by yourself.

And, of course, holding this certificate looks good on the resume.

Use Domino Help

Experienced developers rely on Domino Help. Be aware that there are separate help databases for each of the clients: Notes, Administrator, and Designer.

The Lotus Domino Designer 8 Help database contains over 9,000 documents. In it, you will find extensive information about features, language syntax, classes, limits, errors, tips, and code examples.

The code examples can be particularly useful. If you find some code that looks just like what you need, simply copy it into your application, and then modify it as necessary.

Especially if you are new to Domino, spend enough time with Help to be comfortable with where things are and how to find information on specific topics. The Contents view organizes the information like a book, by general subject area. Use the Index if you know what you are looking for the syntax of a specific @ function, for example. Use the Search feature when you are not quite sure for what you are looking. Beware of searching too broadly. Search for the term "web" and you will find over a thousand documents!

Once you are comfortable with Designer Help, try Designer's context sensitive help, which is invoked by opening or highlighting a design element and then pressing F1. Display forms in the Work pane and press F1 help on designing forms displays. Select a tab in a Properties box and press F1 help on that tab displays, and so on.

Consider using external editors and development tools

Designer provides basic editing for text, so for the most part, you can develop applications without using external editors. However, dedicated editors for HTML, JavaScript, Java, and CSS will provide you with conveniences such as syntax checking, color coding, validation, and ready-made functions which may appeal to you. If you develop code in an external editor, you will have to import the files as resources into your application or copy/paste the text into appropriate locations in your design.

You can reasonably get on without external text editors, but learning to use an image editor may be well worth the time it takes, especially if you do not have access to a graphic designer or a library of images. Almost any image editor will do as long as it saves images as JPEG or GIF files. (Designer can accommodate other graphic types, but JPEG and GIF files are natively compatible with the Web.) Although it may take some effort to learn, the open source program GIMP is a no-cost, feature-rich image editor. Find more information at the GIMP website: http://www.gimp.org.

In this book, except where noted, examples rely on only the native capabilities of Designer.

Create sandbox applications

New ideas for solving problems constantly present themselves. But introducing a new, untried technique into an existing application may result in many more problems than it solves due to unintended consequences and side-effects.

Create one or more sandbox applications in which to try out new ideas. Constraining new development this way facilitates isolating and resolving problems specifically related to the new technique. And if, at the end of the day, the technique does not live up to its promise, then nothing needs to be removed from the real application design on which you are working.

Create a personal cookbook

Solutions discovered or invented for one application inevitably find their way into other applications. Code snippets, strategies, and even entire agents are often reused to save development time and effort.

Keeping track of such ideas may be difficult over a period of years, especially if you work on dozens of applications or move from job to job. It might be inappropriate (ethically or legally) to keep personal copies of designs created for previous employers without permission, but it is certainly reasonable to keep detailed personal notes in one form or another. The tools are readily available: paper notebook, flash drive, optical disk.

Keep your notes organized and periodically review items in your cookbook. Revise and annotate. Include variations and caveats. As it is impossible to remember in detail all the code you will ever write, you will find your notes to be an invaluable resource.

Create a personal document library

As a Notes developer, you should always have access to the Notes and Designer clients, so creating a personal document library or a simple Notes application is certainly an option. You can use the standard Lotus Document Library template or you can simply create your own application with whatever features work for you.

One database might contain notes and descriptions. A second database might contain working examples of many techniques a private code library if you will.

Create a website

The Web is a wonderful repository of ideas. Consider keeping a website (blog or Wiki) on which you can post code and ideas that may be helpful to others. Of course this approach may entail some expense and extra effort, but it is also a great way to contribute to the development community. And if you are a freelance consultant, it is also a way to market your skills.

Alternatively, consider contributing ideas to existing websites with blog entries or even entire development projects.

Adopt new language and terms

Over time, the language of Notes and Domino changes, as do the tools. At one time, the Domino Directory was called the Name and Address Book or NAB. The file that contains design elements and documents was called a database and is now referred to as an application. In Designer, the Design Pane became the Application Navigator. Of course, you will come across references that use the older language and some developers who continue to use deprecated terms out of habit or stubbornness.

Be alert for these changes of terms and the definitions which go with them. Be mindful of the old names, but use contemporary and correct vocabulary, just as you should use contemporary development techniques.

Pay attention to web programming developments and practices

Domino applications intended to be accessed with a web browser can take advantage of many contemporary web technologies like Ajax, CSS, and XML. In fact, support for these standards has been included in Domino for many years. As web technologies evolve, so does Domino.

So pay attention to non-Domino web technologies and strategies. Web-enabled Domino applications should be crafted using the best web programming practices.

Standardizing applications

Application development is part engineering and part art. Building some pieces of an application is fairly routine, while other aspects call for inventiveness and creativity.

Domino caters to developers to some extent by enabling applications to be built with any of the several programming languages. It also supports many web technologies which can be pieced together in an unlimited number of ways. This flexibility enables programmers to work the way they want to work. But this same flexibility makes it all too easy to ignore organizational standards.

Standardizing applications makes it easier to develop new ones since reusable components may already exist. And if applications look and operate in a similar manner, then users of new applications will need less training and will be more willing to use them.

Abide by your organization's web development guidelines

If your organization has written web development guidelines, find out what they are and try to embrace them in your own applications. The set of web applications deployed by your organization is probably much larger than just the Domino applications. If they exist, these development guidelines and standards define stylistic and functional commonality that your organization determined to be beneficial. Someone above your pay grade approved those standards, so abide by them!

Web application development guidelines can provide several benefits. They promote an organizational identity or brand through a common look and feel. They improve the effectiveness and the usability of web applications as a whole by standardizing how features and functions operate. And from a developer's point of view, they speed the deployment of new applications and simplify the maintenance and enhancement of existing ones.

If your organization has no written standards, consider discussing this issue with management. Consider taking on the task yourself.

The number of specific development standards can easily number in the hundreds, depending upon how detailed they are. Whoever determines these standards must understand to some extent the entire universe of options, and then must select those guidelines which make sense and which can be implemented within the existing development environment. Many guidelines turn out to be "nice to have" suggestions that are not practical to implement within the confines of budget and project deadlines.

Development guidelines can be classified roughly into three kinds:

Usability guidelinesStylistic guidelinesMechanical or process guidelines

Usability

Guidelines that address the usability of an application or website concern themselves with issues of effectiveness, efficiency, learnability, and overall user satisfaction. How well does this application achieve its goals? How easy is it to learn to use? How well do users like it? Usability influences how willing people are to use an application, which can have a dramatic impact on whether they choose your solution or go somewhere else for assistance.

Usability guidelines focus on what things make a website easy to use from the end user's point of view. Examples of usability considerations include the following:

Content organizationHeadings and labelsPage and form layoutFeatures and functionsAccessibilityNavigationImages

Explore this topic in greater detail. One online reference which you might consider reviewing is the http://usability.gov website maintained by the U.S. Department of Health and Human Services.

The Guidelines documents at this site were written based on the extensive research. They can serve as a good starting point for understanding usability issues.

Style

Guidelines which address style concern themselves with issues of look and feel, and sometimes function. An organization's font preferences and color palette can be identified. Layouts and menu styles can be defined. Acceptable logos and images can be specified, as can boilerplate text for Copyright, Privacy, and other notices. Very specific guidelines might address issues such as whether or not to underline links or how wide margins should be.

Beyond simply specifying preferences, an organization might codify style requirements into common style sheets. The guidelines would then provide information about how to link to and incorporate those style sheets into applications. Details such as style class names for headings and labels would be included.

Mechanics and process

Guidelines which address issues of coding and application deployment can be extensive and no small task to gather together.

Because Domino web applications can include so many different technologies, coding guidelines could address various options, including the use of these design tools:

HTMLCSSJavaScript and JavaScript frameworksLotusScriptJavaImages

Other guidelines might specify requirements for the following design aspects:

The About and Using documentsElement naming conventionsForm and page layoutNavigationE-mail notificationsData import and extractContext sensitive helpAgent error handlingSecurity and access control

Still other guidelines might concern themselves with the general way in which applications are designed, tested, and rolled into production:

How development work is requested and prioritizedHow applications are named and sponsoredThe use of templatesThe use of shared code and resource librariesThe use of rolesThe use and management of Domino groupsApplication signingReplicationTesting and approvalMigration to productionDocumentation and user training

Some developers might find coding and process guidelines to be onerous and overly constraining. Inevitably, there will be requests for exceptions to the rules, so organizations must be prepared to deal with the issues of exceptions and non-compliance.

Clearly, an extensive effort is required to compile standards and guidelines that are appropriate to application development within the context of a specific organization. Additional effort will be required periodically to review, update, and reapprove those guidelines.

Create libraries of common resources

Organizations should consider creating common repositories of reusable objects. The most obvious kinds of libraries (not surprisingly supported natively by Designer) would contain standard design elements such as:

ImagesJava codeJavaScript codeLotusScript codeStyle sheets

Images can be organized into common types as follows:

Arrows and linesBanners and logosButtonsPatternsPhotosSquares and other common shapesWatermarks

Other repositories might include standard or approved "boilerplate" text:

Copyright noticeDisclaimers and caveatsError messagesPrivacy notice

Common repositories enable developers to work more rapidly and to create products which conform to organizational standards. Organizational management must address the following issues:

Who will create and maintain the repositories?What process will be used to approve, add, and deprecate repository objects?Will applications be reviewed to assure the use of the approved objects?How will developers (especially new developers) be informed about the repositories and how to use them?

Common repositories, like development standards in general, can seriously boost productivity, but they also require ongoing maintenance and commitment. If your organization has such repositories, learn to use them. If no such collections yet exist, speak to management about instituting common repositories for approved design resources.

Planning your work

Volumes have been written about planning, and even more volumes have been written about how to become and stay organized. Here are just a few simple ideas that can be enormously powerful in keeping you personally on task.

Take notes

When you are young and brilliant, your mind might be as sharp as a tack and your memory as long as the Great Wall of China. But as your responsibilities increase, as your projects become larger, as you attend more meetings and deal with more customers as you get older your infallible memory will become fallible.

Take notes. Write things down. Some people prefer to use a laptop or PDA. Personally, after many years of trying several methods, I've come to appreciate the simple notebook. I jot notes all day long at my desk, in the car, at a meeting, in bed at night. It contains my list of tasks, my key contacts, notes from meetings, to-do lists, and timestamps. It is my work-life in a compact, lightweight, versatile package and it works without electricity.

Use to-do lists

It is a simple fact that people who make lists of things they must do, tend to get more things done. This is true on a personal level as well as on the job.

Start each day by making a list of tasks you will work on, meetings you will attend, and phone calls you must make. Keep that list nearby and refer to it often. If things come up during the day, add them to your to-do list. As you finish an item, check it off or scratch it out.

At the end of the day, review what you achieved and what is still undone. Create a new to-do list for the next day. Prioritize each item either in terms of how important it is to do or in terms of when you will do it. This simple activity will help you focus, and when you focus, you accomplish more.

If you are not used to working with to-do lists, it will take some self-discipline. You might also consider creating weekly, monthly, quarterly, or annual to-do lists as well. As you plan each day, consult the lists which deal with the longer timeframes and incorporate all relevant items on the daily to-do. The adage "Plan the work and work the plan" can be fulfilled easily with the simple to-do list.

Keep a list of all active projects and tasks

You should maintain a current list of all your active and pending projects, tasks, and commitments. Each item should include a rough estimate of how long it takes or will take, when you might start and finish it, and who the key contacts are for each item.

Inevitably, you will be asked to undertake new tasks, join committees, attend meetings, and perform services which take time. People easily become overbooked because, with an eagerness to please or to start something new, they simply do not estimate well how much time tasks take to do. Keeping a list of projects and tasks to which you can refer will help you and your boss allocate your time more effectively.

Report your progress

Developers and other technicians are often loath to spend time documenting, especially writing progress reports to managers. Managers, on the other hand, really do need to understand what their employees are doing. Well-informed managers can make better decisions when authorizing new work, prioritizing current tasks, handling contrary customers, reporting accomplishments to their managers, and requesting budget for the coming year.

As a developer, you should submit a summary of your work on a regular basis. Your organization may have a prescribed format for this activity. If not, here is a simple outline for weekly e-mail which can work satisfactorily:

Highlights from this weekTasks for next weekIssues and other itemsPending projects

Add bulleted items in each section. Be concise, clear, and plain-spoken. Your goal is to convey a sense of your activities and progress to your (possibly non-technical) manager. Send this summary to him or to a project leader at the end of each work week when the information is fresh. Do not embellish, don't minimize. Use this report also to help plan the week ahead.

Working the project