Die Rolle von Features und Aspekten in der Softwareentwicklung (The Role of Features and Aspects in Software Development)

Zusammenfassung Feature-orientierte Programmierung (FOP) und Aspekt-orientierte Programmierung (AOP) sind komplementäre Technologien. Obwohl beide auf die Modularität von so genannten querschneidenden Belangen abzielen, so tun sie dies auf unterschiedliche Art und Weise. Im Rahmen der Arbeit wurde beobachtet, dass FOP und AOP kombiniert werden können, um ihre individuellen Schwächen zu überwinden. Die Arbeit schlägt mit Aspekt-basierten Featuremodulen und Aspektverfeinerung zwei Techniken zur Symbiose von FOP und AOP vor. Beide Techniken werden in einer Fallstudie evaluiert und entsprechende Programmierrichtlinien zum Einsatz von FOP und AOP werden abgeleitet. Schlussendlich wird mittels der Analyse von acht AspectJ-Programmen unterschiedlicher Größe die Frage beantwortet, wie Implementierungsmechanismen der FOP und der AOP heutzutage Verwendung finden. Summary Feature-Oriented Programming (FOP) and Aspect-Oriented Programming (AOP) are complementary technologies. Though they aim at crosscutting modularity, they do so in different ways. We observed that FOP and AOP can be combined to overcome their individual limitations. Consequently, we propose with Aspectual Feature Modules (AFMs) and Aspect Refinement (AR) two techniques to unify FOP and AOP. We use AFMs and AR in a non-trivial case study to create a product line of overlay networks. We also present a set of guidelines to assist programmers in using FOP and AOP techniques for implementing product lines in a stepwise and generative manner. Finally, we answer the question of how FOP and AOP-related implementation techniques are used today by analyzing a representative set of eight AspectJ programs of different sizes.

[1]  Jonathan P. Bowen.  Formal Specification and Documentation Using Z: A Case Study Approach , 1996 .

[2]  Ivar Jacobson,et al.  The Unified Modeling Language User Guide , 1998, J. Database Manag..

[3]  Jörg Liebeherr,et al.  HyperCast: A Protocol for Maintaining Multicast Group Members in a Logical Hypercube Topology , 1999, Networked Group Communication.

[4]  Roger T. Alexander,et al.  Distributing classes with woven concerns: an exploration of potential fault scenarios , 2005, AOSD '05.

[5]  Jia Liu,et al.  Feature oriented refactoring of legacy applications , 2006, ICSE.

[6]  Mira Mezini,et al.  Programming with Aspectual Components , 1999 .

[7]  Mira Mezini,et al.  Adaptive plug-and-play components for evolutionary software development , 1998, OOPSLA '98.

[8]  David Notkin,et al.  Using C++ Templates to Implement Role-Based Designs , 1996, ISOTAS.

[9]  Don S. Batory,et al.  Achieving Extensibility Through Product-Lines and Domain-Specific Languages: A Case Study , 2000, ICSR.

[10]  Sven Apel,et al.  When to use features and aspects?: a case study , 2006, GPCE '06.

[11]  Gunter Saake,et al.  Implementing Bounded Aspect Quantification in AspectJ , 2006, RAM-SE.

[12]  Tzilla Elrad,et al.  Aspect-oriented programming: Introduction , 2001, CACM.

[13]  Mariano Ceccato,et al.  Measuring the Effects of Software Aspectization , 2004 .

[14]  Sven Apel,et al.  On the Structure of Crosscutting Concerns : Using Aspects or Collaborations ? , 2006 .

[15]  Oege de Moor,et al.  Adding open modules to AspectJ , 2006, AOSD.

[16]  John R. Gurd,et al.  A join point for loops in AspectJ , 2006, AOSD '06.

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

[18]  Karl J. Lieberherr,et al.  Aspectual Collaborations: Combining Modules and Aspects , 2003, Comput. J..

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

[20]  Edsger W. Dijkstra,et al.  A Discipline of Programming , 1976 .

[21]  E. Dijkstra.  On the Role of Scientific Thought , 1982 .

[22]  Mira Mezini,et al.  Conquering aspects with Caesar , 2003, AOSD '03.

[23]  Calvin Lin,et al.  Comparing frameworks and layered refinement , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

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

[25]  Friedrich Steimann,et al.  Domain models are aspect free , 2005, MoDELS'05.

[26]  Gunter Saake,et al.  TROLL: a language for object-oriented specification of information systems , 1996, TOIS.

[27]  Mary Shaw,et al.  Abstraction Techniques in Modern Programming Languages , 1984, IEEE Software.

[28]  Mourad Badri,et al.  A Cohesion Measure for Aspects , 2006, J. Object Technol..

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

[30]  Eric Eide,et al.  A comparison of Jiazzi and AspectJ for feature-wise decomposition , 2004 .

[31]  Shmuel Katz,et al.  Superimpositions and Aspect-oriented Programming , 2003, Comput. J..

[32]  Cliff B. Jones,et al.  Structure for dependability - computer-based systems from an interdisciplinary perspective , 2005 .

[33]  Matthew Flatt,et al.  Jiazzi: new-age components for old-fasioned Java , 2001, OOPSLA '01.

[34]  Edsger W. Dijkstra,et al.  The structure of the “THE”-multiprogramming system , 1968, CACM.

[35]  Carlos José Pereira de Lucena,et al.  AJATO: an AspectJ Assessment Tool , 2006 .

[36]  Wouter Joosen,et al.  Dynamic and selective combination of extensions in component-based applications , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

[37]  Carlos José Pereira de Lucena,et al.  Modularizing design patterns with aspects: a quantitative study , 2005, AOSD '05.

[38]  Thomas Leich,et al.  Using Step-Wise Refinement to Build a Flexible Lightweight Storage Manager , 2005, ADBIS.

[39]  Rémi Douence,et al.  A Framework for the Detection and Resolution of Aspect Interactions , 2002, GPCE.

[40]  Eric Bodden,et al.  Avoiding Infinite Recursion with Stratified Aspects , 2006, NODe/GSEM.

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

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

[43]  Sven Apel,et al.  On the Notion of Functional Aspects in Aspect-Oriented Refactoring , 2006 .

[44]  Kenneth N. Lodding.  The Hitchhiker’s Guide to Biomorphic Software , 2004, ACM Queue.

[45]  Martin Gogolla.  Unified Modeling Language , 2009, Encyclopedia of Database Systems.

[46]  Ralf Lämmel,et al.  Declarative Aspect-Oriented Programming , 1999, PEPM.

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

[48]  Baowen Xu,et al.  Measuring Aspect Cohesion , 2004, FASE.

[49]  Calvin Lin,et al.  Using mixins to build flexible widgets , 2002, AOSD '02.

[50]  Friedrich Steimann.  The paradoxical success of aspect-oriented programming , 2006, OOPSLA '06.

[51]  Ettore Merlo,et al.  Assessing the benefits of incorporating function clone detection in a development process , 1997, 1997 Proceedings International Conference on Software Maintenance.

[52]  Mark Handley,et al.  A scalable content-addressable network , 2001, SIGCOMM '01.

[53]  Mariano Ceccato,et al.  Aspect mining through the formal concept analysis of execution traces , 2004, 11th Working Conference on Reverse Engineering.

[54]  David Notkin,et al.  Decoupling change from design , 1996, SIGSOFT '96.

[55]  Ole Lehrmann Madsen,et al.  Virtual classes: a powerful mechanism in object-oriented programming , 1989, OOPSLA '89.

[56]  Mira Mezini,et al.  An Overview of CaesarJ , 2006, LNCS Trans. Aspect Oriented Softw. Dev..

[57]  William R. Cook,et al.  A denotational semantics of inheritance , 1989 .

[58]  Don S. Batory,et al.  Scaling step-wise refinement , 2004, IEEE Transactions on Software Engineering.

[59]  Don Batory,et al.  From Crosscutting Concerns to Product Lines : A Function Composition Approach , 2006 .

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

[61]  Shigeru Chiba,et al.  A Selective, Just-in-Time Aspect Weaver , 2003, GPCE.

[62]  Antero Taivalsaari,et al.  On the notion of inheritance , 1996, CSUR.

[63]  Niklaus Wirth,et al.  Program development by stepwise refinement , 1971, CACM.

[64]  Gustavo Alonso,et al.  Dynamic weaving for aspect-oriented programming , 2002, AOSD '02.

[65]  Awais Rashid,et al.  Framed Aspects: Supporting Variability and Configurability for AOP , 2004, ICSR.

[66]  Gregor Kiczales,et al.  A semantics for advice and dynamic join points in aspect-oriented programming , 2001, TOPL.

[67]  Stefan Hanenberg,et al.  Roles and Aspects: Similarities, Differences, and Synergetic Potential , 2002, OOIS.

[68]  Oscar Nierstrasz,et al.  Traits: A mechanism for fine-grained reuse , 2006, TOPL.

[69]  Hans-Arno Jacobsen,et al.  Resolving feature convolution in middleware systems , 2004, OOPSLA.

[70]  Roberto Erick Lopez-Herrejon,et al.  A disciplined approach to aspect composition , 2006, PEPM '06.

[71]  Niklaus Wirth,et al.  Algorithms + Data Structures = Programs , 1976 .

[72]  Shmuel Katz,et al.  A superimposition control construct for distributed systems , 1993, TOPL.

[73]  H. Rajan,et al.  Classpects: unifying aspect- and object-oriented language design , 2005, Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005..

[74]  Nissim Francez,et al.  A compositional approach to superimposition , 1988, POPL '88.

[75]  Carlos José Pereira de Lucena,et al.  Separation of Concerns in Multi-agent Systems: An Empirical Study , 2003, SELMAS.

[76]  Stefan Hanenberg,et al.  Using and Reusing Aspects in AspectJ , 2001 .

[77]  David Lorge Parnas,et al.  A technique for software module specification with examples , 1972, CACM.

[78]  Yuanyuan Zhou,et al.  CP-Miner: finding copy-paste and related bugs in large-scale software code , 2006, IEEE Transactions on Software Engineering.

[79]  Diomidis Spinellis,et al.  A survey of peer-to-peer content distribution technologies , 2004, CSUR.

[80]  Jack Greenfield,et al.  Software factories: assembling applications with patterns, models, frameworks and tools , 2004, OOPSLA '03.

[81]  Yannis Smaragdakis,et al.  Mixin layers: an object-oriented implementation technique for refinements and collaboration-based designs , 2002, TSEM.

[82]  David Lorge Parnas,et al.  On the Design and Development of Program Families , 2001, IEEE Transactions on Software Engineering.

[83]  Martin P. Robillard,et al.  Separating features in source code: an exploratory study , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

[84]  DeLesley Hutchins,et al.  Eliminating distinctions of class: using prototypes to model virtual classes , 2006, OOPSLA '06.

[85]  Olaf Spinczyk,et al.  AspectC++ – An AOP Extension for C++ , 2005 .

[86]  Paul Clements,et al.  Software product lines - practices and patterns , 2001, SEI series in software engineering.

[87]  Manfred Broy,et al.  Specification and development of interactive systems: focus on streams, interfaces, and refinement , 2001 .

[88]  Gregor Kiczales,et al.  Role-based refactoring of crosscutting concerns , 2005, AOSD '05.

[89]  Michael Jackson,et al.  The structure of software development thought , 2006 .

[90]  Don Batory,et al.  A programming language for writing domain-specific software system generators , 1996 .

[91]  Charles W. Krueger,et al.  Software reuse , 1992, CSUR.

[92]  Jeffrey C. Mogul,et al.  Emergent (mis)behavior vs. complex software systems , 2006, EuroSys.

[93]  Hidehiko Masuhara,et al.  Dataflow Pointcut in Aspect-Oriented Programming , 2003, APLAS.

[94]  Klaus Ostermann,et al.  Dynamically Composable Collaborations with Delegation Layers , 2002, ECOOP.

[95]  Ira D. Baxter,et al.  Design maintenance systems , 1991, CACM.

[96]  Friedrich Steimann,et al.  On the representation of roles in object-oriented and conceptual modelling , 2000, Data Knowl. Eng..

[97]  Mira Mezini,et al.  Expressive Pointcuts for Increased Modularity , 2005, ECOOP.

[98]  Barry Boehm,et al.  A view of 20th and 21st century software engineering , 2006, ICSE.

[99]  Oscar Nierstrasz,et al.  Classbox/J: controlling the scope of change in Java , 2005, OOPSLA '05.

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

[101]  Jan Bosch,et al.  Superimposition: a component adaptation technique , 1999, Inf. Softw. Technol..

[102]  Daniel P. Friedman,et al.  Aspect-Oriented Programming is Quantification and Obliviousness , 2000 .

[103]  Hidehiko Masuhara,et al.  Modeling Crosscutting in Aspect-Oriented Mechanisms , 2003, ECOOP.

[104]  Xin Qi,et al.  J&: nested intersection for scalable software composition , 2006, OOPSLA '06.

[105]  Stefan Hanenberg,et al.  Idioms for Building Software Frameworks in AspectJ , 2003 .

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

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

[108]  Thomas Leich,et al.  Tool support for feature-oriented software development: featureIDE: an Eclipse-based approach , 2005, eclipse '05.

[109]  Gunter Saake,et al.  Piggyback Meta-Data Propagation in Distributed Hash Tables , 2005, WEBIST.

[110]  Kyo Chul Kang,et al.  Feature-Oriented Domain Analysis (FODA) Feasibility Study , 1990 .

[111]  Robert D. Logcher,et al.  Object-oriented database management systems for engineering: a comparison , 1992 .

[112]  Shriram Krishnamurthi,et al.  Pointcuts and advice in higher-order languages , 2003, AOSD '03.

[113]  Wolfgang De Meuter,et al.  Efficient Layer Activation for Switching Context-Dependent Behavior , 2006, JMLC.

[114]  Don S. Batory,et al.  Feature Models, Grammars, and Propositional Formulas , 2005, SPLC.

[115]  Gerald W. Both,et al.  Object-oriented analysis and design with applications , 1994 .

[116]  Andrew C. Myers,et al.  Scalable extensibility via nested inheritance , 2004, OOPSLA.

[117]  William R. Cook,et al.  Mixin-based inheritance , 1990, OOPSLA/ECOOP '90.

[118]  João M. Fernandes,et al.  Towards a catalog of aspect-oriented refactorings , 2005, AOSD '05.

[119]  Hans-Arno Jacobsen,et al.  Towards just-in-time middleware architectures , 2005, AOSD '05.

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

[121]  Michael Kölling,et al.  Objects First with Java - A Practical Introduction Using BlueJ (5th Edition) , 2002 .

[122]  Martin Odersky,et al.  Scalable component abstractions , 2005, OOPSLA '05.

[123]  Yuanyuan Song,et al.  Modular software design with crosscutting interfaces , 2006, IEEE Software.

[124]  Stephan Herrmann,et al.  Object Teams: Improving Modularity for Crosscutting Collaborations , 2002, NetObjectDays.

[125]  Robert L. Glass,et al.  The Standish report: does it really describe a software crisis? , 2006, CACM.

[126]  Thomas Leich,et al.  Aspect refinement and bounding quantification in incremental designs , 2005, 12th Asia-Pacific Software Engineering Conference (APSEC'05).

[127]  Ted J. Biggerstaff,et al.  A perspective of generative reuse , 1998, Ann. Softw. Eng..

[128]  Klemens Böhm,et al.  Free riding-aware forwarding in Content-Addressable Networks , 2007, The VLDB Journal.

[129]  Don S. Batory,et al.  Achieving extensibility through product-lines and domain-specific languages: a case study , 2000, TSEM.

[130]  Ondrej Lhoták,et al.  Adding trace matching with free variables to AspectJ , 2005, OOPSLA '05.

[131]  Thomas Leich,et al.  Aspectual mixin layers: aspects and features in concert , 2006, ICSE '06.

[132]  K. Mani Chandy,et al.  An example of stepwise refinement of distributed programs: quiescence detection , 1986, TOPL.

[133]  Václav Rajlich,et al.  Removing clones from the code , 1999, J. Softw. Maintenance Res. Pract..

[134]  Paulo Borba,et al.  Deriving refactorings for AspectJ , 2005, AOSD '05.

[135]  Stefan Hanenberg,et al.  Parametric introductions , 2003, AOSD '03.

[136]  Elke Pulvermüller,et al.  Implementing collaboration-based designs using aspect-oriented programming , 2000, Proceedings. 34th International Conference on Technology of Object-Oriented Languages and Systems - TOOLS 34.

[137]  R. T. Alexander,et al.  The real costs of aspect-oriented programming , 2003 .

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

[139]  Henry Lieberman,et al.  Using prototypical objects to implement shared behavior in object-oriented systems , 1986, OOPLSA '86.

[140]  Michael Haupt,et al.  Virtual machine support for dynamic join points , 2004, AOSD '04.

[141]  M. F.,et al.  Bibliography , 1985, Experimental Gerontology.

[142]  Sven Apel,et al.  Self-Organization in Overlay Networks , 2005, CAiSE Workshops.

[143]  Yuanyuan Song,et al.  Information hiding interfaces for aspect-oriented design , 2005, ESEC/FSE-13.

[144]  Erik Ernst,et al.  Family Polymorphism , 2001, ECOOP.

[145]  Stanley M. Sutton,et al.  Hyper/J™: multi-dimensional separation of concerns for Java™ , 2001, ICSE '02.

[146]  Arie van Deursen,et al.  Identifying aspects using fan-in analysis , 2004, 11th Working Conference on Reverse Engineering.

[147]  Larry L. Peterson,et al.  RPC in the x-Kernel: evaluating new design techniques , 1989, SOSP '89.

[148]  Günter Kniesel,et al.  A Definition, Overview and Taxonomy of Generic Aspect Languages , 2006, Obj. Logiciel Base données Réseaux.

[149]  Don S. Batory,et al.  GENESIS: An Extensible Database Management System , 1988, IEEE Trans. Software Eng..

[150]  William R. Cook,et al.  A virtual class calculus , 2006, POPL '06.

[151]  K.J. Lieberherr,et al.  Controlling the complexity of software designs , 2004, Proceedings. 26th International Conference on Software Engineering.

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

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

[154]  Jan Bosch,et al.  On the notion of variability in software product lines , 2001, Proceedings Working IEEE/IFIP Conference on Software Architecture.

[155]  Jia Liu,et al.  Refinements and multi-dimensional separation of concerns , 2003, ESEC/FSE-11.

[156]  Jonathan Aldrich,et al.  Open Modules: Modular Reasoning About Advice , 2005, ECOOP.

[157]  Oscar Díaz,et al.  Feature refactoring a multi-representation program into a product line , 2006, GPCE '06.

[158]  Hans-Arno Jacobsen,et al.  Horizontal decomposition of Prevayler , 2005, CASCON.

[159]  Jens Krinke,et al.  Aspect mining using event traces , 2004, Proceedings. 19th International Conference on Automated Software Engineering, 2004..

[160]  Gordon S. Novak,et al.  Interactions of Abstractions in Programming , 2000, SARA.

[161]  Rémi Douence,et al.  Composition, reuse and interaction analysis of stateful aspects , 2004, AOSD '04.

[162]  N. Falconer.  Structured Programming , 1973, Nature.

[163]  A. Nico Habermann,et al.  Modularization and hierarchy in a family of operating systems , 1976, CACM.

[164]  Daniel Jackson,et al.  Alloy: a lightweight object modelling notation , 2002, TSEM.

[165]  Gregor Kiczales,et al.  Back to the future: a retroactive study of aspect evolution in operating system code , 2003, AOSD '03.

[166]  Mira Mezini,et al.  Integrating independent components with on-demand remodularization , 2002, OOPSLA '02.

[167]  Roberto Erick Lopez-Herrejon,et al.  Evaluating Support for Features in Advanced Modularization Technologies , 2005, ECOOP.

[168]  Mira Mezini,et al.  Component Integration with Pluggable Composite Adapters , 2002 .

[169]  Sven Apel,et al.  The role of features and aspects in software development: similarities, differences, and synergetic potential , 2007 .

[170]  Harold Ossher,et al.  Combination of Inheritance Hierarchies , 1992, OOPSLA.

[171]  Erik Ernst,et al.  Higher-Order Hierarchies , 2003, ECOOP.

[172]  Sven Apel,et al.  Towards the Development of Ubiquitous Middleware Product Lines , 2004, SEM.

[173]  Carlos José Pereira de Lucena,et al.  Quantifying the Effects of Aspect-Oriented Programming: A Maintenance Study , 2006, 2006 22nd IEEE International Conference on Software Maintenance.

[174]  Don S. Batory,et al.  Composition Validation and Subjectivity in GenVoca Generators , 1997, IEEE Trans. Software Eng..

[175]  Douglas C. Schmidt,et al.  Ultra-Large-Scale Systems: The Software Challenge of the Future , 2006 .

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

[177]  Elizabeth A. Kendall,et al.  Role model designs and implementations with aspect-oriented programming , 1999, OOPSLA '99.

[178]  David Notkin,et al.  Using role components in implement collaboration-based designs , 1996, OOPSLA '96.

[179]  Sven Apel,et al.  Measuring and Characterizing Crosscutting in Aspect-Based Programs: Basic Metrics and Case Studies , 2007, FASE.

[180]  Don S. Batory,et al.  P2: A Lightweight DBMS Generator , 1997, Journal of Intelligent Information Systems.

[181]  Arie van Deursen,et al.  On the use of clone detection for identifying crosscutting concern code , 2005, IEEE Transactions on Software Engineering.

[182]  Erick Lopez Herrejon.  Understanding feature modularity , 2006 .

[183]  Brenda S. Baker,et al.  On finding duplication and near-duplication in large software systems , 1995, Proceedings of 2nd Working Conference on Reverse Engineering.

[184]  David Walker,et al.  Harmless advice , 2006, POPL '06.

[185]  Kris Gybels,et al.  Arranging language features for more robust pattern-based crosscuts , 2003, AOSD '03.

[186]  Thomas Leich,et al.  Generic feature modules: Two-staged program customization , 2006, ICSOFT.

[187]  Kathryn S. McKinley,et al.  Composing high-performance memory allocators , 2001, PLDI '01.

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

[189]  Stanley M. Sutton,et al.  N degrees of separation: multi-dimensional separation of concerns , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[190]  Don S. Batory,et al.  The design and implementation of hierarchical software systems with reusable components , 1992, TSEM.

[191]  David Lorge Parnas,et al.  Review of David L. Parnas' "Designing Software for Ease of Extension and Contraction" , 2004 .

[192]  Don S. Batory,et al.  Creating reference architectures: an example from avionics , 1995, SSR '95.

[193]  Sven Apel,et al.  Biology-Inspired Optimizations of Peer-to-Peer Overlay Networks , 2005, Prax. Inf.verarb. Kommun..