Your Development & Design Resource
First Impressions: Mastering XPages and Upcoming Giveaway!
03/14/2011 08:36 AM by Chris Toohey
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:
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.
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:
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.
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
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.
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 dominoGuru.com Amazon Store, tune in to the complete review on March 25th to learn how you can win your own copy.