Resolving feature convolution in middleware systems

Middleware provides simplicity and uniformity for the development of distributed applications. However, the modularity of the architecture of middleware is starting to disintegrate and to become complicated due to the interaction of too many orthogonal concerns imposed from a wide range of application requirements. This is not due to bad design but rather due to the limitations of the conventional architectural decomposition methodologies. We introduce the principles of horizontal decomposition (HD) which addresses this problem with a mixed-paradigm middleware architecture. HD provides guidance for the use of conventional decomposition methods to implement the core functionalities of middleware and the use of aspect orientation to address its orthogonal properties. Our evaluation of the horizontal decomposition principles focuses on refactoring major middleware functionalities into aspects in order to modularize and isolate them from the core architecture. New versions of the middleware platform can be created through combining the core and the flexible selection of middleware aspects such as IDL data types, the oneway invocation style, the dynamic messaging style, and additional character encoding schemes. As a result, the primary functionality of the middleware is supported with a much simpler architecture and enhanced performance. Moreover, customization and configuration of the middleware for a wide-range of requirements becomes possible.

[1]  Pamela Zave,et al.  Feature interactions and formal specifications in telecommunications , 1993, Computer.

[2]  Roel Wieringa,et al.  A survey of structured and object-oriented software specification methods and techniques , 1998, CSUR.

[3]  Hans-Arno Jacobsen,et al.  Refactoring middleware systems: A Case Study , 2003 .

[4]  Glenn D. Bergland,et al.  Structured Design Methodologies , 1978, 15th Design Automation Conference.

[5]  John A. Zinky,et al.  QoS Aspect Languages and Their Runtime Integration , 1998, LCR.

[6]  Fabio Kon,et al.  Monitoring, Security, and Dynamic Configuration with the dynamicTAO Reflective ORB , 2000, Middleware.

[7]  Premkumar T. Devanbu,et al.  DADO: enhancing middleware to support crosscutting features in distributed, heterogeneous systems , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[8]  Luca Benini,et al.  System-level power optimization: techniques and tools , 1999, Proceedings. 1999 International Symposium on Low Power Electronics and Design (Cat. No.99TH8477).

[9]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[10]  Pamela Zave,et al.  A compositional approach to multiparadigm programming , 1989, IEEE Software.

[11]  Douglas C. Schmidt,et al.  Pattern-Oriented Software Architecture, Patterns for Concurrent and Networked Objects , 2013 .

[12]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[13]  Andrew Clement,et al.  Large-scale AOSD for middleware , 2004, AOSD '04.

[14]  Christian Prehofer,et al.  Feature-Oriented Programming: A Fresh Look at Objects , 1997, ECOOP.

[15]  Nalini Venkatasubramanian,et al.  Design and implementation of a composable reflective middleware framework , 2001, Proceedings 21st International Conference on Distributed Computing Systems.

[16]  Massachusett Framingham,et al.  The Common Object Request Broker: Architecture and Specification Version 3 , 2003 .

[17]  Glenford J. Myers,et al.  Structured Design , 1999, IBM Syst. J..

[18]  Gregor Kiczales,et al.  Design pattern implementation in Java and aspectJ , 2002, OOPSLA '02.

[19]  Hans-Arno Jacobsen,et al.  Refactoring Middleware with Aspects , 2003, IEEE Trans. Parallel Distributed Syst..

[20]  Gordon S. Blair,et al.  The design of a configurable and reconfigurable middleware platform , 2002, Distributed Computing.

[21]  Bernd J. Krämer,et al.  A design pattern based approach to generating synchronization adaptors from annotated IDL , 1998, Proceedings 13th IEEE International Conference on Automated Software Engineering (Cat. No.98EX239).

[22]  Steffen Göbel,et al.  The COMQUAD component model: enabling dynamic selection of implementations by weaving non-functional aspects , 2004, AOSD '04.

[23]  A. Watson,et al.  OMG (Object Management Group) architecture and CORBA (common object request broker architecture) specification , 2002 .

[24]  Clemens A. Szyperski,et al.  Component software - beyond object-oriented programming , 2002 .

[25]  John A. Zinky,et al.  Building adaptive distributed applications with middleware and aspects , 2004, AOSD '04.

[26]  Gul A. Agha,et al.  Customizable middleware for modular distributed software , 2001, CACM.

[27]  Mik Kersten,et al.  Atlas: a case study in building a web-based learning environment using aspect-oriented programming , 1999, OOPSLA '99.

[28]  R. Pawlak,et al.  AspectTAZ : a new approach based on aspect oriented programming for object oriented industrial messaging services design , 2002, 4th IEEE International Workshop on Factory Communication Systems.

[29]  Louis P. DiPalma,et al.  Applying corba in a contemporary embedded military combat system , 2001 .

[30]  Gregor Kiczales,et al.  Aspect-oriented programming , 2001, ESEC/FSE-9.

[31]  Robert J. Walker,et al.  An initial assessment of aspect-oriented programming , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[32]  Edsger W. Dijkstra,et al.  The humble programmer , 1972, CACM.

[33]  Mehmet Aksit,et al.  Aspects and Crosscutting in Layered Middleware Systems , 2000 .

[34]  David R. O'Hallaron,et al.  Languages, Compilers and Run-Time Systems for Scalable Computers , 1998, Springer US.

[35]  Pattie Maes,et al.  Concepts and experiments in computational reflection , 1987, OOPSLA '87.

[36]  Gordon S. Blair,et al.  The Design and Implementation of Open ORB 2 , 2001, IEEE Distributed Syst. Online.

[37]  Hans-Arno Jacobsen,et al.  Quantifying aspects in middleware platforms , 2003, AOSD '03.

[38]  Christopher Gill,et al.  Building Customizable Middleware using Aspect Oriented Programming , 2001 .

[39]  Hans-Arno Jacobsen,et al.  Re-factoring Middleware Systems: A Case Study , 2003, CoopIS/DOA/ODBASE.

[40]  Gordon S. Blair,et al.  An Efficient Component Model for the Construction of Adaptive Middleware , 2001, Middleware.

[41]  KiczalesGregor,et al.  Design pattern implementation in Java and aspectJ , 2002 .