An even better hidden gem in Notes 8.5.2        

Why the hell would I want to email THAT guy anyway? After much gnashing of the teeth and bearing of the claws over this item since Notes 8.0, IBM has finally added "Delete" to the context menu in the Mail address type-ahead. This is an excellent way to purge email addresses that you know are defunct.

In fact, I'd very much appreciate it if you'd take a moment and do this for me by removing my old lotus911.com address!

Unfortunately, the process displays a rather annoying confirmation dialog, but it's still a huge improvement over the old technique of going to the recent contacts list, finding the entry, pressing delete, throwing some chicken bones, chanting "there's no place like 127.0.0.1" three times, and then rubbing your armpits vigorously.  At least I think that was the old way to remove an automatically added contact.

Enjoy!

 Now running 8.5.2, and a hidden gem        

Domino 8.5.2 is GOLD! Just finished the upgrade on our internal dev server as well as the server that hosts this blog.

One thing that I don't think anyone talked about during the beta cycle was the massive performance improvement in start time of the later server.  Check this out...
08/24/2010 01:45:48 PM  Begin scan of databases to be consistency checked
08/24/2010 01:45:48 PM  End scan of databases: 1 found
08/24/2010 01:45:49 PM  Event Monitor started
08/24/2010 01:45:52 PM  0 duplicate PUIDs found while initializing Domino Domain Monitoring
08/24/2010 01:45:52 PM  Lotus Domino (r) Server (64 Bit) started, running Release 8.5.2
08/24/2010 01:45:52 PM  Server started on physical node THENTF
08/24/2010 01:45:53 PM  The Console file is C:\IBM\Lotus\Domino\data\IBM_TECHNICAL_SUPPORT\console.log
08/24/2010 01:45:53 PM  Console Logging is ENABLED
08/24/2010 01:45:54 PM  Database Replicator started
08/24/2010 01:45:54 PM  Replicator is set to Ignore Database Quotas
08/24/2010 01:45:54 PM  Index update process started:
08/24/2010 01:45:54 PM  Admin Process: thentf/GBSBLOGS is the Administration Server of the Domino Directory.
08/24/2010 01:45:54 PM  Administration Process started
08/24/2010 01:45:55 PM  DAOSMGR: DAOS is not enabled, nothing to do.
08/24/2010 01:45:55 PM  Agent Manager started
08/24/2010 01:45:55 PM  AMgr: Executive '1' started. Process id '8004'
08/24/2010 01:45:56 PM  HTTP Server: Using Web Configuration View
08/24/2010 01:45:56 PM  Router: Mail Router started for domain GBSBLOGS
08/24/2010 01:45:56 PM  Router: Internet SMTP host ntf in domain gbs.com
08/24/2010 01:45:56 PM  Database Server started
08/24/2010 01:46:02 PM  JVM: Java Virtual Machine initialized.
08/24/2010 01:46:02 PM  HTTP Server: Java Virtual Machine loaded
08/24/2010 01:46:02 PM  Servlet engine initialization was successful
08/24/2010 01:46:02 PM  HTTP JVM: File or directory C:\IBM\Lotus\Domino\data\domino\servlet does not exist
08/24/2010 01:46:12 PM  XSP Command Manager initialized
08/24/2010 01:46:12 PM  HTTP Server: Started

Yeah, that's from a post-upgrade, so normally the database scan wouldn't even be required.

From 01:45:52 to 01:46:12.  That's 20 seconds from server start to responding to HTTP requests!

According to some IBMers I've talked to, this massive improvements is a side-effect of the LotusLive Notes enhancements. The cloud-based services model requires extremely rapid on-demand response cycles for Domino servers, so the mighty Russ Holden has been dogmatic in his insistence on improving start time.  The results are, in my opinion, phenomenal.

So even if you're not looking to move your on-premises Domino environment into the cloud, you still got a great new benefit from it!

Happy upgrades!

 YellowDay: Yes, Virginia, there is a Santa Claus        

If you've been keeping up with the Escape Velocity relaunch, by now you should be noticing something of a trend...

1) LotusLive Notes doesn't do custom apps, but it does have a hybrid integration approach that makes both on-premises and cloud-hosted apps a lot more viable than people might think.
2) The problem is, even when you move your apps to the cloud, they're still the same apps that they were when they were on your own servers.
3) There's a bunch of things that you're probably used to doing in your custom apps that you can't do easily in Xpages yet, like calendars and dialogs
4) We're partnering with IBM to provide those things in Xpages
5) Your existing Formula code might look like it "just works" in SSJS, but it doesn't really
6) We built something that takes your existing Formula code and turns it into SSJS that "just works"

Can you fill in the missing pieces yet?

It might help to know that GROUP (and Lotus 911 before it) has been cultivating a deep understanding of DXL automation for a long time now.  We're now on our third version of our internal DXL deconstruction toolkit. And since DXL describes everything you could want to know about a Notes template in XML terms, and everything you describe about an Xpages application is done in XML -- well, do I have to spell that part out for you? Turning XML into XML ain't rocket surgery.

But if you want to turn DXL into XSP, it helps to make sure that there's a target component on the XSP side that matches what you had in DXL. Hence point 4 in the above list.

Of course, you'll also have all kind of business logic in your template that controls workflow, progressive disclosure, UI sequencing, etc. Much of that is written in Formula, and you can't just take the <formula> block from DXL and slam it into a #{javascript: EL tag on your Xpage, can you? Hence point 6 in the above list.

In the unlikely event that the light bulb hasn't gone off yet: Yes, Virginia, the Applications Frameworks team at GROUP is creating a tool to transform custom Notes applications into Xpages applications.  It's called the Genesis project. And yes, it'll do it for you in six minutes.

Some smart reader is sitting out there thinking "wait a minute. DXL and @functions are one thing -- but what are you going to do about my 50,000 lines of Lotusscript!??!  You can't make that run in an Xpage!"

Well, not today. Which is why we're not shipping yet. But we're close. The effort is going shockingly well, and the only serious question at this point is not CAN we do it, but how will it ultimately appear from the developer's standpoint. The worst case scenario is that we transform your Lotusscript into a very elaborate set of Java classes that bounce around between methods like a pinball machine, and if you look at them your head will explode. The best case scenario is that we turn it into those exact same classes, but you never see it because we hide it all inside a runtime VM, and you get to maintain all your Lotusscript source code just like you've always done. You'd quite literally have #{lotusscript: EL blocks in your Xpages.

I honestly wouldn't have believed we could do the latter 2 months ago, but at this point, it's merely a question of whether that will be the 1.0 or the 1.2 version.

The first version won't be perfect. They never are. You can probably guess a lot of the things that we won't be able to support in the initial release(s): COM calls, LS:DO integration, Java Applets, 50% of @Commands, a handful of @formula, client-local file manipulation. Some of these things aren't so much hard as tedious, so they'll probably follow on pretty quickly. Others will bring some fundamental technology challenges; you can't get a Webkit browser to call out to Microsoft Office without breaking a LOT of rules.

So this is the engineering team's public announcement of what we're doing. v1.0 of Genesis is targeted for availability in the Fall of 2010. And if you wonder why I've barely looked up from my keyboard in the last 3 months, now you know. This is by far the most difficult and rewarding work I've done in my career, and I couldn't ask for a better dream team to work on it.

Once again, Happy YellowDay 2010!

 YellowDay: Meet @Transmogrifier        

So let's say you're a long-time Notes developer that just starting to cut your teeth on Xpages. You probably know your way around Lotusscript pretty well, but what's even more likely is that you know your way around formula. You can't so much as build a view without formula code, and while working with @ can occasionally be challenging, for the most part, it's the most direct and simple way to get things done in the Notes client.

Now you're looking at Xpages, and maybe you notice that SSJS seems to have some familiar @functions in it. Perhaps, as a wild experiment, you copy some code from your favorite action button and paste it into the Javascript editor. Alas, that didn't work too well, did it? There's some similarities, but it's really not the same.

Here at GROUP, we didn't really like that. We wanted to have our formula code JUST WORK. And because we're basically well-funded lunatics, we set out to do just that.

Say hello to @Transmogrifier. The way it works is simple: just paste your formula code into the top box. Then click on ZAP, and wait a moment. You'll get your shiny SSJS code.

Of course, the result code won't necessarily work right out of the gate.  It will compile, but it uses a number of @functions and JS functions that don't exist in the base Domino product.  However, thanks to the 8.5.2 Extensibility API, we're able to provide you with a library that you can install in Designer and on a Server if you really want to try it out.  Just follow the instructions in the installation guide, and download the library.

For everything else you need to know, please check out the FAQ.

Happy YellowDay!

 YellowDay: Partnering with IBM on Xpages Extensions        

The crazy few that attended our IamLUG presentation in St. Louis already heard this, but because the live streaming didn't work, it turns out that I get to make this announcement twice.

A few weeks ago, the mighty Philippe Riand and I were discussing some of the missing ingredients from Xpages.  While Xpages gives Domino developers unprecedented power and flexibility, many people (including we here at GROUP) were struggling with some of the constructs that are part of the basic nature of the Notes client.  @Picklist, .DialogBox, Mail Address Fields, computed subforms, and even just keyword aliasing were turning out to prove quite a challenge to implement over and over in every XSP project that we engaged in.

Tim and I had been working feverishly on designing and building a collection of reusable controls that would behave as closely as possible to the traditional UI elements of the Notes client. And as it turned out, we were not alone. IBM had too been facing the same challenge, and members of the Xpages team all over the world had been working on similar concepts, in between fixing bugs to get 8.5.2 to ship quality.

Philippe and I agreed: "this seems like a lot of redundant work for us to be doing. Surely there's a better way to get this done."  IBM was already planning on releasing their toolkit on OpenNTF, so we had the option of waiting until they did all the work, and then just reusing it like everyone else.  But we're in a very big hurry, and I wanted to get access to some of these controls just as soon as possible. We also had a slightly different objective with many of them that required 100% consistency with the Notes client behavior, so while IBM's design for a dialog box required that you put the dialog contents into the container at compile time, we needed to be able to determine the contents dynamically at runtime.  (Note: they knew exactly how to do this, of course. It just wasn't a requirement for them where it was for us.)

So I asked my boss if we could join forces with the Xpages team on this effort. We'd have to do something unusual for GROUP, because we would explicitly be tasking full-time resources during regular hours to the production of an open source result. But in the end, we agreed that being able to work with the components that much sooner was worth sharing the results, and thus we moved forward with IBM with all speed.

The official beginning to this project was Monday. And I am thrilled to tell you just SOME of what it includes, as components that are both drag & drop in DDE, and declaratively through SSJS...

1) InputBoxes and @Prompt
2) Aliased keyword lists
3) View-driven Custom Picklists
4) Address selection fields & buttons (using the full Directory API, no less)
5) @DialogBox
6) Computed Subforms
7) Draggable "framesets" with computed contents
8) Multiple styles of Outlines that actually read from Outline design elements
9) Dramatically simpler OneUI implementation
10) Scrolling Dojo Grids driven from back-end data sets like a Notes view
11) Tag Cloud
12) Simple User Bean for Directory Info
13) Sametime Presence Awareness
14) Dojo Layouts and Events
15) Calendar Views (yes, calendar views. I said it.)

I'm not going to tempt fate by announcing a delivery date on my blog, but I can tell you that you'll need Notes/Domino 8.5.2 to work with all these features, and that our objective is "very soon after 8.5.2 is available."  We're as excited as ever to be working on this stuff, and we think that when you see it in action, you'll be excited to.

Thanks for stopping by on YellowDay!

 YellowDay: LotusLive Notes and the meaning of Hybrid        

Unless you've been on a cruise for the last couple of days, you've probably heard about the announcement of LotusLive Notes (LLN). Whether you take the angle that this pushes IBM into immediate market leadership, or that they left out the crucial piece of custom applications, or that Lotus simply isn't as good a hosting provider as their business partners are -- you probably aren't aware of the key market differentiator that LLN provides: the hybrid model.

Well, let me amend that: you're probably aware of it, insofar as you've heard it mentioned. But you probably don't know how it works. And because this is an IBM offering, you're probably figuring that integrating an on-premises Domino implementation with the LLN hosted implementation means putting the IBM Tivoli Cross-Domain Federation Identity Broker Gateway Server into your DMZ with the custom IBM Lotus Domino Blarficator Addon pack that can only be installed by a team of 5 architect-level consultants from the Global Services team who charge $300 every 10 minutes and will only install the software on genuine IBM Z series hardware. So your minimum investment in that integration is $5.3 gagillion and it takes 17 months.

You're wrong.

Here's what you need to integrate your on-premises Domino implementation with LLN: an OU certifier and a single Domino server in the DMZ

Yup. That's it.

Why? Because LLN is built on Domino, not some mishmash of technologies pretending to be Domino. And because it's Domino, it uses the Notes PKI and NRPC from the ground up. So when IBM asked themselves "how can we allow customers to manage the delegation of identity to our hosted environment?" they looked at how they'd solved that problem for customers since Notes 3 and said "we just need a certificate branch that we can control." So you give them an OU branch from your top-level O certificate, and they spawn all the servers they need from that.

Because they do it in Domino terms, that also means that every one of those servers can talk to your Domino server in the DMZ. You just need to enable it as a pass-thru server.  All the gateway services were built into Domino 4 versions ago.  There's nothing new there -- just 128-bit symmetric key encrypted NRPC travelling point-to-point between your DMZ and the LLN data center, and reaching from there into whatever directory and mail servers you've defined in your own Domino domain.

So what that really means is that when you use the hybrid features of LotusLive Notes, you're effectively using a hosted extension to your own existing domain. They even replicate your NAB.

That's all there is to it.  It's crazy elegant, really, because it doesn't worry about introducing a bunch of NEW stuff.  All these problems were addressed ages ago by the platform itself, and now there's just a really cool way to implement it with IBM as a service vendor instead of a product vendor.

And because it doesn't introduce a bunch of new stuff, it JUST WORKS. Your users get to their new LLN-based servers in exactly the same way they would if you migrated them from one server to another in your on-premises environment.  They work with calendar federation, schedule management, directories, authentication, local replicas and transparent mail routing exactly as they would with a high-quality Domino implementation: seamlessly. A cloud-based user can run a busy-time query against on-premises users the same way a pure premises implementation can -- because the server just proxies the request between all the individual home servers as defined by the directory.

Now I won't claim that the implementation is perfect.  There are unsupported features. There are quirks. There are limitations.  But on the whole, what IBM has done here is incredibly innovative and could only be accomplished with a technology like Notes, where identity and security are built into the DNA of the platform.

Here's the real kicker: IBM doesn't care if your "on-premises" servers are really on-premises. They don't even know whether they are. So if you want to, say, put your email services into the LotusLive cloud, but you're disappointed that you can't move your custom applications, you should realize: YOU CAN. You just can't move them to LotusLive. But you can move them to another hosting vendor that supports custom applications. And as far as IBM is concerned, that's just part of your "on-premises" Domino environment.

Have I mentioned the GROUP Live Platform-as-a-Service offering? As many of you saw at Lotusphere, that is our data center middleware platform that lets you dynamically implement and scale Lotus servers with a few clicks of a button. Naturally, we're now extending that platform to allow seamless integration with LLN, using the same fundamental strategy as the IBM team: exploiting Domino's existing capabilities to seamlessly extend a cloud-enablement to be cross-vendor.  Whether you use it in your on-premises facilities, outsource your hosting to a third party, or want specific networks deployments for specific applications, the approach chosen by IBM will allow maximum flexibility.

Of course, while this addresses the IT support need of servers & infrastructure, it doesn't address the business need of end user experience. Whether they're in the cloud or on-premises, your mission critical custom applications are still whatever you designed them to be. So the next big question is: how can we make a 10 year old workflow app not only sit in a hosted data center, but also work better when it does.

The answer, dear reader, is a tale for another blog post....

 YellowDay: Welcome to the new Escape Velocity        

In celebration of YellowDay 2010, I'm starting the day with an official relaunch of my blog.  Right now, you'll notice that the only thing different is the URL, but over the next several days and weeks, you'll start to notice some more dramatic changes, include layout and platform. It is my most earnest belief that what makes this blog worth reading is the incredibly rich interactive content that has appeared here over the last 5 years. So my number 1 priority is ensuring that every post and every comment is retained in the transition to the new environment.

I'm particularly proud that my new host address, ntf.gbs.com. is not only in the gbs.com domain, but is part of our GROUP Live installation in our Atlanta office. This is the first instance in what will be a series of blog transitions for all the GROUP bloggers who choose to do so, with each of us getting a managed Domino server in the Live environment. This will open the doors to a lot more experimentation and demonstration publishing, starting with a nice shiny new page later today.

So Happy YellowDay, good readers. Thanks for coming back by my blog, which once again features working comments!

Enjoy.

 Aug 11 is here again!        

An annual day in celebration of all things Lotus It's August again, and now that I've made it through the crucible known as IamLUG, I've had a chance to make some plans for this year's YellowDay.  I'm delighted to say that my new corporate overlords at Group are supporting the Yellow Day festivities this year, and we'll have several cool new things going live on Wednesday.   Those of you who attended our session at IamLUG know at least one of them.

So get out your Lotus shirts, hats, cars, buttons, or whatever else you can think of and be sure to share in the Yellowness this Wednesday!

 Happy 4th of July!        

 GUEST POST on Tip of the Iceberg        

My comments are broken, so go check out the conversation that I've started on Tim's blog.

Search 

Disclaimer 

Welcome to Escape Velocity!

Opinions expressed here by Nathan T. Freeman are not necessarily those of his employer. However, there's a decent chance they are, so check with them if you really want to know.

But really... do you need that kind of validation? Are the opinions expressed here in doubt?

MiscLinks