A feature model of actor, agent, functional, object, and procedural programming languages

Abstract The number of programming languages is large and steadily increasing. However, little structured information and empirical evidence is available to help software engineers assess the suitability of a language for a particular development project or software architecture. We argue that these shortages are partly due to a lack of high-level, objective programming language feature assessment criteria: existing advice to practitioners is often based on ill-defined notions of ‘paradigms’ [3, p. xiii] and ‘orientation’, while researchers lack a shared common basis for generalisation and synthesis of empirical results. This paper presents a feature model constructed from the programmer's perspective, which can be used to precisely compare general-purpose programming languages in the actor-oriented, agent-oriented, functional, object-oriented, and procedural categories. The feature model is derived from the existing literature on general concepts of programming, and validated with concrete mappings of well-known languages in each of these categories. The model is intended to act as a tool for both practitioners and researchers, to facilitate both further high-level comparative studies of programming languages, and detailed investigations of feature usage and efficacy in specific development contexts.

[1]  Raphael A. Finkel,et al.  Advanced programming language design , 1995 .

[2]  Jean-Pierre Rosen,et al.  What orientation should Ada objects take? , 1992, CACM.

[3]  Vinny Cahill,et al.  Taxonomy of distributed event-based programming systems , 2002, Proceedings 22nd International Conference on Distributed Computing Systems Workshops.

[4]  Brian W. Kernighan,et al.  The C Programming Language, Second Edition , 1988 .

[5]  Andrea Omicini,et al.  Environment as a first class abstraction in multiagent systems , 2007, Autonomous Agents and Multi-Agent Systems.

[6]  Gul A. Agha,et al.  ACTORS - a model of concurrent computation in distributed systems , 1985, MIT Press series in artificial intelligence.

[7]  Michael Haupt,et al.  A comparison of context-oriented programming languages , 2009, COP@ECOOP.

[8]  Mary Shaw,et al.  A comparison of programming languages for software engineering , 1981, Softw. Pract. Exp..

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

[10]  Paul Hudak,et al.  Conception, evolution, and application of functional programming languages , 1989, CSUR.

[11]  Jan Bosch,et al.  A taxonomy of variability realization techniques , 2005, Softw. Pract. Exp..

[12]  Brian Logan,et al.  Modularity and Compositionality in Jason , 2009, PROMAS.

[13]  Gerald J. Sussman,et al.  Structure and interpretation of computer programs , 1985, Proceedings of the IEEE.

[14]  Kim B. Clark,et al.  Design Rules: The Power of Modularity , 2000 .

[15]  Wynne W. Chin,et al.  Understanding frameworks and reviews: a commentary to assist us in moving our field forward by analyzing our past , 2007, DATB.

[16]  Gilad Bracha,et al.  Modularity meets inheritance , 1992, Proceedings of the 1992 International Conference on Computer Languages.

[17]  Joe aRmstRonG,et al.  Erlang , 2010, Commun. ACM.

[18]  William B. Frakes,et al.  Software reuse research: status and future , 2005, IEEE Transactions on Software Engineering.

[19]  Kim B. Clark,et al.  Design Rules: The Power of Modularity Volume 1 , 1999 .

[20]  Annett Baier.  Programming Language Pragmatics , 2016 .

[21]  David A. Fisher.  DoD's Common Programming Language Effort , 1978, Computer.

[22]  Carolyn Begg Thomas Connolly,et al.  Database Systems: A Practical Approach To Design, , 2004 .

[23]  Laura Schweitzer,et al.  Database Systems A Practical Approach To Design Implementation And Management , 2016 .

[24]  Anne Marsden,et al.  International Organization for Standardization , 2014 .

[25]  Christopher Strachey,et al.  Fundamental Concepts in Programming Languages , 2000, High. Order Symb. Comput..

[26]  H. Van Dyke Parunak,et al.  Modeling Agents and Their Environment , 2002, AOSE.

[27]  Robert L. Nord,et al.  Software Product Lines , 2004, Lecture Notes in Computer Science.

[28]  Simon L. Peyton Jones,et al.  Imperative functional programming , 1993, POPL '93.

[29]  Rajkumar Buyya,et al.  A taxonomy and survey of grid resource management systems for distributed computing , 2002, Softw. Pract. Exp..

[30]  Krzysztof Czarnecki,et al.  The Variability Model of The Linux Kernel , 2010, VaMoS.

[31]  T. Kuhn,et al.  The Structure of Scientific Revolutions. , 1964 .

[32]  Bruce E. Martin,et al.  An object-based taxonomy for distributed computing systems , 1991, Computer.

[33]  Eelco Visser,et al.  Meta-programming with Concrete Object Syntax , 2002, GPCE.

[34]  David A. Wheeler,et al.  Ada, C, C++, and Java vs. the Steelman , 1997, ALET.

[35]  Brian W. Kernighan,et al.  The C Programming Language , 1978 .

[36]  David K. Gifford,et al.  Design Concepts in Programming Languages , 2008 .

[37]  C. Q. Lee,et al.  The Computer Journal , 1958, Nature.

[38]  Michael L. Scott.  Programming Language Pragmatics, Third Edition , 2009 .

[39]  Brian A. Wichmann.  A Comparison of Pascal and Ada , 1982, Comput. J..

[40]  Deborah J. Armstrong.  The quarks of object-oriented development , 2006, CACM.

[41]  Peter Van Roy,et al.  Concepts, Techniques, and Models of Computer Programming , 2004 .

[42]  Mehdi Dastani,et al.  Programming Multi-Agent Systems in 3APL , 2005, Multi-Agent Programming.

[43]  A. S. Roa,et al.  AgentSpeak(L): BDI agents speak out in a logical computable language , 1996 .

[44]  Peter Van Roy,et al.  Programming paradigms for dummies: what every programmer should know , 2009 .

[45]  Frank W. Calliss,et al.  A comparison of module constructs in programming languages , 1991, SIGP.

[46]  Ralf Lämmel,et al.  Cracking the 500-Language Problem , 2001, IEEE Softw..

[47]  Uday S. Reddy,et al.  Imperative functional programming , 1996, CSUR.

[48]  D. Gabbay,et al.  Many-Dimensional Modal Logics: Theory and Applications , 2003 .

[49]  Carl Hewitt,et al.  A Universal Modular ACTOR Formalism for Artificial Intelligence , 1973, IJCAI.

[50]  T. Sheard.  Template Metaprogramming for Haskell , 2014 .

[51]  Don S. Batory,et al.  On the modularity of feature interactions , 2008, GPCE '08.

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

[53]  Nicole Stender.  Template Metaprogramming for Haskell , 2014 .

[54]  Sven Apel,et al.  An Overview of Feature-Oriented Software Development , 2009, J. Object Technol..

[55]  Laurence Tratt,et al.  Dynamically Typed Languages , 2009, Adv. Comput..

[56]  Krzysztof Czarnecki,et al.  Sample Spaces and Feature Models: There and Back Again , 2008, 2008 12th International Software Product Line Conference.

[57]  Goetz Botterweck,et al.  A feature model of actor, agent, and object programming languages , 2011, SPLASH Workshops.

[58]  Michael Fisher,et al.  MetateM: The Story so Far , 2005, PROMAS.

[59]  Yoav Shoham,et al.  Agent-Oriented Programming , 1992, Artif. Intell..

[60]  Michael Wooldridge,et al.  A Common Semantic Basis for BDI Languages , 2007, PROMAS.

[61]  Jan Bosch,et al.  Design and use of software architectures - adopting and evolving a product-line approach , 2000 .

[62]  Simon L. Peyton Jones,et al.  Template meta-programming for Haskell , 2002, Haskell '02.

[63]  Michael Fisher,et al.  Language Constructs for Multi-agent Programming , 2008, CLIMA.

[64]  Michael Hanus,et al.  Multi-paradigm Declarative Languages , 2007, ICLP.

[65]  Bjarne Stroustrup,et al.  C++ Programming Language , 1986, IEEE Softw..

[66]  Ana García Bergua,et al.  Ada , 2004, Discurso y experiencias de personas privadas de libertad: afectos y emociones en riesgo. Aquí y ahora al límite: La mujer II.

[67]  Joe Armstrong,et al.  A history of Erlang , 2007, HOPL.

[68]  Kim B. Clark,et al.  The Option Value of Modularity in Design: An Example From Design Rules, Volume 1: The Power of Modularity , 2000 .

[69]  Michael Wooldridge,et al.  Programming Multi-Agent Systems in AgentSpeak using Jason (Wiley Series in Agent Technology) , 2007 .

[70]  David M. Weiss,et al.  Software Product Line Engineering , 2005, SEKE.

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

[72]  Gul A. Agha,et al.  Actor frameworks for the JVM platform: a comparative analysis , 2009, PPPJ '09.

[73]  Boumediene Belkhouche,et al.  A methodical comparison of Ada and Modula-2 , 1988 .

[74]  Narain H. Gehani,et al.  Comparison of the Programming Languages C and Pascal , 1982, CSUR.

[75]  Simon L. Peyton Jones,et al.  Composable memory transactions , 2005, CACM.

[76]  Ehud Shapiro,et al.  The family of concurrent logic programming languages , 1989, CSUR.

[77]  Sergey Yekhanin,et al.  Private information retrieval , 2010, CACM.

[78]  William F. Appelbe,et al.  A survey of systems programming languages: Concepts and facilities , 1985, Softw. Pract. Exp..

[79]  Andy Oram,et al.  Beautiful code , 2007 .

[80]  Krzysztof Czarnecki,et al.  Feature-based survey of model transformation approaches , 2006, IBM Syst. J..