The battle of firmware vs middleware is fierce. Firmware is a particular class of computer software that gives low-level command over the particular hardware of the device.

Francis Fukuyama et al., Middleware for Dominant Digital Platforms: A Technological Solution to a Threat to Democracy, Stanford Cyber Policy Center, 3, https://fsi-live.s3.us-west-1.amazonaws.com/s3fs-public/cpc-middleware_ff_v2.pdf.

If we cannot afford real, diverse, and independent assessment, we will not realize the promise of middleware.

Facebook deploys tens of thousands of people to moderate user content in dozens of languages. It relies on proprietary machine-learning and other automated tools, developed at enormous cost. We cannot expect [End Page 169] comparable investment from a diverse ecosystem of middleware providers. And while most providers presumably will not handle as much content as Facebook does, they will still need to respond swiftly to novel and unpredictable material from unexpected sources. Unless middleware services can do this, the value they provide will be limited, as will users' incentives to choose them over curation by the platforms themselves.

Second, how is everyone going to get paid? Without a profit motive for middleware providers, the magic will not happen, or it will not happen at large enough scale. Something about business models—or, at a minimum, the distribution of ads and ad revenue—will have to change. That leaves the two thorny issues I do know a fair amount about: curation costs and user privacy.

Before we can execute on the middleware vision, I see at least four problems to be solved. Two of those concern matters beyond my ken, but I will flag them here for others to consider.

Fukuyama's work, which draws on both competition analysis and an assessment of threats to democracy, joins a growing body of proposals that also includes Mike Masnick's "protocols not platforms," Cory Doctorow's "adversarial interoperability," my own "Magic APIs," and Twitter CEO Jack Dorsey's "algorithmic choice."

Francis Fukuyama has called "middleware": content-curation services that could give users more control over the material they see on internet platforms such as Facebook or Twitter.

This gem uses a Rack middleware to clear the store object after every request, but that doesn't translate well to background processing with Sidekiq. A companion library, request_store-sidekiq creates a Sidekiq middleware that will ensure the store is cleared after each job is processed, for security and consistency with how this is done in Rack.

Instead of dealing with a mix of before_filters, Rack-middlewares, controller code and callbacks, an endpoint is just another activity and allows to be customized with the well-established Trailblazer mechanics.

// app/middleware/cache.js,`use`ed in app/server.js import LRU from 'lru-cache'; const _cache = new LRU({ max: 500, maxAge: 1000 * 60 * 60 }); async function cache(req, res, next) { req.cache = _cache; next(); }

In this code, we have another function in the middle which allows us to pass through both ctx (context) and a next function call

To make some of this possible, we had to create our webpack configuration API, called webpack-chain. As you may know, webpack exposes a low-level configuration format, but this format isn't well-suited for merging configuration deterministically across middleware, or even across many projects. With webpack-chain, we expose a chainable or fluent API for aggregating a webpack configuration which is much more deterministic.

Neutrino utilizes webpack under the hood for building projects by augmenting it with knowledge about build middleware. Neutrino middleware are discrete pieces of webpack configuration that use a custom configuration API. You can compose many of these middleware together into custom presets, and each will modify the build accordingly.

If you really want to be sure your customisation gets loaded first or last, you can use * as your before or after reference.

before and after also accept arrays of constraints.

Much like the configuration layer, we need to specify a name for this transformation. This will help other modules negotiate their priority over the injector in relation to yours.

Instead of overriding a service with your own implementation, you enhance an existing service with your own concerns. This pattern is known as middleware.

Middleware works a lot like a decorator. It doesn't alter the original API of the service, but it can augment it with new features and concerns. This has the inherent advantage of allowing all thidparty code to have an influence over the behaviour, state, and UI of a component.