Ben Langhinrichs

Photograph of Ben Langhinrichs

E-mail address - Ben Langhinrichs

Recent posts

Tue 19 May 2020

An unladen user

Thu 7 May 2020

Can we get a huzzah for updated Domino Limits?

Wed 29 Apr 2020

A bigger boat: when in Rome

March, 2020
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
29 30 31

Search the weblog

Genii Weblog

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

Thu 19 Mar 2020, 01:05 PM
Inline JPEG image
Talk is cheap, so as a follow-up on my post, Mind the Gap - A mid-level development manifesto, I wanted to show an example that we are adding to both the Midas LSX (LotusScript) and Exciton Power (Node.js and more).
A major draw of our Midas LSX has always been its simplicity combined with power. Developers just venturing into LotusScript could build fairly complex applications and do high-level tasks in a few lines of code. Now, we are taking that approach even further, and adding more high value methods that meet the needs of mid-level developers, while being powerful enough for pro coders to use as well. All the mid-level value methods from Midas are still in place, and some of those were pretty high value already, but these high value methods encapsulate a set of tasks into a single call mostly driven by data, not code.
Today's example is AppendFieldsWithJSON. This deceptively simply method allows the developer to populate fields on a form in a variety for formats, and allows styling based on a rich set of optional parameters. In the demo below, I start with the form design in the node-demo.nsf sample database from the AppDev Pack 1.3. In that sample, the forms are basic, only really intended to hold data, not to display or edit it. I decided to show how you could dynamically create a form with the same fields (and more) using a simple JSON array of values. The goal is similar to the goal of HCL Volt, but at a level where a mid-level developer can build up a toolkit combining the automatic generation of design with the business logic needed for their individual company. Also, as we'll see in future posts, the resulting form elements can be further manipulated and enhanced with existing mid-level methods.
Through the demo, I show how you can tweak the script to build up to a fancier form, all using the same AppendFieldsWithJSON call. I show how you can easily add additional fields just by adding them to the JSON value. For example, the image at the top includes the simple text fields and one number field from the node-demo.nsf Contact form plus a new computed FullName field.
Because this process is data-driven, you can make a script that follows company guidelines and includes all sorts of common features and styles, but then dynamically create the form fields wherever you like. There will likely be additional demos for this high value method, as it can actually do much more than I show here.

Copyright 2020 Genii Software Ltd.


Thu 19 Mar 2020, 10:06 AM
Inline JPEG image
Low-Code and Pro-Code Advances
HCL has done a great job building up the infrastructure for Domino 11, and has made good progress toward a micro-services architecture, basic Node.js support, and other goodies for pro coders. Simultaneously, they've been adding value for low coders/citizen developers with HCL Volt. But as they have acknowledged many times, there is too much of a gap between the two. It is difficult to make the leap from citizen developer to pro coder. If anything, the gap is widening, and HCL doesn't seem to have particularly good answers for how to fill that gap. They have plans, but not the grand vision required.
The need is great and urgent
This is a problem. As governments and companies grapple with the increasingly long-term implications of the COVID-19 pandemic on their need for running distributed enterprises, they will need developers who are closer to the business end than the tech end, or the very mid-level developers who are left out or marginalized by recent app dev efforts. There is no time to waste, and plenty of other companies trying to meet the needs with solutions and technologies no where near as mature or complete as Domino.
Defining what is needed
We need APIs and technologies to bridge the gap. They need to be powerful, yet simple. They need to be intuitive enough that somebody who didn't study software in college can pick it up, but still flexible enough that somebody who did study software in college can use it. We need APIs that focus on Domino-specific functionality, not simply general web or business tech. We need APIs that allow dynamic design, rapid evolution, and a pathway from day one to forever.
The Domino development future isn't built around LotusScript and formula language anymore, but a vast amount of LotusScript is still out there. So, we need APIs that bridge the gaps between LotusScript and formula language and the more widely accepted languages, JavaScript, Java, Python, TypeScript, Go, and so forth. We need APIs that allow mid-level and pro-coders to tap into the vast libraries of modules in NPM and Apache Maven and others. We need APIs that allow mid-level and pro-code developers to take results and logic from these shared modules and libraries and use them inside Notes/Domino quickly and completely. We need APIs that allow quick and seamless integration with other software packages and platforms. While the AppDev Pack is a good starting point, it deals with Domino as if it is nothing more than a data store, when it is really a design and application store. We need APIs that recognize those features and use them effectively, inside and outside of Domino. We need APIs that work on any device, that allow both server and client-side logic, and all within a secure framework.
If HCL doesn't meet the need, we must
The world is in chaos and will be for a long time. For the sake of our customers, our companies, and ourselves, we need to make this work. At Genii Software, we have a long history of building for the mid-level developer, and helping the citizen developer become a mid-level developer, and eventually a pro-coder. We cannot and will not wait to see if HCL can meet this need all by itself. Keeping businesses intact, functioning and moving forward is our primary goal, and Notes/Domino is the best platform for accomplishing that, but only if we can tap into its strengths. Creative, new applications built around collaboration and distributed, secure enterprises are needed now, today, perhaps even yesterday. Of course, Genii Software isn't the only ISV developing solutions in this area. If you are aware of others, please mention them in the comments so people know. Let's do this! 
Update: Watch a demo of one of the API methods we are trying out in my new post: High value methods: AppendFieldsWithJSON.

Copyright 2020 Genii Software Ltd.