Ben Langhinrichs

Photograph of Ben Langhinrichs

E-mail address - Ben Langhinrichs






February, 2021
SMTWTFS
 01 02 03 04 05 06
07 08 09 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28

Search the weblog





























Genii Weblog


Civility in critiquing the ideas of others is no vice. Rudeness in defending your own ideas is no virtue.


Fri 19 Feb 2021, 11:44 AM
Yesterday, I wrote a post called Getting the point(s) across with Domino, O365, and Outlook365, but while it is fascinating, it also related to Notes/Domino email which may be a distant memory for some companies. But last night, it occurred to me to try a similar test with Domino mobile and web development, surely a more pressing issue for many companies today who are upgrading Domino applications. I decided to make one change to the content first, which was to make the lists ordered rather than bullets, as it is easier to tell the levels apart.
 
Note: Before I start, I want to acknowledge that part way through writing this post, I started doubting myself, as I was sure nested lists couldn't be this bad. I realized that there are two ways to create nested lists in Notes, and while they may look identical, one renders more reliably than the other. The basic difference is how you create the indents for the list. Suffice it to say, you have no easy way of knowing which technique was chosen, so the rendering can only be considered unreliable.
 
I decided to start with classic Domino web development and move forward in time. I would have included the new AppDev stuff, but it doesn't really render rich text at all. Go figure. Anyway, let's first look at how this looks in the Notes client, and then how it looks retrieved by our Exciton Boost REST API, just to see what it should look like. In each case, take note of what Roman numeral is displayed for C is for Cantaloupe. In the Notes client, it was III.
 
Created in Notes 11.0.1 client
 
Inline JPEG image
 
 
Displayed by Genii Software's Exciton Boost 4.6.1
 
Inline JPEG image
 
 
Displayed by Domino 11.0.1 HTTP (Classic web design)
 
Inline JPEG image
 
 
Displayed by Domino 11.0.1 XPages
 
Inline JPEG image
 
 
Retrieved by Domino 11.0.1 Domino Access Services (retrieved as HTML with ?multipart=false)
 
Inline JPEG image
 
 
Retrieved by Domino 11.0.1 Domino Access Services (retrieved as MIME)
 
Inline JPEG image
 
 
 
Explanation of the two ways to create nested lists
 
Modern method: The current common way to created a nested list is to use either the Indent and Outdent toolbar icons or F8 and Shift-F8 to do the same thing. This will shift both the left margin and first line left margin. See the two middle icons below with the little arrows.
Inline JPEG image
 
But these were not always there as options, and an earlier way to create nested lists was to change margins via the ruler.
 
Older method: The older way to created a nested list was to use the ruler and change the margins. Older rich text, or text created by long time users, may be more likely to have nested lists created this way. If you look at the ruler below, this is the indentation for Granny Smith. Note that only the top margin (the first line) is indented. In Notes rich text, that first line margin is what determines a "new indentation", which is why the ordered lists start over. But for some reason, the different engines that drive Domino don't seem to recognize that simple fact, and treat the nested list as a single list, albeit with different list types.
 
Inline JPEG image
 
 
--> Request an Exciton Boost evaluation license today and give it a try. <--
 

Copyright 2021 Genii Software Ltd.

Tags:

Thu 18 Feb 2021, 03:11 PM
When running some tests for a couple of prospective CoexLinks Fidelity customers, I was reminded again of two things.
 
One: Domino email doesn't always render well without help (i.e., CoexLinks Fidelity)
 
Two: Outlook 365 is a weird beast, not matter how much people might want it to be a successor to Notes/Domino.
 
Let's take the following email, written in Notes. 
 
Sent from Notes 11.0.1 client
 
While nested bullet points like this may not be elegant, they are reasonably common in office emails, and were back in 1989 when Lotus Notes 1.0 was released. Notes 1.0 supported nested bullet lists.
 
Inline PNG image
 
 
 
Received in Outlook 365 web client (after rendering by Domino)
 
One of the fundamental ideas of nested bullet points is in that first word, "nested", but sadly, the point has been lost due to the Domino rendering. But worse is yet to come.
 
Inline PNG image
 
 
 
Received in Outlook 365 desktop client (same email)
 
Having already lost the first fundamental idea of nested bullet points, Outlook manages to screw up the second, as in that second word, "bullet". The bullets are mysteriously missing from the email. Absent nesting, indentation, and bullets, the combination of Domino 11 and Outlook 365 has taken this commonplace corporate staple and completely missed the point(s).
 
Inline PNG image
 
 
 
Received in Outlook 365 web client (after rendering by Domino with CoexLinks Fidelity)
 
Fortunately, all is not lost even if you use the unholy combo of Domino and Outlook 365. You just need to add CoexLinks Fidelity to the mix, and badda-bing badda-bang, things get rendered right and displayed right in Office 365 on the web.
 
Inline PNG image
 
 
 
Received in Outlook 365 desktop client (same email)
 
... and, of course, in Outlook 365 desktop client. I hope this gets the point(s) across.
 
Inline PNG image
 
If your company uses Notes mail/Verse, even if it just uses them to pass on programmatic emails to Outlook 365 (or Gmail or whatever), CoexLinks Fidelity fixes the problems that both Domino and Exchange have with email. It's that simple. Use the form below to send yourself a few sample emails and see what I mean. (Email address will not be sold or shared or used for anything but a single follow up to offer an evaluation license.)
 

 

Copyright 2021 Genii Software Ltd.

Tags:

Mon 15 Feb 2021, 02:42 PM
Inline JPEG image
 
 
Exciton Boost 4.6.3 was released on our website today. You can find the full release notes online.
 
There are a number of interesting changes in this release, including shortcuts to making more efficient remote procedure calls. You can request an evaluation license today and give it a try, and existing customers can download it as it will work with your current license.

Copyright 2021 Genii Software Ltd.

Tags:

Mon 1 Feb 2021, 05:11 PM
Inline PNG image
 
After a delay due to various projects and a product release, I wanted to get back to the demo I described in REST plus RPC: Do the demo backward.
 
If you remember, I showed how to get the data from the view in REST plus RPC: the right data in the right format, and no more. While it would be possible to pull all the data at one time with this demo, it often would not be if there were many more orders or more textual content. Therefore, looking at the basic JavaScript I wrote about in REST plus RPC: building the JavaScript  for RPC, we should assume we might have multiple batches, one for each page of content. By default, that means 20 orders per batch. Since the image above shows that 312 orders are there to be processed, that would be sixteen calls. A developer knowing the data to be returned and the processing to be done might decide to do this in fewer calls or more calls, and thus adjust the page size accordingly.
 
The JSON-RPC commands all have a particular format with a method required and parameters and return id used as needed. But when the fetch is done, the body of the request is always a single, simple JSON string. So, one of the choices to be made that will vary by project is whether to build up the objects as JavaScript objects and use stringify to create the JSON string, or whether to build the JSON string directly. Sometimes one works better, sometimes the other. To show what I mean, look at the JavaScript object for the rtc.appendTable method that creates the outer tabbed table along with its first tab set to the specified state. We could create all the tabs at once, but we don't know which states are represented, so we need to do them one by one. 
 
var tbl = {
           jsonrpc: "2.0", 
           method:  "rtc.appendTable", 
           params:  [1, 
                     1, 
                     "TableWidth=FIT_TO_WINDOW RowDisplay=TABBED TableColorStyle=ALTERNATING_ROWS TableColor=RGB255,191,191 TableBodyColor=RGB127,255,255"
                    ]
          };
 
This is a template, but in order to set the actual tab of the first state as we create the table, we would modify the object to add an additional parameter for the first "column", which is also the first tab of a tabbed table:
 
tbl.params.push("Text='' TabLabel='"+ o.State + "'");
 
After we do this, the object looks like this:
 
var tbl = {
           jsonrpc: "2.0", 
           method:  "rtc.appendTable", 
           params:  [1, 
                     1, 
                     "TableWidth=FIT_TO_WINDOW RowDisplay=TABBED TableColorStyle=ALTERNATING_ROWS TableColor=RGB255,191,191 TableBodyColor=RGB127,255,255",
                     "Text='' TabLabel='AL'"
                    ]
          };
 
If you want to use templates for the calls, they can just be constants, but here is where the downside comes in. In order to use the templates, you have to do a deep copy using either a utility library like lodash, or some clunky code such as:
 
var rowTmpl = {
               jsonrpc: "2.0", 
               method:  "rtc.appendRow", 
               params:  [false, 1]
              };
 
var appendRow = JSON.parse(JSON.stringify(rowTmpl));
appendRow.params.push("Text='' TabLabel='"+ o.State + "'");
 
batchActions.push(appendRow);
batch = JSON.stringify(batchActions);
 
 
It works, but is inelegant at best, and also does a lot of work given that you are converting the eventual object to JSON anyway. So, an alternative would be to built the template as JSON to start with:
 
const rowTmplStart = "{\"jsonrpc\":"2.0", \"method\":\"rtc.appendRow\", \"params\":[false, 1, ";]
const rowTmplEnd = "]}";
 
var appendRow = rowTmplStart+"\"Text='' TabLabel='\""+ o.State + "'\"" + rowTmplEnd;
batch += appendRow;
 
For this demo, I think we are better off using the JSON string, but I wanted to be clear what I was doing, as it is a little less obvious than building an array of objects and stringifying them. Now, we just have to put it all together. I hope to work on that tonight.
 

Copyright 2021 Genii Software Ltd.

Tags:

Thu 28 Jan 2021, 12:58 PM
Inline PNG image
Today, Genii Software releases version 4.60 of CoexLinks Migrate, our premier mail migration tool for Domino email databases and archives. Along with a wrap up of various fixes for specialized rendering situations required by individual customers, this version features better control of email layout regions, multibyte character sets in group names, and a performance gain of approximately 20% over the previous version.
 
You only get once change to migrate your data. Do it right.
 
Request an evaluation license today, and see for yourself.
 

Copyright 2021 Genii Software Ltd.

Tags:

Mon 25 Jan 2021, 11:28 AM
Inline JPEG image
 
Continuing on from last week's post, we are looking at better ways to retrieve data based on two factors:
 
1) How much data do you need from any given record, and which records do you need it from? If there is related data in another record, can you get it without pulling in loads of stuff you don't need? 
 
2) What format should the data be in? How should it be structured or grouped for maximum usability? While you can certainly write code in your application to reformat or restructure, that adds complexity and room for error on your client.
 
Again using Exciton Boost 4.6 with the Curb Appeal database, we'll examine a couple of additional Fancy Tricks (aka "useful features").
 
 
Fancy trick 3: - Saving preliminary values
This may not sound so fancy, but sometimes the value you want is the result of multiple operations. Rather than passing back all the pieces and doing the processing on the client, which might require multiple requests, we can save the results of a formula or rich text operation into a temporary field, and then use those temporary fields to create the result.
 
On Friday, I posed a challenge called Sorted lists of bullets. In the real estate listings in Curb Appeal, there are usually two, occasionally, three columns of bullet items under the Features heading. These are rich text fields, but all we really care about are the text values for each bullet. In our second Fancy Trick from the first post, I talked about using rich text items as a data source.
 
Inline JPEG image
 
Using that trick, we could get the list of bullets from each of the three rich text fields, Col1, Col2, and Col3. (Imaginative naming, eh?) For this fairly simple example, we could return all three lists as separate arrays, then merge the arrays, then sort, all using JavaScript or whatever language. The item list to retrieve these would look something like this:
 
Col1[BulletList *;$UnformattedText]{A}=bullets1,Col2[BulletList *;$UnformattedText]{A}=bullets2,Col3[BulletList *;$UnformattedText]{A}=bullets3 
 
This would produce three arrays named bullets1, bullets2, and bullets3. But this is where the Fancy Trick comes in. By changing the type string in curly braces from {A} to {AP},  with the P meaning Preliminary, none of the three arrays would appear in the result. Instead, a multi-value temporary text list item would be be added. It uses the name preceded by two dollar signs, e.g., $$bullets1 plus a period plus the chunk property, so the field $$bullets1.UnformattedText is now a Notes text list.
 
Col1[BulletList *;$UnformattedText]{AP}=bullets1,Col2[BulletList *;$UnformattedText]{AP}=bullets2,Col3[BulletList *;$UnformattedText]{AP}=bullets3 
 
As a final step, we can use formula language now that we have simple text list fields, so we add an additional item as 
 
@Sort($$bullets1.UnformattedText:$$bullets2.UnformattedText:$$bullets3.UnformattedText){A}=bulletsSorted 
 
The three text lists get appended together then sorted with @Sort, and the result is a sorted list bullet values returned as bulletsSorted. Since we can use all of Notes formula language, we could done @ReplaceSubstring or @Unique or whatever. The client app simply gets the data it needs in the form and format it needs them.
 
Imagine the following code. Can you see what it would do, and how you might be able to use it while building a web page result?
 
Body[Graphic *;%GraphicWidth]{AP}=widths,@Max($$widths.GraphicWidth)=maxWidth
 
 
Fancy trick 4: - Retrieving related data from other documents and databases
Anyone who has worked with Notes for a while will know that a view cannot do @DbLookups to get related information. If an item number is used but the item name, description, and price are in another database, you can do @DbLookups to retrieve them from inside a document but not from a view. In a typical REST API, you might do one request to get this document's information and then other calls to retrieve related information, but Exciton Boost allows you to use formulas, so you can retrieve related information in your first request. Rather than retrieving lots of data and dealing with it on the client, this also allows highly efficient view operations and caching to empower these lookups. As a simple example from our Curb Appeal database, we could use the following to display the average price of all houses in the current city.
 
City+", "+State{P}=key,@DbLookup("";"";"Listings\\by Location";$$key;2){P}=prices,@Text(@Sum($$prices)/@Elements($$prices);"C")=avg 
 
so, for a listing in Beachwood, OH, you would get
 
{
    "@unid""524C08BF648BE77A85257B8600798F5B",
    "avg""$460628.57"
}
 
Note that I used the previous Fancy Trick twice to save the key and then save the results of the lookup. Also note, when the values do not come from chunk properties but rather from formulas or items, the name is simply preceded by the two dollar signs. This process is very similar to saving variables in any language, but especially in cases where many data points are involved, it saves considerable time and bandwidth.
 
=> Request a free Exciton Boost eval in January, and if you later purchase a license. we'll add in four hours of development assistance, a $700 value. <=
 
If you have found these tricks interesting or intriguing, let me know and I can show more that relate to other parts of the REST API or remote procedure calls.
 

Copyright 2021 Genii Software Ltd.

Tags: