Lean and Efficient System Software Product Lines: Where Aspects Beat Objects

Software development in the domain of embedded and deeply embedded systems is dominated by cost pressure and extremely limited hardware resources. As a result, modern concepts for separation of concerns and software reuse are widely ignored, as developers worry about the thereby induced memory and performance overhead. Especially object-oriented programming (OOP) is still little in demand. For the development of highly configurable fine-grained system software product lines, however, separation of concerns (SoC) is a crucial property. As the overhead of object-orientation is not acceptable in this domain, we propose aspect-oriented programming (AOP) as an alternative. Compared to OOP, AOP makes it possible to reach similar or even better separation of concerns with significantly smaller memory footprints. In a case study for an embedded system product line the memory costs for SoC could be reduced from 148–236% to 2–10% by using AOP instead of OOP.

[1]  Olaf Spinczyk,et al.  Generic Advice: On the Combination of AOP with Generative Programming in AspectC++ , 2004, GPCE.

[2]  Gordon S. Blair,et al.  On the Separation of Concerns in Program Families , 2004 .

[3]  Anthony Young,et al.  Using AspectJ to build a product line for mobile devices , 2005 .

[4]  Olaf Spinczyk,et al.  On Typesafe Aspect Implementations in C++ , 2005, SC@ETAPS.

[5]  Jørgen Lindskov Knudsen.  ECOOP 2001 — Object-Oriented Programming , 2001, Lecture Notes in Computer Science.

[6]  Krzysztof Czarnecki,et al.  Synthesizing objects , 1999, Concurr. Pract. Exp..

[7]  Randy H. Katz,et al.  Next century challenges: mobile networking for “Smart Dust” , 1999, MobiCom.

[8]  Wolfgang Schröder-Preikschat,et al.  On the Design and Development of a Customizable Embedded Operating System , 2004 .

[9]  David L. Tennenhouse,et al.  Proactive computing , 2000, Commun. ACM.

[10]  Danilo Beuche,et al.  The PURE family of object-oriented operating systems for deeply embedded systems , 1999, Proceedings 2nd IEEE International Symposium on Object-Oriented Real-Time Distributed Computing (ISORC'99) (Cat. No.99-61702).

[11]  Cristina Gacek,et al.  Implementing product line variabilities , 2001, SSR '01.

[12]  Hans-Arno Jacobsen,et al.  Generic Middleware Substrate Through Modelware , 2005, Middleware.

[13]  Karel Driesen,et al.  The direct cost of virtual function calls in C++ , 1996, OOPSLA '96.

[14]  Ron Cytron,et al.  Footprint and feature management using aspect-oriented programming techniques , 2002, LCTES/SCOPES '02.

[15]  Mira Mezini,et al.  Variability management with feature-oriented programming and aspects , 2004, SIGSOFT '04/FSE-12.

[16]  Eric Eide,et al.  Knit: component composition for systems software , 2000, OSDI.

[17]  William G. Griswold,et al.  An Overview of AspectJ , 2001, ECOOP.

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

[19]  Wolfgang Schröder-Preikschat,et al.  Static and Dynamic Weaving in System Software with AspectC++ , 2006, Proceedings of the 39th Annual Hawaii International Conference on System Sciences (HICSS'06).

[20]  Thomas Leich,et al.  FeatureC++: on the symbiosis of feature-oriented and aspect-oriented programming , 2005, GPCE'05.

[21]  Lars Ole Andersen,et al.  Program Analysis and Specialization for the C Programming Language , 2005 .

[22]  Rachid Guerraoui,et al.  ECOOP’ 99 — Object-Oriented Programming , 1999, Lecture Notes in Computer Science.

[23]  Olaf Spinczyk,et al.  Advances in AOP with AspectC++ , 2005, SoMeT.

[24]  Calton Pu,et al.  The Synthesis Kernel , 1988, Comput. Syst..

[25]  Adrian M. Colyer,et al.  Using AspectJ for component integration in middleware , 2003, OOPSLA '03.

[26]  Harold Ossher,et al.  Using multidimensional separation of concerns to (re)shape evolving software , 2001, CACM.

[27]  Mark Weiser.  The computer for the 21st century , 1991 .

[28]  Mohammad Ilyas,et al.  Smart Dust , 2006 .

[29]  Krzysztof Czarnecki,et al.  Generative Programming , 2001, ECOOP Workshops.

[30]  Charles Consel,et al.  Tempo: specializing systems applications and beyond , 1998, CSUR.

[31]  Stan Jarzabek,et al.  XML-based method and tool for handling variant requirements in domain models , 2001, Proceedings Fifth IEEE International Symposium on Requirements Engineering.

[32]  Harold Ossher,et al.  Subject-oriented programming: a critique of pure objects , 1993, OOPSLA '93.

[33]  Walter F. Tichy,et al.  Proceedings 25th International Conference on Software Engineering , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[34]  Jay Lepreau,et al.  The Flux OSKit: a substrate for kernel and language research , 1997, SOSP.

[35]  David E. Culler,et al.  The nesC language: A holistic approach to networked embedded systems , 2003, PLDI.

[36]  Eran Yahav,et al.  Compiler Optimization of C++ Virtual Function Calls , 1996, COOTS.

[37]  Oege de Moor,et al.  Measuring the dynamic behaviour of AspectJ programs , 2004, OOPSLA.

[38]  Gregor Kiczales,et al.  Using aspectC to improve the modularity of path-specific customization in operating system code , 2001, ESEC/FSE-9.

[39]  Danilo Beuche,et al.  Streamlining object-oriented software for deeply embedded applications , 2000, Proceedings 33rd International Conference on Technology of Object-Oriented Languages and Systems TOOLS 33.

[40]  Rainer Unland,et al.  Objects, Components, Architectures, Services, and Applications for a Networked World , 2003, Lecture Notes in Computer Science.

[41]  V. Cechticky,et al.  Implementing Adaptability in Embedded Software through Aspect Oriented Programming , 2004 .

[42]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[43]  Gilles Muller,et al.  Scaling up partial evaluation for optimizing the Sun commercial RPC protocol , 1997, PEPM.

[44]  Wolfgang Schröder-Preikschat,et al.  A quantitative analysis of aspects in the eCos kernel , 2006, EuroSys.

[45]  Michael Haupt,et al.  Micro-measurements for Dynamic Aspect-Oriented Systems , 2004, Net.ObjectDays.

[46]  Urs Hölzle,et al.  Eliminating Virtual Function Calls in C++ Programs , 1996, ECOOP.

[47]  Krzysztof Czarnecki,et al.  Generative programming - methods, tools and applications , 2000 .

[48]  Dirk Muthig,et al.  Generic Implementation of Product Line Components , 2002, NetObjectDays.

[49]  Mathias Weske,et al.  Object-Oriented and Internet-Based Technologies , 2004, Lecture Notes in Computer Science.

[50]  Don S. Batory,et al.  Feature-oriented programming and the AHEAD tool suite , 2004, Proceedings. 26th International Conference on Software Engineering.

[51]  David Grove,et al.  Selective specialization for object-oriented languages , 1995, PLDI '95.