Today, we say goodbye to one of the greats of the software industry: Middleware. More of a concept than an off-the-shelf product, it allowed companies to see beyond application silos and envision a new world with integrated processes and strategic initiatives. In its most basic form, middleware allowed developers to design an input/output structure for applications. Unfortunately, this one-to-one, customized approach has been pushed out of relevance by more flexible, business-ready interfaces. Today we are sorry to say – middleware is dead.
The term middleware was first used all the way back in the 1968 NATO Software Engineering Conference report. In this report, it was referencing software used to adapt file generic system functionality to specific application functionality. In the simplest terms, it was defined as “software in the middle of application software and system software.”
Later in the 80s and 90s, middleware became essential to Enterprise Application Integration with the development of message oriented middleware, object middleware, RPC middleware, database middleware, transaction middleware, and portals. As an intermediary that could be used in complex environments, middleware was the solution of choice for exchanging data between software applications.
Unfortunately for many, middleware did not always live up to all of its early promises – especially as the application landscape began to evolve. The solution did come with its limitations:
- Lack of Standards: Before 1995, Common Gateway Interface (CGI) served as a standard that helped compile disparate software languages. Unfortunately, because there are a number of different types of middleware systems (see above), standards could not be applied to the software.
- Cost: Most of the middleware available is commercial software. If you aren’t able to use the current systems, you have the option of using RAD tools, but these are also costly to develop.
- Doesn’t Meet All Developer Needs: While middleware was suitable for focusing on a specific runtime behavior, it did not help with the critical steps necessary for a full software development. Developing, testing and validating software required specialized tool vendors outside of the middleware’s capabilities.
Despite its limitations, middleware was used predominately for Enterprise Application Integrations. Until Application Program Interface (API) came along.
API’s offer a set of routines, protocols and tools that allow programmers to specify how software (and hardware) components should interact with each other and therefore provide key building blocks necessary to develop the program. Unlike vertical, point-to-point middleware, APIs do not impose on development by requiring a specific way of doing things.
With the rise of mobile and cloud technology, the limitations of middleware have become increasingly apparent. On the flip side, by using API technology for enterprise integrations, companies can easily extend their backend services to new, cutting-edge environments while without custom code development or modification to their legacy systems.
Despite its decades-long evolution, the added challenge of working with new mobile and cloud environments proved to be too much for middleware. Its legacy will now pass to modernization techniques featuring APIs. Building on the ideals of middleware, APIs provide an open, standards-based approach to integration. Unlike its predecessor, an API is not a piece of software. Instead, it is a fully functioning integration point that developers can use in their own programs to call any legacy asset – be it data, applications, or workflows.
“We’d like to commemorate middleware for a pioneer in an era of siloed, proprietary information technology,” said a spokesperson for APIs around the world. “Know that we are prepared to take up your mantle and enable connectivity for applications and environments of all types and all ages.”
As middleware fades from the scene, please take a moment to share your treasured stories in the space below. In lieu of flowers, you could send donations to The Middleware Resource Center, only one problem - it closed down 3 years ago.