Your Development & Design Resource

First Impressions: Mastering XPages and Upcoming Giveaway!

IBM Press: Mastering XPages IBM Press recently released the definitive guide for IBM Lotus Notes Domino 8.5.2 XPages: Mastering XPages: A Step-by-Step Guide to XPages Application Development and the XSP Language. In this book, authors Martin Donnelly, Mark Wallace, and Tony McGuckin [with contributing author Jim Quill and foreword written by everyone's favorite IBM XPages Chief Architect Philippe Riand] strive to write the definitive printed reference material for all-things XPages.

This First Impressions review will deep-dive into Chapters 1-6 [out of 17, not including Appendixes].

From the book's back cover:

The Definitive XPages Development Guide -- Straight from the XPages Team at IBM Lotus

XPages is the most significant improvement to Lotus Notes/Domino® development in 20 years. Now, three IBM® Lotus insiders have written the definitive programmer's guide to this breakthrough web application development framework. Packed with tips, tricks, and best practices, Mastering XPages brings together all the information you need to become an XPages expert, whether you're experiences with Notes/Domino development or not.

So without much further ado...

Sectioned into Parts after the foreword, acknowledgements, and all of the other stuff at the beginner of the book... we start with Part I - Getting Started with XPages.

Chapter 1: An Introduction to XPages

The obligatory introduction chapter, but the authors immediately set the stage and relay what I think is the most important message of XPages for the IBM Lotus developer:

[Emphasis added]

The catch, if you can call it that, is that the XPages development paradigm is different to what Domino web developers were used to up until version 8.5. Here, black magic practices, like $$Return fields and strategically embedded pass-through HTML, are no longer the web dev modus operandi.

Simply put: leave your hackaday techniques at the doorstep; they're no longer required. And while this all-but-nullifies years 0-6 of this website, I couldn't be happier.

The rest of this chapter does what any well-written introductory chapter is meant to do: quickly establishes and outlines the given subject (in this case, XPages). Once we have the basic idea of what XPages are, we'll need to suit up... which is the subject of the next chapter.

Chapter 2: Getting Everything You Need

This chapter was a hit and a miss for me...

First, I applaud the authors for writing this not only for the enterprise customer developer but also including directions for a developer new to IBM Lotus as a platform and instructing them on how they can download DDE v8.5.2 and get started writing apps.

The brief overview of the DDE client is brilliant, which lends as an intro to the Lotus SDK but also establishing Lotus developer nomenclature for the reader.

The miss in this chapter is the dive into creating a Hello World app. Not only is your next chapter titled Building Your First XPages Application (which is thus a misnomer), but there were some missed opportunities here.

I would have preferred to see an overview of the Domino Designer in Eclipse Help Database.

I would have preferred a tip on running Lotus Notes/DDE as Administrator in Windows 7 which is the only way to get localhost previews of XPages to work due to built-in Windows 7 security settings...

I would have preferred to make sure the new XPages developer be fully-dressed before jumping into Hello World, especially since the first part of the chapter so brilliantly includes new-to-Lotus developers in it's audience.

Chapter 3: Building Your First XPages Application

The discussion8.ntf Template takes center-stage for this chapter. This allows us to establish the prototypical XPages app layout [which will work for well over 90% of the target audience of Lotus developers]. It shows the functional similarities of the traditional and the XPages-based Main Topic Forms, and walks the reader through creating fully-functional myTopic.xsp and myView.xsp XPages to handle CRUD operations against the Discussion Template-based NotesDatabase app.

Smart move here, as it establishes the best practices techniques and the ability to employ your own XPages to further extend a given app.

New Lotus developers may not be blown away by the example, but traditional Lotus developers who have tried to do something multiple-NotesDocument selection and [in this case] Deletion requests will be impressed by the near out-of-the-box functionality of XPages.

This chapter ends Part I, and the next chapter begins Part II - XPages Development: First Principles.

Chapter 4: Anatomy of an XPage

From this chapter:

This is the primary reason that this chapter is important to you:

You will learn to create an XPage by hand so that you can understand what is actually happening under the covers to an XPage when you use Designer.

This chapter quickly establishes that, unlike HTML, XML and thus XPages are very critical to tag-syntax. It dives into XHTML, XML Documents with XHTML and XForms, simple and complex Properties, the use of character data or CDATA sections, computed Properties via CDATA-based JavaScript...

Before you realize it, you're defining Data Sources and surfacing NotesData via XPage Controls.

Where the chapters in Part I were simply introducing the technology, Chapter 4 runs with it. In the conclusion of this chapter, the authors correctly offer:

[Emphasis added]

Don't worry if you haven't fully mastered all of the tags covered; at this point, the important this is to look at the sources for a simple XPage (like the samples provided in this chapter) and to read the source and begin to understand what the page will do. Being able to use source mode to read and write XSP is a key skill that you need to master.

Later chapters in the book establish that while RAD capabilities allow you to deliver fully-functional rich web browser [and Lotus Notes Client] applications using XPages, getting even more out of the technology requires that you sometimes abandon the WYSIWYG Editor of the Design pane and the GUI-driven Properties and instead dive deeper into the XPages markup.

Chapter 5: XPages and JavaServer Faces

JavaServer Faces (or JSF) and it's relationship to XPages is covered in this chapter, and is an example of needing to understand exactly what XPages are before you can extend their RAD capabilities.

The MVC software architecture of XPages is discussed, along with detailed diagrams showing the firing times of JSF - from writing the UI/restoring the View and populating it with data from the Faces Request, to Process Events post-Response and post-Validation. You begin to appreciate the iterative processing of the JSF and learn exactly how your XPages gets from the Domino Server to your given Web Browser or Lotus Notes Client.

While I honestly think that most of this will be lost on the Notes developer and thought too big-brained... remember the paradigm shift that XPages brings -- understanding exactly what XPages are is critical to embracing them, honing your expertise, and ultimately extending their capabilities far-beyond their out-of-the-box perceived limitations.

Chapter 6: Building XPages Business Logic

Being a fan of MVC software architecture, I was really excited to see just how they handled business logic being enveloped into XPages.

This was a chapter that I thought- as someone who's written NotesDatabase apps employing MVC software architecture techniques - was a hit and a slight miss.

This chapter, simply put, should have been named Application Logic instead of Business Logic. Business Logic is not what JavaScript is fired from which button or what Renderkit is used for a given button's EventHandler or UI Control-level validation events. To me, that's Application Logic.

Business Logic is workflow routing [eg., If the Status == "Submitted", and there is no manager approval, set the Status to "Pending Manager Review", initiate an email to the author's manager including a link to the request, and update the History to reflect the workflow processing.]. It's something that is the story of what the application does, not the individual events being triggered from individual buttons or the surfacing of those buttons based on User Group/User Role assignment. That's Application Logic as far as I'm concerned.

Slight misnomer aside... awesome chapter. It covers embracing the MVC software architecture capabilities of XPages through separation of View [XPages User Interface] and Model [NotesData-based Data Sources], showcases the use of CSJS and SSJS to manipulate rendered UI Controls, and even works in View and SessionScope Variables.

This chapter, which is the first of two chapters dealing with creating your own business logic within XPages (the second being Chapter 11), does an excellent job of showing the interaction of SSJS and CSJS with UI Controls (such as inputText, and button), interaction of SSJS and CSJS [surfacing Server Data with CSJS], the leveraging of Scoped Variables, and built-in XSP Properties and Functions.

This chapter ends Part II of the book, and readies us for more NotesData manipulation in Part III - Data Binding.

First Impressions: Conclusion

An amazingly solid start to what might be most important published work for the IBM Lotus Notes Domino Application Developer.

Each chapter [where appropriate] comes with a downloadable demo NotesDatabase, which can be used in-tandem with the contents of the chapter to give those who learn via hands-on vs. written-word a more tactile learning experience. Used in combination with the contents from these chapters, I suspect most developers would be employing XPages-based templates available with 8.5.2 in their environments and making slight tweaks where appropriate. The use of the 8.5.2 Discussion Template as an example in the early chapters was a smart move and gives even novice developers an immediate best practices demo as well as a working example of a target for what they'll be able to do with XPages.

This review may be gushing, but if you're reading this site... this book was written for you. XPages are the future of the IBM Lotus platform, and this is indeed the most comprehensive guide to the technology published to date.

The release of this book has spawned a Skype-based book club that meets every Thursday at 8PM Eastern to discuss each chapter (I believe, ironically, that they just covered Chapter 6), I believe it sold out at the IBM Store at Lotusphere 2011, and is -- spoiler warning -- quite possibly one of the most important publications available to the IBM Lotus developer.

Expect my full review, targeted for March 25th, 2011.

Mastering XPages Giveaway

As with all of my reviews, I plan on giving away a copy of Mastering XPages [with special thanks to IBM Press]. While you can purchase a copy for yourself at the Amazon Store, tune in to the complete review on March 25th to learn how you can win your own copy.

About the author: Chris Toohey

Thought Leadership, Web & Mobile Application Development, Solutions Integration, Technical Writing & Mentoring

A published developer and webmaster of, Chris Toohey specializes in platform application development, solutions integration, and evangelism of platform capabilities and best practices.

More from is powered by IBM Notes Domino XPages & hosted by Prominic.NET

Contact Us

Use our Contact / Feedback form or one of these email addresses:

Creative Commons License

Except where otherwise noted, by Chris Toohey is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.