Time Analysis of Electron Cost

We've spent considerable time making sure that the MEME application can be served from the Electron binary. At the start of this project, the Electron community promised ready-made easy-to-deploy frameworks that we thought might be easy to use to make double-clickable server apps that did not require developer expertise to run.

While I still believe that is possible, the cost of Electron has been much higher over time than I originally thought.

Development Cost

Here's how much time I've spent on Electron-related activities as of October 23, 2019. See timesheet excerpt for source data.

• 86 hours total
• subtotal 30 hours for Electron engineering and configuration for our build process
• subtotal 32 hours for Electron dictating use of Webpack (with subsequent reorganization)
• subtotal 24 hours for Apple-related codesigning and notarization activity (ongoing)

Challenges

In general, all these systems are not well documented beyond simple use cases. It takes significant trial and error to work out the systems. Here's what we faced:

• The typical Electron app framework demo is quite a bit simpler than our NodeJS app. It took a while to realize that the "easy" approaches would not work for our application, which is a SERVER as well as several clients.
• Adding Electron as a deployment host created three additional configurations that had to work seamlessly together. This took significant time to get working smoothly will retaining "quality of life" features like hot module reloading.
• To support four different configurations, we needed to have a Webpack configuration that worked also for the two additional codebases added by Electron-renderer and Electron-console in addition to our Node server and client webapp. That we needed to do this wasn't initially clear, because we had been mislead to think that "oh, it will just work" by Electron hype.
• Application signing for Apple's ever-tightening requirements (now with Notarization) requires a dive into the murky world of Apple Developer documentation. It has taken me time to absorb how their system is intended to work, and to find which tools in Electron will work given our custom configuration. There are four different configurations that could apply to us as well as a new operating system (Catalina).

Current Status

The goal is to have a runnable App that can be downloaded and double-clicked to run. For this to work on Catalina requires Notarization, which itself requires Codesigning of the application. The application itself must use a 'hardened runtime' with specific 'entitlements' before the application can even go through Notarization.

We have just gotten to the point where we can actually try to notarize our app, but it is currently failing because of an additional unknown requirement. After notarization succeeds (a trial-and-error process involving uploading a file to Apple and waiting for them to respond later in the day), we will then have to test our app on a clean Catalina system and ensure that it functions as necessary.

Our risks are:

• We don't know how long it will take to get notarization to work. It could be another half day to another calendar week.
• Our testing workload just doubled, because we have to test the built stand-alone app.
• We can not debug the notarized/hardened stand-alone app unless we figure out how to build extra instrumentation into it
• In addition to notarization there is notarized distribution, which requires either writing an installer (which itself must be signed and notarized using a different process) or creating a Disk Image and notarizing that.
• We have to write operating procedures for running the app and extracting data from it. We assume it is possible but we haven't tried it yet since we can't get the app to run on Catalina due to the notarization issue.

Even if we get notarization working, getting the rest of this to work for a clean deployment is likely impossible for our current timeline and team size.