Die-hard Emacs users (myself included) happily spend an inordinate amount of time tweaking their configurations in order to personalize their look-and-feel, or more importantly, streamline their workflows. The elimination of even a few keystrokes can significantly reduce the time spent completing a task. Whether it's a keyboard macro, a newly discovered package, or custom elisp code, the time savings - and the sense of accomplishment - make the tinkering worthwhile.

I started using elfeed-curate (see Introducing elfeed-curate) regularly a couple of years ago. In the recent v0.3.0 release, I added two time-saving features: annotation link creation - for those who publish curated link content - and ask gptel, which may appeal to most elfeed RSS users.

Annotation Link Creation

One curation feature that I often use is the ability to override the feed link with a custom link. This link most often originates from the original feed post. This is done by adding an org-mode link and other text between two brackets, <Org-Link ...>, into the annotation buffer. It has always been time consuming and error prone to do this manually.

The new function elfeed-curate-get-link (j key) solves the most annoying part of the workflow. Normally, I have to open a link in a Browser and create an org-mode link (I use the Chrome Create Link plugin for this) and then paste it back into the annotation buffer.

The elfeed-curate-get-link function takes the link under point in the entry buffer, creates the org-mode link from it, and inserts it as part of an annotation template: <Org-Link (author) =comment=>. The org-mode link is also added to the kill ring in case you want to add it to an org-mode file.

Usage and Configuration

M-x elfeed-curate-get-link RET

(define-key elfeed-show-mode-map "j" #'elfeed-curate-get-link)

This may seem like a small thing, but it greatly improves the speed and enjoyment of my curation workflow.

Ask gptel (experimental)

As everyone knows, LLMs are eating the world! I've been using the amazing gptel package for a while and have been spoiled by its seamless integration into Emacs.

I wanted to ask an LLM about the content of links in my RSS feed. Because many feeds truncate articles while others are too long to read, I built custom integration between elfeed and gptel to handle both cases.

Also, if you ask an LLM to get the contents from a URL, it responds:

I can't fetch URLs from here. Please paste the page content, or run one of these and share the output, and I'll summarize it:

This necessitated implementing a function to fetch the content from the link URL and convert it to text for inclusion in the prompt request.

elfeed-curate-ask-gptel (i key) will first ask you to enter a prompt (see elfeed-curate-gptel-prompt--default = "Briefly summarize:") and then send a request to an LLM (see the gptel-request API) with the prompt text along with the link content. The response will be displayed in the *ask-gptel* buffer and added to the kill ring. The gptel backends and models are configured separately and can be changed as desired.

Usage and Configuration

M-x elfeed-curate-ask-gptel RET

(define-key elfeed-search-mode-map "i" #'elfeed-curate-ask-gptel)
(define-key elfeed-show-mode-map "i" #'elfeed-curate-ask-gptel)

*ask-gptel* Buffer example

The reasons I consider ask-gptel experimental are:

1. Testing ask-gptel was mostly done with only one LLM: ChatGPT:gpt-5. Other backends and models may not function properly and changes may be needed for broader support.
2. Extraction of the URL content is a work in progress. I've already seen that some URLs do not work at all, but I haven't had time to investigate the root causes. Also, I think the extracted content sent to the LLM can be improved to be more concise which will reduce the token count (and cost) and increase upload speed.
3. Besides CliffNotes-like functionality, I'm not really sure what other RSS reader use cases there might be for LLM integration. This is currently a "hammer looking for a nail", so it may not end up going anywhere.

Feedback Welcome

Please do not hesitate to report bugs and suggestions. Thanks and enjoy!

Ideas can feel complete. It's only when you try to put them into words that you discover they're not.

PG's other message, also echoed by many others, is that "Writing is hard. ... You have to work at it." (Fear of Writing).  Another thing you read a lot about is how writing improves your overall professional abilities. If you're a journalist or novel writer, you hone these skills as part of your chosen craft. Suppose you're a business or technical professional. In that case, communicating ideas is probably a big part of your job, but improving your writing skills is likely something that requires extra effort beyond your day job.

Of course, the prerequisite for writing is coming up with an idea in the first place. In the software industry, these ideas typically boil down to explaining the details of a technology or the mechanics of some complex code, library/API, or algorithm. Most software solutions involve understanding the pros and cons of multiple open-source and/or commercial offerings.  Good technology writers not only communicate the nuts and bolts, but they also effectively express opinions about these alternatives.

Many (actually, most) technology decisions involve trade-offs that have to be evaluated. Architectural decision-making processes are a good example of this. E.g. Scaling the Practice of Architecture, Conversationally proposes that software architecture can be done "as a series of conversations".  A critical aspect of the “Advice Process” is documenting the decisions. This must be done effectively so anyone (a new employee or even the author 6 months later) can understand it.

My primary motivation for writing (see Blogging is hard) is envy:

Whenever I read a great article or book I’m always envious of the writer’s talent. It’s like watching an athlete: you know how great they are by how easy they make extraordinary feats look.

This post is a great example of one of my (many) writing challenges: procrastination! PG's original article was published in Feb. 2022 which was when I created the first draft. Over the last 3 years (!) I've made sporadic edits but for some reason didn't pull the trigger. Typical delay tactics include not being satisfied with the flow, content, or even minor sentence structure. A lot of times, just finding the right title can be a real challenge.

Anyway, one of my New Year's resolutions (all unspoken, until now!) was to blog more often. Just like exercising and eating better, this is easier said than done. I had an idea for a technical post (Emacs-related, of course), but that led me to old drafts like this one. If posting this is like the first visit after joining a gym, I guess we'll have to wait and see if I keep coming back!

Happy 2025! 

This post documents the development journey and some implementation details of a relatively simple Emacs package and is arguably overkill for such a small piece of functionality. On the other hand, some of these details may be useful for others who want to develop similar functionality.

If you're not interested, skip to the last section for a brief package description, or see the full package here: password-menu.

Making life easier

The need to automate something usually becomes apparent when an often-used workflow is awkward or inefficient. The effort to create the automation will hopefully pay off over time. I.e. ideally, the ROI will be high. This is why Emacs users spend so much time tweaking their configurations, even though I suspect the ROI may not be as high as they'd like!

In my case, the pain point was about the repeated need to provide passwords and tokens in a variety of situations. This is a common scenario — websites, CLI logins, curl/Postman, etc. all need credentials.

In addition to using auth-source (authinfo.gpg) I had gotten into the bad habit of scattering credentials around various org-mode files (unencrypted! ?). When I needed a password, it required a search, buffer open, select, copy, and then paste to the target to complete. This is (and felt) very clumsy and inefficient. The addition of Org Mode custom link: copy to clipboard made the select/copy a little easier, but the overall experience still sucked.

The search for an existing solution came up empty. This was surprising given that the Emacs package ecosystem (Melpa) is extensive and has been around for a long time.

One of the distinguishing features of Emacs is the ability to customize and extend its functionality with Elisp. So, here we go.

Feature #1: Transient prefix menu

My approach was to use the auth-source-search API along with the transient package to provide the menu UI. This type of "porcelain" has become popular for Emacs projects that have complex user interfaces (Magit! being the best example). My use case is far simpler, but the UI style was still desirable.

The only real Elisp challenge (for me anyway) was creating a dynamic transient prefix list. I couldn't find any examples of this. Transient prefixes are implemented as vectors. Also, note that the transient interface is very complex (Prefixes, Suffixes, Infixes) but this use case only needed prefixes.

A typical transient prefix group looks like this (excerpted from transient-showcase).

(transient-define-prefix messenger ()
  "Prefix with descriptions"
   ["Send Message"
     ("s" "snow people" (lambda () (interactive) (message "snow people!")))
     ("k" "kitty cats"  (lambda () (interactive) (message "kitty cats!")))])

Dynamically creating a vector like this can be implemented with this pseudocode:

(defun get-prefix-list ()
  "Create dynamic transient prefix list."
  (vconcat '["Get password for: "]
    (apply #'vector
      (mapcar
       (lambda (source))
         ;; Extract user and host from source
         (list
          (get-next-picker-string) 
          (concat user "@" host)
          `(lambda () (interactive) (get-password ,user ,host)))
      (get-sources)))))

You won't find this code in password-menu.el because it was refactored with macros as described below.

An Elisp expert could have knocked out this implementation without breaking a sweat, but it was a learning experience for me.

The development of the picker string functionality (1..0, a1..a0, b1..b0,...) was also a lot of fun.

Feature #2: Completing-read menu

All done, right? In the middle of the transient work, I ran across a post that included a good description of using completing-read with a list. The completing-read list interface could leverage the same core transient prefix list elements. Specifically, the user@host string menu item and the lambda that gets the password. The prefix picker string is not needed.

The implementation was refactored with a couple of macros so both UI interfaces could share the list generation. I won't dig into the details here, but the password-menu.el code should be self-explanatory. Getting the completing-read list boiled down to this:

(defun password-menu-get-completing-list ()
  "Get the completing list from the password sources."
  (password-menu--get-source-list
   (password-menu--selection-item)))

The transient version uses these same two macros, but is a little more complex. This shows the usefulness of macros and was another Elisp learning experience.

Feature #3: Kill ring and clipboard expiration

Finally, while investigating other password management packages I ran across this kill ring expiration implementation. It makes sense to remove the secret from the kill ring and system clipboard automatically so I incorporated their code pretty much unmodified.

This additional functionality is like icing on the cake.

Epilogue

I've been dogfooding password-menu for a while. I use it often and can safely say it has improved the "get credential" experience. Before, it was "Oh crap, here we go...". Now it's simply C-x j 3 from anywhere, then paste. Easy peasy!

The other benefit is that I've now removed all those unencrypted secrets from my org files and have everything tucked away in one secure place: authinfo.gpg. That's a big win too.

The password-menu package

Password-menu is a UI wrapper ("porcelain") for the built-in Emacs auth-source secrets library. This package allows you to display auth-source entries in the minibuffer with either completing-read or transient. The password for the selected entry is copied to the kill ring and system clipboard and automatically removed later.

Transient

Completing-read

I read a lot of RSS feeds on a select set of topics (see About | Bob's Content of Interest). I sometimes tweet/toot about individual posts but have the desire to expand that capability. I'd like to be able to regularly (and efficiently) publish a curated collection of articles. There are three primary functional requirements needed to accomplish this:

Collection: Deciding which articles you want to export (publish). Filtering can be done based on their title, subject matter (tags), and time constraints. My preference is to specifically mark (or tag) selected entries independent of their subject matter (see below).

Annotation: Some article titles speak for themselves, but others are best presented with associated comments that allow the reader to know what's special about the content. You need the ability to add annotations to individual articles that are included in the published result.

Publication: Once a set of articles has been identified, exporting them in an easily consumable format is the next step. One important component of exporting this content is grouping the articles based on their subject matter.

The Investigation

There are many RSS feed aggregators out there, but there was no solution that even came near to addressing the curation requirements listed above. Apparently, all of those link collection sites are just rolling their own.

As a software developer, finding such a glaring functionality gap that needs to be filled is a real win-win! ? Not only is this something I want to use, but there are probably a few others who will also find a solution helpful.

Now all I had to do was design and develop that solution. I've been using Emacs and Elfeed as my RSS reader for many years. Extending Emacs functionality is a cult-like activity that attracts many. I'm not brain-washed, but even as a (non-evil) Doom user, I do spend a lot of time tweaking my Emacs configuration.

Anyway, providing this RSS curation functionality as an elfeed extension was not only the ideal technical solution, but it was also the perfect opportunity to author my first Emacs package (another win, I hope).

The Solution

Elfeed-curate is an add-on to the elfeed Emacs-based RSS feed management system that provides the ability to easily curate RSS feed entries.

Elfeed's tagging and search functionality takes care of the collection requirements and elfeed-curate adds annotation and publication (exporting) capabilities.

I have an opinionated workflow that looks like this:

See Curation Workflow for details.

A key factor (essentially, a non-functional requirement) for making this workflow practical is that each step (marking, annotation, export review, etc.) has to be fast. I think the combination of elfeed and elfeed-curate accomplishes this. I'm also sure there will be refinements and improvements in the future.

Export example

The same content exported to Hugo is here: 21-Sep-2023 Content of Interest

Feedback is always welcome. Thanks!

I have a deps.edn/figwheel-main re-frame project that I'm trying to add re-frame-10x to. The deps.edn (day8.re-frame/re-frame-10x {:mvn/version "1.5.0"}) and dev.cjls.edn (:preloads [day8.re-frame-10x.preload]) seem correct and the project builds without errors. When the web app is started though, I get this run-time error:

Uncaught Error: Bad dependency path or symbol: highlight.js.lib.core

I and others have also seen this type of build-time error:

No such namespace: highlight.js/lib/core, could not locate highlight/js_SLASH_lib_SLASH_core.cljs, highlight/js_SLASH_lib_SLASH_core.cljc, or JavaScript source providing "highlight.js/lib/core" (Please check that namespaces with dashes use underscores in the ClojureScript file name) in file target/public/cljs-out/dev/re_highlight/core.cljs

Both errors are originating from re-highlight/core.cljs:

(ns re-highlight.core
  (:require
    [goog.object                          :as gobj]
    [reagent.core                         :as r]
    [reagent.dom                          :as rdom]
    ["highlight.js/lib/core"              :as hljs]
    ["highlight.js/lib/languages/clojure" :as clojure]))
...

re-highlight (a re-frame-10x dependency) is built with shadow-cljs while the re-frame project is built with lein/deps.edn/figwheel-main. The re-frame project does not have a dependency on either re-highlight or highlight.js.  The challenge here is providing the highlight.js (an NPM library) dependencies to re-highlight.

There are ways to include NPM libraries in ClojureScript projects, but each is specific to a particular build system:

• ClojureScript is not an Island: Integrating Node Modules
• ClojureScript with Webpack
• figwheel-main: Using NPM
• shadow-cljs: NPM

This cross-build system situation seems unique though. Providing the highlight.js library to re-highlight turned out to be an eye-opening deep dive into ClojureScript build systems. See the Commentary section at the end of this post.

Long story short, I was able to find a solution for exposing NPM libraries to shadow-cljs projects included in a deps.edn build.

It involves creating a Javascript bundle containing the needed NPM dependency (highlight.js) using webpack and then "manually" making it available to re-highlight.

Here is a step-by-step guide for adding re-frame-10x to a deps.edn re-reframe project.

First, create package.json with the needed dependencies.

npm install highlight.js --save
npm install webpack webpack-cli --save-dev
# Manually add this to package.json:
# "scripts": {
#    "build": "webpack --mode=development"
#  },

Final package.json:

{
  "scripts": {
    "build": "webpack --mode=development"
  },
  "dependencies": {
    "highlight.js": "^11.5.1"
  },
  "devDependencies": {
    "webpack": "^5.74.0",
    "webpack-cli": "^4.10.0"
  }
}

Create src/js/main.js with these contents. The require() statements are needed so webpack will include the NPM libraries in the output bundle.

require('highlight.js')
require('highlight.js/lib/languages/clojure')

Create webpack.config.js with these contents:

const webpack = require('webpack');
const path = require('path');

const BUILD_DIR = path.resolve(__dirname, 'resources', 'public', 'js', 'compiled');
const APP_DIR = path.resolve(__dirname, 'src', 'js');

const config = {
  entry: `${APP_DIR}/main.js`,
  output: {
    path: BUILD_DIR,
    filename: 'bundle.js'
  }
};
module.exports = config;

Add the following lines before the complied app.js in resources/public/index.html.

...
<script src="js/compiled/out/goog/base.js" type="text/javascript"></script>
<script>
   goog.addDependency("../../bundle.js", ['highlight.js.lib.core', 'highlight.js.lib.languages.clojure'], []);
</script>
<script src="js/compiled/app.js" type="text/javascript"></script>
...

This is where the magic is happening.

• The highlight.js dependencies are being manually added with goog.addDependency() before the rest of the application dependencies are loaded.
• The Clojurescript compiler-generated app.js has the following code. We're just loading goog/base.js first so the goog functions are defined.

...
if(typeof goog == "undefined") document.write('<script src="js/compiled/out/goog/base.js"></script>');
...

Note: The paths and JS build file names (e.g. app.js) above may not match your specific project structure. If so, they would need to be adjusted accordingly.

Add re-frame-10x dependencies to deps.edn:

...
 day8.re-frame/tracing {:mvn/version "0.6.2"}
 day8.re-frame/test {:mvn/version "0.1.5"}
 day8.re-frame/re-frame-10x {:mvn/version "1.5.0"}
...

The dev.cljs.edn file needs the following so re-frame-10x is loaded properly:

...
:closure-defines {
  "goog.DEBUG" true
  "re_frame.trace.trace_enabled_QMARK_" true}
:preloads [day8.re-frame-10x.preload]
...

Run the project:

npm run build  # Creates bundle.js
lein repl
# or
lein figwheel

Voilà! The highlight.js dependency in re-highlight is satisfied and re-frame-10x runs as expected.

There must be a better way to do this. I just couldn't find it...

Commentary

This solution seems rather hacky and took way too long to discover. I can't tell you the number of rabbit holes I went down with the NPM inclusion methods listed above. Each of them just uncovered further dependency and configuration issues or would have resulted in undesirable refactoring. The code base I'm working with is rather large and I didn't want to completely change the build system just to add a development tool.

To be honest, the CLJ/CLJS build tools and their cross-pollinated dependency systems (lein, shadown-cljs, etc.) are very confusing. There is no idiomatic/standard way to build Clojure(Script) projects. Everyone is using a different combination or permutation of build systems.  Also, the clojure/clj CLI and tooling just plain suck.  I think these things are a real barrier to Clojure(Script) adoption.

I've only dabbled with Clojure over the last few years. See Exploring Clojure (and FP vs OOP). The real motivation was to explore the advantages of functional programming. Shifting your fundamental programming paradigm from OOP to FP has far-reaching impact. Language warts are not going to be a major factor in determining your success in doing this type of transformation.

The other major language/technology selection considerations involve organizational headwinds. For most large companies, there are three major challenges:

1. Inertia. Convincing management that an esoteric language and techniques (FP) are worth diverting and training existing personnel is a difficult hill to climb. I also think there's a certain amount of organizational entrenchment going on here. For example, the C#/CLR vs. Java/JVM divide is really more cultural than technical. Because niche technologies like Clojure/FP are also generally viewed in this cultural context ("esoteric"), they don't stand a chance.
2. Talent. Unless you're in Finland, it's difficult to find qualified people. This is also an on-going issue because programs developed today need to be maintained for the long-term (years). With all-remote employment now being more mainstream, maybe this will become less of an issue.
3. Trends. As you can see from the 5-year trends below, Clojure has been on a slow decline. Also, Lisp languages are minor players. They are orders of magnitude smaller than the mainstream (Java, JavaScript, Python) and do not show up on the TIOBE top 20 lists (Lisp is #36).

Even if you're a small company or a startup, selecting Clojure is still a tough call. This would likely only happen if there were a critical mass of programmers (#2) that already had positive Clojure/FP development experiences.

There are many good reasons to choose Clojure as a front-end (JavaScript) and/or back-end (JVM) technology solution. I would love to see first-hand how well Clojure/FP performs on a large-scale project.  Unfortunately, there are also plenty of non-technical reasons that prevent organizations from choosing Clojure.

This organizational structure increases the speed of feature delivery and allows for experimentation to further improve the customer experience. Tooling and automation ("paved roads") are key. The model that Netflix came up with:

"Full cycle developers" is a model where a development team, equipped with amazing developer productivity tools, is responsible for the full software life cycle: design, development, test, deploy, operate, and support.

If you work for a large enough enterprise, you likely have teams of people that provide the following functions:

• Product development (creates and designs applications software and includes architects, product owners, and scrum masters)
• Quality assurance (QA). They test the software. For a medical device company, we call this team Verification and Validation (V&V)
• Site Reliability Engineering (SRE). Ensures scalability and reliability of the infrastructure and applications. They do performance testing and may implement some Chaos engineering techniques.
• Development operations (DevOps). Manage the code repositories, shared development tools, CI/CD pipelines, middleware, databases, etc.
• Infrastructure management (on-prem hardware and operating systems)
• Cloud management (same as above,  but in the cloud)
• Applications support (monitor and manage applications in production)

Do not confuse FCTs with "Full Stack Teams" (see Full Stack Pronounced Dead). This "stack" refers to technologies that are used to implement a typical web-based application (e.g. LAMP).

FCTs are about supporting functionality end-to-end (product idea to production), but both have the challenge of developer specialization in common. A FCT has to broaden their skill-set even further to include application/infrastructure deployment, monitoring, and support. This is the future!

Full Cycle Team Challenges for Medical Device Companies

The transformation from a legacy organization (as described above) to FCTs is made even more challenging for a medical device company creating software that has to maintain FDA regulatory controls (see Quality System Regulation Subpart C–Design Control § 820.30).

Below is a list of regulatory and transition considerations that impact the release process. Most are associated with keeping the Design History File (DHF) documentation up-to-date. The organizational challenge in a FCT world is figuring out who is responsible for these tasks.

Spoiler alert: The suggested answers should be obvious, but many times the best I can do is just ask the question. Every organization, and even different teams within a single organization, will have different solutions. These can be tough problems to solve. Don't shoot the messenger!

Medical Device Data System (MDDS)

Not all of your software may be under FDA Class II/III regulatory controls. Some could fall under MDDS, see Identifying an MDDS. There is still some risk associated with MDDS but special controls and premarket approval -- the 510(k) -- are not necessary (see MDDS Rule).

MDDS software requires the same QMS documentation (see MDDS Section VI-E. Current Good Manufacturing Practices (CGMP)/QS Regulation/MDR Compliance of the rule) so most of the items listed here still apply.

Also, see Comment 25 from the rule which addresses "modular software". I.e mixing MDDS components with medical device components. The response says "The MDDS regulation does not necessarily prevent modular implementation.", but the FDA can't make a "generalized determination" on the various ways these combinations may be made. This may be a situation you run into and the FDA suggests it is best to contact them if you have questions.

Validation and Verification

General Principles of Software Validation; Final Guidance for Industry and FDA Staff (PDF)

Based on the intended use and the safety risk associated with the software to be developed, the software developer should determine the specific approach, the combination of techniques to be used, and the level of effort to be applied. While this guidance does not recommend any specific life cycle model or any specific technique or method, it does recommend that software validation and verification activities be conducted throughout the entire software life cycle.

FDA guidance documents, and FDA regulations in general (e.g. IEC 62304), tell you what to do, but leave the how up to the organization.  

Let's highlight the SRS* to System test verification from the V-model. This is essentially end-to-end testing. In a microservice-based architecture, each FCT is likely responsible for different sets of services. These services may be dependent on the services provided by other teams.

Which team is responsible for ensuring that the entire system is functioning properly (i.e. end-to-end test protocols and results) after changes are made to one or more of these services?

In an ideal world, these end-to-end tests are completely automated, but even then someone still needs to maintain them.

Validation testing (was the right product built?) presents even more challenges as a single FCT is may only be responsible for a small portion of the entire product.

Risk analysis

From Medical Device Design Risk Management Basic Principles:

Risk analysis is typically done by a cross-functional team that may span multiple business units, but it is probably not unreasonable for the FCT Product Owner to drive this process and get the documentation updated as needed.

Traceability

From the FDA guidance:

A source code traceability analysis is an important tool to verify that all code is linked to established specifications and established test procedures.

Creating this documentation is well suited for automation. It still requires ensuring that all requirements and related test scenarios are properly tagged so they can be parsed to produce a release report.

Software Design Evidence

From the FDA guidance:

The Quality System regulation requires that at least one formal design review be conducted during the device design process. However, it is recommended that multiple design reviews be conducted (e.g., at the end of each software life cycle activity, in preparation for proceeding to the next activity).

This is a challenge for any Agile-based development process so is not specific to the FCT-based organization. Running formal design reviews as early in the development process as possible should be a team responsibility.

Manual Approval Gates

For many unregulated software products continuous integration (CI) and continuous delivery (CD) is a reality. I.e. Code can be pushed, run through the CI/CD pipelines, and delivered to customers without human intervention.

It is very unlikely (not impossible though I suppose, depending on the product) that this would occur for FDA-regulated software. Even with automated document generation, software deployment to production will still require human sign-off steps and audit trails.

Off-The-Shelf (OTS) Software

OTS/SOUP Software Validation documentation needs to be kept up-to-date. This is mostly a book-keeping exercise for OTS/SOUP that is part of the software product. For tools though, see OTS/SOUP Software Validation Strategies.

Another consideration to keep in mind for including 3rd party software into your product is the software license. The corporate (legal) policy should dictate license requirements, but teams would be aided by an automated tracking process.

Infrastructure

Installation, operational, and performance qualification -- IQ/OQ/PQ. FDA regulated software must have these processes in place to ensure that after any changes are made, the infrastructure continues to meet quality requirements.  With the microservice architecture becoming a best practice, the team would now be responsible for documenting the IQ/OQ/PQ for their particular microservice or container flavor(s).

Cloud Offerings

Serverless architectures (Note: I'm most familiar with AWS, so will use their cloud products as examples. Azure and GCP have similar offerings.) One of the key advantages of the Lambda, Fargate, RDS, and similar managed/SaaS products is their undifferentiated heavy lifting.  AWS is responsible for the care and maintenance of the underlying infrastructure and servers. For on-prem servers, this is something the organization spends significant time and money on, but these expenditures do not directly benefit the customer.  Serverless allows companies to focus their efforts on things that make a difference to their customers.

How do you ensure IQ/OQ/PQ quality when you don't have control over the servers that are running your application(s)?

Another consideration: Teams will need to take regulatory impact into consideration when selecting new cloud technologies.

Infrastructure as Code (IaC)

The use of IaC (e.g. CloudFormation or Terraform) may require new release cycle processes. I.e since this code is not part of the application, you may want to have a separate release cycle for when the infrastructure is updated. The same is true for container (Docker) code updates.

The FCT should be responsible for the IaC associated with their product as it directly impacts both functionality and performance.

Transformation

When thinking about transforming to a FCT-based organization, the 2019 AWS re:invent keynote by Andy Jassy comes to mind. His "transformation" is referring to migrating from on-premise to cloud infrastructure (AWS, of course), but I think the non-technical transformation recommendations he outlines (start: 5:04 end 11:48) are also applicable to the FCT organizational change:

I think aggressive goals (item #2) is particularly important. Legacy organizations have a lot of inertia that needs to be overcome in order to move things forward. Breaking those initial barriers is even more difficult when you're having to deal with regulatory requirements.

Bottom Line

FDA regulatory requirements add tasks and documentation to the software release process. This has always been the case for medical device companies, but how this additional work is managed when trying to implement full-cycle teams can be a complicated problem to solve.

Just like unregulated development, providing the tooling to automate these tasks is the key to allow teams to deliver quality software to customers more quickly.

---------------

*SRS, Software Requirements Specification. The old-school water-fall requirements document. I don't miss those days!

When I upgraded Windows 10 (64-bit) from 1909 to 2004 I found that Virtualbox 6.1.x no longer worked properly. All of my guest instances (Ubuntu, Mint, etc.) failed to start. Specifically, they just hung with a blinking cursor and there were no errors in the logs.

There were no reports on this problem on the VirtualBox on Windows Hosts forum. [30-May-2020 Update] See No VMs Work On Windows 10.

It turns out that when Windows 10 2004 is installed it enables the Windows Hypervisor Platform feature. Note that the Hyper-V feature was disabled prior to the upgrade and remained so after.

To check this setting run OptionalFeatures.exe from a Windows command shell. You'll see this:

The resolution to the hang problem is to disable this feature. Doing this is simple:

1. Uncheck the Windows Hypervisor Platform checkbox (above).
2. Reboot. Even though it's not indicated when you do step #1, a reboot is required to disable the feature.

That's it!

My work colleague and basketball buddy Stan sells a nerd t-shirt here: 314 Digits of Pi.py. It has the Python code on the front and the results on the back. I "won" one of these at our annual White Elephant gift exchange in December. Even though the Amazon Best Sellers Rank is #12,306,667 in Clothing, Shoes & Jewelry, I really like it!

I've been staring at the code backward in the mirror for a number of months:

This got me wondering what this algorithm would look like in Clojure?

The first pass on the port was pretty straight forward, but I think it's worth noting some of the subtle differences. All of the code is here: pi-digits.

Here's the original Python code and result:

import math

def pi():
  r = 4*(4*arccot(5) - arccot(239))
  return str(r)[0] + '.' + str(r)[1:-5]

def arccot(x):
  total = power = 10**319 // x
  divisor = 1
  while abs(power) >= divisor:
    power = -power // x**2
    divisor += 2
    total += power // divisor
  return total

print("314 digits of Pi " + pi())

$ python3 pi.py
314 digits of Pi 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612847564823378678316527120190914564856692346034861045432664821339360726024914127372458700660631

For the interested, here's an explanation of the calculation of Pi using fixed point math for speed improvements: Pi - Machin: The Machin formula, developed by John Machin in 1706 (!), is:

And here's a Clojure version that returns the identical result:

(ns pi-digits.core
  (:gen-class)
  (:require [clojure.math.numeric-tower :as math]))

(defn pow [b e] (math/expt b e))
(defn abs [n] (math/abs n))

(defn arccot
  [x]
  (let [power (atom (quot (pow 10 319) x))
        total (atom @power)
        divisor (atom 1)]
    (while (>= (abs @power) @divisor)
      (do
        (swap! power #(quot (- %) (pow x 2)))
        (swap! divisor #(+ % 2))
        (swap! total #(+ % (quot @power @divisor)))))
    @total))

(defn pi
  "Calculate Pi to 314 digits"
  []
  (let [r (str (* 4 (- (* 4 (arccot 5)) (arccot 239))))]
    (str (subs r 0 1) "." (subs r 1 315))))

(defn -main
  [& _]
  (println "314 digits of Pi" (pi)))

• One thing I discovered is Python's use of an arbitrary-precision integer implementation that allows 10³¹⁹ to actually have 319 digits of precision.  The use of Java's double power implementation,

  (Math/pow b e)

  in Clojure, will not work because a double value can only represent about ± 10³⁰⁸.  Getting the required precision required the use of the clojure/math.numeric-tower library and the

  (math/expt b e)

  function (integer implementation when e is a positive value).
• The Clojure quot[ient] does the same thing as Python's floor division (//) function.

One problem with the

arccot

(defn arccot-recur
  [x]
  (loop [power (quot (pow 10 319) x)
         divisor  1
         tot 0]
    (let [total (+ tot (quot power divisor))]
      (if (>= (abs power) divisor)
        (recur (quot (- power) (pow x 2)) (+ divisor 2) total)
        total))))

We use loop/recur for a recursive implementation. This has the benefit of tail-call optimization (TCO). Here are the execution times (average of 10 runs) for calculating Pi with the three implementations:

Method	Digits Time in seconds
	10,000	50,000	100,000	200,000
python	0.158	3.74	14.9	60.3
clojure-while	0.260	5.14	19.8	78.6
clojure-recur	0.252	5.10	19.8	78.5

Python is certainly faster, but the purpose here was not to compare computation speed. It was to get a Clojure version of the t-shirt made! Who's the real nerd now?

It's no surprise that Onera has leveraged research on monitoring lung resistivity with this technology (e.g. here and here) and is applying AI for automated respiratory event detection. Since electrode placement is important for reliable data acquisition, the patch is a good design choice, but it doesn't look like it would be that comfortable to wear to sleep.

Another review, Wearable Patch Uses Machine Learning to Detect Sleep Apnea, notes that assessing sleep apnea requires additional physiological signals to be monitored and that more work needs to be done to combine this technology with these other signals.

………………………………………………

*Purchased by SonoSite in 2009. SonoSite has since stopped manufacturing the BioZ DX.