Notes and Domino Buzz Kit

In case if you have not seen this, have a look at the below link for the large collection of links to videos, demos and community websites around the Notes/Domino marketplace.
Have a look at all the TABS {Welcome, Market Buzz, Resources...}
its really a good resource for education on Notes and Domino.

My IBM Lotus Notes and Domino Buzz Kit <http://www.netvibes.com/tcoustenoble> {http://www2.netvibes.com/tcoustenoble#Developing_extensions <http://www2.netvibes.com/tcoustenoble>}


Also have a look at the

1.) LotusPlanet <http://planetlotus.org/> {<http://planetlotus.org/>}

2.) developerWorks e-kits <http://www-128.ibm.com/developerworks/offers/ekits/?S_TACT=105AGY01&S_CMP=BLOG> : its give you a collection of tutorials, articles, webcasts, podcasts, and demos about a particular product, task, or role.
{ http://www-128.ibm.com/developerworks/offers/ekits/?S_TACT=105AGY01&S_CMP=BLOG#lotus <http://www-128.ibm.com/developerworks/offers/ekits/?S_TACT=105AGY01&S_CMP=BLOG> }

Thanks,
Abhijit.

In Place Merge Sort

According to Wikipedia InPlaceMergeSort is a pretty fast sorting algorithm (O(n log n) on average, O(n log n) worst case and O(1) memory usage.) Sub InPlaceMergeSort(vArray As Variant, nLow0 As Integer, nHigh0 As Integer)

Dim nLow As Integer
Dim nHigh As Integer
Dim nMid As Integer
Dim nEndLow As Integer
Dim nStartHigh As Integer
Dim vTemp As Variant
Dim nCount As Integer nLow = nLow0
nHigh = nHigh0
If nLow >= nHigh Then
Exit Sub
End If nMid = (nLow + nHigh) \ 2 Call InPlaceMergeSort(vArray, nLow, nMid)
Call InPlaceMergeSort(vArray, nMid + 1, nHigh) nEndLow = nMid
nStartHigh = nMid + 1 While nLow <= nEndLow And nStartHigh <= nHigh
If vArray(nLow) < vArray(nStartHigh) Then
nLow = nLow + 1
Else
vTemp = vArray(nStartHigh)
For nCount = nStartHigh -1 To nLow Step -1
vArray(nCount + 1) = vArray(nCount)
Next
vArray(nLow) = vTemp
nLow = nLow + 1
nEndLow = nEndLow + 1
nStartHigh = nStartHigh + 1
End If
Wend
End Sub Sub sort(vArray As Variant)
Call InPlaceMergeSort(vArray, Lbound(vArray), Ubound(vArray))
End Sub

Profiling agents and Web services

Today I came to know about new very interesting and helpful Designer-7 feature. i.e. "Profiling agents and Web services".

By using profile document developers can know total execution time taken by the agent in milliseconds. Here is how to profile an agent -
1. To enable profiling in an agent or Web service, select the Security tab of the properties box and check "Profile this agent" or "Profile this web service."
2. Run your agent

To view profile document results of latest run-
1. Select the agent and choose Agent - View Profile Results, or select the Web service and choose Design - View Profile Results.

Screen shot for profile document results is shown below:

For more information on the same please have a look at Designer Help Document.

Thing Two of Three about @Dbfunctions

Yesterday I talked about reasons to use a separate, hidden view for @DbColumn and @DbLookup. But if you choose to risk the wrath of harkpabst, and use a single view (without re-sorts!) for both users and lookups, can you at least mitigate the adverse effect on maintainability?

There is one thing you can do. For @DbLookup, for the argument that specifies what column to get the results from, you can code either a column number, or a name. For instance, if column 5 displays the field DateDue, you could write either:

@DbLookup(""; ""; "lkByKey"; Key; 5)

or

@DbLookup(""; ""; "lkByKey"; Key; "DateDue")

and the result is the same. (For @DbColumn, you must use a column number. Too bad.)

You might have been taught that it's more efficient to use the column number because the value is read directly from the view index, whereas using a fieldname requires accessing the document, which is slower. This is only approximately true. The Designer help actually says, "Lookups based on view columns are more efficient than those based on fields not included in the view." Because DueDate is included in the view -- there's a column that displays that exact value -- the two formulas above are equally efficient. There may be some tiny difference between them, but very small compared to the extra time it takes to "crack open" the document note to read an item value that's not in a column, and I'm not actually even sure which is faster.

So, all right; that's nice. If the above two formulas are equally fast, there are two good reasons to use the second one.

• It's more readable.
• It's more maintainable because it won't break if you edit the view design and rearrange the columns. Even if you delete the column, the lookup will still work. It just won't be as fast.

But wait! There's more! By successive approximations, we come ever closer to the truth. In fact, when you specify a name argument to @DbLookup, it's not a fieldname. It's really the column name. Only if there are no columns with the specified name, does the lookup code open the document note to look for items with that name.

"What!" (you might be saying to yourself) "Columns have names? Does he mean the column title?"

No. I'm referring to the column "programmatic name" which appears on the Advanced tab of the column properties. If the column just refers to a field, it's automatically assigned a programmatic name which is the name of the field. That's why "DueDate" works in the above formula. You're not referring to the field named DueDate in that formula; you're referring to the column by that name. If you write a formula in the column instead of selecting a field, the column is assigned a unique programmatic name of the form $n where n is a number, but you can change it if you like.

Now here's a key point: you can use the column name to specify the data column for your lookup. So if you know a column is called "$4", you can write:

@DbLookup(""; ""; "lkByKey"; Key; "$4")

instead of using the column number. Once again it's just as efficient, but less likely to break when someone edits the view design.

Of course, $4 is not a very descriptive name to appear in your formula. If you want to use the column for lookups, I suggest entering a better name in the column properties.

One other fun thing you can do with column names (if you share my ideas of fun), is use them in the formulas of other columns. This is occasionally useful in avoiding a repetition of some complex calculation.

Notes Domino 8 LotusScript courses

The Learning Continuum Company (TLCC) has released three new distance learning LotusScript courses for Notes Domino 8. There is no need to travel with TLCC's self-paced courses that will take a new LotusScript programmer from a beginner to an expert in two weeks. There are many demonstrations and activities to give you the hands-on experience you need to become an expert. An expert TLCC instructor can provide assistance via the course discussion database. Taking all three LotusScript courses will prepare the student to take the certification exam 803: Using LotusScript in IBM Lotus Notes Domino 8 Applications.

The three new courses are Beginner LotusScript for Notes Domino 8, Intermediate LotusScript for Notes Domino 8, and Advanced LotusScript for Notes Domino 8. All three courses may be purchased individually. Another option is TLCC's Notes Domino 8 LotusScript Package, which includes all three courses. TLCC is having an introduction sale on the Notes Domino 8 LotusScript Package. Developers can save $800 compared to purchasing the courses separately if the package is purchased by April 15th.

Quick way to populate drop down for calendar Years

range := (-1) : 0 : 1 : 2 : 3;
thisYear := @Year(@Today);
thisYear + range
Although, this works in web, I find that Notes Client needs this list as "Text" !, so we the last line changed to:
@Text(thisYear + range)

Result:
2007
2008
2009
2010
2011

The History of Notes and Domino

The History of Notes and Domino

Notes and Domino began in the work of Ray Ozzie, Tim Halvorsen, and Len Kawell, first on PLATO Notes at the University of Illinois and later on DECNotes. Lotus founder Mitch Kapor saw the potential in Ozzie's collaboration project and the rest is history.

As you might expect of such complex and successful software, IBM Lotus Notes and Domino share a long and rich history. In some respects, this history mirrors the evolution of the computing industry itself -- the development and widespread adoption of PCs, networks, graphical user interfaces, communication and collaboration software, and the Web. Lotus Notes and Domino have been there nearly every step of the way, influencing (and being influenced by) all these critical developments.

This article briefly retraces the history of Lotus Notes and Domino, starting with the earliest conceptual and development stages and continuing through major feature releases. Along the way, it examines:
Where the idea of Notes originated
Notes pre-release development

Release 1.0
Release 2.0
Release 3.0
Release 4.0 and 4.5
Release 5.0
Release 6 and 6.5
Release 7
Release 8

The early days: The birth of an idea

You may find this a little surprising, but the original concept that eventually led to the Notes client and Domino server actually pre-dates the commercial development of the personal computer by nearly a decade. Lotus Notes and Domino find their roots in some of the first computer programs written at the Computer-based Education Research Laboratory (CERL) at the University of Illinois. In 1973, CERL released a product called PLATO Notes. At that time, the sole function of PLATO Notes was to tag a bug report with the user's ID and the date and to make the file secure so that other users couldn't delete it. The system staff could then respond to the problem report at the bottom of the screen. This kind of secure communication between users was the basis of PLATO Notes. In 1976, PLATO Group Notes was released. Group Notes took the original concept of PLATO Notes and expanded on it by allowing users to:

• Create private notes files organized by subject
• Create access lists
• Read all notes and responses written since a certain date
• Create anonymous notes
• Create director message flags
• Mark comments in a document
• Link notes files with other PLATO systems
• Use multiplayer games

PLATO Group Notes became popular and remained so into the 1980s. However, after the introduction of the IBM PC and MS-DOS by Microsoft in 1982, the mainframe-based architecture of PLATO became less cost-effective. Group Notes began to metamorphose into many other "notes type" software products.
Share this...

Ray Ozzie, Tim Halvorsen, and Len Kawell worked on the PLATO system at CERL in the late 1970s. All were impressed with its real-time communication. Halvorsen and Kawell later took what they learned at CERL and created a PLATO Notes-like product at Digital Equipment Corporation.

At the same time, Ray Ozzie worked independently on a proposal for developing a PC-based Notes product. At first, he was unable to obtain funding for his idea. However, Mitch Kapor, founder of Lotus Development Corporation, saw potential in Ozzie'