Customer Reviews

Lotus® Notes® Developer's Toolbox: Tips for Rapid and Successful Deployment

5 star:		(3)
4 star:		(3)
3 star:		(0)
2 star:		(1)
1 star:		(0)

 

 

It's not often that I get the chance to review a book that directly focuses on my chosen technology niche... IBM Lotus Notes/Domino. Needless to say, when Mark Elliott's new book Lotus Notes Developer's Toolkit - Tips for Rapid and Successful Deployment came out, it moved to the top of my review pile. I'm happy to report that this book is a worthy addition to the Notes development books on the market, and fills a number of roles.

Contents: An Introduction to the Lotus Domino Tool Suite, Getting Started with Designer, Navigating the Domino Designer Workspace. Domino Design Elements, An Introduction to Formula Language, An Introduction to LotusScript, Fundamentals of a Notes Application, Calendar Applications, Collaborative Applications, Reference Library Applications, Workflow Applications, Web Applications, Design Enhancements Using LotusScript, Design Enhancements Using Formula Language, View Enhancements, Sample Agents, Miscellaneous Enhancements and Tips for Domino Databases, Data Management, Security, Application Deployment and Maintenance, Troubleshooting, Appendix A - Online Project Files and Sample Applications, Appendix B - IBM Lotus Notes and Domino - What's Next?

One of the most difficult things to do in my opinion is to get someone started in Notes development. It's easy enough to produce powerful applications with very little effort, but it's hard to try and get someone's head around all the concepts such as forms, views, agent, and so forth. The first part of Elliott's book (through chapter 7) is tailor-made for getting someone started with Notes development. He shows the reader how all the elements fit together in the process of building an application, as well as how Domino Designer functions to put these things together. For those who have been building Notes applications for awhile, there won't be anything new here, but don't despair... Your turn is coming up.

Chapters 8 and beyond is where the book starts to become valuable for the developer who already knows how to build a Notes application, as well as for the up and coming Notes developer. Elliott takes five basic categories of applications (calendar, collaborative, reference library, workflow, and web) and actually walks the reader through a project that builds one of those apps. Most books currently on the shelves don't try to have you build anything. Generally it's "go look at some of the existing templates", and we all know that you can get lost in some of those. While these projects will be most valuable for those learning the art of Notes development, it's worth reading over the material just to see if you've gotten into any development "ruts" or patterns that might be best replaced by more updated methods. It's embarrassing when the new developer asks why you're still doing something the old R4 way...

Chapters 13 to the end of the book will be where most of us (the developers who have been doing this for awhile) will spend the bulk of our time. There are a number of tips, tricks, and code samples that do a variety of things, and the odds are high that a number of them will spark your interest. For instance, one tip in the LotusScript design enhancements chapter shows how to add both a View icon and a Mood Stamp to an agent-generated email. This tip talks about two fields that are not well-documented (_ViewIcon and $Moods), and you can take the sample agent and apply it to your own application. A seemingly minor thing, but I've had users ask for stranger items. There's even an agent that exports to Excel. If that's something you've been meaning to try, here's your chance. And if you've been doing this type of routine for awhile, perhaps his examples will help you make your code more efficient. It's always good to learn as much as you can from others.

I was also quite impressed by the way that the book ties in to the DeveloperWorks site. Each chapter ends with appropriate links back to online material and relevant articles that serve to enhance the chapter material. If you've not gotten into the habit of checking out DeveloperWorks on a regular basis, this will be a good introduction for you, and you'll benefit from the time spent there.

All things considered, I think this book achieved a difficult objective. It attempted to offer something to both the beginning and intermediate Notes developer without alienating either end of that spectrum. It did that quite well. The Notes gurus probably know 95% of this information, but for those of us slogging away in the trenches, this book will either get you started with a powerful tool or expand the existing skills that you've already built up over time. Definitely a book worth getting...

The first technical book that I have read, cover to cover, is Lotus Notes Developer's Toolbox: Tips for Rapid and Successful Deployment by Mark Elliott. This is also the first book that a publisher sent to me specifically for review. Luckily, it is a topic that I know a little something about and I didn't mind that it wasn't my normal nightstand book.

Contents:
Chapter 1 - An Introduction to the Lotus Domino Tool Suite
Chapter 2 - Getting Started with Designer
Chapter 3 - Navigating the Domino Designer Workspace
Chapter 4 - Domino Designer Elements
Chapter 5 - An Introduction to Formula Language
Chapter 6 - An Introduction to LotusScript
Chapter 7 - Fundamentals of a Notes Application
Chapter 8 - Calendar Applications
Chapter 9 - Collaborative Applications
Chapter 10 - Reference Library Applications
Chapter 11 - Workflow Applications
Chapter 12 - Web Applications
Chapter 13 - Design Enhancements Using LotusScript
Chapter 14 - Design Enhancements Using Formula Language
Chapter 15 - View Enhancements
Chapter 16 - Sample Agents
Chapter 17 - Miscellaneous Enhancements and Tips for Domino Databases
Chapter 18 - Data Management
Chapter 19 - Security
Chapter 20 - Application Deployment and Maintenance
Chapter 21 - Troubleshooting
Appendix A - Online Project Files and Sample Applications
Appendix B - Lotus Notes/Domino: What's Next?

How many times have you wondered if there is a good book covering Domino development? Take a serious look at this book. Lotus Notes Developer's Toolbox is a book that should take space on your bookshelf, whether you are new to Domino development or an old hand.

While the seasoned developer would find the first few chapters "review," Mark puts some excellent nuggets in those early chapters. One of the best things that I found in the early going was a figure showing the way that a Notes form processes (page 60). That is just one example. Another would include excellent development practices, helping the new developer to design an application using best practices. For those that have developing in Domino for awhile, the later chapters are indispensable. There are copious code examples, written so that even I could follow the logic, that would probably fit (with proper modification) any development issue or user request that you may get. While most are used to develop a specific application (the latter chapters help you develop specific apps), they could be very useful to a project that you are working on, or supporting. By the way, that is another nice feature of this book - Elliott creates new applications from scratch, he does not use the standard templates as guides or say "go look here for examples." This was an excellent idea.

An interesting, and very valuable addition, is that Mark includes links for more information at developerWorks:Lotus at the end of every chapter. He may touch on a topic, but provides a URL for more, detailed information on the web. A very nice touch. He also sprinkles throughout the book, tips for the developer that show how administrators (and their use of groups and security) that may affect your application. Elliott recommends that the developer create a good, working relationship with the admins, as they can assist with troubleshooting. And allow your agents to run on the server (sorry, a little "Admin humor").

Finally, look at the chapter listing. Mark moves easily from basic concepts to advanced features. This is a fairly comprehensive guide to Notes development (a pretty amazing achievement) and he manages it nicely. One of the latter chapters, "Troubleshooting" should help you with the wonderful "Variant does not contain an object error" or assisting you with using the Lotus provided tools for troubleshooting agents. Take a look at those steps before posting to developerWorks:Lotus. :-)

New to development or a pro looking to enhance your skills, this is an excellent book and one that I highly recommend.

As an aside, be sure to look at the Acknowledgements. You may see some names that you recognize.

I thought I'd share my thoughts on the first new Notes development book that I've seen in quite a while. The book in question, "Lotus Notes Developer's Toolbox: Tips for Rapid and Successful Deployment" by Mark Elliot, would do well to find a place on the shelf of every new and intermediate Notes developer. According to the back jacket, Mark has been employed by IBM since the early 90s and has implemented commercial applications for many large clients. He uses this background to craft a very solid technical book that covers a lot of ground.

While there is probably nothing new here for the truly advanced Notes crowd, I would recommend this book highly for those developers that have been working with the technology for a few years and want to fill in a lot of the gaps. Even better, this book should be required reading for someone new to Lotus Notes. Thinking back to my introductory days of Notes development, owning this book would have been a blessing. Mark does a fantastic job of starting at the beginning, introducing the reader to the concept of Notes. He explores often overlooked pieces, such as the various clients, installing Notes, an in-depth tour of the Designer client, etc. As Chapter 4 kicks off, we get into the actual architectural details of Notes before he launches into discussions of the Formula Language (Chapter 5), LotusScript (Chapter 6) and the fundamentals of a Notes application (Chapter 7).

The next several chapters are quite nice, as they focus on real-world applications. Each chapter introduces a new project (workflow app, calendar database, etc.), walking the user through all of the bits and pieces to get it going. There's even a section of the book that delves into web apps via Domino.

The remainder of the book builds upon information introduced before, focusing on specific techniques in LotusScript, Formula Language, building views, writing agents, etc. Mark rounds out the book by addressing data management, security, troubleshooting and application deployment and maintenance. Two appendices provide information about the related online materials and a discussion of Notes' future state. Of course ( and yes...I'm a bit biased), I'd have liked to see more emphasis on the importance of designing an attractive and usable interface in Notes, but I guess we'll need to wait for the sequel. ;-)

All in all, this is probably the most solid Notes development book that I've ever read. I especially liked all the "Note" sections that are interspersed among the text. These might be one of the most valuable parts of the book, since they point out little tips, tricks and pitfalls that many of us learned the hard way. For all of the beginning and intermediate Notes developers on your shopping list, I'd be happy to recommend finding a place for Lotus Notes Developer's Toolbox on it.

This book will be one of the most valuable and frustrating books you'll ever read. I definitely recommend it, but preface that recommendation with some advice - be patient... it will make sense eventually. This book starts off with a couple of good 'foundation' chapters - feel free to skip them if you are very Notes savvy - and then moves on to the heavy stuff. There are several step-by-step projects for a novice programmer to complete, which on one hand is a great learning tool, but on the other may be extremely frustrating. A lot of what is covered in the projects isn't explained until much later in the book; the examples instruct the reader to perform a lot of actions (such as insert pre-written LotusScript into an action button) without explaining the syntax/logic. I am a very analytical person, and it was very confusing/frustrating to be told 'Just do this and don't ask questions' - but I am glad I powered through - chapters later on in the book went back and did a lot more explaining.

This book has example code the will be useful for learning notes. As a consultant supporting many types of development languages, I recommend this book. I like to read good tech book front to back since I train myself in new/different development tools. Some of the chapters could be review for experienced developer but good none the less. 4 stars are as high as I rate books.

This book claims (among other things)
a) to be for all levels of developers
b) to have online content

The problem with promise a) is that the book is only useful for newbies. Reasonably experienced developers find almost nothing here that can't be found in the standard F1 help.

The problem with promise b) is that the online content is missing. I registerd at the website as instructed in the book, but the link to the source code examples points to a 404 (not found) error. I sent a mail to the contact address supplied at the web site but received a delivery time out a few days later. Really lousy service.

Apart from the above problems the book is probably quite useable to anyone new to Notes/Domino development.

This is a very well written book on developing applications with Lotus Notes. There are abundant samples of code that you can plug into your applications. If you work with Notes/Domino, or are thinking about it then this book belongs in your library.