This concludes my posts for this year and see you all in next one.

Now to what every geek likes. Statistics. But not more than just enough to wet your nose.

In past year, more than 3300 of you decided to read what was posted here. And some of you even returned for more. Way above my expectations, to be quite honest. Most of you were from USA (1.2K), followed by UK, Germany, Slovenia and India.

FireFox was most used browser (51%), even thought some of you used IE (38%). Which is a bit different from world stats. Not that I mind.

Most read articles would be (in order of views): Exporting form into DXL, Microsoft Expression Superview Beta, Design patterns series and a rant about Notes rendering engine. Most surprising is high placement of Microsoft thingy and on blog that focuses on Lotus technology. The fact that DXL is still such a popular topic is not that surprising, as documentation and Notes help are still too vague about that. Thankfully now, there are examples included. When I started using DXL for exporting documents to Wiki and Atom format, that was still not the case.

Unfortunately, my work orientation is lately changing to technologies not connected to Lotus. I do hope I will be able to keep up in the future.

Now, I need to get back to work. Then, later today, a decent meal and couple pints of beer. Hopefully.

Not a good idea. I don’t know, when was the last time, someone at IBM took a look at their rendering engine, but this just isn’t it. Unordered lists don’t close, leading to a total mess of your layout. On numerous occasions, a div tag marked as pass through text got put to the bottom of contents and not at the spot where it was in the body field, leading to some more confusion. And what killed it for me was a sudden br tag flood in the HTML for no apparent reason. All 6 of them were gone when text was put in the same line as pass through text and appeared right after I put the text back in new line. And all of this appeared randomly, which amused me for a while.

So, I guess it is no wonder, why there are so many CMS application in Notes, where content needs to be entered as HTML. However, in my experience, you as a developer or admin of such system can be glad if a content editor knows how to use Lotus Notes.

Mediator pattern provides a unified interface to set of interfaces in a subsystem.

Or, to simplify… Mediator pattern is mediator for communication between several classes.

Example

Now, the easiest way to explain this pattern is via example. Example itself is borrowed from dofactory page, but modified to fit LotusScript. It is about a simple support chat room. This chat room has several users of two types: admins and customers. I will call them participants. These participants can communicate amongst each other, presuming, they know user ids.

First, we need a chatroom template class, as we might end up with more than one chat room. Chat room will need to register participants and to be able to deliver messages to them.

Class CChatroomTemplate
   Sub Register (participant As CParticipant)
   End Sub

   Sub Send (strFrom As String, strTo As String, strMsg As String)
   End Sub
End Class

As participants need instance of chatroom class and chatroom needs list of participant class instances, we need to create chatroom and participant class frameworks and only then put code into it. Participants need to be able to send and receive messages. Finished classes are displayed below.

Class CSupportChat As CChatroomTemplate
   m_LMembers List As CParticipant

   Sub Register(participant As CParticipant)
      If (Not Iselement (m_LMembers (participant.UserId))) Then
         Set m_LMembers (participant.UserId) = participant
      End If
      Set participant.Chatroom = Me
   End Sub

   Sub Send (strFrom As String, strTo As String, strMsg As String)
      Dim participant As CParticipant

      If (Not Iselement (m_LMembers (strTo))) Then Exit Sub
      Set participant = m_LMembers (strTo)
      Call participant.Receive (strFrom, strMsg)
   End Sub
End Class

Class CParticipant
   m_chatroom As CSupportChat
   m_strUserId As String

   Property Set Chatroom As CSupportChat
      Set m_chatroom = Chatroom
   End Property

   Property Get UserId As String
      UserId = m_strUserId
   End Property

   Property Set UserId As String
      m_strUserId = UserId
   End Property

   Sub new (strUserId As String)
      m_strUserId = strUserId
   End Sub

   Sub Send (strTo As String, strMsg As String)
      Call m_chatroom.Send (m_strUserId, strTo, strMsg)
   End Sub

   Sub Receive (strFrom As String, strMsg As String)
      Messagebox strFrom & " to " & m_strUserId & ": " & strMsg
   End Sub
End Class

Now that base classes are set, it is time to create real participant classes. In our case, we need one for admins and one for regular users.

Class CAdmin As CParticipant
   Sub new (strUserId As String)
   End Sub

   Sub Receive (strFrom As String, strMsg As String)
      Messagebox "Admin message"
      Call CParticipant..Receive (strFrom, strMsg)
   End Sub
End Class

Class CUser As CParticipant
   Sub new (strUserId As String)
   End Sub

   Sub Receive (strFrom As String, strMsg As String)
      Messagebox "User message"
      Call CParticipant..Receive (strFrom, strMsg)
   End Sub
End Class

Testing the code

For testing purposes, I put it all in agent, created four users (of which one is admin) and sent 3 messages to admin and admin responded to first one. The code is below.

Sub Initialize
   Dim chatroom As CSupportChat
   Dim user1 As CParticipant
   Dim user2 As CParticipant
   Dim user3 As CParticipant
   Dim user4 As CParticipant

   Set chatroom = New CSupportChat()
   Set user1 = New CUser ("User 1")
   Set user2 = New CUser ("User 2")
   Set user3 = New CUser ("User 3")
   Set user4 = New CAdmin ("Admin 1")

   Call chatroom.Register (user1)
   Call chatroom.Register (user2)
   Call chatroom.Register (user3)
   Call chatroom.Register (user4)

   Call user1.Send ("Admin 1", "Help?")
   Call user4.Send ("User 1", "What's wrong?")
   Call user2.Send ("Admin 1", "My server just crashed!!!")
   Call user3.Send ("Admin 1", "Network died!")
End Sub

• some sort of IDE with a compiler
• version control
• and bug tracking.

Usually you get stuck with IDE with a compiler. Everything else is up to you. But how are things in Lotus Notes?

Version control

As expected Lotus Designer doesn’t have an integrated version control software. Not yet anyway. They are planing to build subclipse to work in new 8.5 designer, but that still needs some time. Also most people are probably still stuck at R7.

Well, one of the things you could use is Teamstudio Ciao!. This is a payed software meaning that either it becomes your department policy to use it or you will never use it. I had a chance of working with Ciao and I have to say that I was less than impressed. But that is just me. I know a lot of people using it without any drawbacks and with lack of tools out there, this is probably the way to go.

Next widely used option is to use separate templates for each and every version of your application. There are two things wrong with this. One is that there is no way any developer would do a new template just for fixing one single agent. Second one is that I am yet to see a consistent template policy.

Another possibility is to copy your database locally and then import it into Subversion (SVN) or perhaps write a script that would periodically do that for you. The thing is that you won’t be able to just revert to desired version of the database without deleting the existing one. There is one other option. You could export objects (agents, views etc.) as DXL, import it into SVN and then when needed import DXL back to the database. However, DXL is not 100% representation of design elements. Thus I wouldn’t recommend it.

As mentioned there is a subclipse project that would enable subclipse in Domino Designer 8.5. Subclipse is Eclipse plug-in for Subversion. And since Domino Designer 8.5 is built on Eclipse framework, this would finally solve most of our version control issues.

Bug Tracking

Why bug tracking? Well, I am yet to see software without bugs. And the thing that helps the most is some sort of bug tracking engine. However, oddly enough, this is the part rarely seen and used. Typical bug tracking process should go like this:

• someone reports a bug
• developer is assigned to the bug
• developer fixes the bug
• third person (inside a company and related to project the bug was reported for) tests the fixed code
• bug report is completed.

Now, show of hands. How many of you have this process implemented in your development cycle? I thought so. But being a Notes developer, what are your options?

There is a great open source project at openntf.org called BugTracker. Another option is to use some commercial product like Trackersuit Help Desk Software or similar.

If you are not attached to domino apps only, there are tons of open source applications for bug tracking. Probably most known amongst them are Mantis BugTracker and Bugzilla.

The most inappropriate systems for bug tracking I have seen thus far are internal forum and wiki. These applications are not meant to be bug trackers. So, please, don’t use them as such.

Oh, and you have probably noticed, there won’t be an article this week .