+
+@inproceedings{achten_high_1993,
+ address = {London},
+ title = {High {Level} {Specification} of {I}/{O} in {Functional} {Languages}},
+ isbn = {978-1-4471-3215-8},
+ abstract = {The interface with the outside world has always been one of the weakest points of functional languages. It is not easy to incorporate I/O without being allowed to do side-effects. Furthermore, functional languages allow redexes to be evaluated in any order while I/O generally has to be performed in a very specific order. In this paper we present a new solution for the I/O problem which we have incorporated in the language Concurrent Clean. Concurrent Clean offers a linear type system called Unique Types. It makes it possible to define functions with side-effects without violating the functional semantics. Now it is possible to change any object in the world in the way we wanted: e.g. arrays can be updated in-situ, arbitrary file manipulation is possible. We have used this powerful tool among others to create a library for window based I/O. Using an explicit environment passing scheme provides a high-level and elegant functional specification method for I/O, called Event I/O. Now the specification of I/O has become one of the strengths of functional languages: interactive programs written in Concurrent Clean are concise, easy to write and comprehend as well as efficient. The presented solution can in principle be applied for any other functional language as well provided that it actually uses graph rewriting semantics in the implementation.},
+ booktitle = {Functional {Programming}, {Glasgow} 1992},
+ publisher = {Springer London},
+ author = {Achten, Peter and van Groningen, John and Plasmeijer, Rinus},
+ editor = {Launchbury, John and Sansom, Patrick},
+ year = {1993},
+ pages = {1--17},
+ file = {Achten et al. - 1993 - High Level Specification of IO in Functional Lang.pdf:/home/mrl/.local/share/zotero/storage/4QVH7AYC/Achten et al. - 1993 - High Level Specification of IO in Functional Lang.pdf:application/pdf},
+}
+
+@inproceedings{pickering_staged_2020,
+ address = {New York, NY, USA},
+ series = {Haskell 2020},
+ title = {Staged {Sums} of {Products}},
+ isbn = {978-1-4503-8050-8},
+ url = {https://doi.org/10.1145/3406088.3409021},
+ doi = {10.1145/3406088.3409021},
+ abstract = {Generic programming libraries have historically traded efficiency in return for convenience, and the generics-sop library is no exception. It offers a simple, uniform, representation of all datatypes precisely as a sum of products, making it easy to write generic functions. We show how to finally make generics-sop fast through the use of staging with Typed Template Haskell.},
+ booktitle = {Proceedings of the 13th {ACM} {SIGPLAN} {International} {Symposium} on {Haskell}},
+ publisher = {Association for Computing Machinery},
+ author = {Pickering, Matthew and Löh, Andres and Wu, Nicolas},
+ year = {2020},
+ note = {event-place: Virtual Event, USA},
+ keywords = {generic programming, staging},
+ pages = {122--135},
+ file = {Pickering et al. - 2020 - Staged Sums of Products.pdf:/home/mrl/.local/share/zotero/storage/Q6ZWX4YP/Pickering et al. - 2020 - Staged Sums of Products.pdf:application/pdf},
+}
+
+@article{xie_staging_2022,
+ title = {Staging with {Class}: {A} {Specification} for {Typed} {Template} {Haskell}},
+ volume = {6},
+ url = {https://doi.org/10.1145/3498723},
+ doi = {10.1145/3498723},
+ abstract = {Multi-stage programming using typed code quotation is an established technique for writing optimizing code generators with strong type-safety guarantees. Unfortunately, quotation in Haskell interacts poorly with type classes, making it difficult to write robust multi-stage programs. We study this unsound interaction and propose a resolution, staged type class constraints, which we formalize in a source calculus λ⇒ that elaborates into an explicit core calculus F. We show type soundness of both calculi, establishing that well-typed, well-staged source programs always elaborate to well-typed, well-staged core programs, and prove beta and eta rules for code quotations. Our design allows programmers to incorporate type classes into multi-stage programs with confidence. Although motivated by Haskell, it is also suitable as a foundation for other languages that support both overloading and quotation.},
+ number = {POPL},
+ journal = {Proc. ACM Program. Lang.},
+ author = {Xie, Ningning and Pickering, Matthew and Löh, Andres and Wu, Nicolas and Yallop, Jeremy and Wang, Meng},
+ month = jan,
+ year = {2022},
+ note = {Place: New York, NY, USA
+Publisher: Association for Computing Machinery},
+ keywords = {Staging, Type Classes, Typed Template Haskell},
+ file = {Xie et al. - 2022 - Staging with Class A Specification for Typed Temp.pdf:/home/mrl/.local/share/zotero/storage/QGDB5YHR/Xie et al. - 2022 - Staging with Class A Specification for Typed Temp.pdf:application/pdf},
+}
+
+@article{rhiger_type-safe_2009,
+ title = {Type-safe pattern combinators},
+ volume = {19},
+ doi = {10.1017/S0956796808007089},
+ number = {2},
+ journal = {Journal of Functional Programming},
+ author = {Rhiger, Morten},
+ year = {2009},
+ note = {Publisher: Cambridge University Press},
+ pages = {145--156},
+ file = {RHIGER - 2009 - Type-safe pattern combinators.pdf:/home/mrl/.local/share/zotero/storage/D4N7PGBS/RHIGER - 2009 - Type-safe pattern combinators.pdf:application/pdf},
+}
+
+@inproceedings{de_vries_true_2014,
+ address = {New York, NY, USA},
+ series = {{WGP} '14},
+ title = {True {Sums} of {Products}},
+ isbn = {978-1-4503-3042-8},
+ url = {https://doi.org/10.1145/2633628.2633634},
+ doi = {10.1145/2633628.2633634},
+ abstract = {We introduce the sum-of-products (SOP) view for datatype-generic programming (in Haskell). While many of the libraries that are commonly in use today represent datatypes as arbitrary combinations of binary sums and products, SOP reflects the structure of datatypes more faithfully: each datatype is a single n-ary sum, where each component of the sum is a single n-ary product. This representation turns out to be expressible accurately in GHC with today's extensions. The resulting list-like structure of datatypes allows for the definition of powerful high-level traversal combinators, which in turn encourage the definition of generic functions in a compositional and concise style. A major plus of the SOP view is that it allows to separate function-specific metadata from the main structural representation and recombining this information later.},
+ booktitle = {Proceedings of the 10th {ACM} {SIGPLAN} {Workshop} on {Generic} {Programming}},
+ publisher = {Association for Computing Machinery},
+ author = {de Vries, Edsko and Löh, Andres},
+ year = {2014},
+ note = {event-place: Gothenburg, Sweden},
+ keywords = {lenses, datatype-generic programming, generic views, json, metadata, sums of products, universes},
+ pages = {83--94},
+ file = {de Vries and Löh - 2014 - True Sums of Products.pdf:/home/mrl/.local/share/zotero/storage/QHT5IPQA/de Vries and Löh - 2014 - True Sums of Products.pdf:application/pdf},
+}
+
+@article{willis_staged_2020,
+ title = {Staged {Selective} {Parser} {Combinators}},
+ volume = {4},
+ url = {https://doi.org/10.1145/3409002},
+ doi = {10.1145/3409002},
+ abstract = {Parser combinators are a middle ground between the fine control of hand-rolled parsers and the high-level almost grammar-like appearance of parsers created via parser generators. They also promote a cleaner, compositional design for parsers. Historically, however, they cannot match the performance of their counterparts. This paper describes how to compile parser combinators into parsers of hand-written quality. This is done by leveraging the static information present in the grammar by representing it as a tree. However, in order to exploit this information, it will be necessary to drop support for monadic computation since this generates dynamic structure. Selective functors can help recover lost functionality in the absence of monads, and the parser tree can be partially evaluated with staging. This is implemented in a library called Parsley.},
+ number = {ICFP},
+ journal = {Proc. ACM Program. Lang.},
+ author = {Willis, Jamie and Wu, Nicolas and Pickering, Matthew},
+ month = aug,
+ year = {2020},
+ note = {Place: New York, NY, USA
+Publisher: Association for Computing Machinery},
+ keywords = {combinators, meta-programming, parsers},
+ file = {Willis et al. - 2020 - Staged Selective Parser Combinators.pdf:/home/mrl/.local/share/zotero/storage/RCD842QK/Willis et al. - 2020 - Staged Selective Parser Combinators.pdf:application/pdf},
+}
+
+@inproceedings{pickering_multi-stage_2019,
+ address = {New York, NY, USA},
+ series = {Haskell 2019},
+ title = {Multi-{Stage} {Programs} in {Context}},
+ isbn = {978-1-4503-6813-1},
+ url = {https://doi.org/10.1145/3331545.3342597},
+ doi = {10.1145/3331545.3342597},
+ abstract = {Cross-stage persistence is an essential aspect of multi-stage programming that allows a value defined in one stage to be available in another. However, difficulty arises when implicit information held in types, type classes and implicit parameters needs to be persisted. Without a careful treatment of such implicit information—which are pervasive in Haskell—subtle yet avoidable bugs lurk beneath the surface. This paper demonstrates that in multi-stage programming care must be taken when representing quoted terms so that important implicit information is kept in context and not discarded. The approach is formalised with a type-system, and an implementation in GHC is presented that fixes problems of the previous incarnation.},
+ booktitle = {Proceedings of the 12th {ACM} {SIGPLAN} {International} {Symposium} on {Haskell}},
+ publisher = {Association for Computing Machinery},
+ author = {Pickering, Matthew and Wu, Nicolas and Kiss, Csongor},
+ year = {2019},
+ note = {event-place: Berlin, Germany},
+ keywords = {metaprogramming, staging, implicits},
+ pages = {71--84},
+ file = {Pickering et al. - 2019 - Multi-Stage Programs in Context.pdf:/home/mrl/.local/share/zotero/storage/3EW7FM44/Pickering et al. - 2019 - Multi-Stage Programs in Context.pdf:application/pdf},
+}
+
+@article{pickering_specification_2021,
+ title = {A {Specification} for {Typed} {Template} {Haskell}},
+ volume = {abs/2112.03653},
+ url = {https://arxiv.org/abs/2112.03653},
+ doi = {10.48550/arXiv.2112.03653},
+ journal = {CoRR},
+ author = {Pickering, Matthew and Löh, Andres and Wu, Nicolas},
+ year = {2021},
+ note = {arXiv: 2112.03653},
+ file = {Pickering et al. - 2021 - A Specification for Typed Template Haskell.pdf:/home/mrl/.local/share/zotero/storage/YBTN4DLK/Pickering et al. - 2021 - A Specification for Typed Template Haskell.pdf:application/pdf},
+}
+
+@book{steenvoorden_tophat_2022,
+ address = {Nijmegen},
+ title = {{TopHat}: {Task}-{Oriented} {Programming} with {Style}},
+ isbn = {978-94-6458-595-7},
+ shorttitle = {{TopHat}: {TOP} with {Style}},
+ language = {English},
+ publisher = {UB Nijmegen},
+ author = {Steenvoorden, Tim},
+ year = {2022},
+ file = {Steenvoorden - 2022 - TopHat Task-Oriented Programming with Style.pdf:/home/mrl/.local/share/zotero/storage/ZV8IT9J5/Steenvoorden - 2022 - TopHat Task-Oriented Programming with Style.pdf:application/pdf},
+}
+
+@inproceedings{folmer_high-level_2022,
+ address = {Cham},
+ title = {High-{Level} {Synthesis} of {Digital} {Circuits} from {Template} {Haskell} and {SDF}-{AP}},
+ isbn = {978-3-031-15074-6},
+ abstract = {Functional languages as input specifications for HLS-tools allow to specify data dependencies but do not contain a notion of time nor execution order. In this paper, we propose a method to add this notion to the functional description using the dataflow model SDF-AP. SDF-AP consists of patterns that express consumption and production that we can use to enforce resource usage. We created an HLS-tool that can synthesize parallel hardware, both data and control path, based on the repetition, expressed in Higher-Order Functions, combined with specified SDF-AP patterns.},
+ booktitle = {Embedded {Computer} {Systems}: {Architectures}, {Modeling}, and {Simulation}},
+ publisher = {Springer International Publishing},
+ author = {Folmer, H. H. and Groote, R. de and Bekooij, M. J. G.},
+ editor = {Orailoglu, Alex and Reichenbach, Marc and Jung, Matthias},
+ year = {2022},
+ pages = {3--27},
+ file = {Folmer et al. - 2022 - High-Level Synthesis of Digital Circuits from Temp.pdf:/home/mrl/.local/share/zotero/storage/5JSW6MAL/Folmer et al. - 2022 - High-Level Synthesis of Digital Circuits from Temp.pdf:application/pdf},
+}
+
+@article{materzok_generating_2022,
+ title = {Generating {Circuits} with {Generators}},
+ volume = {6},
+ url = {https://doi.org/10.1145/3549821},
+ doi = {10.1145/3549821},
+ abstract = {The most widely used languages and methods used for designing digital hardware fall into two rough categories. One of them, register transfer level (RTL), requires specifying each and every component in the designed circuit. This gives the designer full control, but burdens the designer with many trivial details. The other, the high-level synthesis (HLS) method, allows the designer to abstract the details of hardware away and focus on the problem being solved. This method however cannot be used for a class of hardware design problems because the circuit's clock is also abstracted away. We present YieldFSM, a hardware description language that uses the generator abstraction to represent clock-level timing in a digital circuit. It represents a middle ground between the RTL and HLS approaches: the abstraction level is higher than in RTL, but thanks to explicit information about clock-level timing, it can be used in applications where RTL is traditionally used. We also present the YieldFSM compiler, which uses methods developed by the functional programming community – including continuation-passsing style translation and defunctionalization – to translate YieldFSM programs to Mealy machines. It is implemented using Template Haskell and the Clash functional hardware description language. We show that this approach leads to short and conceptually simple hardware descriptions.},
+ number = {ICFP},
+ journal = {Proc. ACM Program. Lang.},
+ author = {Materzok, Marek},
+ month = aug,
+ year = {2022},
+ note = {Place: New York, NY, USA
+Publisher: Association for Computing Machinery},
+ keywords = {circuit synthesis, generators, hardware description languages},
+ file = {Materzok - 2022 - Generating Circuits with Generators.pdf:/home/mrl/.local/share/zotero/storage/LH4Q8J73/Materzok - 2022 - Generating Circuits with Generators.pdf:application/pdf},
+}
+
+@article{egi_embedding_2022,
+ title = {Embedding {Non}-linear {Pattern} {Matching} with {Backtracking} for {Non}-free {Data} {Types} into {Haskell}},
+ volume = {40},
+ issn = {1882-7055},
+ url = {https://doi.org/10.1007/s00354-022-00177-z},
+ doi = {10.1007/s00354-022-00177-z},
+ abstract = {Pattern matching is an important language construct for data abstraction. Many pattern-match extensions have been developed for extending the range of data types to which pattern matching is applicable. Among them, the pattern-match system proposed by Egi and Nishiwaki features practical pattern matching for non-free data types by providing a user-customizable non-linear pattern-match facility with backtracking. However, they implemented their proposal only in dynamically typed programming languages, and there were no proposals that allow programmers to benefit from both static type systems and expressive pattern matching. This paper proposes a method for implementing this pattern-match facility by meta-programming in Haskell. There are two technical challenges: (i) we need to design a set of typing rules for the pattern-match facility; (ii) we need to embed these typing rules in Haskell to make types of the pattern-match expressions inferable by the Haskell type system. We propose a set of typing rules and show that several GHC extensions, such as multi-parameter type classes, datatype promotion, GADTs, existential types, and view patterns, play essential roles for embedding these typing rules into Haskell. The implementation has already been distributed as a Haskell library miniEgison via Hackage.},
+ number = {2},
+ journal = {New Generation Computing},
+ author = {Egi, Satoshi and Kawata, Akira and Kori, Mayuko and Ogawa, Hiromi},
+ month = jul,
+ year = {2022},
+ pages = {481--506},
+ file = {Egi et al. - 2022 - Embedding Non-linear Pattern Matching with Backtra.pdf:/home/mrl/.local/share/zotero/storage/PXT9L9Z4/Egi et al. - 2022 - Embedding Non-linear Pattern Matching with Backtra.pdf:application/pdf},
+}
+
+@inproceedings{blanchette_liquid_2022,
+ address = {New York, NY, USA},
+ series = {Haskell 2022},
+ title = {Liquid {Proof} {Macros}},
+ isbn = {978-1-4503-9438-3},
+ url = {https://doi.org/10.1145/3546189.3549921},
+ doi = {10.1145/3546189.3549921},
+ abstract = {Liquid Haskell is a popular verifier for Haskell programs, leveraging the power of SMT solvers to ease users' burden of proof. However, this power does not come without a price: convincing Liquid Haskell that a program is correct often necessitates giving hints to the underlying solver, which can be a tedious and verbose process that sometimes requires intricate knowledge of Liquid Haskell's inner workings. In this paper, we present Liquid Proof Macros, an extensible metaprogramming technique and framework for simplifying the development of Liquid Haskell proofs. We describe how to leverage Template Haskell to generate Liquid Haskell proof terms, via a tactic-inspired DSL interface for more concise and user-friendly proofs, and we demonstrate the capabilities of this framework by automating a wide variety of proofs from an existing Liquid Haskell benchmark.},
+ booktitle = {Proceedings of the 15th {ACM} {SIGPLAN} {International} {Haskell} {Symposium}},
+ publisher = {Association for Computing Machinery},
+ author = {Blanchette, Henry and Vazou, Niki and Lampropoulos, Leonidas},
+ year = {2022},
+ note = {event-place: Ljubljana, Slovenia},
+ keywords = {Liquid Haskell, Proof Macros, Tactics},
+ pages = {27--38},
+ file = {Blanchette et al. - 2022 - Liquid Proof Macros.pdf:/home/mrl/.local/share/zotero/storage/YXPCWQNI/Blanchette et al. - 2022 - Liquid Proof Macros.pdf:application/pdf},
+}
+
+@phdthesis{baaij_digital_2015,
+ address = {Netherlands},
+ type = {{PhD} {Thesis}},
+ title = {Digital circuit in {C}\${\textbackslash}lambda\${aSH}: functional specifications and type-directed synthesis},
+ abstract = {Over the last three decades, the number of transistors used in microchips has increased by three orders of magnitude, from millions to billions. The productivity of the designers, however, lags behind. Managing to implement complex algorithms, while keeping non-functional properties within desired bounds, and thoroughly verifying the design against its specification, are the main difficulties in circuit design. As a motivation for our work we make a qualitative analysis of the tools available to circuit designers. Here we see that progress has been slow, and that the same techniques have been used for over 20 years. We claim that functional languages can be used to raise the abstraction level in circuit design. Especially higher-order functional languages, where functions are first-class and can be manipulated by other functions, offer a single abstraction mechanism that can capture many design patterns. This thesis explores the idea of using the functional language Haskell directly as a hardware specification language, and move beyond the limitations of embedded languages. Additionally, we can use normal functions from existing Haskell libraries to model the behaviour of our circuits. This thesis describes the inner workings of our CλaSH compiler, which translates the aforementioned circuit descriptions written in Haskell to low-level descriptions in VHDL. The challenge then becomes the reduction of the higher-level abstractions in the descriptions to a form where synthesis is feasible. This thesis describes a term rewrite system (with bound variables) to achieve this reduction. We prove that this term rewrite system always reduces a polymorphic, higher-order circuit description to a synthesisable variant. Even when descriptions use high-level abstractions, the CλaSH compiler can synthesize efficient circuits. Case studies show that circuits designed in Haskell, and synthesized with the C?aSH compiler, are on par with hand-written VHDL, in both area and gate propagation delay. This thesis thus shows the merits of using a modern functional language for circuit design. The advanced type system and higher-order functions allow us to design circuits that have the desired property of being correct-by-construction. Finally, our synthesis approach enables us to derive efficient circuits from descriptions that use high-level abstractions.},
+ language = {Undefined},
+ school = {University of Twente},
+ author = {Baaij, C. P. R.},
+ month = jan,
+ year = {2015},
+ doi = {10.3990/1.9789036538039},
+ note = {ISBN: 978-90-365-3803-9},
+ keywords = {Haskell, Digital Circuits, EC Grant Agreement nr.: FP7/248465, EC Grant Agreement nr.: FP7/610686, EWI-23939, FPGA, Functional Programming, Hardware, IR-93962, Lambda calculus, METIS-308711, Rewrite Systems},
+ file = {Baaij - 2015 - Digital circuit in CλaSH functional specification.pdf:/home/mrl/.local/share/zotero/storage/MYJ33ISL/Baaij - 2015 - Digital circuit in CλaSH functional specification.pdf:application/pdf},
+}
+
+@inproceedings{mcdonell_embedded_2022,
+ address = {New York, NY, USA},
+ series = {Haskell 2022},
+ title = {Embedded {Pattern} {Matching}},
+ isbn = {978-1-4503-9438-3},
+ url = {https://doi.org/10.1145/3546189.3549917},
+ doi = {10.1145/3546189.3549917},
+ abstract = {Haskell is a popular choice for hosting deeply embedded languages. A recurring challenge for these embeddings is how to seamlessly integrate user defined algebraic data types. In particular, one important, convenient, and expressive feature for creating and inspecting data—pattern matching—is not directly available on embedded terms. We present a novel technique, embedded pattern matching, which enables a natural and user friendly embedding of user defined algebraic data types into the embedded language, and allows programmers to pattern match on terms in the embedded language in much the same way they would in the host language.},
+ booktitle = {Proceedings of the 15th {ACM} {SIGPLAN} {International} {Haskell} {Symposium}},
+ publisher = {Association for Computing Machinery},
+ author = {McDonell, Trevor L. and Meredith, Joshua D. and Keller, Gabriele},
+ year = {2022},
+ note = {event-place: Ljubljana, Slovenia},
+ keywords = {Haskell, algebraic data types, embedded languages, pattern matching},
+ pages = {123--136},
+ file = {2108.13114.pdf:/home/mrl/.local/share/zotero/storage/AJAT8AXI/2108.13114.pdf:application/pdf},
+}
+
+@phdthesis{krishnamurthi_linguistic_2001,
+ address = {Houston, USA},
+ type = {{PhD} {Thesis}},
+ title = {Linguistic reuse},
+ school = {Rice University},
+ author = {Krishnamurthi, Shriram},
+ year = {2001},
+ file = {Krishnamurthi - 2001 - Linguistic reuse.PDF:/home/mrl/.local/share/zotero/storage/LSKHFPIS/Krishnamurthi - 2001 - Linguistic reuse.PDF:application/pdf},
+}
+
+@misc{ashton_internet_1999,
+ address = {London, UK},
+ type = {Presentation},
+ title = {Internet of {Things}},
+ author = {Ashton, Kevin},
+ year = {1999},
+ note = {Presentation at Proctor \& Gamble},
+}
+
+@article{ashton_that_2009,
+ title = {That ‘{Internet} of {Things}’ {Thing}},
+ volume = {22},
+ number = {7},
+ journal = {RFID journal},
+ author = {Ashton, Kevin},
+ year = {2009},
+ note = {Publisher: Hauppauge, New York},
+ pages = {97--114},
+ file = {Ashton - 2009 - That ‘Internet of Things’ Thing.pdf:/home/mrl/.local/share/zotero/storage/SJ33G6VR/Ashton - 2009 - That ‘Internet of Things’ Thing.pdf:application/pdf},
+}
+
+@phdthesis{van_gemert_task_2022,
+ address = {Nijmegen},
+ type = {Bachelor's {Thesis}},
+ title = {Task {Oriented} {Programming} in {LUA}},
+ language = {en},
+ school = {Radboud University},
+ author = {van Gemert, Dante},
+ year = {2022},
+ file = {van Gemert - 2022 - Task Oriented Programming in LUA.pdf:/home/mrl/.local/share/zotero/storage/UQHAWT83/van Gemert - 2022 - Task Oriented Programming in LUA.pdf:application/pdf},
+}
+
+@misc{lijnse_toppyt_2022,
+ title = {Toppyt},
+ url = {https://gitlab.com/baslijnse/toppyt},
+ urldate = {2022-10-07},
+ author = {Lijnse, Bas},
+ year = {2022},
+}
+
+@article{sun_compositional_2022,
+ title = {Compositional {Embeddings} of {Domain}-{Specific} {Languages}},
+ volume = {6},
+ doi = {10.1145/3563294},
+ language = {en},
+ number = {OOPSLA2},
+ journal = {Proc. ACM Program. Lang.},
+ author = {Sun, Yaozhu and Dhandhania, Utkarsh and Oliveira, Bruno C. d. S.},
+ year = {2022},
+ pages = {34},
+ file = {Sun and Dhandhania - Compositional Embeddings of Domain-Specific Langua.pdf:/home/mrl/.local/share/zotero/storage/Y4GADQFP/Sun and Dhandhania - Compositional Embeddings of Domain-Specific Langua.pdf:application/pdf},
+}
+
+@misc{lubbers_htask_2022,
+ title = {{hTask}},
+ url = {https://gitlab.com/mlubbers/acsds},
+ urldate = {2022-10-07},
+ author = {Lubbers, Mart},
+ year = {2022},
+}