Tuesday, January 12, 2010

The WildFire Is Spreading...And It's Hot! Update Your Status Across Multiple Networks From Lotus Notes!

A new OpenNTF project hit the ground running today and it is hot! I installed it this morning and think it's a great piece of work. The project is WildFire, a Lotus Notes 8.5 sidebar application that allows the user to update status messages across a ton of different social platforms. Networks supported in this initial release include Facebook, Twitter, Lotus Sametime, Lotus Connections and many more! While this type of client for allowing simultaneous updates of your micro-conversations is not new, the implementation, interface and integration with the Notes client is top notch. Installation was smooth and it worked as expected right out of the box. Having the ability to selectively update given services or all at once right from the Notes sideshelf is a great value proposition, especially considering that it's free!

Here's a screenshot of WildFire from my Notes client with the services I've configured so far. I love the fact that you are not locked into a single instance of a given service. For example, I have my embedded Sametime client configured for 7 different communities, and if I wanted to, WildFire would allow me to update my status across all of those.


Configuration of WildFire is extremely simple. Once installed, the application options appear in the standard Notes Preferences dialog. You simply add a new service and select the Account Type (Sametime, Connections, Facebook, etc.). Each account type can be given a unique name and it is this name that appears in the WildFire UI. For a given account type, the credentials required vary somewhat, but it is all very easy to understand. You can also group your various accounts together (e.g. Personal, Work, Friends, etc.). This allows you to selectively send that hilarious, NSFW video to your buddies from school but not to your work associates with just a single click. I especially like how it pulls in your information for Sametime from the communities you already have configured. Making it easy to get up and running quickly is a great user experience feature!


To update your status, you type your message, select the service(s) you want to update and hit the Post button. Simple stuff, but the simple tools are sometimes the best. I believe I'll find this over time to be a big time saver.

Check out some other screenshots of WildFire:








So who is behind this awesome piece of work? It's available on OpenNTF, the Lotus Notes open source community, courtesy of ISW, a Premier IBM Business Partner located in Australia. Thanks to Andrew Welch, Adam Brown, Joel Thirgood and anyone else involved in this great project.

There's a lot to like about this application and if you use more than one of the many social networking tools out there today, it is worth your time to check out WildFire.

Labels: , ,

permalink | leave a comment

Friday, January 08, 2010

Folder Name Issue Causing Java UI Rendering Problem In Notes 8 Mail File

I was working with one of my customers and was told about an interesting problem. They are currently in the process of upgrading to Notes 8.5.1 and so far, most of the client upgrades have been nice and smooth. One user had an unusual issue that was causing a bit of angst. After being upgraded and getting the new mail template, most of his folders were not visible in the UI. Here's what it looked like. Notice anything odd?


A quick check using File - Go To confirmed that the folders were indeed still in the database. However, this was the only way the user could navigate to these folders. Looking at the folders in the Admin client did not give us any additional information. Without digging into it too much, we first performed the normal triage procedures (compact, fixup, etc.). These did not yield any positive results. Neither did replacing the design or creating a new database copy. In fact, I went as far as to replace the design to something totally different, then replaced back to the mail template. Nope...same result. Time to get sleuthy.

I received a design copy of the database and began to look at it a little more closely. One odd fact was that some automatically generated folders that Mail Attender created were there, but that was it. These were prefixed with a "-", so I tried adding a new folder with a "-" in front. One worked (-A Test) and one didn't (-Test). Ah...interesting. This caused me to look at the navigation in a little more detail and I realized that the entire UI was not rendering. There should have been some additional options under the folders like "Archive", "Tools", etc. Since the first folder I created appeared under the folder list in the navigation pane but the other did not, this clued me in that perhaps Notes was hitting a folder name it did not like and that caused it to cease rendering the rest of the UI elements at that point. I opened the database in the Notes 8 Basic client and everything appeared fine, so I was pretty confident that this was a bad name or corrupted folder. Sure enough, when I opened the design, I found the offending folders.

There were two folders that used a nested name and each of them were wrapped in parenthesis. They were named:

-To Be Deleted\(-To Be Deleted)\(--ToBeAutoDeleted\Meetings)

-To Be Deleted\(-To Be Deleted)\(All Documents)



As soon as I renamed these folders to remove the parenthesis, everything started working as expected and the entire navigation UI was rendered correctly.

I started playing around a bit and it seems it is the second set of parenthesis after the second backslash that cause the problem. So,

Interface\(Matters)

doesn't cause things to break, although it still results in strange behavior in that "Interface" appears but doesn't do anything.


Interface\(Matters)\(Rocks)

breaks everything. No folders or additional UI elements below "Interface" show up at all.

Interface\Matters\(Rocks)

is OK, as is

Interface\Matters\(Rocks)(Hard)

But

Interface\Matters\(Rocks)\(Hard)

blows everything up again.

So...there you have it. Avoid making folder names with multiple levels that are surrounded in parenthesis when using the Java UI. I just wanted to document this in case anyone comes across it again in the future. I haven't checked if this is a known issue yet, but I'll be sure to pass it on to development.

Labels: ,

permalink | leave a comment

Tuesday, December 08, 2009

Forgive Them...For They Know Not What They Do...With Your App

If you've been following along with the home game, then you are aware that there are many excellent UI patterns that you can use to improve the user experience you deliver to your users in your applications.  Today, I wanted to explore another simple yet powerful pattern: "Forgiving Formats".  This pattern is perfect for those applications in which speed to data entry is key (or at least desirable in most circumstances).  I know in many of the business applications I have encountered over the years, we tend to develop nice, complex forms to capture all of the data the customer says they absolutely need.  When you come back and look at the database later, however, you often find that only a few key fields are filled out (just the required ones if you're using validation!).  The Forgiving Format pattern is all about letting users enter those key bits of data quickly, without having to worry overly much about the way they are entering the content.  This pattern puts the onus on you as the developer to do the heavy lifting, not the end user.  Of course, this is one of the tenants of interface first design.  It allows you to simplify the UI and make the problem really about the behind-the-scenes code.

A great example of the Forgiving Format pattern is Google Maps.  When searching for an address, you can use a variety of inputs.  For example, when searching for a location in my town, I can put in:

Aurora
Aurora, OH
Aurora, Ohio
44202
etc.



This flexibility allows me to focus on the job at hand, not on the exact way I have to format the address so that Google understands it.  This lets me get my work done faster, so obviously it makes me a happy user.

You can apply this same idea to your applications.  I find it can be useful both for allowing quick data entry for Notes documents as well as for use as a search mechanism.  The underlying idea is simple.  As the developer, you have to account for the various input types the user may enter and then code for those instances.  In my Movie Review sample database, the main input is obviously movie information.  While the form allows you to capture more data, there are only a few fields that are key to building a good database of movie knowledge.  These include the movie title, the rating, the genre and the running time.  I created a Quick Movie Entry option in the database to show this in action.  First, let's take a look at how I implemented this.


I created a caption in the frame so that the user could free up screen real estate if they didn't want to use this option.  It gets it out of the way if the user will be doing something other than data entry.  However, if they want to quickly add a bunch of movies, they can expand the caption area and then will see an input line for the movie information.  Of course you could break the input into a bunch of separate fields to capture the user input, but a single field is easier and more elegant. 


I included a brief explanation of what the user should enter with this control. This particular pattern works best when you have information that is targeted to a specific objective and when the input is something that you can prepare for. Leaving it completely open ended would be incredibly hard to program for and would likely result in failure. In this case, I'm expecting those four particular bits of data and I want the user to enter them in that order, as specified by the help text. When you choose to implement this functionality in your own application, you will have to weigh how flexible you want to be with the input field and possible combinations of entries vs. the complexity of the evaluating code.

In the Movie Review example, the user can enter the title, rating, genre and running time and then hit the "Go" button. If the code successfully recognizes the entry, a new document is created in the database and the user is informed via a popup message (using the fade in/fade out technique). If the input can't be recognized, the user sees an error message.

As far as the backend code goes, it can be fairly simple or very complex, depending again on how flexible you want to make this functionality for the end user. In this example, there are two fields that I'm actually mapping to already established categories. The rating should obviously be a valid entry (G, PG, PG-13, R and NC-17) and the genre has values such as Science Fiction, Drama, Comedy, etc. To evaluate these, I used a Select Case statement. This allows for the "forgiving" part of this pattern.

In the case of the rating, one user might enter a NC-17 movie as NC17 while another might use X and another might use XXX. They could also use varying values of upper and lower case (e.g. Nc17, nc-17, xxx). For each of these different possibilities, a Select Case statement makes it nice and easy to evaluate the input. I did the same thing with the genres. For a Disney movie, users might enter options like cartoon, animated, animation, etc.

Below is the sample code behind the button. Feel free to use this as a guide, but remember there is no robust error handling in the example.

Sub Click(Source As Button)

Dim workspace As New NotesUIWorkspace
Dim session As New NotesSession
Dim db As NotesDatabase
Dim uidoc As NotesUIDocument
Dim movieDoc As NotesDocument
Dim entryDoc As NotesDocument
Dim movieEntry As Variant

Set db = session.CurrentDatabase
Set uidoc = workspace.CurrentDocument
Set entryDoc = uidoc.Document

On Error Goto ShowError

movieEntry = entryDoc.MovieEntry

'Here's where you are going to do the meat of your work.
'You need to determine just how much logic you want to put
'in place to decode what the user has entered. I've given a
'couple of simple examples below.

Set movieDoc = db.CreateDocument
movieDoc.Form = "Movie Review"

'Let's deal with the title first
Dim movieTitle As String
movieTitle = Strconv(movieEntry(0), 3)

'Rating
Select Case movieEntry(1)
Case "G", "g":
movieRated = "G"
Case "PG", "pg":
movieRated = "PG"
Case "PG13", "PG-13", "pg13", "pg-13":
movieRated = "PG13"
Case "R", "r":
movieRated = "R"
Case "NC17", "NC-17", "X", "XXX", "nc17", "nc-17", "x", "xxx":
movieRated = "NC17"
Case Else
movieRated = ""
End Select

'Category
Select Case movieEntry(2)
Case "Science Fiction", "scifi", "sci-fi", "SciFi", "Sci-Fi", "Sci-fi", "Scifi":
Category = "Science Fiction"
Case "Action", "action", "Adventure", "adventure":
Category = "Action"
Case "Comedy", "comedy", "funny", "Funny", "humor", "Humor":
Category = "Comedy"
Case "cartoon", "cartoon", "animation", "Animation", "animated", "Animated":
Category = "Animation"
'etc, etc....
Case Else
Category = ""
End Select

'Here you'd actually perform the task (such as creating the
'new document if everything validated correctly. It should
'if you are careful with your forgiving format.
If movieTitle <> "" And movieRated <> "" And Category <> "" Then
Dim newMovie As NotesDocument
Set newMovie = db.CreateDocument
newMovie.Form = "Movie Review"
newMovie.MovieTitle = movieTitle
newMovie.Category = Category
newMovie.MovieRated = movieRated
newMovie.MovieTime = movieEntry(3)
Call newMovie.Save(True, False)

'Display cool fade-in success message here
Else
ShowError:
'Display cool fade-in error message here
End If
Exit Sub

End Sub

This LotusScript was converted to HTML using the ls2html routine,
provided by Julian Robichaux at nsftools.com.

When you break it down, I think that this a very simple UI pattern to implement in your applications. As always, it comes down to trying to simplify the user's task. While this pattern is not applicable to all situations, I can think of a good number of Notes applications I use frequently that could benefit from the Forgiving Format pattern. Does one of yours? Give it a try and let me know how it goes.

Labels: , , ,

permalink | leave a comment

Wednesday, November 18, 2009

Sweet Drag and Drop Actions In the Lotus Notes Client

I've mentioned once or twice before that I really like using drag and drop. Although it is often a bit slower than other actions and you sometimes have to show the user how to do it, I find it to be a preferred method for executing certain tasks in an application. Lotus Notes itself offers many cool and useful drag and drop actions. I've been showing end users some of these for a long time, and always there are folks that had no clue drag and drop actions were even available. I wanted to share a few of them with you now.

Drag & Drop Links

You can drag and drop a document from any Notes view or a database icon into a rich-text field and Notes will create a document link or database link (as applicable). If the document is open, you can actually perform the drag and drop action from the tab. This is a much easier way to teach users how to send links to documents.


A couple of hints: You can often drag information from one part of Notes into another by hovering over the appropriate tab. For example, click and hold the tab of an open document, then drag it over to the tab of a document in edit mode. Hold it there for a second and the focus will change to the new document. You can then perform the drop action into a rich-text field and the link will be created. Also, an easy way to get the Notes:// address of an element is to perform that drag and drop into a regular text field. This will give you the Notes:// link along with the title of the item.


Drag & Drop Attachments

You can take attachments from a Notes document and drag them to the file system or your Windows desktop. For those of you on Notes 8, check out the very cool File Navigator side shelf component on OpenNTF. You can use this to drag and drop files directly from your Notes client!



Drag & Drop To/From Sametime

With Notes 8.5, you can drag a mail message to the Sametime Contacts list. When you drop it, a dialog will appear and present you with a list of all recipients of that e-mail message. You can choose to add them all or just select individuals to your contacts. This is a very speedy way to create groups within Sametime.


Going the reverse direction, you can drag a single contact or a group name from your Sametime Contacts list into the address fields of a new memo to instantly add those recipients to the mail message.


If you drag and drop a contact into a rich-text field, a mailto link to that individual will be created.



Drag & Drop Text

With Notes 8.5, users can now have a more rich experience as they drag & drop text. You can drag and drop text within a rich-text field (useful for rearranging some paragraphs, for example) or even between rich-text fields. I'll often use this when I am creating a new calendar entry and I want to pull some information out of an existing doc. Sure copy and paste is a bit faster, but drag and drop is so fun! ;-)


Drag & Drop Tabs

I often work with several documents and views open at one time and I generally like to have an orderly flow to how the tabs are arranged. If I open up these elements in an order other than the way I like them arranged, I just grab the tabs and reorder them via drag & drop. Perfect.


Drag & Drop Table Controls

There are some long awaited functions now available for manipulating tables via drag & drop. One of the best is the ability to resize columns without using the ruler. With Notes 8.5.1, you just grab the column border and drag & drop to resize.


You can also move whole rows or columns at one time via drag & drop. If you hover over the outside border of a row or column, you'll see the cursor change to an arrow pointing at a row or column respectively. Click, hold and drag and you'll see a shadow moving to represent that row/column. Drop it where you want it in the table and the other elements will be reordered accordingly (see animation below).



If you just want to move the content of a single cell, highlight it and then drag & drop it into the destination cell of choice. You can move multiple cells at once, as well. Play around with this a bit and you'll find some interesting functions.

While I'm on the subject of tables, while not strictly drag & drop specific, there are a couple of other very handy new tricks you might like. If you want to add a new row or column, you can now do this without resorting to the Table menu. To do this, hold the Shift key down and then hover over a row/column border. You'll see the cursor change to a thick horizontal or vertical line with a little blue diamond next to it. When you see this cursor, double click with your mouse and the new row/column will be inserted. Thanks to the developers...I really like that new edition!



So, those are some of my favorite drag & drop features in the Notes client. There are many more. How about you? Any particular drag & drop actions I missed that you really like? If so, please share in the comments.

Labels: , , ,

permalink | leave a comment

Friday, July 31, 2009

Add Document Ratings To Your Notes Client Designs

Way back when I was actively developing stuff on a daily basis, I wrote about a quickly cobbled together idea I had to include a document rating system in a Notes client application (might want to read that first). Document Rating is a familiar "Web 2.0" design pattern that can actually be quite useful. Document ratings allow users to democratically decide on good content and by using this technique the best stuff will bubble up to the top (at least theoretically). In the original post, I wanted to explore the concept of using editable view columns with icons in a little more detail while showing off some cool functionality in the client. With the frequent use of this design pattern in modern websites, I think it is safe to assume that it is a pattern that is around to stay. Thus, I wanted to make the solution a little more robust. As with most of the things I put here on Interface Matters, I've removed a lot of the extraneous code that you really should use in production so that you can focus on the core of the technique, but the sample database below should be enough to get you started.

Before we begin going through the technique, I suggest you read through the Rate Content design pattern page on UI Patterns.com. That page should give you a little more detail on what I am shooting for. For our purposes, let's focus on the following mechanisms:

* Voting mechanism.
* Display the average rating an item has received.
* Display explanatory comments from users rating an item.



I've left off the three mechanisms below, but they seem like a perfect fit for dashboard-like functionality.

* Show the highest rated items.
* Favor quality items.
* Related items.



In the original post, I wasn't taking into account security on the document that is being rated. Thus, this technique really wouldn't work for most real world situations. To overcome this, I decided to use the concept of stub documents to capture each user's rating of a particular document. This offers several advantages. First, I can easily perform a lookup to see if the user has already rated a given document or not. Second, it allows me to extend the original functionality by allowing for additional information such as comments. Finally, this idea respects the security of the main document, as the average rating is calculated by an agent so that the user never has to have edit access to it. Thus, the flow of the process goes something like this:

1. User clicks a star to define their rating.



2. If desired, pop up a dialog box to capture their comments about why they rated the document as they did.



3. Write a stub document that captures a unique key value that corresponds to main document and user, their rating and comments.



4. Run an agent (that executes with proper authority) to update the main document with the new average rating. This agent will loop through all of its rating documents to determine the average.



At the risk of making this post too long, I am going to break this down step-by-step:

Step 1: Add columns to your view. I created a separate column for each star, since I want to know explicitly which one was clicked. Set the column to be editable and set it to "Display values as icons".



Step 2: The column value checks the current average rating of the document and based on the position of the column determines if it should show the filled or unfilled star.

@If(num_Rating >= 1; "star_red"; "star_open") and so on...

Step 3: Add the code to the InViewEdit event. I've included a bunch of comments to the code so you can follow what is happening. It's here that we first check to see if the user has rated the document previously and decide to allow them to edit that rating or not. I chose to implement this as a flag that you can enable or disable in the code itself for easy demonstration, but you could make this and some of the other options part of the db configuration. If the user hasn't voted yet, the InViewEdit code creates the stub doc, asks them for a comment (if appropriate) and kicks off the update agent.

(Please note I added some line breaks into the code samples. If you want to copy and paste, do so from the sample database)


Sub Inviewedit(Source As Notesuiview, Requesttype As Integer, Colprogname As Variant,
Columnvalue As Variant, Continue As Variant)

Dim workspace As New NotesUIWorkspace
Dim session As New NotesSession
Dim db As NotesDatabase
Dim doc As NotesDocument
Dim caret As String
Dim flag As Boolean

'Set AllowChanges to 0 to keep users from changing their rating. If set to 1, then can modify their initial value
Const AllowChanges = 1

'Get the CaretNoteID - exit if it does not point at a document
caret = Source.CaretNoteID
If caret = "0" Then Exit Sub

'Get the current database and document
Set db = Source.View.Parent
Set doc = db.GetDocumentByID(caret)

Dim ratingsView As NotesView
Dim ratingsDoc As NotesDocument
Dim DocUNID As String
Dim key As String

'We need to check to make sure the user hasn't already rated this document
Set ratingsView = db.GetView("viewRatingsByKey")
DocUNID = doc.UniversalID
key = DocUNID & "_" & session.CommonUserName
Set ratingsDoc = ratingsView.GetDocumentByKey(key)

If Not (ratingsDoc Is Nothing) Then
If AllowChanges = 1 Then
flag = workspace.DialogBox("dlgRatingsCommentDialog", True, True, True, True, False, False,
"Enter A Comment About Your Rating"
, ratingsDoc, True, True, False)
If flag = True Then
Call ratingsDoc.Save(True, False)
Call RunTheAgent(db, doc) 'Call the agent to update the main document with the new rating value
End If
Else
Messagebox "Sorry...you've already rated this document"
End If
Exit Sub
End If


'If we got this far, the user hasn't voted yet, so we'll take their entry. Here we are creating the new stub document.
'This document uses a combination of the main document's UNID and the user name for the key value. This
'stub document could capture as much information as you need...just add the appropriate fields. If you don't
'ever plan to show the underlying content to the end users, you don't need an actual backend form.
Dim newRatingsDoc As NotesDocument
Dim item As NotesItem
Dim readersItem As NotesItem
Dim newValues( 1 To 2 ) As String
newValues( 1 ) = session.UserName
newValues( 2 ) = "[Admin]"

Set newRatingsDoc = db.CreateDocument
newRatingsDoc.Form = "frmRatingsDoc"
newRatingsDoc.txt_TargetUNID = DocUNID
newRatingsDoc.txt_RatingComment = ""
newRatingsDoc.txt_Key = DocUNID & "_" & session.CommonUserName
Set item = New NotesItem(newRatingsDoc, "nam_UserRated", session.UserName, NAMES)

'To keep ratings private, uncomment the line below. But if you do this, probably no use asking for comments.
'Set readersitem = New NotesItem(newRatingsDoc, "read_Users", newValues, READERS)


Select Case Colprogname(0)
Case "Star1"
newRatingsDoc.num_Rating = 1
Case "Star2"
newRatingsDoc.num_Rating = 2
Case "Star3"
newRatingsDoc.num_Rating = 3
Case "Star4"
newRatingsDoc.num_Rating = 4
Case "Star5"
newRatingsDoc.num_Rating = 5
End Select

'Modify the code for comments as necessary to suit your needs

'Now lets see if the user wants to add a comment
Call ratingsView.Refresh

'Option 1 - Use this if you want to pull up the comment dialog but don't require a comment.
'Call workspace.DialogBox("dlgRatingsCommentDialog", True, True, True, False, False, False,
"Enter A Comment About Your Rating", newRatingsDoc, True, True, False)

'Call newRatingsDoc.Save(True, False)

'Option 2 - Use this if you want to require comments before a rating can be saved.
flag = workspace.DialogBox("dlgRatingsCommentDialog", True, True, True, False, False, False,
"Enter A Comment About Your Rating"
, newRatingsDoc, True, True, False)
If flag = True Then
Call newRatingsDoc.Save(True, False)
End If


'Call the agent to update the main document with the new rating value
Call RunTheAgent(db, doc)


End Sub

Sub RunTheAgent(db As NotesDatabase, doc As NotesDocument)

'Call the agent to update the main document with the new rating value
Dim agent As NotesAgent

Set agent = db.GetAgent("agtCalculateRatings")
Call agent.RunOnServer(doc.NoteID)


End Sub


This LotusScript was converted to HTML using the ls2html routine,
provided by Julian Robichaux at nsftools.com.


Step 4: Add the agent that updates the main document with the average rating. This agent is called by the InViewEdit code as described above. This agent will take the main document, find all of the stub rating documents based on the UNID of the main doc and then loop through the collection, simply adding the values of the ratings and then dividing by the number of ratings to get the average. This average value is then written back to the main document. Make sure that this agent is set to run with an id that has access to all of the main documents, not as the current user.


Sub Initialize

Dim session As New NotesSession
Dim db As NotesDatabase
Dim agent As NotesAgent
Dim ratingsView As NotesView
Dim mainDoc As NotesDocument
Dim ratingsDoc As NotesDocument
Dim ratingsCollection As NotesDocumentCollection

Set db = session.CurrentDatabase
Set agent = session.CurrentAgent
Set ratingsView = db.GetView("viewRatingsByUNID")
Set mainDoc = db.GetDocumentByID(agent.ParameterDocID)
Set ratingsCollection = ratingsView.GetAllDocumentsByKey(mainDoc.UniversalID)

If (ratingsCollection.Count = 0) Then
'Whoops...something went wrong and you'd do some good error trapping here
Exit Sub
End If

Dim ratingsCounter As Long
Dim numberOfRatings As Long
Dim averageRating As Long

ratingsCounter = 0
numberOfRatings = ratingsCollection.Count
Set ratingsDoc = ratingsCollection.GetFirstDocument

'Let's add up the total of all ratings first
Do While Not (ratingsDoc Is Nothing)
ratingsCounter = ratingsCounter + ratingsDoc.num_Rating(0)
Set ratingsDoc = ratingsCollection.GetNextDocument(ratingsDoc)
Loop

'Now, we average the ratings by taking the total and dividing by the number of votes
(assuming all have the same weight)

averageRating = ratingsCounter / numberOfRatings

'And now we can set this on the main document and be on our way
mainDoc.num_Rating = averageRating
Call mainDoc.Save(True, False)

End Sub


This LotusScript was converted to HTML using the ls2html routine,
provided by Julian Robichaux at nsftools.com.


There are a lot of ways in which you could flush this technique out even more. For example, I added an embedded view to the main document form that is used to show the stub document ratings. This way, when you open a particular content document, you can see in detail who rated the content and why (via their comments). This is a nice way to provide users with real meaning behind the values. I'd be interested in hearing about other ways you might use this functionality as well.



The sample database is available below. You've likely seen this before, as it contains a variety of sample design patterns, some of which I haven't talked about yet. You can switch to the "User Ratings" view by using the selection box in the lower right corner of the main screen. Yes...this database is a bit ugly. I was playing with some different theme ideas and didn't want to make another boring looking Notes app. ;-)

Have fun, let me know what you think and please share with the others if you find a use for this in your company's applications.


Labels: , , , ,

permalink | leave a comment

Monday, May 11, 2009

Implementing A Tag Cloud In The Lotus Notes Client

Welcome back. It's been awhile. I'd ask you why you haven't visited or called lately, but I know...it's me. I haven't been giving much to this relationship lately. I'll try harder...I promise. How about starting with a new post about creating a tag cloud in a Lotus Notes client application? That sounds good? Great...thanks for giving me a second chance! :-)

Way back at Lotusphere 2009, Nathan and I delivered a presentation on Web 2.0 design patterns for Lotus Notes. He focused on the web side of things (with XPages) and I worked on the client UI side. Unfortunately, some technical difficulties got in our way and the session wasn't nearly as good as it could have been. However, the content is still worth digging into, so I thought I'd start out with one that is useful for injecting the idea of topic popularity into your application: The Tag Cloud.

I'd guess that most people have at least seen a tag cloud by now, given that it is a pretty common Web 2.0 pattern. A tag cloud is used as a navigation mechanism to allow users to browse information and see at a glance what content is most popular or prevalent in an application. A tag cloud is simply a list of tags (be they user added or generated from categories) where the physical size of the tag represents the weight (frequency) of that information within the application. An important aspect of the tag cloud is that you can click on a tag and this action will filter the data list to show only the content with that tag. Here's an example from one of the Lotus products, Lotus Connections:



Tag clouds can be very useful in situations when a user wants to discover information rather than search for it. I've gone on and on before about the fact that most business applications are such that a user has a targeted objective when they use the app, so the UI should be designed to facilitate getting them to the info they need as quickly as possible. There are certain classes of applications, however, where browsing of information is more meaningful. A discussion database is a great example of this, as are apps such as product reviews, policies and procedures and so on. When discoverability will add value to your application, then a tag cloud might be a good choice for a UI component.

Before we jump into the implementation, let me put forth a few caveats. First, when I was initially coming up with this, I went through about four different methods of creating a tag cloud. These methods ranged from quite simple (like I'll be showing you here) to insane hackery. While it's pretty easy to build a tag cloud on the web and there are tons of code samples to do so, it was a bit of a challenge to implement one in the Notes client. Each of the different techniques I tried had strengths and weaknesses. I decided to go with the method shown below because it was the most straightforward and will work in R6 and above, so it's not limited to the latest and greatest version of Notes. It's not elegant, but it works. I'm a fan of clean, elegant design, but sometimes it's necessary to create something less than beautiful behind the scenes to make the end user experience better. As long as you are not creating a maintenance nightmare, I think it is OK that we work harder so our users don't have to.

The way I approached this technique was to make use of the category field in an existing Notes database. Exposing existing categories as a tag cloud is a very easy way to get started and introduce this functionality to your users. Personally, I find that tag clouds work best when the number of entries is not overwhelming. They do take up a lot of valuable screen real estate, so you'll need to make the call as to whether they add enough value to justify use or not. Of course, the ideas presented here can be applied to any data captured in a discrete field on your documents.

Aside: I would be remiss if I didn't point out that there is a Tag Cloud component available on OpenNTF that you can use in a Composite Application. With this component, you can add tag cloud functionality to your application within minutes. There's a good tutorial on doing so here.


The first step in building the tag cloud component for the Notes client is to create the view that will be used to get the tags (categories). Here's a screenshot showing the view in my demo database.



The first column includes the count of all the tags in that grouping, which I find useful to display along with the tag cloud in some cases. We'll use this view to lookup the tags and display them in the tag cloud.

The next thing we need is to create the form that will serve as a container for the tag cloud. I decided to use a form as it gives the flexibility of having the tag cloud generated on the fly or via a process such as a scheduled agent. I'm also trying to make these techniques easy for newer developers, so the form and field idea works pretty well. Because we need the tags to be clickable, we need some sort of hotspot on each one. This could be likely by accomplished by using Lotusscript or a third-party product like Midas to build the tags in a rich text field and then put links around them but this seemed a little complex for my tastes. Thus, I decided to implement the tag cloud as a series of fields. Each field holds a single tag and then I created an action hotspot around each field. Let's break it down bit by bit:

Click to enlarge


First, the top of the form houses some computed fields that are used to lookup the tags and the quantity each of the tags. These values come directly from the tag cloud view.

Next are the various tag fields themselves. Now...before you start going off...I know that this is cumbersome to build the first time. However, I decided to strike a balance between functionality, ease to maintain and ease for the developer to understand, so it is what it is! :-) If you decide to use this technique, it would be a good idea to try to gauge how many tags you have before you build it. My personal preference is to limit a tag cloud to no more than 40 or 50 tags (I like less). Beyond that number is just too much visual noise for my taste. However, this could expand to as many fields as you want to create.

The field values themselves are populated in the PostOpen event. This event holds the meat of the code, as it implements the tag cloud algorithm to allow us to determine how large (from a font size perspective) each tag should be. There are variety of these algorithms available on the web, and I won't belabor them here. For our purposes, just know that I selected a common one and implemented it in formula language. The code loops through each value of the num_CategoryTotals field, determines how many entries there are for that tag and then uses that number in the algorithm to set the font size, plugging the value of the current tag into the txt_Tag# field that corresponds to the counter in the loop.
If you'd like to use a different tag cloud algorithm, just substitute your code as necessary.

The final part of the equation is to add a hotspot around each tag field. This hotspot will filter the view that you are displaying to the end user so that it only shows the given tag (category). In order to do this, we make use of the @SetViewInfo command. If you are not familiar with this command, it was added in R6 and allows you to display only documents from a given category in a categorized view. Armed with this tool, we open the view in question, make sure all the categories are expanded (or else you can end up with what appears to be a blank view) and then perform @SetViewInfo, using the given tag as the filter string.

One other note: You may want your tag cloud to have different colors. Not only does this provide visual interest, but it also can provide another clue as to the relative weight of a given tag (i.e. tags with the same color have close to the same number of entries). You add color in one of two ways. You can set the color values using formula language in the PostOpen event, or you can just apply color to the individual tag fields. The advantage of the first option is that it does respect the concept of relative weight of tags, but the disadvantage is that you are limited to the 15 colors allowed in @Command([TextSetFontColor]). With the second option, you can use any color you want, allowing you to make the tag cloud fit better with the design of your application. What you lose here, however, is the idea of relative weight since you are randomly choosing the colors. As always, it's a judgment call. Use whatever concept works best for you.

Once you put all of this together, all that is needed is to drop your tag cloud form into a place that makes sense. In most cases, a tag cloud will be most compelling when included alongside a view, so if you are building a frameset with navigation elements in one frame and a Notes view in another, the tag cloud should be included in one of the navigation frames.

When complete, the generic, non-styled version looks something like this:



But a little more work integrating it into the design of your application can give you something like this:



Now that is all said and done and I know what you are thinking: "Give me the code and sample database already!". OK, OK. Here we go:

I've included two downloads below. One is the complete design pattern database that was used at Lotusphere. This has all of the code and you can see how it was customized for the specific database in question. (This is a database that is about 10 years old...created in R4.6 or R5, I think, and I reskinned it for use as a demo). The other download is the very generic implementation of the tag cloud with just the tag cloud components in it. The idea is you should be able to grab these design elements, throw them into your database and be up and running with a tag cloud in a few minutes. I've included the instructions to add the tag cloud to your application in the Using This Database document. Download the database and dig in to give it a try.

I know there are a lot of improvements that can be made here, but my hope is that this gets the ideas going. I haven't seen an implementation of a tag cloud in the Notes client from the blogsphere yet, but I can't wait to see what you all come up with based on this skeleton. Please let me know and if you'd like, I can share your results here.

*Download the complete Lotusphere Demo

*Download the tag cloud design elements database



Labels: , , ,

permalink | leave a comment

Wednesday, March 25, 2009

Cheap UI Trick: Add Whitespace With Borders

When I'm building a new UI or composing a document to send to an audience, I like simple elements that make a big difference in the final presentation. I thought I'd share a trick that I use to add whitespace to designs when using graphics with wrapping text in Lotus Notes.

If you've not tried it before, first let me point out that you can paste or import an image into a Notes form/document and set the properties of the image so that text can wrap left or right. This is analogous to using floats in CSS on the web.



While this can spice up your formatting quite a bit, in the Notes client the text butts right up against the graphic, so this doesn't look particularity nice. By way of example, the other day, I wanted to send my latest blog post to some internal folks through Notes and I wanted to retain the formatting (as close as possible) to my web entry. Thus, I made use of the text wrap property. This ended up looking like so:



Notice the lack of whitespace around the photos. Here's a close up to show what I mean:



So how do you fix this? Simple really. Most elements have a Border property which can be manipulated. This doesn't necessarily mean you have to have a physical line around your element. A border can be used to emulate padding. If an element has a border, you can also define the space between the inside border and outside border and between the outside border and the elements outside of that. Click the drop down in the border properties box to choose between the border thickness, the inside spacing and outside spacing.

For the purpose of this e-mail, I thought a spacing of 7 looked about right, so my properties box was set accordingly



This quick update produced the following results:



and close up once more



A very subtle effect, but a powerful one. Remember that whitespace is very important for guiding the eye and providing a feeling of space. It's a little thing that people may not be able to articulate if you ask them to point it out, but I guarantee that they'll think the option with good use of whitespace looks better ever ytime. Whether it's really true or not, if it looks better, people will think it is better. When dealing with the UI, often perception is reality. I hope this helps. Cheers!

Labels: ,

permalink | leave a comment

Monday, March 23, 2009

The Inaugural GTD Summit...Did It Change The Way The World Works?

After attending the GTD Global Summit a little over a week ago, my mind is still swirling with all kinds of thoughts. I wanted to write a final post to close things out earlier, but I hit the road to visit customers literally a couple of hours after I arrived back from San Francisco. Now that I've been back for a day, it's time to process my inboxes, update my lists and get some things done. One of the main items was to write this post, so here we go. First, I'll try to distill down some of my notes from the opening keynote, then wrap up with my overall impression of the event.

The conference kicked off on Thursday morning with the opening keynote session, although there was a social mixer the evening before. For those who could make it, it was a great treat. As Eric Mack told me it would be, it was a classy affair. Nothing fancy...just nice. A jazz band played while people mingled and introduced themselves to fellow GTD enthusiasts. There was great food and drink available as well, and the atmosphere was very casual. It was kind of funny to see so many people with capture tools (pen, pad, etc.) in one place, scribbling things down to remember later as people talked about books, other GTD tools, etc. I met more than a couple Lotus Notes customers and people from around the world, which I found exciting. My wife and I met a guy who had come up from Chile while we were in the elevator, and during the evening event, we met folks from Hong Kong, Antigua, Spain and other exotic locales. I think it speaks to the power and efficacy of GTD that even in a tough economic climate, these people felt it was beneficial to come to San Francisco to attend this gathering. The Wednesday evening event set up a promise of a great two days to come.

Thanks to the David Allen Company (and to Eric, of course), I was fortunate enough to attend the GTD Summit as a guest blogger. While I endeavored to live blog the breakout sessions, there was just too much info flying during the keynote to do it justice. I was given a press pass and took advantage of the area they had set aside for us to capture the action.

David is an unassuming, yet compelling speaker. Its interesting that in our society, our expectation of a "celebrity" (and he certainly is in this circle) is one who is standoffish and self important. David spoke with an ease of one having a conversation with the audience rather than presenting to them, which was really refreshing. He also has a great sense of humor. During his opening remarks, David talked about the phenomenon that is GTD. His original book, "Getting Things Done" has been published in 28 languages and has sold close to 2 million copies. There are over 150 software applications to support GTD. It truly is a global phenomenon. He jokingly shared that "Getting Things Done" was published during the dot bomb phase and his new book, "Making It All Work", was introduced at the height of the sub-prime crisis, prompting him to promise "For the right amount of money, I'll guarantee I will never write another book". He also shared stories of groups using GTD in their lives and work. The Simpsons writers, for example, are big advocates of GTD. Many other corporations are evaluating GTD and determining how they can inject it into the organization.

When David started putting together the ideas for this Summit, he generated a list of speakers, panelists and moderators that he wanted to attend. He figured only a small number would commit, but 85% of them said yes to the invitation, all coming to the conference on their own dime. I think that speaks volumes to the respect that this community has for David and his ideas. These speakers are all masters in their field, thought leaders and entrepreneurs. In the end, even with the best systems and best intentions, however, we can all be victims of circumstances beyond our control. David was very candid and chose to share that he had to lay off 40% of his staff recently due to the huge drop in training budgets from companies. I was impressed by the fact that he shared this. It implied a trust with his audience that even amidst all of this trouble, he believes that all of us as practitioners of the GTD methodology are on the right track. In fact, David believes that the tools of GTD are more important than ever now that we are in survival mode. To quote David as he finished his opening remarks, "Now is the time that this is in it's time". Very interesting times indeed...

For the second half of the keynote session, David introduced Guy Kawasaki, serial entrepreneur, venture capitalist and founder of Alltop. David invited Guy to serve as moderator and to interview David for the remainder of the session. They dove right in to a frank and open discussion. It was obvious that nothing was rehearsed ahead of time, which was another refreshing touch you don't see at too many conferences. Of course, this also meant the conversation took some unusual turns and tended to meander a bit, but overall it was a stimulating conversation. I loved how one of Guy's first questions was about Twitter and he asked David if Twitter gets in the way of our productivity. David's reply, which probably comes as no surprise to the GTD crowd, was that Twitter doesn't get in the way at all if Twitter is what you want to be doing. :-) At this point, David commented about the phenomenon of Twitter, how intimidating it is in some ways to be "followed" by 75,000 people (now over 126k!) and that he was fascinated by the number of people who were using Twitter. It was at this moment that he pointed out my blog post in which I was gathering a list of people tweeting at the conference and asked "where's my IBM guy" (which I thought was totally cool). I was sitting at the press table in the back and told him we only had about 30 or so names on the list. He asked the audience who was using Twitter and at least 1/2 the hands went up. It seems we have a way to go to get the GTD community following one another, much like we do in the Lotus community.

Guy and David had a great rapport. Guy is an unnaturally good moderator, combining humor, self-deprecation and fun questions to keep the audience's attention. He had a lot of great soundbites, and I could see during my peeks into the #gtdsummit Twitter stream that people were enjoying capturing them. He ribbed David about not using a Mac, asked if the key to getting things done was not having kids, and suggested that claiming e-mail bankruptcy is perhaps key to being productive! I do think one of the more humorous quotes to come out of the whole conference was when Guy told David, "I don't see how anyone that thinks they are going to get things done uses Windows". After the initial playful banter, Guy settled into some more serious questions. He asked David what he felt was the greatest barrier to GTD. David's replied that it was "addiction to stress". In order to solve this problem, according to David, it is necessary to get your mind clear. By being more aware of the stress, you will be much more interested to alleviate it quickly.

The conversation continued with a few more questions and answers before moving into the second half of the session, the plenary panel. One additional comment was made that I think was worth mentioning before moving on. David noted that he believes small communities have the best chance of having GTD take hold. If we could build this up as a mind swell, we could start to have a big impact. I think this is very true, as I've seen GTD work very well as a grassroots effort and spread by word of mouth. It's my hope we'll start to see these ideas introduced to kids in school. In fact, I'm starting to work with my son this week to give him the GTD basics.

The plenary panel was up next, and this was a special treat. The panelists represented some of the top thinkers in their field and it was a pleasure to listen to each of them. The panel consisted of Maj. Gen. Randal Fullhart, James Fallows, Paul Saffo, and Marshall Goldsmith with moderators David Allen and Guy Kawasaki. Each panelist took a bit of a different approach, talking about various topics from the work they do to a general overview of how they "do" GTD. Of particular interest was Marshall Goldsmith's talk on the idea of peer coaching and the concept of "daily questions". As a way to stay accountable, the two peer coaches ask each other a series of questions every single day. Each question is structured to be answered with only a "Yes" or "No" and is designed this way to make you focus on living your values. I heard more than one attendee express interest in this idea and I expect we'll be hearing more about this from other GTDers in the coming months. (For more information, I found this great document at the Marshal Goldsmith Library.

The remainder of the two days of the GTD summit were filled with some amazing panels. You can find my thoughts from some of these sessions in my earlier blog posts and entries on Twitter. I found it pretty amazing that so many of the attendees were sharing their thoughts in real-time via Twitter. Most were using the #gtdsummit hashtag, so you can go back through and get a feel for how the GTD Summit unfolded through their eyes. The conversations in the hall between events and in the exhibitors hall were all equally stimulating. I hope that we'll see this event repeated in the future and that it will reflect by it's growth the corresponding growing awareness of GTD in the public at large.

Of special interest to me was the fact that I found many people who were surprised to find that David Allen uses Lotus Notes to manage his own GTD system. In fact, he has been using Notes for about 15 years in all aspects of his business. For his GTD implementation, David uses the eProductivity template developed by Eric Mack. I know that based on some of the conversations I had, people who were unaware of Lotus Notes are going to be taking a look at it. I think this is a great opportunity for us in the Lotus community. We have a champion in a well-known figure, a person being followed on Twitter by 126,000 people and counting. It's natural for people to want to use the systems their "heroes" are using (sports stars, musicians, etc.) and the same is true for GTD. On a personal note as an IBMer (but certainly speaking for myself), I hope that IBM/Lotus can figure out a way to team up with David to get the word out about both GTD and Lotus Notes. I think it would be a win-win for both sides.

Another cool aspect of the GTD Summit was the vendor exhibit area. All of the exhibitors there were focused specifically on GTD or personal productivity in some way, shape or form. I was very pleased to see that the eProductivity booth was usually busy. Eric and his daughters Wendy and Amy did a fantastic job demoing the software and I saw many people walk away very impressed by how it all works. Special shout out to my friends at Mindjet...it was great to meet you all in person!

The GTD Summit was all about "Changing the way the world works". I think that it certainly met this promise and started to instigate the change needed to bring this methodology to everyone. It's up to us as attendees to now take it as a next action to propagate these ideas in our circles of influence. In doing so, we'll help keep the spirit of the GTD Summit alive.

Labels: , , , ,

permalink | leave a comment

Monday, March 09, 2009

It's All About The Whole Package...Designing for the User Experience

While the title of this site is Interface Matters (because I thought it had a good double meaning to it and it reflects an area where many Notes applications have issues), I'm really more inclined to think about the entire user experience (UX). Now certainly, the user interface is one important aspect of the user experience, but UX is much more than just what the screens look like and what the user sees. I'm an advocate of taking a holistic approach to the art and science of application design. I want every aspect of the process to be all about the user...making them happy and productive. Let's be honest here. If you are reading this blog, it's most likely because you are a developer in a corporate capacity in some shape or form. And that means that the users don't necessarily choose to use your software. They may request that it be written for them, but not because they are looking to have fun. In many cases, they are unwilling victims that must use it, no matter how bad it is. If that's the case, then I think we have an imperative to make the user experience the best it can possibly be.

I think I'm going to explore this in more detail in subsequent posts, but let's lay the foundation for what user experience is all about. In my definition, the UX is every interaction that a user has with a software application, from beginning to end, cradle to grave. Thus, the user experience encompasses:

- The project request

- The initial meetings with the customer (business/requirements gathering, proposal)

- The design phase (prototyping, usability testing)

- The actual software itself (the deliverable)

- The implementation phase

- Post-implementation (bug reporting, feedback, enhancement requests)

As you can see, using my definition, we're talking about the entire lifecycle of the project. And how you engage and interact with the user at those times when you are not even dealing with code is just as important as when they are sitting in front of the screen. In some cases, those events are even more important. The reason for this is simple. Our brains are great at associating events. If you start out a project on the wrong foot, even the best deliverable in the world might not be able to keep the user from thinking that the application is not that great. I've seen this happen in my own experience. I used to have a co-worker that was quite arrogant and rude. This person thought they had all the answers and subsequently alienated every customer we talked to. While the project this person engaged on was delivered ahead of schedule (and was quite good, I begrudgingly admit), the adoption of the application never took off. After this person left, I inquired as to why when the project was eventually resurrected. It turns out that the people in the department knew there were going to be other phases and more enhancements, but they didn't want to deal with this person! So here you had money spent, people's time invested and an inefficient business process that could have been much better, but people rejected the application because they didn't like working with the developer. That, my friends, is a breakdown in the user experience and it has absolutely nothing to do with bits or bytes.

I know that many traditional application developers claim that they don’t "do UI” almost as a badge of honor. As such, the idea of designing for the User Experience is probably even more foreign to them. However, I think it is vitally important to start to overcome these challenges. This will come about only through an organization making the necessary cultural change. Before app developers can actually start making progress in developing a good user experience for corporate applications, the process needs to support this objective. This means that designing for the UX needs to be injected into the design methodology. Whether they use traditional methods or an agile methodology, thinking about and designing for the user experience needs to be woven throughout the process. When your organization steps up to embrace this idea, it's amazing to see the transformation that takes place.

Have you followed a user-centric approach in your design process? Has it changed how you work? If so, I'd love to hear your story. I plan on sharing some more of my ideas in this space next time.

Labels: ,

permalink | leave a comment

Monday, March 02, 2009

GTD, Lotus Notes & the eProductivity Challenge: The Weekly Review

Webster defines a coach as "one who instructs or trains."

I'm a big fan of coaching. Whether talking about a presentation coach to help hone your skills on the stage, a performance coach to help you better your 5k time or a life coach to get you to focus on your overall goals and objectives, coaching is a fantastic way to help you achieve your potential and then reach for loftier heights. In fact, I'm writing this post right now while waiting for my son to get out of his teen life coaching session. I occasionally work as a technology coach, helping people map out what they want to get out of using technology, then putting a plan together to meet that goal in the most efficient way possible. So right off the bat, I figured I would like the Weekly Review Coach functionality of eProductivity. I was wrong, though...I actually love it!

Ask any GTD fan, new to the system or grizzled veteran, what the biggest obstacle to complete mastery of the GTD concepts is and they'll likely tell you it is the Weekly Review. The Weekly Review is the part of GTD that brings everything into focus, helping you to close open loops, determine what is needed to move your projects forward and keeps you on track toward your higher level life goals. David Allen calls the Weekly Review the "secret sauce" and in my experience that is very true. I've posted before about my GTD journey to this point and the times when I was most on my game and feeling that I was living the vision that Mr. Allen maps out in his book was when I was diligently doing my Weekly Review. But let's be honest...it takes some serious focus to plan out the time to sit down every week to look over what you need to be working on. In fact, in some ways, the Weekly Review exerts a certain force of opposition if you are afraid of what you'll uncover. You need to do this, however, to get full clarity of what you should and shouldn't be working on. Thus, the concept of having a "coach" for helping you get through this process is outstanding.

The Weekly Review Coach in eProductivity is basically an enhanced wizard, walking you through all of the steps necessary for a successful Weekly Review. It's an elegant approach because it allows you to focus on just one thing at a time. This is key since maintaining this focus will drive you toward completion faster and allow you to be more thorough in your work. The coach kept me engaged, targeted and on track. I'll admit that in the past I got distracted chasing an idea or item down a rabbit hole. While this can still happen in any system, I felt more focused because I had the coach to guide me through the review in the correct order.

After launching it, the Weekly Review Coach takes you to the first step in the process: Collect Loose Papers. For each step of the Weekly Review, the coach tells you what you should be doing and gives you suggestions to improve your game. You can see a sample shot from the Weekly Review Coach below.



Steps of the Weekly Review covered in the Wizard include:
  • Collect Loose Items

  • Process Papers

  • Empty Capture Tools

  • Process Email

  • Empty Head

  • Review Action Lists

  • Review Previous Calendar

  • Review Upcoming Calendar

  • Review Tickler Files

  • Review Waiting-for List

  • Review Projects

  • Review Goals & Objectives

  • Review Areas of Focus

  • Review Relevant Checklists

  • Review Reference & Support

  • Review Someday/Maybe List


As you can see, that's quite an exhaustive list of things to do and it's no wonder that it can be daunting to consider performing a weekly review when you have all that staring at you. Of course, the scarier this process seems to you, the more you probably need to be doing it! Once the Weekly Review becomes an ingrained habit, the process goes pretty smoothly. Even so, there's always the temptation to jump ahead and work on something more interesting. When I used the Weekly Review Coach, I found that this temptation wasn't there. Instead, it kept me completely on task, a characteristic of a great coach.

After the first step is complete, you check it off and the coach automatically takes you to the next step. I love the layout of this wizard, along with the graphic representation of what step we're on coupled with the help text. Of particular genius is the way the coach allows you to do all of your work in context. Thus, when it's time to review your action lists or empty your inbox, the appropriate view appears directly below the coaching instructions (see below). I've talked about the effectiveness of this technique in interface design before, so it makes me very happy to see this being implemented in other Notes-based applications. This idea helps the user stay in that focused, flow state, further improving the user's performance of the task at hand.



I did my first weekly review in eProductivity on Sunday night and I was amazed at how fast I went through the process. Granted my system was nice and clean from just migrating all my actions and projects over, but I still credit the Weekly Review Coach with enabling this speedy completion. When you finish walking through every step (where you are even encouraged to work on the higher level stuff...goals, aspirations, etc.), you are presented with a nice summary report of when you started each step, when you ended and your elapsed time. This is a nice touch and will be a good reward and motivation for continuing to stay on top of the Weekly Review process.

You can find some additional information and screenshots of the Weekly Review Coach on the eProductivity site. I encourage you to take a look and consider this as yet another great reason to review eProductivity for your GTD implementation. If I had to use a single word to describe this software, it would probably be "frictionless". By that I mean that it so smoothly supports the GTD methodology, I don't really have to think about the mechanics of getting data into the system or getting the right information out of it. Instead, I can just do my work and be productive.

As it says on the eProductivity site, "Your Weekly Review just got easier". Yes...I'd say it did!

Labels: , ,

permalink | leave a comment