MOBYL: MOdel-driven BYpassing of middleware Layers

The Layered architectural style presents a quandary for software architects. On the one hand, the style provides important advantages: separation of concerns, abstraction, ease of evolution, etc. Each layer can build on lower layers to add specific abstractions or services. On the other hand, the layers can become opaque, rigid barriers that inhibit the ability to adapt to new application needs. Consider, for example that some application functions may not need the services of all the layers; it may be more efficient to implement them in a lower layer. We refer to these as bypassing functions. In such situations, where changes to lower layers are needed, developers must resort to writing tricky, intricate, low-level code, which is time-consuming, error prone, and not portable. We address this phenomenon in the context of middleware, and extend the middleware notion of model-driven development with new modeling syntax, code generation tools, and development processes to make it easier to build bypassing implementations. We will describe our approach and provide several illustrative examples and performance data. We will use this data to argue that bypassing implementations can provide more efficient use of a server’s resources, leading to overall better client experience. Our core contribution is this idea: model-driven code generation can enable application developers to conveniently bypass middleware layers when they are not needed, thus improving the server’s performance