Acquisition Global Viewpoint – August 2022

It’s almost as if software engineering has come a full circle. Pioneers working on early operating systems such as UNIX found that it was much more convenient and efficient to write small standalone programs that could have the output of one program piped to the input of another. Applied multiple times this would deliver incredible power that would solve complex tasks. Microservices adopt a similar approach.

Huge monolithic programs dominated software for many years. However, they have proved difficult to maintain and advance. Software maintenance often requires the whole code base to be recompiled to fix the smallest of bugs. And this could easily result in the generation of new bugs.

There is also the issue of scalability. One of the major benefits of cloud infrastructures is that we can increase and decrease the amount of resource needed to meet the demands of the business instead of having to design for peak demand. This proves a difficult challenge for monolithic software but is much easier to achieve with microservices as their core design allows outputs to be routed to inputs with multiple instances being made available.

Microservices can be thought of as a development of the standalone programs of UNIX as they adopt the philosophy of small, isolated programs. That is not to say that they work in isolation, far from it, containers help maintain communication and monitoring while at the same time reducing the risk of one program crashing another.

Also, object storage provides user rights and unique addressing to make multiple programs access achievable. Long obscure file path names are no longer needed as global unique identifiers allow files to be moved transparently around the storage system. This helps achieve efficient storage as files can be moved between long- and short-term memory independently of the programs processing the underlying media.

To achieve this level of flexibility and scalability, cloud software must be written from the ground up. In other words, microservices must be at the core of the design working with object storage and container systems such as Kubernetes or Docker. Although it is technically possible to run monolithic code in a container, the benefit of doing so often outweighs any gains in moving workflows to the cloud.

Microservices are much easier to maintain as they can be tested with tighter constraints. For example, an HD proc-amp type microservice would only need to consider RGB working at specific frame rates. Furthermore, the interfaces are well designed allowing for backwards compatibility and future proofing of broadcast workflows.

For cloud services to deliver the promised scalability, flexibility, and resilience, with all the associate cost and efficiency savings, the infrastructure and code must be written with microservice type software running in containers, and this must be built in at the very beginning of the design.