632 lines
24 KiB
BibTeX
632 lines
24 KiB
BibTeX
|
||
|
||
|
||
@misc{Proposal:DoProposal,
|
||
title = {{Proposal ``Do Expression''}},
|
||
journal = {GitHub},
|
||
year = {2024},
|
||
month = may,
|
||
note = {[Online; accessed 2. May 2024]},
|
||
url = {https://github.com/tc39/proposal-do-expressions}
|
||
}
|
||
|
||
@misc{Langium,
|
||
title = {{Langium}},
|
||
journal = {Langium},
|
||
year = {2024},
|
||
month = apr,
|
||
note = {[Online; accessed 10. May 2024]},
|
||
url = {https://langium.org}
|
||
}
|
||
|
||
@misc{Babel,
|
||
title = {{Babel}},
|
||
year = {2024},
|
||
month = may,
|
||
note = {[Online; accessed 10. May 2024]},
|
||
url = {https://babeljs.io}
|
||
}
|
||
|
||
@misc{BabelTraverse,
|
||
title = {{@babel/traverse {$\cdot$} Babel}},
|
||
year = {2024},
|
||
month = may,
|
||
note = {[Online; accessed 12. May 2024]},
|
||
url = {https://babeljs.io/docs/babel-traverse}
|
||
}
|
||
|
||
@inproceedings{VisitorPattern,
|
||
author = {Palsberg, J. and Jay, C.B.},
|
||
booktitle = {Proceedings. The Twenty-Second Annual International Computer Software and Applications Conference (Compsac '98) (Cat. No.98CB 36241)},
|
||
title = {The essence of the Visitor pattern},
|
||
year = {1998},
|
||
volume = {},
|
||
number = {},
|
||
pages = {9-15},
|
||
keywords = {Electrical capacitance tomography;Java;Reflection;Computer science;Australia;Ice;Read only memory;Functional programming;Writing},
|
||
doi = {10.1109/CMPSAC.1998.716629}
|
||
}
|
||
|
||
@misc{BabelGenerate,
|
||
title = {{@babel/generator {$\cdot$} Babel}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-12},
|
||
note = {[Online; accessed 12. May 2024]},
|
||
url = {https://babeljs.io/docs/babel-generator}
|
||
}
|
||
@incollection{SlidingWindow,
|
||
author = {Hirzel, Martin and Schneider, Scott and Tangwongsan, Kanat},
|
||
title = {{Sliding-Window Aggregation Algorithms: Tutorial}},
|
||
booktitle = {{DEBS '17: Proceedings of the 11th ACM International Conference on Distributed and Event-based Systems}},
|
||
pages = {11--14},
|
||
year = {2017},
|
||
month = jun,
|
||
urldate = {2024-05-13},
|
||
isbn = {978-1-45035065-5},
|
||
publisher = {Association for Computing Machinery},
|
||
address = {New York, NY, USA},
|
||
url = {https://dl.acm.org/doi/abs/10.1145/3093742.3095107},
|
||
doi = {10.1145/3093742.3095107}
|
||
}
|
||
|
||
|
||
@misc{BabelParser,
|
||
title = {{@babel/parser {$\cdot$} Babel}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-14},
|
||
note = {[Online; accessed 14. May 2024]},
|
||
url = {https://babeljs.io/docs/babel-Parser}
|
||
}
|
||
|
||
|
||
|
||
@inproceedings{AST1,
|
||
author = {Neamtiu, Iulian and Foster, Jeffrey S. and Hicks, Michael},
|
||
title = {Understanding source code evolution using abstract syntax tree matching},
|
||
year = {2005},
|
||
isbn = {1595931236},
|
||
publisher = {Association for Computing Machinery},
|
||
address = {New York, NY, USA},
|
||
url = {https://doi.org/10.1145/1083142.1083143},
|
||
doi = {10.1145/1083142.1083143},
|
||
abstract = {Mining software repositories at the source code level can provide a greater understanding of how software evolves. We present a tool for quickly comparing the source code of different versions of a C program. The approach is based on partial abstract syntax tree matching, and can track simple changes to global variables, types and functions. These changes can characterize aspects of software evolution useful for answering higher level questions. In particular, we consider how they could be used to inform the design of a dynamic software updating system. We report results based on measurements of various versions of popular open source programs. including BIND, OpenSSH, Apache, Vsftpd and the Linux kernel.},
|
||
booktitle = {Proceedings of the 2005 International Workshop on Mining Software Repositories},
|
||
pages = {1–5},
|
||
numpages = {5},
|
||
keywords = {abstract syntax trees, software evolution, source code analysis},
|
||
location = {St. Louis, Missouri},
|
||
series = {MSR '05}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
@article{RecursiveDescent,
|
||
author = {Davis, Matthew S.},
|
||
title = {An object oriented approach to constructing recursive descent parsers},
|
||
year = {2000},
|
||
issue_date = {Feb.2000},
|
||
publisher = {Association for Computing Machinery},
|
||
address = {New York, NY, USA},
|
||
volume = {35},
|
||
number = {2},
|
||
issn = {0362-1340},
|
||
url = {https://doi.org/10.1145/345105.345113},
|
||
doi = {10.1145/345105.345113},
|
||
abstract = {We discuss a technique to construct a recursive descent parser for a context free language using concepts found in object oriented design and implementation. A motivation for the technique is given. The technique is then introduced with snippets of a Smalltalk implementation. Some advantages and disadvantages of the technique are examined. Finally some areas of possible future work are discussed.},
|
||
journal = {SIGPLAN Not.},
|
||
month = {feb},
|
||
pages = {29–35},
|
||
numpages = {7},
|
||
keywords = {Greibach normal form, context free grammar, design patterns, object oriented, recursive descent parser, smalltalk}
|
||
}
|
||
|
||
@misc{SpeedyWebCompiler,
|
||
title = {{Speedy Web Compiler}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-21},
|
||
note = {[Online; accessed 21. May 2024]},
|
||
url = {https://swc.rs}
|
||
}
|
||
|
||
@misc{Pipeline,
|
||
title = {{``Pipeline'' Operator}},
|
||
journal = {GitHub},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-21},
|
||
note = {[Online; accessed 21. May 2024]},
|
||
url = {https://github.com/tc39/proposal-pipeline-operator}
|
||
}
|
||
|
||
@misc{AcornJS,
|
||
title = {{Acorn}},
|
||
journal = {GitHub},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-21},
|
||
note = {[Online; accessed 21. May 2024]},
|
||
url = {https://github.com/acornjs/acorn}
|
||
}
|
||
|
||
@inproceedings{ProgrammingLanguageEcolutionViaSourceCodeQueryLanguages,
|
||
author = {Urma, Raoul-Gabriel and Mycroft, Alan},
|
||
title = {Programming language evolution via source code query languages},
|
||
year = {2012},
|
||
isbn = {9781450316316},
|
||
publisher = {Association for Computing Machinery},
|
||
address = {New York, NY, USA},
|
||
url = {https://doi.org/10.1145/2414721.2414728},
|
||
doi = {10.1145/2414721.2414728},
|
||
abstract = {Programming languages evolve just like programs. Language features are added and removed, for example when programs using them are shown to be error-prone. When language features are modified, deprecated, removed or even deemed unsuitable for the project at hand, it is necessary to analyse programs to identify occurrences to refactor.Source code query languages in principle provide a good way to perform this analysis by exploring codebases. Such languages are often used to identify code to refactor, bugs to fix or simply to understand a system better.This paper evaluates seven Java source code query languages: Java Tools Language, Browse-By-Query, SOUL, JQuery, .QL, Jackpot and PMD as to their power at expressing queries required by several use cases (such as code idioms to be refactored).},
|
||
booktitle = {Proceedings of the ACM 4th Annual Workshop on Evaluation and Usability of Programming Languages and Tools},
|
||
pages = {35–38},
|
||
numpages = {4},
|
||
keywords = {program analysis, query languages, source code},
|
||
location = {Tucson, Arizona, USA},
|
||
series = {PLATEAU '12}
|
||
}
|
||
@misc{Jackpot,
|
||
author = {NetBeans, Apache},
|
||
title = {{Java Declarative Hints Language}},
|
||
year = {2024},
|
||
month = mar,
|
||
urldate = {2024-05-21},
|
||
note = {[Online; accessed 21. May 2024]},
|
||
url = {https://netbeans.apache.org/front/main/jackpot/HintsFileFormat/#variables}
|
||
}
|
||
|
||
@misc{ApacheNetBeans,
|
||
author = {NetBeans, Apache},
|
||
title = {{Apache NetBeans}},
|
||
year = {2024},
|
||
month = feb,
|
||
urldate = {2024-05-21},
|
||
note = {[Online; accessed 21. May 2024]},
|
||
url = {https://netbeans.apache.org/front/main/index.html}
|
||
}
|
||
|
||
@misc{PMDXPath,
|
||
title = {{Writing XPath rules PMD Source Code Analyzer}},
|
||
year = {2024},
|
||
month = apr,
|
||
urldate = {2024-05-30},
|
||
note = {[Online; accessed 30. May 2024]},
|
||
url = {https://docs.pmd-code.org/latest/pmd_userdocs_extending_writing_xpath_rules.html}
|
||
}
|
||
@misc{StructuralSearchAndReplaceJetbrains,
|
||
title = {{Structural search and replace {$\vert$} IntelliJ IDEA}},
|
||
journal = {IntelliJ IDEA Help},
|
||
year = {2024},
|
||
month = apr,
|
||
urldate = {2024-05-22},
|
||
note = {[Online; accessed 22. May 2024]},
|
||
url = {https://www.jetbrains.com/help/idea/structural-search-and-replace.html}
|
||
}
|
||
|
||
@misc{Atom,
|
||
title = {{Atom}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-23},
|
||
note = {[Online; accessed 23. May 2024]},
|
||
url = {https://github.com/atom/atom}
|
||
}
|
||
|
||
@misc{Bootstrap,
|
||
title = {{Bootstrap}},
|
||
journal = {GitHub},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-23},
|
||
note = {[Online; accessed 23. May 2024]},
|
||
url = {https://github.com/twbs/bootstrap}
|
||
}
|
||
|
||
@misc{React,
|
||
title = {{React}},
|
||
journal = {GitHub},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-23},
|
||
note = {[Online; accessed 23. May 2024]},
|
||
url = {https://github.com/facebook/react}
|
||
}
|
||
@misc{NEXT.JS,
|
||
title = {{Next.js}},
|
||
journal = {GitHub},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-23},
|
||
note = {[Online; accessed 23. May 2024]},
|
||
url = {https://github.com/vercel/next.js}
|
||
}
|
||
|
||
@misc{ThreeJS,
|
||
title = {{Three.js}},
|
||
journal = {GitHub},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-23},
|
||
note = {[Online; accessed 23. May 2024]},
|
||
url = {https://github.com/mrdoob/three.js}
|
||
}
|
||
@misc{PipelineBikeshedding,
|
||
title = {{Bikeshedding the Hack topic token}},
|
||
journal = {GitHub},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-24},
|
||
note = {[Online; accessed 24. May 2024]},
|
||
url = {https://github.com/tc39/proposal-pipeline-operator/issues/91}
|
||
}
|
||
|
||
@misc{FPipeOperator,
|
||
author = {KathleenDollard},
|
||
title = {{Symbol and Operator Reference - F{\#}}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-24},
|
||
note = {[Online; accessed 24. May 2024]},
|
||
url = {https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/symbol-and-operator-reference/#type-symbols-and-operators}
|
||
}
|
||
|
||
@misc{JuliaPipe,
|
||
title = {{Pipe Operator The Julia Language}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-24},
|
||
note = {[Online; accessed 24. May 2024]},
|
||
url = {https://docs.julialang.org/en/v1/manual/functions/#Function-composition-and-piping}
|
||
}
|
||
|
||
@misc{ecma262,
|
||
title = {{ECMA-262 Language Specification}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-28},
|
||
note = {[Online; accessed 28. May 2024]},
|
||
url = {https://tc39.es/ecma262}
|
||
}
|
||
|
||
@misc{TC39Process,
|
||
title = {{The TC39 Process}},
|
||
year = {2024},
|
||
month = apr,
|
||
urldate = {2024-05-24},
|
||
note = {[Online; accessed 24. May 2024]},
|
||
url = {https://tc39.es/process-document}
|
||
}
|
||
|
||
|
||
@misc{TC39,
|
||
title = {{TC39 - Specifying JavaScript.}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-26},
|
||
note = {[Online; accessed 26. May 2024]},
|
||
url = {https://tc39.es}
|
||
}
|
||
|
||
@misc{TOML,
|
||
title = {{TOML: Tom's Obvious Minimal Language}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-27},
|
||
note = {[Online; accessed 27. May 2024]},
|
||
url = {https://toml.io/en}
|
||
}
|
||
|
||
@misc{BabelProposalSupport,
|
||
title = {{Babel Proposal Support}},
|
||
journal = {GitHub},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-27},
|
||
note = {[Online; accessed 27. May 2024]},
|
||
url = {https://github.com/babel/proposals}
|
||
}
|
||
@misc{BabelAST,
|
||
title = {{Babel AST Specification}},
|
||
journal = {GitHub},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-28},
|
||
note = {[Online; accessed 28. May 2024]},
|
||
url = {https://github.com/babel/babel/blob/main/packages/babel-parser/ast/spec.md}
|
||
}
|
||
@misc{AST3,
|
||
title = {Abstract Syntax Tree for Programming Language Understanding and Representation: How Far Are We?},
|
||
author = {Weisong Sun and Chunrong Fang and Yun Miao and Yudu You and Mengzhe Yuan and Yuchen Chen and Quanjun Zhang and An Guo and Xiang Chen and Yang Liu and Zhenyu Chen},
|
||
year = {2023},
|
||
eprint = {2312.00413},
|
||
archiveprefix = {arXiv},
|
||
primaryclass = {cs.SE}
|
||
}
|
||
|
||
@misc{BabelSpecCompliant,
|
||
title = {{Babel Specification Compliant}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-29},
|
||
note = {[Online; accessed 29. May 2024]},
|
||
url = {https://babeljs.io/docs/#spec-compliant}
|
||
}
|
||
|
||
@misc{TC39RecommendBabel,
|
||
title = {{TC39 How We Work}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-29},
|
||
note = {[Online; accessed 29. May 2024]},
|
||
url = {https://github.com/tc39/how-we-work/blob/main/implement.md#transpiler-implementations}
|
||
}
|
||
|
||
|
||
@article{ExpressionOriented,
|
||
author = {Bantchev, Boyko B.},
|
||
title = {{Putting more meaning in expressions}},
|
||
journal = {SIGPLAN Not.},
|
||
volume = {33},
|
||
number = {9},
|
||
pages = {77--83},
|
||
year = {1998},
|
||
month = sep,
|
||
urldate = {2024-05-24},
|
||
issn = {0362-1340},
|
||
publisher = {Association for Computing Machinery},
|
||
url = {https://dl.acm.org/doi/10.1145/290229.290237},
|
||
doi = {10.1145/290229.290237}
|
||
}
|
||
|
||
@misc{Xtext,
|
||
author = {Efftinge, Sven and Spoenemann, Miro},
|
||
title = {{Xtext - Language Engineering Made Easy!}},
|
||
year = {2024},
|
||
month = feb,
|
||
urldate = {2024-05-29},
|
||
note = {[Online; accessed 29. May 2024]},
|
||
url = {https://eclipse.dev/Xtext}
|
||
}
|
||
@article{LanguageWorkbench,
|
||
title = {Evaluating and comparing language workbenches: Existing results and benchmarks for the future},
|
||
author = {Erdweg, Sebastian and Van Der Storm, Tijs and V{\"o}lter, Markus and Tratt, Laurence and Bosman, Remi and Cook, William R and Gerritsen, Albert and Hulshout, Angelo and Kelly, Steven and Loh, Alex and others},
|
||
journal = {Computer Languages, Systems \& Structures},
|
||
volume = {44},
|
||
pages = {24--47},
|
||
year = {2015},
|
||
publisher = {Elsevier}
|
||
}
|
||
@article{DSLSANDHOW,
|
||
author = {Mernik, Marjan and Heering, Jan and Sloane, Anthony M.},
|
||
title = {When and how to develop domain-specific languages},
|
||
year = {2005},
|
||
issue_date = {December 2005},
|
||
publisher = {Association for Computing Machinery},
|
||
address = {New York, NY, USA},
|
||
volume = {37},
|
||
number = {4},
|
||
issn = {0360-0300},
|
||
url = {https://doi.org/10.1145/1118890.1118892},
|
||
doi = {10.1145/1118890.1118892},
|
||
abstract = {Domain-specific languages (DSLs) are languages tailored to a specific application domain. They offer substantial gains in expressiveness and ease of use compared with general-purpose programming languages in their domain of application. DSL development is hard, requiring both domain knowledge and language development expertise. Few people have both. Not surprisingly, the decision to develop a DSL is often postponed indefinitely, if considered at all, and most DSLs never get beyond the application library stage.Although many articles have been written on the development of particular DSLs, there is very limited literature on DSL development methodologies and many questions remain regarding when and how to develop a DSL. To aid the DSL developer, we identify patterns in the decision, analysis, design, and implementation phases of DSL development. Our patterns improve and extend earlier work on DSL design patterns. We also discuss domain analysis tools and language development systems that may help to speed up DSL development. Finally, we present a number of open problems.},
|
||
journal = {ACM Comput. Surv.},
|
||
month = {dec},
|
||
pages = {316–344},
|
||
numpages = {29},
|
||
keywords = {Domain-specific language, application language, domain analysis, language development system}
|
||
}
|
||
|
||
@misc{CodeQL,
|
||
title = {{CodeQL}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-29},
|
||
note = {[Online; accessed 29. May 2024]},
|
||
url = {https://codeql.github.com}
|
||
}
|
||
|
||
@misc{Coccinelle,
|
||
title = {{Coccinelle The Linux Kernel documentation}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-29},
|
||
note = {[Online; accessed 29. May 2024]},
|
||
url = {https://docs.kernel.org/dev-tools/coccinelle.html}
|
||
}
|
||
@inproceedings{CodeQLStuff,
|
||
author = {Moor, Oege de and Verbaere, Mathieu and Hajiyev, Elnar and Avgustinov, Pavel and Ekman, Torbjorn and Ongkingco, Neil and Sereni, Damien and Tibble, Julian},
|
||
booktitle = {Seventh IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2007)},
|
||
title = {Keynote Address: .QL for Source Code Analysis},
|
||
year = {2007},
|
||
volume = {},
|
||
number = {},
|
||
pages = {3-16},
|
||
keywords = {},
|
||
doi = {10.1109/SCAM.2007.31}
|
||
}
|
||
@misc{BabelAcornBased,
|
||
title = {{Babel Credits}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-30},
|
||
note = {[Online; accessed 30. May 2024]},
|
||
url = {https://babeljs.io/docs/babel-parser#credits}
|
||
}
|
||
|
||
|
||
@inbook{ModelToModelTransformations,
|
||
author = {Wąsowski , Andrzej and Berger, Thorsten},
|
||
title = {Model and Program Transformation},
|
||
btitle = {Domain-Specific Languages: Effective Modeling, Automation, and Reuse},
|
||
year = {2023},
|
||
publisher = {Springer International Publishing},
|
||
address = {Cham},
|
||
pages = {233--292},
|
||
abstract = {So far, we focused on defining the syntax of DSLs in efficient ways. We worked with abstract and concrete syntax. We have seen tools that can transform syntax definitions (meta-models and grammars in our case) not only into model editors, but into a whole infrastructure for processing models that adhere to the syntax definition.},
|
||
isbn = {978-3-031-23669-3},
|
||
doi = {10.1007/978-3-031-23669-3_7},
|
||
url = {https://doi.org/10.1007/978-3-031-23669-3_7}
|
||
}
|
||
|
||
@misc{XSLT,
|
||
title = {{XSL Transformations (XSLT) Version 2.0 (Second Edition)}},
|
||
year = {2021},
|
||
month = mar,
|
||
urldate = {2024-05-30},
|
||
note = {[Online; accessed 30. May 2024]},
|
||
url = {https://www.w3.org/TR/xslt20}
|
||
}
|
||
@book{Kleppe,
|
||
author = {Kleppe, Anneke G.},
|
||
title = {{Software Language Engineering: Creating Domain-Specific Languages Using Metamodels}},
|
||
year = {2008},
|
||
month = jan,
|
||
urldate = {2024-05-31},
|
||
isbn = {978-0-32155345-4},
|
||
publisher = {Addison-Wesley Professional},
|
||
address = {Boston, MA, USA}
|
||
}
|
||
|
||
@misc{PipelineHistory,
|
||
title = {{History ``Pipeline'' Operator In EcmaScript}},
|
||
journal = {GitHub},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-05-31},
|
||
note = {[Online; accessed 31. May 2024]},
|
||
url = {https://github.com/tc39/proposal-pipeline-operator/blob/main/HISTORY.md}
|
||
}
|
||
@misc{ElixirPipe,
|
||
title = {{Enumerables and Streams {\ifmmode---\else\textemdash\fi} Elixir v1.16.3}},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-06-01},
|
||
note = {[Online; accessed 1. Jun. 2024]},
|
||
url = {https://hexdocs.pm/elixir/1.16.3/enumerable-and-streams.html#the-pipe-operator}
|
||
}
|
||
|
||
@misc{BashPipeline,
|
||
title = {{Bash Reference Manual}},
|
||
year = {2024},
|
||
month = jun,
|
||
urldate = {2024-06-01},
|
||
note = {[Online; accessed 1. Jun. 2024]},
|
||
url = {https://www.gnu.org/software/bash/manual/bash.html#Pipelines}
|
||
}
|
||
|
||
@misc{PMDXPathRule,
|
||
title = {{XPath rule for PMD Source Code Analyzer }},
|
||
year = {2024},
|
||
month = apr,
|
||
urldate = {2024-06-01},
|
||
note = {[Online; accessed 1. Jun. 2024]},
|
||
url = {https://docs.pmd-code.org/latest/pmd_userdocs_extending_your_first_rule.html}
|
||
}
|
||
|
||
@article{AOP,
|
||
author = {Lopes, Cristina and Kiczales, Gregor and Lamping, John and Mendhekar, Anurag and Maeda, Chris and Loingtier, Jean-marc and Irwin, John},
|
||
year = {1999},
|
||
month = {10},
|
||
pages = {},
|
||
title = {Aspect-Oriented Programming},
|
||
volume = {28},
|
||
journal = {ACM Computing Surveys},
|
||
doi = {10.1145/242224.242420}
|
||
}
|
||
|
||
@misc{LanguageWorkbenchMartinFowler,
|
||
title = {{Language Workbenches: The Killer-App for Domain Specific Languages?}},
|
||
journal = {Martinfowler},
|
||
year = {2024},
|
||
month = may,
|
||
urldate = {2024-06-01},
|
||
note = {[Online; accessed 1. Jun. 2024]},
|
||
url = {https://www.martinfowler.com/articles/languageWorkbench.html#DefiningALanguageWorkbench}
|
||
}
|
||
@inproceedings{LanguageWorkbenchMikhail,
|
||
author = {Barash, Mikhail},
|
||
title = {Vision: the next 700 language workbenches},
|
||
year = {2021},
|
||
isbn = {9781450391115},
|
||
publisher = {Association for Computing Machinery},
|
||
address = {New York, NY, USA},
|
||
url = {https://doi.org/10.1145/3486608.3486907},
|
||
doi = {10.1145/3486608.3486907},
|
||
abstract = {Language workbenches (LWBs) are tools to define software languages together with tailored Integrated Development Environments for them. A comprehensive review of language workbenches by Erdweg et al. (Comput. Lang. Syst. Struct. 44, 2015) presented a feature model of functionality of LWBs from the point of view of "languages that can be defined with a LWB, and not the definition mechanism of the LWB itself". This vision paper discusses possible functionality of LWBs with regard to language definition mechanisms. We have identified five groups of such functionality, related to: metadefinitions, metamodifications, metaprocess, LWB itself, and programs written in languages defined in a LWB. We design one of the features ("ability to define dependencies between language concerns") based on our vision.},
|
||
booktitle = {Proceedings of the 14th ACM SIGPLAN International Conference on Software Language Engineering},
|
||
pages = {16–21},
|
||
numpages = {6},
|
||
keywords = {software languages, metaprogramming, algebraic specifications, Language workbenches},
|
||
location = {Chicago, IL, USA},
|
||
series = {SLE 2021}
|
||
}
|
||
@book{MarkusDSL,
|
||
author = {Markus Voelter et al.},
|
||
title = {DSL Engineering
|
||
Designing, Implementing and Using
|
||
Domain-Specific Languages} ,
|
||
year = 2013
|
||
}
|
||
|
||
@misc{PMDAnalyzer,
|
||
title = {{ PMD Source Code Analyzer}},
|
||
year = {2024},
|
||
month = jun,
|
||
urldate = {2024-06-02},
|
||
note = {[Online; accessed 2. Jun. 2024]},
|
||
url = {https://pmd.github.io/pmd/index.html}
|
||
}
|
||
@book{SQL,
|
||
author = {Alan Beaulieu},
|
||
title = {Learning SQL},
|
||
publisher = {O'Reilly Media, Inc.},
|
||
year = {2005}
|
||
}
|
||
@inproceedings{EindhovenQuantifierNotation,
|
||
author = {Backhouse, Roland and Michaelis, Diethard},
|
||
year = {2006},
|
||
month = {07},
|
||
pages = {69-81},
|
||
title = {Exercises in Quantifier Manipulation},
|
||
isbn = {978-3-540-35631-8},
|
||
doi = {10.1007/11783596_7}
|
||
}
|
||
@article{Datalog,
|
||
title={What you always wanted to know about Datalog(and never dared to ask)},
|
||
author={Ceri, Stefano and Gottlob, Georg and Tanca, Letizia and others},
|
||
journal={IEEE transactions on knowledge and data engineering},
|
||
volume={1},
|
||
number={1},
|
||
pages={146--166},
|
||
year={1989},
|
||
publisher={Citeseer}
|
||
}
|
||
@InProceedings{Predicates,
|
||
author="Chambers, Craig",
|
||
editor="Nierstrasz, Oscar M.",
|
||
title="Predicate Classes",
|
||
booktitle="ECOOP' 93 --- Object-Oriented Programming",
|
||
year="1993",
|
||
publisher="Springer Berlin Heidelberg",
|
||
address="Berlin, Heidelberg",
|
||
pages="268--296",
|
||
abstract="Predicate classes are a new linguistic construct designed to complement normal classes in object-oriented languages. Like a normal class, a predicate class has a set of superclasses, methods, and instance variables. However, unlike a normal class, an object is automatically an instance of a predicate class whenever it satisfies a predicate expression associated with the predicate class. The predicate expression can test the value or state of the object, thus supporting a form of implicit property-based classification that augments the explicit type-based classification provided by normal classes. By associating methods with predicate classes, method lookup can depend not only on the dynamic class of an argument but also on its dynamic value or state. If an object is modified, the property-based classification of an object can change over time, implementing shifts in major behavior modes of the object. A version of predicate classes has been designed and implemented in the context of the Cecil language.",
|
||
isbn="978-3-540-47910-9"
|
||
}
|
||
|
||
|
||
@article{MDE,
|
||
title={Model-driven engineering},
|
||
author={Schmidt, Douglas C and others},
|
||
journal={Computer-IEEE Computer Society-},
|
||
volume={39},
|
||
number={2},
|
||
pages={25},
|
||
year={2006},
|
||
publisher={Citeseer}
|
||
}
|