pith. sign in

arxiv: 2509.15150 · v1 · submitted 2025-09-18 · 💻 cs.SE · cs.PL

Code Less to Code More: Streamlining Language Server Protocol and Type System Development for Language Families

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

Pith reviewed 2026-05-18 15:35 UTC · model grok-4.3

classification 💻 cs.SE cs.PL
keywords language server protocoltype systemmodular workbenchdomain-specific languagesvariant-oriented programmingLSP plugin generationlanguage familiesediting support
0
0 comments X

The pith

Typelang and automated generation cut type system code by over 93 percent for language families

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

This paper introduces Typelang as a family of languages for creating modular and reusable type systems for programming languages. It pairs this with a process to automatically generate language servers and plugins for the Language Server Protocol. The goal is to simplify providing editing support when there are many languages and many editors by allowing reuse of components so that not every language needs its own full type system implementation. A sympathetic reader would care because building editors for new languages or variants is currently very labor intensive.

Core claim

The paper claims that integrating Typelang into language artifacts within a modular workbench, managed by variant-oriented programming and a coordination layer, allows generation of language servers per artifact and full automation of LSP plugins for editors. This first reduces the problem to one language server per type system, and with reuse of artifacts across languages further reduces it to a small number of unique type systems, demonstrated by a 93.48% reduction in the characters required for type system code and 100% automation of plugin generation.

What carries the argument

Typelang, a family of domain-specific languages designed for modular, composable, and reusable type system implementations, together with a variant-oriented programming paradigm for handling interdependent language variants.

If this is right

  • Language servers are produced automatically from each modular language artifact.
  • LSP plugins for different editors are generated without manual coding, achieving 100% automation.
  • Reuse of language artifacts across related languages reduces the number of unique type systems needed from T to N where N is much smaller than T.
  • The total effort to provide editing support for language families drops substantially due to the character reduction and automation.

Where Pith is reading between the lines

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

  • This method could be applied to other language implementation concerns like parsing or runtime semantics to achieve similar reuse benefits.
  • Large libraries of reusable language components might emerge if the reuse across families proves effective in practice.
  • Empirical studies on real-world language families would help quantify the reuse factor N/T in typical scenarios.

Load-bearing premise

Language artifacts from the modular workbench can be reused across different languages to reduce the count of unique type systems to far fewer than the number of languages.

What would settle it

A direct comparison of total code characters and development time for type systems and LSP plugins when building support for a set of related languages with full reuse versus without any reuse.

Figures

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

Figure 1
Figure 1. Figure 1: Traditional vs LSP approach to language editing support [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: LSP approach to language support. Borrowed from [122] [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: The diagram on the left illustrates the two dimension of variability: (1) [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: The diagram shows the four layers of Typelang in action. Execution Layer ❶: Divided into three vertical sections. The left shows a function scope created within the global scope; the right shows a function scope within a class scope. The center displays the contents of each scope and their hierarchical relationships. Declaration Layer ❷: Includes three artifacts—function, class, and assignment. Each artifa… view at source ↗
Figure 5
Figure 5. Figure 5: The modularity and extensibility of Typelang, illustrating the inde￾pendent definition and composition of scopes, types, and signatures as reusable building blocks that can be assembled into language-specific variants at compile￾time. The diagram demonstrates a simplified version of Typelang scopes struc￾ture, with each scope associated with a typing environment that contains the unordered pairs of identif… view at source ↗
Figure 6
Figure 6. Figure 6: The diagram shows an AST with the compilation unit tasks associated. – the executor, which accepts a configuration and executes the tasks concurrently according to the executor service; – the executor service, which provides routines to manage termination and methods that can produce a Future for tracking the progress of asynchronous tasks; – the task queue—a min-heap priority queue—in which the task depen… view at source ↗
Figure 7
Figure 7. Figure 7: A comparison of the LoC and NoC needed to implement a type system using [PITH_FULL_IMAGE:figures/full_fig_p018_7.png] view at source ↗
Figure 5
Figure 5. Figure 5: Given the variety of type inference strategies available— [PITH_FULL_IMAGE:figures/full_fig_p019_5.png] view at source ↗
Figure 8
Figure 8. Figure 8: A comparison of the LoC and NoC needed to implement a type system using [PITH_FULL_IMAGE:figures/full_fig_p021_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: Comparative analysis of LoCs and NoCs required to implement the [PITH_FULL_IMAGE:figures/full_fig_p023_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: A graphical representation of the T × 1 and N × 1 reduction using the client generator. In Sect. 5.1 and Sect. 5.3, we highlighted the possibility of generating the language server implementation by leveraging the data structures provided by the language workbench. We also demonstrated that the properties of variant-oriented pro￾gramming and cross-artifact modularization layer have been crucial in ensurin… view at source ↗
read the original abstract

Developing editing support for $L$ languages in $E$ editors is complex and time-consuming. Some languages do not provide dedicated editors, while others offer a single native editor. The $\textit{language server protocol}$ (LSP) reduces the language-editor combinations $L \times E$ to $L + E$, where a single language server communicates with editors via LSP plugins. However, overlapping implementations of linguistic components remain an issue. Existing language workbenches struggle with modularity, reusability, and leveraging type systems for language server generation. In this work, we propose: (i) Typelang, a family of domain-specific languages for modular, composable, and reusable type system implementation, (ii) a modular language server generation process, producing servers for languages built in a modular workbench, (iii) the variant-oriented programming paradigm and a cross-artifact coordination layer to manage interdependent software variants, and (iv) an LSP plugin generator, reducing $E$ to $1$ by automating plugin creation for multiple editors. To simplify editing support for language families, each language artifact integrates its own Typelang variant, used to generate language servers. This reduces combinations to $T \times 1$, where $T = L$ represents the number of type systems. Further reuse of language artifacts across languages lowers this to $N \times 1$, where $N << T$, representing unique type systems. We implement Typelang in Neverlang, generating language servers for each artifact and LSP plugins for three editors. Empirical evaluation shows a 93.48% reduction in characters needed for type system implementation and 100% automation of LSP plugin generation, significantly lowering effort for editing support in language families, especially when artifacts are reused.

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

2 major / 2 minor

Summary. The paper introduces Typelang, a family of DSLs for modular and composable type system definitions, a modular language server generation process, the variant-oriented programming paradigm with a cross-artifact coordination layer, and an automated LSP plugin generator. It claims these reduce editing support effort for language families from L × E combinations to T × 1 and further to N × 1 (N ≪ T) via artifact reuse, with an empirical evaluation in Neverlang showing a 93.48% reduction in type system implementation characters and 100% automation of LSP plugin generation for three editors.

Significance. If the reuse claims are substantiated, the work addresses a practical pain point in language engineering by enabling shared type system components across language variants and automating LSP plugin creation, potentially lowering barriers for families of related languages. The implementation in an existing workbench (Neverlang) and support for multiple editors are practical strengths that could influence language workbench design.

major comments (2)
  1. [§5] §5 (Empirical Evaluation): The reported 93.48% reduction in characters for type system implementation and 100% LSP automation lack any description of baselines, measurement methodology, controls, specific languages evaluated, or the fraction of components actually reused across artifacts. Without these details it is impossible to determine whether the results support the central claim that reuse reduces the problem from T to N ≪ T rather than providing only per-language modularization benefits.
  2. [§3.3] §3.3 (Cross-Artifact Coordination Layer): The description of how the coordination layer resolves inter-variant dependencies is not accompanied by concrete metrics, examples, or case studies showing successful sharing of type system components across multiple languages in a family; this mechanism is load-bearing for the N × 1 reduction but remains unevidenced in the reported outcomes.
minor comments (2)
  1. [Introduction] The notation L × E, T × 1, and N × 1 would benefit from an accompanying diagram in the introduction to clarify the claimed reductions in editor-language combinations.
  2. [Abstract] Ensure all quantitative claims in the abstract are cross-referenced to the corresponding tables or figures in the evaluation section for traceability.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive feedback. The comments highlight opportunities to strengthen the substantiation of our empirical claims and the cross-artifact coordination mechanism. We address each point below and will revise the manuscript to incorporate additional details and evidence.

read point-by-point responses

  1. Referee: [§5] §5 (Empirical Evaluation): The reported 93.48% reduction in characters for type system implementation and 100% LSP automation lack any description of baselines, measurement methodology, controls, specific languages evaluated, or the fraction of components actually reused across artifacts. Without these details it is impossible to determine whether the results support the central claim that reuse reduces the problem from T to N ≪ T rather than providing only per-language modularization benefits.

    Authors: We agree that §5 would be strengthened by explicit descriptions of the evaluation methodology. In the revised version we will add: the specific Neverlang language variants used as subjects, the baseline (non-modular) implementations against which character counts were compared, the precise measurement procedure for source characters and reuse fraction, and quantitative data on how many type-system components were actually shared across variants. These additions will clarify that the observed 93.48 % reduction is attributable to cross-variant reuse rather than intra-language modularity alone, thereby supporting the claimed reduction from T × 1 to N × 1 with N ≪ T. revision: yes

  2. Referee: [§3.3] §3.3 (Cross-Artifact Coordination Layer): The description of how the coordination layer resolves inter-variant dependencies is not accompanied by concrete metrics, examples, or case studies showing successful sharing of type system components across multiple languages in a family; this mechanism is load-bearing for the N × 1 reduction but remains unevidenced in the reported outcomes.

    Authors: We acknowledge that §3.3 currently provides only a high-level description. We will revise the section to include concrete examples of inter-variant type dependencies, a small case study illustrating how the coordination layer resolves them when components are reused across family members, and quantitative metrics (e.g., number of shared components and resolved dependency edges) drawn from the Neverlang implementation. These additions will supply the missing evidence that the coordination layer enables the N × 1 reduction. revision: yes

Circularity Check

0 steps flagged

No significant circularity in derivation chain

full rationale

The paper describes Typelang as a family of DSLs for modular type systems, a modular LSP generation process, variant-oriented programming, and an LSP plugin generator, all implemented in Neverlang. The combination reductions (L×E to L+E, then T×1, then N×1) are high-level conceptual descriptions of the intended benefits of modularity and reuse rather than any mathematical derivation or equation that reduces to its own inputs by construction. The central claims rest on reported empirical outcomes (93.48% character reduction and 100% automation) from their implementation and evaluation, which are independent measurements. No self-definitional constructs, fitted inputs presented as predictions, or load-bearing self-citation chains appear. The derivation is self-contained against external benchmarks of code size and automation effort.

Axiom & Free-Parameter Ledger

0 free parameters · 1 axioms · 2 invented entities

Only the abstract is available, so the ledger is limited to elements explicitly named in it. No numeric free parameters are described. The main invented entities are the new DSL family and programming paradigm.

axioms (1)
  • domain assumption Existing language workbenches struggle with modularity, reusability, and leveraging type systems for language server generation.
    Stated directly in the abstract as motivation for the work.
invented entities (2)
  • Typelang no independent evidence
    purpose: Family of domain-specific languages for modular, composable, and reusable type system implementation
    Introduced as the central new artifact in the proposal.
  • variant-oriented programming paradigm no independent evidence
    purpose: Manage interdependent software variants across language artifacts
    Presented as a new paradigm to handle variant coordination.

pith-pipeline@v0.9.0 · 5859 in / 1378 out tokens · 39178 ms · 2026-05-18T15:35:12.483442+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

141 extracted references · 141 canonical work pages

  1. [1]

    Compilers: Prin- ciples, Techniques, and Tools

    Aho, A.V ., Sethi, R., Ullman, J.D., 1986. Compilers: Prin- ciples, Techniques, and Tools. Addison Wesley, Reading, Massachusetts

    work page 1986

  2. [2]

    Error Recovery in Recursive Descent Parsers and Run-Time Storage Organization

    Ammann, U., 1978. Error Recovery in Recursive Descent Parsers and Run-Time Storage Organization. Technical Report D-INFK. ETH Zürich, Department of Computer Science. Zürich, Switzerland

    work page 1978

  3. [3]

    Aspectual Feature Modules

    Apel, S., Leich, T., Saake, G., 2008. Aspectual Feature Modules. IEEE Transactions on Software Engineering 34, 162–180

    work page 2008

  4. [4]

    Strategies for Product-Line Verifica- tion: Case Studies and Experiments, in: Chang, B.H., Pohl, K

    Apel, S., von Thein, A., Wendler, P., Größlinger, A., Beyer, F., 2013. Strategies for Product-Line Verifica- tion: Case Studies and Experiments, in: Chang, B.H., Pohl, K. (Eds.), Proceedings of the 35th International Conference on Software Engineering (ICSE’13), IEEE, San Francisco, CA, USA. pp. 482–491

    work page 2013

  5. [5]

    Barros, D., Peldszus, S., Assunção, W.K.G., Berger, T.,

    work page

  6. [6]

    (Ed.), Proceedings of the 25th International Conference on Model Driven Engineering Langauges and Systems (MoDELS’22), ACM, Montréal, Canada

    Editing Support for Software Languages: Imple- mentation Practices in Language Server Protocols, in: Wimmer, M. (Ed.), Proceedings of the 25th International Conference on Model Driven Engineering Langauges and Systems (MoDELS’22), ACM, Montréal, Canada. pp. 232–243

    work page

  7. [7]

    Framing Software Reuse: Lessons from the Real World

    Bassett, P., 1996. Framing Software Reuse: Lessons from the Real World. Prentice Hall

    work page 1996

  8. [8]

    Modular Language Implementation in Rascal— Experience Report

    Basten, B., van den Bos, J., Hills, M., Klint, P., Lankamp, A., Lisser, B., van der Ploeg, A., van der Storm, T., Vinju, J., 2015. Modular Language Implementation in Rascal— Experience Report. Science of Computer Programming 114, 7–19

    work page 2015

  9. [9]

    Batory, D., Lofaso, B., Smaragdakis, Y ., 1998. JTS: Tools for Implementing Domain-Specific Languages, in: Pro- ceedings of the 5th International Conference on Software Reuse (ICSR’98), IEEE Computer Society, Victoria, BC, Canada. pp. 143–153

    work page 1998

  10. [10]

    Scaling Step-Wise Refinement

    Batory, D., Sarvela, J.N., Rauschmayer, A., 2004. Scaling Step-Wise Refinement. IEEE Transactions on Software Engineering 30, 355–371

    work page 2004

  11. [11]

    Reuse Frequency as Metric for Component Assessment

    Bay, T.G., Pauls, K., 2004. Reuse Frequency as Metric for Component Assessment. Technical Report 464. ETH, Department of Computer Science. Zürich, Switzerland

    work page 2004

  12. [12]

    Application of SMT in a Meta-Compiler: A Logic DSL for Specifying Type Systems, in: Graham-Lengrand, S., Preiner, M

    Béguet, R., Amiard, R., 2023. Application of SMT in a Meta-Compiler: A Logic DSL for Specifying Type Systems, in: Graham-Lengrand, S., Preiner, M. (Eds.), Proceedings of the 21st International Workshop on Satisfi- ability Modulo Theories (SMT’23), CEUR, Haifa, Israel. pp. 46–61

    work page 2023

  13. [13]

    Computational Geometry: Algorithms and Applications

    de Berg, M., Cheong, O., van Kreveld, M., Overmars, M., 2008. Computational Geometry: Algorithms and Applications. 3rd ed., Springer

    work page 2008

  14. [14]

    On the Granularity of Linguistic Reuse

    Bertolotti, F., Cazzola, W., Favalli, L., 2023a. On the Granularity of Linguistic Reuse. Journal of Systems and Software 202. doi:10.1016/j.jss.2023.111704. 27 Cite as: F. Bruzzone, W. Cazzola, and L. Favalli.Code Less to Code More: Streamlining Language Server Protocol and Type System Development for Language Families. Journal of Systems and Software, Ju...

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

  15. [15]

    Journal of Systems and Software 205

    Bertolotti, F., Cazzola, W., Favalli, L., 2023b.SP LL SP: Software Product Lines Extraction Driven by Language Server Protocol. Journal of Systems and Software 205. doi:10.1016/j.jss.2023.111809

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

  16. [16]

    A DSL for Writing Type Systems for Xtext Languages, in: Probst, C.W., Wimmer, C

    Bettini, L., 2011. A DSL for Writing Type Systems for Xtext Languages, in: Probst, C.W., Wimmer, C. (Eds.), Proceedings of the 9th International Conference on Prin- ciples and Practice of Programming in Java (PPPJ’11), ACM, Kongens Lyngby, Denmark. pp. 31–40

    work page 2011

  17. [17]

    Implementing Domain-Specific Lan- guages with Xtext and Xtend

    Bettini, L., 2013a. Implementing Domain-Specific Lan- guages with Xtext and Xtend. PACKT Publishing Ltd

    work page

  18. [18]

    Implementing Java-like Languages in Xtext with Xsemantics, in: Proceedings of the 28th An- nual ACM Symposium on Applied Computing (SAC’13), ACM, Coimbra, Portugal

    Bettini, L., 2013b. Implementing Java-like Languages in Xtext with Xsemantics, in: Proceedings of the 28th An- nual ACM Symposium on Applied Computing (SAC’13), ACM, Coimbra, Portugal. pp. 1559–1564

    work page

  19. [19]

    Implementing Type Systems for the IDE with Xsemantics

    Bettini, L., 2016. Implementing Type Systems for the IDE with Xsemantics. Journal of Logical and Algebraic Methods in Programming 85, 655–680

    work page 2016

  20. [20]

    Type Errors for the IDE with Xtext and Xsemantics

    Bettini, L., 2019. Type Errors for the IDE with Xtext and Xsemantics. Journal Open Computer Science 9, 52–79

    work page 2019

  21. [21]

    Imple- menting a Typed Javascript and Its IDE: A CASE-Study with Xsemantics

    Bettini, L., von Pilgrim, J., Reiser, M.O., 2016. Imple- menting a Typed Javascript and Its IDE: A CASE-Study with Xsemantics. Journal on Advances in Software 9, 283–303

    work page 2016

  22. [22]

    Measures for Quality Evaluation of Feature Models, in: Proceedings of the 9th International Conference on Soft- ware and Software Reuse (ICSR’15), Springer, Miami, FL, USA

    Bezerra, C.I.M., Andrade, R.M.C., Monteiro, J.M., 2015. Measures for Quality Evaluation of Feature Models, in: Proceedings of the 9th International Conference on Soft- ware and Software Reuse (ICSR’15), Springer, Miami, FL, USA. pp. 282–297

    work page 2015

  23. [23]

    Object-Oriented Anal- ysis and Design with Applications

    Booch, G., Maksimchuk, R., Engle, M., Young, B., Conallen, J., Houston, K., 2007. Object-Oriented Anal- ysis and Design with Applications. Third ed., Addison- Wesley

    work page 2007

  24. [24]

    A Unified Frame- work for Coupling Measurement in Object-Oriented Sys- tems

    Briand, L.C., Daly, J.W., Wüst, J., 1999. A Unified Frame- work for Coupling Measurement in Object-Oriented Sys- tems. IEEE Transactions on Software Engineering 25, 91–121

    work page 1999

  25. [25]

    Decoupling Language and Editor: The Impact of the Language Server Protocol on Tex- tual Domain-Specific Languages, in: Hammoudi, S., Fer- reira Pires, L., Seliç, B

    Bünder, H., 2019. Decoupling Language and Editor: The Impact of the Language Server Protocol on Tex- tual Domain-Specific Languages, in: Hammoudi, S., Fer- reira Pires, L., Seliç, B. (Eds.), Proceedings of the 7th International Conference on Model-Driven Engineering and Software Development (MODELW ARD’19), SciTe Press, Prague, Czech Republic. pp. 129–140

    work page 2019

  26. [26]

    Towards Multi-editor Sup- port for Domain-Specific Languages Utilizing the Lan- guage Server Protocol, in: Hammoudi, S., Pires, L.F., Seli´c, B

    Bünder, H., Kuchen, H., 2019. Towards Multi-editor Sup- port for Domain-Specific Languages Utilizing the Lan- guage Server Protocol, in: Hammoudi, S., Pires, L.F., Seli´c, B. (Eds.), Proceedings of the 7th International Conference on Model-Driven Engineering and Software Development (MODELSWARD’19), Springer, Prague, Czech Republic. pp. 225–245

    work page 2019

  27. [27]

    Butting, A., Eikermann, R., Kautz, O., Rumpe, B., Wort- mann, A., 2018a. Controlled and Extensible Variability of Concrete and Abstract Syntax with Independent Lan- guage Features, in: Proceedings of the 12th International Workshop on Variability Modelling of Software Intensive Systems (V AMOS’18), ACM, Madrid, Spain. pp. 75–82

    work page

  28. [28]

    Modeling Language Variability with Reusable Language Components, in: Berger, T., Borba, P

    Butting, A., Eikermann, R., Kautz, O., Rumpe, B., Wort- mann, A., 2018b. Modeling Language Variability with Reusable Language Components, in: Berger, T., Borba, P. (Eds.), Proceedings of the 22nd International Systems and Software Product Line Conference (SPLC’18), ACM, Gothenburg, Sweden. pp. 65–75

    work page

  29. [29]

    Structural Subtyping and the Notion of Power Type, in: Ferrante, J., Peter, M

    Cardelli, L., 1988. Structural Subtyping and the Notion of Power Type, in: Ferrante, J., Peter, M. (Eds.), Pro- ceedings of the 15th ACM Symposium on Principles of Programming Languages (POPL’88), ACM, San Diego, CA, USA. pp. 70–79

    work page 1988

  30. [30]

    Feature-Oriented Programming and Context-Oriented Programming: Comparing Paradigm Characteristics by Example Implementations, in: Hartmann, H., Breivold, H.P

    Cardozo, N., Günther, S., D’Hondt, T., Mens, K., 2011. Feature-Oriented Programming and Context-Oriented Programming: Comparing Paradigm Characteristics by Example Implementations, in: Hartmann, H., Breivold, H.P. (Eds.), Proceedings of the 6th International Con- ference on Software Engineering Advances (ICSEA’11), IARIA, Barcelona, Spain. pp. 130–135

    work page 2011

  31. [31]

    Domain-Specific Languages in Few Steps: The Neverlang Approach, in: Gschwind, T., De Paoli, F., Gruhn, V ., Book, M

    Cazzola, W., 2012. Domain-Specific Languages in Few Steps: The Neverlang Approach, in: Gschwind, T., De Paoli, F., Gruhn, V ., Book, M. (Eds.), Proceedings of the 11th International Conference on Software Com- position (SC’12), Springer, Prague, Czech Republic. pp. 162–177

    work page 2012

  32. [32]

    Towards a Recipe for Language Decomposition: Quality Assessment of Lan- guage Product Lines

    Cazzola, W., Favalli, L., 2022. Towards a Recipe for Language Decomposition: Quality Assessment of Lan- guage Product Lines. Empirical Software Engineering 27. doi:10.1007/s10664-021-10074-6

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

  33. [33]

    Software Modernization Powered by Dynamic Language Product Lines

    Cazzola, W., Favalli, L., 2024. Software Modernization Powered by Dynamic Language Product Lines. Journal of Systems and Software 218. doi: 10.1016/j.jss.2024. 112188

    work page doi:10.1016/j.jss.2024 2024

  34. [34]

    Gradually Learn- ing Programming Supported by a Growable Program- ming Language

    Cazzola, W., Olivares, D.M., 2016. Gradually Learn- ing Programming Supported by a Growable Program- ming Language. IEEE Transactions on Emerging Top- ics in Computing 4, 404–415. doi: 10.1109/TETC.2015. 2446192. special Issue on Emerging Trends in Education

    work page doi:10.1109/tetc.2015 2016

  35. [35]

    DSL Evolution through Composition, in: Proceedings of the 7 th ECOOP Work- shop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE’10), ACM, Maribor, Slovenia

    Cazzola, W., Poletti, D., 2010. DSL Evolution through Composition, in: Proceedings of the 7 th ECOOP Work- shop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE’10), ACM, Maribor, Slovenia

    work page 2010

  36. [37]

    Type Sys- tems as Macros, in: Gordon, A.D

    Chang, S., Knauth, A., Greenman, B., 2017. Type Sys- tems as Macros, in: Gordon, A.D. (Ed.), Proceedings of the 44th Symposium on Principles of Programming Languages (PoPL’17), ACM, Paris, France. pp. 694–705

    work page 2017

  37. [38]

    Software Product Lines: Practices and Patterns

    Clements, P., Northrop, L., 2001. Software Product Lines: Practices and Patterns. Addison-Wesley

    work page 2001

  38. [39]

    Inheritance Is Not Subtyping, in: Allen, F.E

    Cook, W.R., Hill, W., Canning, P.S., 1990. Inheritance Is Not Subtyping, in: Allen, F.E. (Ed.), Proceedings of the 17th ACM SIGPLAN-SIGACT Symposium on Prin- ciples of Programming Languages (POPL’90), ACM, San Francisco, CA, USA. pp. 125–135

    work page 1990

  39. [40]

    Engineering a Compiler

    Cooper, K.D., Torczon, L., 2022. Engineering a Compiler. Morgan Kaufmann

    work page 2022

  40. [41]

    Crane, M.L., Dingel, J., 2005. UML vs. Classical vs. Rhapsody Statecharts: Not All Models Are Created Equal, in: Briand, L., Williams, C. (Eds.), Proceedings of the 8th International Conference on Model Driven Engineering Languages and Systems (MoDELS’05), Springer, Mon- tego Bay, Jamaica. pp. 97–112

    work page 2005

  41. [42]

    Staged Configuration Using Feature Models, in: Weiss, D., van Ommering, R

    Czarnecki, K., Helsen, S., Eisenecker, U., 2004. Staged Configuration Using Feature Models, in: Weiss, D., van Ommering, R. (Eds.), Proceedings of the 3rd Interna- tional Conference on Software Product-Line (SPLC’04), Springer, Boston, MA, USA. pp. 266–283

    work page 2004

  42. [43]

    Delta- Oriented Multi Software Product Lines, in: Heymans, P., Rubin, J

    Damiani, F., Schaefer, I., Winkelmann, T., 2014. Delta- Oriented Multi Software Product Lines, in: Heymans, P., Rubin, J. (Eds.), Proceedings of 18th International Software Product Line Conference (SPLC’14), ACM, Florence, Italy. pp. 232–236

    work page 2014

  43. [44]

    A Formal Model for Multi Software Product Lines

    Damini, F., Lienhardt, M., Paolini, L., 2019. A Formal Model for Multi Software Product Lines. Science of Computer Programming 172, 203–231

    work page 2019

  44. [45]

    Product Derivation in Software Product Families: A Case Study

    Deelstra, S., Sinnema, M., Bosch, J., 2005. Product Derivation in Software Product Families: A Case Study. Journal of Systems and Software 74, 173–194

    work page 2005

  45. [46]

    Melange: a Meta-Language for Modular and Reusable Development of DSLs, in: Di Rus- cio, D., Völter, M

    Degueule, T., Combemale, B., Blouin, A., Barais, O., Jézéquel, J.M., 2015. Melange: a Meta-Language for Modular and Reusable Development of DSLs, in: Di Rus- cio, D., Völter, M. (Eds.), Proceedings of the 8th Inter- national Conference on Software Language Engineering (SLE’15), ACM, Pittsburgh, PA, USA. pp. 25–36

    work page 2015

  46. [47]

    Visual Studio Distilled

    Del Sole, A., 2023. Visual Studio Distilled. Third ed., Apress

    work page 2023

  47. [48]

    The JastAdd System — Modular Extensible Compiler Construction

    Ekman, T., Hedin, G., 2007. The JastAdd System — Modular Extensible Compiler Construction. Science of Computer Programming 69, 14–26

    work page 2007

  48. [49]

    Support- ing Heterogeneous Compositional Multi Software Prod- uct Lines, in: Santana de Almeida, E., Kishi, T

    El-Sharkawy, S., Kröher, C., Schmid, K., 2011. Support- ing Heterogeneous Compositional Multi Software Prod- uct Lines, in: Santana de Almeida, E., Kishi, T. (Eds.), Proceedings of the 15th International Software Product Line Conference (SPLC’11), IEEE, Münich, Germany. pp. 1–4

    work page 2011

  49. [50]

    The State of the Art in Language Workbenches, in: Erwig, M., Paige, R.F., Van Wyk, E

    Erdweg, S., van der Storm, T., Völter, M., Boersma, M., Bosman, R., Cook, W.R., Gerrtsen, A., Hulshout, A., Kelly, S., Loh, A., Konat, G.D.P., Molina, P.J., Palatnik, M., Pohjonen, R., Schindler, E., Schindler, K., Solmi, R., Vergu, V .A., Visser, E., 2013. The State of the Art in Language Workbenches, in: Erwig, M., Paige, R.F., Van Wyk, E. (Eds.), Proce...

    work page 2013

  50. [51]

    Neverlang and FeatureIDE Just Married: Integrated Language Product Line Development Environment, in: Collet, P., Nadi, S

    Favalli, L., Kühn, T., Cazzola, W., 2020. Neverlang and FeatureIDE Just Married: Integrated Language Product Line Development Environment, in: Collet, P., Nadi, S. (Eds.), Proceedings of the 24th International Software Product Line Conference (SPLC’20), ACM, Montréal, Canada. pp. 285–295

    work page 2020

  51. [52]

    A New Data Structure for Cumula- tive Frequency Tables

    Fenwick, P.M., 1994. A New Data Structure for Cumula- tive Frequency Tables. Software: Practice and Experience 24, 327–336

    work page 1994

  52. [53]

    Inversion of Control

    Fowler, M., 2005. Inversion of Control. Martin Fowler’s Blog. URL: https://martinfowler.com/ bliki/InversionOfControl.html

    work page 2005

  53. [54]

    Software Reuse: Metrics and Models

    Frakes, W., Terry, C., 1996. Software Reuse: Metrics and Models. ACM Computing Surveys 28, 415–435

    work page 1996

  54. [55]

    Design Patterns: Elements of Reusable Object-Oriented Software

    Gamma, E., Helm, R., Johnson, R., Vlissides, J., 1995. Design Patterns: Elements of Reusable Object-Oriented Software. Professional Computing Series, Addison- Wesley, Reading, Ma, USA

    work page 1995

  55. [56]

    Practical LR Error Recovery, in: Johnson, S.C

    Graham, S.L., Haley, C.B., Joy, W.N., 1979. Practical LR Error Recovery, in: Johnson, S.C. (Ed.), Proceedings of the 1979 Sigplan Symposium on Compiler Construction (CC’79), ACM, Denver, CO, USA. pp. 168–175

    work page 1979

  56. [57]

    TextMate: Power Editing for the Mac

    Gray, II, E.J., 2007. TextMate: Power Editing for the Mac. Pragmatic Bookshelf

    work page 2007

  57. [58]

    Implementing Product-Line Features with Component Reuse, in: Frakes, W.B

    Griss, M.L., 2000. Implementing Product-Line Features with Component Reuse, in: Frakes, W.B. (Ed.), Proceed- ings of the 6th International Conference on Software Reuse (ICSR’00), Springer, Vienna, Austria. pp. 137– 151

    work page 2000

  58. [60]

    Language Server Pro- tocol and Implementation: Supporting Language-Smart Editing and Programming Tools

    Gunasinghe, N., Marcus, N., 2022. Language Server Pro- tocol and Implementation: Supporting Language-Smart Editing and Programming Tools. Apress

    work page 2022

  59. [61]

    Using Feature Diagrams with Context Variability to Model Multiple Product Lines for Software Supply Chains, in: Geppert, B

    Hartmann, H., Trew, T., 2008. Using Feature Diagrams with Context Variability to Model Multiple Product Lines for Software Supply Chains, in: Geppert, B. (Ed.), Pro- ceedings of the 12th International Software Product Line Conference (SPLC’08), IEEE, Limerick, Ireland. pp. 12– 21

    work page 2008

  60. [62]

    Adding Standardized Variabil- ity to Domain Specific Languages, in: Pohl, K., Geppert, B

    Haugen, Ø., Møller-Pedersen, B., Oldevik, J., Olsen, G.K., Svendsen, A., 2008. Adding Standardized Variabil- ity to Domain Specific Languages, in: Pohl, K., Geppert, B. (Eds.), Proceedings of the 12th International Software Product Line Conference (SPLC’08), IEEE, Limerick, Ireland. pp. 139–148

    work page 2008

  61. [63]

    Model-Based Language Engineering with EMFText, in: Lämmel, R., Visser, J., Saraiva, J

    Heidenreich, F., Johannes, J., Karol, S., Seifert, M., Wende, C., 2011. Model-Based Language Engineering with EMFText, in: Lämmel, R., Visser, J., Saraiva, J. (Eds.), Proceedings of the International Summer School on Generative and Transformational Techniques in Soft- ware Engineering (GTTSE’11), Springer, Braga, Portugal. pp. 322–345

    work page 2011

  62. [64]

    The Principal Type-Scheme of an Ob- ject in Combinatory Logic

    Hindley, R., 1969. The Principal Type-Scheme of an Ob- ject in Combinatory Logic. Transactions of the America Mathematical Society 146, 29–60

    work page 1969

  63. [65]

    A Systematic Review and an Expert Survey on Capabilities Supporting Multi-Product Lines

    Holl, G., Grünbacher, P., Rabiser, R., 2012. A Systematic Review and an Expert Survey on Capabilities Supporting Multi-Product Lines. Information and Software Technol- ogy 54, 828–852

    work page 2012

  64. [66]

    Configuration in Industrial Product Families: The ConIPF Methodology

    Hotz, L., Wolter, K., Krebs, T., Deelstra, S., Sinnema, M., Nijhuis, G.J., MacGregor, J., 2006. Configuration in Industrial Product Families: The ConIPF Methodology. IOS Press

    work page 2006

  65. [67]

    Data-Oriented Programming: On the Ex- pressiveness of Non-control Data Attacks, in: Shmatikov, V ., Erlingsson, U

    Hu, H., Shinde, S., Adrian, S., Chua, Z.L., Saxena, P., Liang, Z., 2016. Data-Oriented Programming: On the Ex- pressiveness of Non-control Data Attacks, in: Shmatikov, V ., Erlingsson, U. (Eds.), Proceedings of the 2016 IEEE Symposium on Security and Privacy (SP’16), IEEE, San Josè, CA, USA. pp. 969–986

    work page 2016

  66. [68]

    Modular Domain Specific Languages and Tools, in: Devanbu, P., Poulin, J

    Hudak, P., 1998. Modular Domain Specific Languages and Tools, in: Devanbu, P., Poulin, J. (Eds.), Proceedings of the 5th International Conference on Software Reuse (ICSR’98), IEEE, Victoria, BC, Canada. pp. 134–142

    work page 1998

  67. [69]

    Why Functional Programming Matters

    Hughes, J., 1989. Why Functional Programming Matters. The Computer Journal 32, 98–107

    work page 1989

  68. [70]

    Separation of Con- cerns

    Hürsch, W., Videira Lopes, C., 1995. Separation of Con- cerns. Technical Report NU-CCS-95-03. Northeastern University, Boston

    work page 1995

  69. [71]

    A Langium-Based Approach to BigER

    Jordan, T., Zib, S., 2024. A Langium-Based Approach to BigER. Bachelor’s thesis. Technische Universität Wien. Wien, Austria

    work page 2024

  70. [72]

    Feature-Oriented Domain Analysis (FODA) Feasibility Study

    Kang, K.C., Cohen, S.G., Hess, J.A., Novak, W.E., Pe- terson, A.S., 1990. Feature-Oriented Domain Analysis (FODA) Feasibility Study. Technical Report CMU/SEI- 90-TR-21. Carnegie Mellon University. Pittsburgh, Penn- sylvania, USA

    work page 1990

  71. [73]

    The Road to Feature Modularity?, in: Schäfer, I., John, I., Schmid, K

    Kästner, C., Apel, S., Ostermann, K., 2006. The Road to Feature Modularity?, in: Schäfer, I., John, I., Schmid, K. (Eds.), Proceedings of the 3rd Workshop on Feature-Oriented Software Development (FOSD’11), ACM, Münich, Germany

    work page 2006

  72. [74]

    The Spoofax Language Workbench: Rules for Declarative Specification of Lan- guages and IDEs, in: Rinard, M., Sullivan, K.J., Stein- berg, D.H

    Kats, L.C.L., Visser, E., 2010. The Spoofax Language Workbench: Rules for Declarative Specification of Lan- guages and IDEs, in: Rinard, M., Sullivan, K.J., Stein- berg, D.H. (Eds.), Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications (OOPSLA’10), ACM, Reno, Nevada, USA. pp. 444–463

    work page 2010

  73. [75]

    Kats, L.C.L., Visser, E., Wachsmuth, G., 2010. Pure and Declarative Syntax Definition: Paradise Lost and Regained, in: Proceedings of ACM Conference on New Ideas in Programming and Reflections on Software (On- ward! 2010), ACM, Reno-Tahoe, Nevada, USA

    work page 2010

  74. [76]

    An Overview of AspectJ, in: Knud- sen, J.L

    Kiczales, G., Hilsdale, E., Hugunin, J., Kersten, M., Palm, J., Griswold, B., 2001. An Overview of AspectJ, in: Knud- sen, J.L. (Ed.), Proceedings of the 15th European Con- ference on Object-Oriented Programming (ECOOP’01), Springer-Verlag, Budapest, Hungary. pp. 327–353

    work page 2001

  75. [77]

    Aspect- Oriented Programming, in: Ak¸ sit, M., Matsuoka, S

    Kiczales, G., Lamping, J., Mendhekar, A., Maeda, C., Videira Lopes, C., Loingtier, J.M., Irwin, J., 1997. Aspect- Oriented Programming, in: Ak¸ sit, M., Matsuoka, S. (Eds.), 11th European Conference on Object Oriented Programming (ECOOP’97), Springer-Verlag, Helsinki, Finland. pp. 220–242

    work page 1997

  76. [78]

    EASY Meta-Programming with Rascal, in: Fernandes, J.M., Lämmel, R., Visser, J., Saraiva, J

    Klint, P., van der Storm, T., Vinju, J., 2009. EASY Meta-Programming with Rascal, in: Fernandes, J.M., Lämmel, R., Visser, J., Saraiva, J. (Eds.), Proceedings of the International Summer School on Generative and Transformational Techniques in Software Engineering III (GTTSE’09), Springer, Braga, Portugal. pp. 222–289

    work page 2009

  77. [79]

    The Art of Computer Programming: Fundamental Algorithms

    Knuth, D.E., 1997. The Art of Computer Programming: Fundamental Algorithms. third ed., Addison Wesley

    work page 1997

  78. [80]

    Domain Specific Languages: A Systematic Mapping Study

    Kosar, T., Bohra, S., Mernik, M., 2016. Domain Specific Languages: A Systematic Mapping Study. Information and Software Technology 71, 77–91

    work page 2016

  79. [82]

    Efficient Ed- itor Generation for Compositional DSLs in Eclipse, in: Tolvanen, J.P., Gray, J., Rossi, M., Sprinkle, J

    Krahn, H., Rumpe, B., Völkel, S., 2007. Efficient Ed- itor Generation for Compositional DSLs in Eclipse, in: Tolvanen, J.P., Gray, J., Rossi, M., Sprinkle, J. (Eds.), Proceedings of the 7th OOPSLA Workshop on Domain- Specific Modeling (DSM’07), Montréal, Canada

    work page 2007

  80. [83]

    MontiCore: A Framework for Compositional Development of Domain Specific Languages

    Krahn, H., Rumpe, B., Völkel, S., 2010. MontiCore: A Framework for Compositional Development of Domain Specific Languages. International Journal on Software Tools for Technology Transfer 12, 353–372

    work page 2010

Showing first 80 references.