IBM Lotus Domino: Classic Web Application Development Techniques


IBM Lotus Domino: Classic Web Application Development Techniques
eBook: $35.99
Formats: PDF, PacktLib, ePub and Mobi formats
$30.59
save 15%!
Print + free eBook + free PacktLib access to the book: $95.98    Print cover: $59.99
$59.99
save 37%!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Overview
Table of Contents
Author
Support
Sample Chapters
  • Classic techniques used for Web-enabling traditional Domino applications
  • Demonstrates how to incorporate HTML, CSS and JavaScript into designs
  • Offers tips and suggestions for testing, debugging, and troubleshooting
  • Organized, easy to read, and well-illustrated, with numerous code examples
  • Instructions valid for Domino versions 6, 7, and 8

Book Details

Language : English
Paperback : 344 pages [ 235mm x 191mm ]
Release Date : March 2011
ISBN : 1849682402
ISBN 13 : 9781849682404
Author(s) : Richard G. Ellis
Topics and Technologies : All Books, Enterprise Products and Platforms, Enterprise, IBM, Web Development

Table of Contents

Preface
Chapter 1: Preparation and Habits
Chapter 2: Design and Development Strategies
Chapter 3: Forms and Pages
Chapter 4: Navigation
Chapter 5: Cascading Style Sheets
Chapter 6: JavaScript
Chapter 7: Views
Chapter 8: Agents
Chapter 9: Security and Performance
Chapter 10: Testing and Debugging
Index
  • Chapter 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
    • Chapter 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
      • Chapter 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
        • Chapter 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
          • Chapter 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
            • Chapter 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
              • Chapter 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
                • Chapter 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
                  • Chapter 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
                    • Chapter 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

                      Richard G. Ellis

                      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. Richard is certified as both a Domino developer and a Domino administrator.

                      Sorry, we don't have any reviews for this title yet.

                      Code Downloads

                      Download the code and support files for this book.


                      Submit Errata

                      Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.

                      Sample chapters

                      You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

                      Frequently bought together

                      IBM Lotus Domino: Classic Web Application Development Techniques +    IBM Cognos TM1 Developer's Certification guide =
                      50% Off
                      the second eBook
                      Price for both: $51.15

                      Buy both these recommended eBooks together and get 50% off the cheapest eBook.

                      What you will learn from this book

                      • Incorporate dynamic debugging, which can be turned on after an application is in production
                      • Learn to style design elements with CSS rules
                      • Learn how to use the various application launching options
                      • Create and customize views for the Web
                      • Work with hidden fields and CGI variables
                      • Validate fields with JavaScript
                      • Include a date picker on a web form
                      • Learn to incorporate AJAX into an application
                      • Include diagnostic features to help you understand an existing application
                      • Understand how LotusScript agents work with web pages
                      • Learn to troubleshoot web applications
                      • Review ways to improve application performance

                      In Detail

                      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.

                      Classic and timeless tips and techniques for Web-enabling traditional Lotus Domino applications

                      Approach

                      Chapters present principles and techniques in an order that roughly mirrors the application development process itself, from gathering requirements through final testing. The focus is on understanding and enhancing applications using classic techniques, in circumstances where it is impractical to rewrite applications using XPages. Each chapter focuses upon a particular aspect of Domino Web applications and provides guidance, recommendations, illustrations, and sample code.

                      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.

                      Code Download and Errata
                      Packt Anytime, Anywhere
                      Register Books
                      Print Upgrades
                      eBook Downloads
                      Video Support
                      Contact Us
                      Awards Voting Nominations Previous Winners
                      Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
                      Resources
                      Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software