pith. sign in

arxiv: 2605.28989 · v1 · pith:R3GBVVJYnew · submitted 2026-05-27 · 💻 cs.SE · cs.PL

Generalized Software Product Line Extraction

Federico Bruzzone , Walter Cazzola , Luca Favalli This is my paper

Pith reviewed 2026-06-29 10:33 UTC · model grok-4.3

classification 💻 cs.SE cs.PL
keywords software product linesfeature model extractionatomsworkbench-agnosticlanguage product linesbottom-up extractionSPL serverSPL client
0
0 comments X

The pith

A workbench-agnostic protocol extracts feature models from software artifacts using lightweight atoms.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper proposes a general protocol for extracting feature models from existing software artifacts and for configuring and deriving products. It follows a bottom-up approach based on lightweight dependency units called atoms. The architecture separates an SPL server that remains independent of any workbench from a client that uses a specific backend and a generic frontend. This design makes the protocol applicable to varied software product lines because it avoids strong assumptions about languages or composers. The method is shown working with language product lines through a prototype that combines Neverlang artifacts, a Java backend, a Go and Prolog server, and a JavaScript frontend.

Core claim

The protocol follows a bottom-up approach based on lightweight dependency units called atoms, and organizes the extraction and configuration process around an SPL server (workbench-independent) and an SPL client with a workbench-specific backend and a generic frontend. The protocol makes few assumptions on the underlying software artifacts and is therefore applicable to varied SPLs. The applicability of this approach is presented through a prototypical implementation of the architecture in which several subsystems interact and can be swapped freely without affecting the others, with focus on language product lines while preserving workbench-agnosticism.

What carries the argument

Lightweight dependency units called atoms that capture feature dependencies, organized through a client-server architecture with an agnostic SPL server and workbench-specific client backends.

If this is right

  • Extraction and configuration steps can be reused across different IDEs and languages.
  • Software product lines can be derived independently of the original development environment.
  • The same server can support multiple client backends for different technological spaces.
  • Subsystems in the architecture can be replaced without changing the overall protocol.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The method could be applied to extract product lines from legacy systems where features are not explicitly declared.
  • Atoms might enable mixing components written in unrelated languages within one product line.
  • The protocol could be tested on an SPL whose artifacts use a composer not represented in the Neverlang example.

Load-bearing premise

That atoms can be defined and extracted in a way that captures the necessary feature dependencies without requiring strong assumptions on the technological space or specific composer mechanisms.

What would settle it

A case where atoms cannot be identified for a given SPL without embedding assumptions about its particular language or composer.

Figures

Figures reproduced from arXiv: 2605.28989 by Federico Bruzzone, Luca Favalli, Walter Cazzola.

Figure 1
Figure 1. Figure 1: High-level overview of the protocol, including its actors and its steps. [PITH_FULL_IMAGE:figures/full_fig_p005_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Feature model of the LogLang LPL. on the development process and on the project scale, the user may be a single entity or a team of multiple entities, such as language developer, language deployer and language user [19]. The Software assets are the concrete software artifacts of the product line. With regards to our running example, it com￾prises the linguistic assets, including both syntax and semantics, … view at source ↗
Figure 3
Figure 3. Figure 3: Exemplary configuration process step within the SPL client frontend. [PITH_FULL_IMAGE:figures/full_fig_p012_3.png] view at source ↗
read the original abstract

Software product line (SPL) engineering has been successfully applied to software development by obtaining software systems as compositions of modular features. Existing approaches to SPL engineering, however, are typically bound to a specific technological space (such as, a programming language and a composer) and integrated development environment (IDE), and rely on extraction mechanisms that make strong assumptions on the underlying technological space. This tight coupling hinders reuse, evolution, and adoption of heterogeneous development environments. We propose a general, workbench-agnostic protocol for extracting feature models from existing software artifacts and for configuring and deriving software products. The protocol follows a bottom-up approach based on lightweight dependency units called "atoms", and organizes the extraction and configuration process around an SPL server (workbench-independent) and an SPL client with a workbench-specific backend and a generic frontend. The protocol makes few assumptions on the underlying software artifacts and is therefore applicable to varied SPLs. The applicability of this approach is presented through a prototypical implementation of the architecture in which several subsystems interact and can be swapped freely without affecting the others. In particular, we focus on the application of such a protocol in the context of language product lines (LPLs), demonstrating its applicability to concrete scenarios while preserving workbench-agnosticism. From bottom to top, the implementation comprises: Neverlang language artifacts, a Java SPL client backend, an agnostic and reusable SPL server written in Go and Prolog, and a JavaScript SPL client frontend.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

1 major / 0 minor

Summary. The paper proposes a general, workbench-agnostic protocol for extracting feature models from existing software artifacts and for configuring/deriving products. It uses a bottom-up approach based on lightweight dependency units called 'atoms', organized around an SPL server (implemented in Go and Prolog) that is independent of any specific workbench and SPL clients that have workbench-specific backends but generic frontends. The protocol is claimed to make few assumptions on artifacts and thus apply to varied SPLs; applicability is shown via a prototype focused on language product lines (LPLs) using Neverlang artifacts, with swappable subsystems.

Significance. If the atom-based extraction can be shown to work without reintroducing technology-specific assumptions, the client-server separation and reusable server could enable broader reuse and evolution of SPL engineering across heterogeneous environments. The architecture's modularity (server in Go/Prolog, swappable clients) is a concrete strength that supports the workbench-agnostic claim.

major comments (1)
  1. [Abstract] Abstract: the central claim that the protocol 'makes few assumptions on the underlying software artifacts and is therefore applicable to varied SPLs' is load-bearing for the contribution, yet the only concrete extraction and dependency handling described uses Neverlang language artifacts; no argument, mapping, or example is supplied showing how atoms and their dependency relations would be identified for a non-language SPL (e.g., C preprocessor-based) without reintroducing the technological assumptions the protocol claims to avoid.

Simulated Author's Rebuttal

1 responses · 0 unresolved

We thank the referee for the constructive review and for highlighting the architecture's modularity as a potential strength. We address the single major comment below.

read point-by-point responses

  1. Referee: [Abstract] Abstract: the central claim that the protocol 'makes few assumptions on the underlying software artifacts and is therefore applicable to varied SPLs' is load-bearing for the contribution, yet the only concrete extraction and dependency handling described uses Neverlang language artifacts; no argument, mapping, or example is supplied showing how atoms and their dependency relations would be identified for a non-language SPL (e.g., C preprocessor-based) without reintroducing the technological assumptions the protocol claims to avoid.

    Authors: We agree with the observation. The manuscript's concrete extraction logic and atom identification are demonstrated exclusively through Neverlang language artifacts, while the core protocol (atoms as minimal dependency units, server-side resolution in Prolog, and client backends) is presented abstractly. No explicit mapping or worked example is supplied for a non-language SPL such as one based on the C preprocessor. We will revise the paper to add a dedicated subsection that sketches how atoms and their relations could be extracted from preprocessor directives (or equivalent artifacts) while keeping the protocol-level assumptions minimal and technology-independent; the revision will also clarify the separation between the general protocol and the workbench-specific extraction performed by clients. revision: yes

Circularity Check

0 steps flagged

No circularity: architectural protocol proposal with no equations, fits, or self-referential derivations

full rationale

The paper presents a new workbench-agnostic extraction protocol organized around atoms, an SPL server, and client backends. No equations, parameter fitting, or predictive derivations appear in the provided text. The generality claim rests on the stated design property that the protocol 'makes few assumptions on the underlying software artifacts,' which is an architectural assertion rather than a reduction of an output to its own inputs by construction. No self-citations are invoked as load-bearing uniqueness theorems, and the single Neverlang example is presented as a demonstration, not as a fitted input renamed as a prediction. The derivation chain is therefore self-contained as a proposal of structure and interfaces.

Axiom & Free-Parameter Ledger

0 free parameters · 1 axioms · 1 invented entities

The central claim rests on the domain assumption that atoms can serve as a universal lightweight unit for dependency extraction across technological spaces; no free parameters or invented entities with independent evidence are described.

axioms (1)
  • domain assumption Lightweight dependency units called atoms can capture necessary feature dependencies without strong assumptions on the underlying technological space.
    Invoked in the abstract as the basis for the bottom-up extraction protocol and its claimed wide applicability.
invented entities (1)
  • atoms no independent evidence
    purpose: Lightweight dependency units for bottom-up feature model extraction
    New concept introduced to organize the extraction process; no independent evidence or falsifiable prediction provided in the abstract.

pith-pipeline@v0.9.1-grok · 5786 in / 1269 out tokens · 31545 ms · 2026-06-29T10:33:33.323821+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

67 extracted references · 9 canonical work pages · 1 internal anchor

  1. [1]

    Mathieu Acher, Anthony Cleve, Philippe Collet, Philippe Merle, Laurence Duchien, and Philippe Lahire. 2014. Ex- traction and Evolution of Architectural Variability Models in Plugin-Based Systems.Software and Systems Modeling 13, 4 (July 2014), 1367–1394

    2014

  2. [2]

    Aho, Ravi Sethi, and Jeffrey D

    Alfred V . Aho, Ravi Sethi, and Jeffrey D. Ullman. 1986. Compilers: Principles, Techniques, and Tools. Addison Wesley, Reading, Massachusetts

    1986

  3. [3]

    Sven Apel and Christian Kästner. 2009. An Overview of Feature-Oriented Software Development.Journal of Object Technology8, 5 (July 2009), 49–84

    2009

  4. [4]

    Sven Apel, Alexander von Thein, Philipp Wendler, Armin Größlinger, and Firk Beyer. 2013. Strategies for Product- Line Verification: Case Studies and Experiments. InPro- ceedings of the 35th International Conference on Software Engineering (ICSE’13), Betty H. Chang and Klaus Pohl (Eds.). IEEE, San Francisco, CA, USA, 482–491

    2013

  5. [5]

    Wesley K. G. Assunção, Roberto E. Lopez-Herrejon, Lukas Linsbauer, Silvia R. Vergilio, and Alexander Egyed

  6. [6]

    2017), 2972–3016

    Reengineering Legacy Applications into Software Product Lines: A Systematic Mapping.Empirical Software Engineering22, 6 (Feb. 2017), 2972–3016

    2017

  7. [7]

    Don Batory. 2005. Feature Models, Grammars, and Propo- sitional Formulas. InProceedings of the 4th International Conference on Software Product-Line (SPLC’05) (LNCS 3714), Henk Obbink and Klaus Pohl (Eds.). Springer, Rennes, France, 7–20. 14

    2005

  8. [8]

    Don Batory, Jacob Neal Sarvela, and Axel Rauschmayer

  9. [9]

    Scaling Step-Wise Refinement.IEEE Transactions on Software Engineering30, 6 (June 2004), 355–371

    2004

  10. [10]

    ter Beek, Ferruccio Damiani, Michael Lien- hardt, Franco Mazzanti, and Luca Paolini

    Maurice H. ter Beek, Ferruccio Damiani, Michael Lien- hardt, Franco Mazzanti, and Luca Paolini. 2019. Static Analysis of Featured Transition Systems. InProceedings of the 23rd International Systems and Software Product Line Conference (SPLC’19), Laurence Duchien and Thomas Thüm (Eds.). ACM, Paris, France, 39–51

    2019

  11. [11]

    David Benavides, Sergio Segura, and Antonio Ruiz-Cortés

  12. [12]

    2010), 615–636

    Automated Analysis of Feature Models 20 Years Later: A Literature Review.Information Systems35, 6 (Sept. 2010), 615–636

    2010

  13. [13]

    Lorenzo Bettini. 2016. Implementing Type Systems for the IDE with Xsemantics.Journal of Logical and Algebraic Methods in Programming85, 5 (Aug. 2016), 655–680

    2016

  14. [14]

    Lorenzo Bettini and Pierluigi Crescenzi. 2015. An Eclipse IDE for Teaching Java--. InProceedings of 10th Interna- tional Conference on Software Technology (ICSOFT’15) (Communications in Computer and Information Science 586), Pascal Lorenz, Jorge Cardoso, Leszek A. Maciaszek, and Marten van Sinderen (Eds.). Springer, Colmar, France, 63–78

    2015

  15. [15]

    Federico Bruzzone and Walter Cazzola

  16. [16]

    Meta-Monomorphizing Specializations

    Meta-Monomorphizing Specializations. arXiv:2602.12973 [cs.PL] https://arxiv.org/ abs/2602.12973

    work page internal anchor Pith review Pith/arXiv arXiv

  17. [18]

    Code Less to Code More: Streamlining Language Server Protocol and Type System Development for Lan- guage Families.Journal of Systems and Software231 (Jan. 2026). doi:10.1016/j.jss.2025.112554

    work page doi:10.1016/j.jss.2025.112554 2026

  18. [19]

    Federico Bruzzone, Walter Cazzola, and Luca Favalli

  19. [20]

    arXiv:2602.03777 [cs.PL] https://arxiv

    From Separate Compilation to Sound Language Composition. arXiv:2602.03777 [cs.PL] https://arxiv. org/abs/2602.03777

    work page arXiv

  20. [21]

    Federico Bruzzone, Walter Cazzola, and Luca Favini

  21. [22]

    arXiv:2601.16008 [cs.PL] https://arxiv.org/abs/2601.16008

    Prioritizing Configuration Relevance via Compiler- Based Refined Feature Ranking. arXiv:2601.16008 [cs.PL] https://arxiv.org/abs/2601.16008

    work page arXiv

  22. [23]

    Hendrick Bünder and Herbert Kuchen. 2019. Towards Multi-editor Support for Domain-Specific Languages Uti- lizing the Language Server Protocol. InProceedings of the 7th International Conference on Model-Driven Engi- neering and Software Development (MODELSWARD’19), Slimane Hammoudi, Luís Ferreira Pires, and Bran Seli ´c (Eds.). Springer, Prague, Czech Repu...

    2019

  23. [24]

    Bruno B. P. Cafeo, Elder Cirilo, Alessandro Garcia, Fran- cisco Dantas, and Jaejoon Lee. 2016. Feature Dependen- cies as Change Propagators: An Exploratory Study of Soft- ware Product Lines.Information and Software Technology 69 (Jan. 2016), 37–49

    2016

  24. [25]

    Walter Cazzola. 2012. Domain-Specific Languages in Few Steps: The Neverlang Approach. InProceedings of the 11th International Conference on Software Composi- tion (SC’12) (Lecture Notes in Computer Science 7306), Thomas Gschwind, Flavio De Paoli, V olker Gruhn, and Matthias Book (Eds.). Springer, Prague, Czech Republic, 162–177

    2012

  25. [26]

    Walter Cazzola and Luca Favalli. 2022. Towards a Recipe for Language Decomposition: Quality Assessment of Lan- guage Product Lines.Empirical Software Engineering27, 4 (April 2022). doi:10.1007/s10664-021-10074-6

    work page doi:10.1007/s10664-021-10074-6 2022

  26. [27]

    Walter Cazzola and Luca Favalli. 2023. The Language Mutation Problem: Leveraging Language Product Lines for Mutation Testing of Interpreters.Journal of Systems and Software195 (Jan. 2023). doi: 10.1016/j.jss.2022. 111533

    work page doi:10.1016/j.jss.2022 2023

  27. [28]

    Walter Cazzola and Diego Mathias Olivares. 2016. Grad- ually Learning Programming Supported by a Growable Programming Language.IEEE Transactions on Emerg- ing Topics in Computing4, 3 (Sept. 2016), 404–415. doi:10.1109/TETC.2015.2446192 Special Issue on Emerg- ing Trends in Education

    work page doi:10.1109/tetc.2015.2446192 2016

  28. [29]

    2000.Java Card Technology for Smart Cards: Architecture and Programmer’s Guide

    Zhiqun Chen. 2000.Java Card Technology for Smart Cards: Architecture and Programmer’s Guide. Addison- Wesley, Reading, MA, USA

    2000

  29. [30]

    Alain Colmerauer and Philippe Roussel. 1996. The Birth of Prolog. InHistory of Programming Languages, Thomas J. Bergin and Richard G. Gibson (Eds.). ACM, Chapter VII, 331–367

    1996

  30. [31]

    Crane and Juergen Dingel

    Michelle L. Crane and Juergen Dingel. 2005. UML vs. Classical vs. Rhapsody Statecharts: Not All Models Are Created Equal. InProceedings of the 8th International Conference on Model Driven Engineering Languages and Systems (MoDELS’05) (Lecture Notes in Computer Science 3713), Lionel Briand and Clay Williams (Eds.). Springer, Montego Bay, Jamaica, 97–112

    2005

  31. [32]

    Krzysztof Czarnecki and Andrzej W ˛ asowski. 2007. Fea- ture Diagrams and Logics: There and Back Again. InPro- ceedings of the 11th International Software Product Line Conference (SPLC’07), Tomoji Kishi and Dirk Muthig (Eds.). IEEE, Kyoto, Japan, 23–34

    2007

  32. [33]

    Thomas Degueule, Benoît Combemale, Arnaud Blouin, Olivier Barais, and Jean-Marc Jézéquel. 2015. Melange: a Meta-Language for Modular and Reusable Development of DSLs. InProceedings of the 8th International Confer- ence on Software Language Engineering (SLE’15), Davide Di Ruscio and Markus Völter (Eds.). ACM, Pittsburgh, PA, USA, 25–36

    2015

  33. [34]

    Florian Drux, Nico Jansen, and Bernhard Rumpe. 2022. A Catalog of Design Patterns for Compositional Language Engineering.Journal of Object Technology21, 4 (Oct. 15 2022), 4:1–13. doi: 10.5381/jot.2022.21.4.a4 Special Issue dedicated to Antonio Vallecillo on his 60th Birthday

    work page doi:10.5381/jot.2022.21.4.a4 2022

  34. [35]

    Sebastian Erdweg, Tillmann Rendel, Christian Kästner, and Klaus Ostermann. 2011. SugarJ: Library-Based Syn- tactic Language extensibility. InProceedings of the 26th ACM SIGPLAN Conference on Object-Oriented Program- ming (OOPSLA’11). ACM, Portland, Oregon, USA, 391– 406

    2011

  35. [36]

    Luca Favalli, Thomas Kühn, and Walter Cazzola. 2020. Neverlang and FeatureIDE Just Married: Integrated Lan- guage Product Line Development Environment. InPro- ceedings of the 24th International Software Product Line Conference (SPLC’20), Philippe Collet and Sarah Nadi (Eds.). ACM, Montréal, Canada, 285–295

    2020

  36. [37]

    Haslinger, Roberto E

    Elisabeth N. Haslinger, Roberto E. Lopez-Herrejon, and Alexander Egyed. 2013. On Extracting Feature Models from Sets of Valid Feature Combinations. InProceedings of the 16th International Conference on Fundamental Ap- proaches to Software Engineering (FASE’13) (LNCS 7793), Vittorio Cortellessa and Daniel Varrò (Eds.). Springer, Rome, Italy, 53–67

    2013

  37. [38]

    1968.Logical Writings

    Jacques Herbrand. 1968.Logical Writings. Springer. «Écrits Logiques» translated in English by Jean van Hei- jenoort

    1968

  38. [39]

    Kang, Sholom G

    Kyo C. Kang, Sholom G. Cohen, James A. Hess, William E. Novak, and A. Spencer Peterson. 1990.Feature-Oriented Domain Analysis (FODA) Feasibility Study. Technical Report CMU/SEI-90-TR-21. Carnegie Mellon University, Pittsburgh, Pennsylvania, USA

    1990

  39. [40]

    Lennart C. L. Kats, Eelco Visser, and Guido Wachsmuth

  40. [41]

    InProceedings of ACM Conference on New Ideas in Programming and Reflections on Software (Onward! 2010)

    Pure and Declarative Syntax Definition: Paradise Lost and Regained. InProceedings of ACM Conference on New Ideas in Programming and Reflections on Software (Onward! 2010). ACM, Reno-Tahoe, Nevada, USA

    2010

  41. [42]

    Gregor Kiczales, Erik Hilsdale, Jim Hugunin, Mik Ker- sten, JeffPalm, and Bill Griswold. 2001. An Overview of AspectJ. InProceedings of the 15th European Conference on Object-Oriented Programming (ECOOP’01) (LNCS 2072), Jørgen Lindskov Knudsen (Ed.). Springer-Verlag, Budapest, Hungary, 327–353

    2001

  42. [43]

    Paul Klint, Tijs van der Storm, and Jurgen Vinju. 2009. EASY Meta-Programming with Rascal. InProceedings of the International Summer School on Generative and Transformational Techniques in Software Engineering III (GTTSE’09) (Lecture Notes in Computer Science 6491), João M. Fernandes, Ralf Lämmel, Joost Visser, and João Saraiva (Eds.). Springer, Braga, Po...

    2009

  43. [44]

    Holger Krahn, Bernhard Rumpe, and Steven Völkel. 2010. MontiCore: A Framework for Compositional Development of Domain Specific Languages.International Journal on Software Tools for Technology Transfer12, 5 (Sept. 2010), 353–372

    2010

  44. [45]

    Charles W. Krueger. 2001. Easing the Transition to Soft- ware Mass Customization. InProceedings of the 1st Inter- national Workshop on Software Product-Family Engineer- ing (PFE’01) (Lecture Notes in Computer Science 2290), F. van der Linden (Ed.). Springer, Bilbao, Spain, 282–293

    2001

  45. [46]

    Thomas Kühn and Walter Cazzola. 2016. Apples and Or- anges: Comparing Top-Down and Bottom-Up Language Product Lines. InProceedings of the 20th International Software Product Line Conference (SPLC’16), Rick Ra- biser and Bing Xie (Eds.). ACM, Beijing, China, 50–59

    2016

  46. [47]

    Thomas Kühn, Walter Cazzola, and Diego Mathias Oli- vares. 2015. Choosy and Picky: Configuration of Language Product Lines. InProceedings of the 19th International Software Product Line Conference (SPLC’15), Goetz Bot- terweck and Jules White (Eds.). ACM, Nashville, TN, USA, 71–80

    2015

  47. [48]

    Bissyandé, Jacques Klein, and Yves le Traon

    Jabier Martinez, Tewfik Ziadi, Tegawendé F. Bissyandé, Jacques Klein, and Yves le Traon. 2015. Automating the Extraction of Model-Based Software Product Lines from Model Variants. InProceedings of the 30th IEEE/ACM In- ternational Conference on Automated Software Engineer- ing (ASE’15), Myra Cohen, Lars Grunske, and Michael Whalen (Eds.). IEEE, Lincoln, N...

    2015

  48. [49]

    Matsakis

    Nicholas D. Matsakis. 2018. Maximally Min- imal Specialization: Always Applicable impls. Blog Post. https://smallcultfollowing. com/babysteps/blog/2018/02/09/ maximally-minimal-specialization-always-applicable-impls/

    2018

  49. [50]

    Marcilio Mendonca, Moises Branco, and Donald Cowan

  50. [51]

    InCompanion Proceedings of the 24th Conference on Object-Oriented Programming Systems Languages and Applications (Companion OOPSLA’09)

    S.P.L.O.T.—Software Product Lines Online Tools. InCompanion Proceedings of the 24th Conference on Object-Oriented Programming Systems Languages and Applications (Companion OOPSLA’09). ACM, Orlando, FL, USA, 761–762

  51. [52]

    Pierre M. Nugues. 2014.An Introduction to Language Processing with Perl and Prolog(second ed.). Springer

    2014

  52. [53]

    Jérôme Pfeiffer and Andreas Wortmann. 2021. Towards the Black-Box Aggregation of Language Components. In Proceedings of the 3rd International Workshop on Mod- elling Language Engineering (MLE’21), Federico Cic- cozzi, Thomas Degueule, Romina Eramo, and Sébastien Gérard (Eds.). IEEE, Fukuoka, Japan, 576–585

    2021

  53. [54]

    Jérôme Pfeiffer and Andreas Wortmann. 2023. A Low- Code Platform for Systematic Component-Oriented Lan- guage Composition. InProceedings of the 16th Inter- national Conference on Software Language Engineering (SLE’23), Thomas Degueuele and Elizabeth Scott (Eds.). ACM, Cascais, Portugal, 208–213

    2023

  54. [55]

    van der Linden

    Klaus Pohl, Klaus Böckle, and Frank J. van der Linden. 2005.Software Product Line Engineering: Foundations, Principles and Techniques. Springer. 16

    2005

  55. [56]

    Alan Robinson

    J. Alan Robinson. 1965. A Machine-Oriented Logic Based on the Resolution Principle.J. ACM12, 1 (Jan. 1965), 23–41

    1965

  56. [57]

    Ina Schaefer, Lorenzo Bettini, Viviana Bono, Ferruccio Damiani, and Nico Tanzarella. 2010. Delta-Oriented Pro- gramming of Software Product Lines. InProceedings of the 14th International Software Product Line Conference (SPLC’10) (Lecture Notes on Computer Science 6287), Jan Bosch and Jaejoon Lee (Eds.). Springer, Jeju Island, South Korea, 77–91

    2010

  57. [58]

    Baliga, Jonathan T

    Paul Shannon, Andrew Markiel, Owen Ozier, Nitin S. Baliga, Jonathan T. Wang, Daniel Ramage, Nada Amin, Benno Schwikowski, and Trey Ideker. 2003. Cytoscape: A Software Environment for Integrated Models of Biomolec- ular Interaction Networks.Genome Research13, 11 (Nov. 2003), 2498–2504

    2003

  58. [59]

    Steven She, Rafael Lotufo, Thorsten Berger, Andrzej W˛ asowski, and Krzysztof Czarnecki. 2011. Reverse Engi- neering Feature Models. InProceedings of the 33rd Inter- national Conference on Software Engineering (ICSE’11), Harald Gall and Nenad Medvidovi´c (Eds.). IEEE, Waikiki, Honolulu, Hawaii, 461–470

    2011

  59. [60]

    Thomas Thüm, Christian Kästner, Fabian Benduhn, Jens Meinicke, Gunter Saake, and Thomas Leich. 2014. Fea- tureIDE: An Extensible Framework for Feature-Oriented Software Development.Science of Computer Program- ming79, 1 (Jan. 2014), 70–85

    2014

  60. [61]

    Laurence Tratt. 2008. Domain Specific Language Imple- mentation Via Compile-Time Meta-Programming.ACM Transactions on Programming Languages and Systems30, 6 (Oct. 2008), 31:1–31:40

    2008

  61. [62]

    Aaron Turon. 2017. Shipping Specialization: A Story of Soundness. Blog Post. https://aturon.github.io/ blog/2017/07/08/lifetime-dispatch/

    2017

  62. [63]

    Edoardo Vacchi and Walter Cazzola. 2015. Neverlang: A Framework for Feature-Oriented Language Development. Computer Languages, Systems&Structures43, 3 (Oct. 2015), 1–40. doi:10.1016/j.cl.2015.02.001

    work page doi:10.1016/j.cl.2015.02.001 2015

  63. [64]

    Edoardo Vacchi, Walter Cazzola, Benoît Combemale, and Mathieu Acher. 2014. Automating Variability Model In- ference for Component-Based Language Implementations. InProceedings of the 18th International Software Product Line Conference (SPLC’14), Patrick Heymans and Julia Rubin (Eds.). ACM, Florence, Italy, 167–176

    2014

  64. [65]

    Edoardo Vacchi, Walter Cazzola, Suresh Pillay, and Benoît Combemale. 2013. Variability Support in Domain-Specific Language Development. InProceedings of 6 th Interna- tional Conference on Software Language Engineering (SLE’13) (Lecture Notes on Computer Science 8225), Mar- tin Erwig, Richard F. Paige, and Eric Van Wyk (Eds.). Springer, Indianapolis, USA, 76–95

    2013

  65. [66]

    Markus Völter, Daniel Ratiu, Bernhard Schätz, and Bernd Kolb. 2012. mbeddr: an Extensible C-Based Programming Language and IDE for Embedded Systems. InProceedings of the 3rd Annual Conference on Systems, Programming, and Applications: Software for Humanity (SPLASH’12). ACM, Tucson, AZ, USA, 121–140

    2012

  66. [67]

    Wachsmuth, Gabriël D

    Guido H. Wachsmuth, Gabriël D. P. Konat, and Eelco Visser. 2014. Language Design with the Spoofax Language Workbench.IEEE Software31, 5 (Sept./Oct. 2014), 35– 43

    2014

  67. [68]

    Huilin Ye and Hanchang Liu. 2005. Approach to Modelling Feature Variability and Dependencies in Software Product Lines.IEE Proceedings—Software152, 3 (June 2005), 101–109. 17

    2005