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: