language = {English},
urldate = {2021-02-24},
publisher = {Release},
- author = {{GHC Team}},
+ author = {GHC Team},
year = {2021},
file = {GHC Team - 2021 - GHC User’s Guide Documentation.pdf:/home/mrl/.local/share/zotero/storage/87ZT5VXL/GHC Team - 2021 - GHC User’s Guide Documentation.pdf:application/pdf},
}
language = {English},
urldate = {2021-02-24},
publisher = {Release},
- author = {{GHC Team}},
+ author = {GHC Team},
year = {2021},
}
file = {svenningsson2013combining.pdf:/home/mrl/.local/share/zotero/storage/NFBGZCZT/svenningsson2013combining.pdf:application/pdf},
}
-@article{mitchell_abstract_1988,
- title = {Abstract {Types} {Have} {Existential} {Type}},
- volume = {10},
- issn = {0164-0925},
- doi = {10.1145/44501.45065},
- abstract = {Abstract data type declarations appear in typed programming languages like Ada, Alphard, CLU and ML. This form of declaration binds a list of identifiers to a type with associated operations, a composite “value” we call a data algebra. We use a second-order typed lambda calculus SOL to show how data algebras may be given types, passed as parameters, and returned as results of function calls. In the process, we discuss the semantics of abstract data type declarations and review a connection between typed programming languages and constructive logic.},
- number = {3},
- journal = {ACM Trans. Program. Lang. Syst.},
- author = {Mitchell, John C. and Plotkin, Gordon D.},
- month = jul,
- year = {1988},
- note = {Place: New York, NY, USA
-Publisher: Association for Computing Machinery},
- pages = {470--502},
- file = {Mitchell and Plotkin - 1988 - Abstract types have existential type.pdf:/home/mrl/.local/share/zotero/storage/QXDE5H7C/Mitchell and Plotkin - 1988 - Abstract types have existential type.pdf:application/pdf},
-}
-
@inproceedings{yorgey_giving_2012,
address = {New York, NY, USA},
series = {{TLDI} '12},
author = {Barendregt, HP and van Eekelen, MCJD and Glauert, JRW and Kennaway, JR and Plasmeijer, MJ and Sleep, MR},
year = {1987},
pages = {159--174},
- file = {barh87-Lean.ps.gz:/home/mrl/.local/share/zotero/storage/63FBHND7/barh87-Lean.ps.gz:application/gzip},
+ file = {barh87-Lean.ps.gz:/home/mrl/.local/share/zotero/storage/63FBHND7/barh87-Lean.ps.gz:application/gzip;barh87-Lean.ps.gz:/home/mrl/.local/share/zotero/storage/6H2UKQGZ/barh87-Lean.ps.gz:application/gzip},
}
@misc{johnson-davies_lisp_2020,
file = {Stutterheim et al. - 2018 - Maintaining Separation of Concerns Through Task Or.pdf:/home/mrl/.local/share/zotero/storage/4GXJEM2U/Stutterheim et al. - 2018 - Maintaining Separation of Concerns Through Task Or.pdf:application/pdf},
}
+@phdthesis{serrano_type_2018,
+ type = {{PhD} {Thesis}},
+ title = {Type {Error} {Customization} for {Embedded} {Domain}-{Specific} {Languages}},
+ school = {Utrecht University},
+ author = {Serrano, Alejandro},
+ year = {2018},
+}
+
@inproceedings{steiner_firmata:_2009,
title = {Firmata: {Towards} {Making} {Microcontrollers} {Act} {Like} {Extensions} of the {Computer}.},
booktitle = {{NIME}},
@inproceedings{jansen_towards_2010,
address = {Seattle, USA},
title = {Towards dynamic workflows for crisis management},
- booktitle = {{ISCRAM} 2010 – 7th {International} {Conference} on {Information} {Systems} for {Crisis} {Response} and {Management}: {Defining} {Crisis} {Management} 3.0, {Proceedings}},
+ isbn = {978-972-49-2247-8},
+ booktitle = {7th {Proceedings} of the {International} {Conference} on {Information} {Systems} for {Crisis} {Response} and {Management}, {Seattle}, {WA}, {USA}, {May}, 2010.},
publisher = {Information Systems for Crisis Response and Management, ISCRAM},
author = {Jansen, Jan Martin and Lijnse, Bas and Plasmeijer, Rinus},
- editor = {French, B. and Tomaszewski, C.},
+ editor = {French, Simon and Tomaszewski, n and Zobel, Christopher},
year = {2010},
file = {Jansen et al. - 2010 - Towards dynamic workflows for crisis management.pdf:/home/mrl/.local/share/zotero/storage/AQSZJ3TA/Jansen et al. - 2010 - Towards dynamic workflows for crisis management.pdf:application/pdf},
}
title = {Managing {COPD} exacerbations with telemedicine},
booktitle = {Conference on {Artificial} {Intelligence} in {Medicine} in {Europe}},
publisher = {Springer},
- author = {Van Der Heijden, Maarten and Lijnse, Bas and Lucas, Peter JF and Heijdra, Yvonne F and Schermer, Tjard RJ},
+ author = {van der Heijden, Maarten and Lijnse, Bas and Lucas, Peter JF and Heijdra, Yvonne F and Schermer, Tjard RJ},
year = {2011},
pages = {169--178},
file = {Van Der Heijden et al. - 2011 - Managing COPD exacerbations with telemedicine.pdf:/home/mrl/.local/share/zotero/storage/AS3MPSEF/Van Der Heijden et al. - 2011 - Managing COPD exacerbations with telemedicine.pdf:application/pdf},
file = {Lijnse et al. - 2012 - Incidone A task-oriented incident coordination to.pdf:/home/mrl/.local/share/zotero/storage/EYS9U69B/Lijnse et al. - 2012 - Incidone A task-oriented incident coordination to.pdf:application/pdf},
}
+@inproceedings{santanna_safe_2013,
+ title = {Safe system-level concurrency on resource-constrained nodes},
+ booktitle = {Proceedings of the 11th {ACM} {Conference} on {Embedded} {Networked} {Sensor} {Systems}},
+ publisher = {ACM},
+ author = {Sant'Anna, Francisco and Rodriguez, Noemi and Ierusalimschy, Roberto and Landsiedel, Olaf and Tsigas, Philippas},
+ year = {2013},
+ pages = {11},
+ file = {Sant'Anna et al. - 2013 - Safe system-level concurrency on resource-constrai.pdf:/home/mrl/.local/share/zotero/storage/4865FAU3/Sant'Anna et al. - 2013 - Safe system-level concurrency on resource-constrai.pdf:application/pdf},
+}
+
@mastersthesis{bohm_asynchronous_2019,
address = {Nijmegen},
title = {Asynchronous {Actions} in a {Synchronous} {World}},
year = {2008},
note = {Place: New York, NY, USA
Publisher: Association for Computing Machinery},
- keywords = {domain specific languages, compile-time meta-programming, Syntax extension},
+ keywords = {compile-time meta-programming, domain specific languages, Syntax extension},
file = {Tratt - 2008 - Domain Specific Language Implementation via Compil.pdf:/home/mrl/.local/share/zotero/storage/HHGYJK4H/Tratt - 2008 - Domain Specific Language Implementation via Compil.pdf:application/pdf},
}
}
@article{hammond_automatic_2003,
- title = {{AUTOMATIC} {SKELETONS} {IN} {TEMPLATE} {HASKELL}},
+ title = {Automatic {Skeletons} in {Template} {Haskell}},
volume = {13},
doi = {10.1142/S0129626403001380},
abstract = {This paper uses Template Haskell to automatically select appropriate skeleton implementations in the Eden parallel dialect of Haskell. The approach allows implementation parameters to be statically tuned according to architectural cost models based on source analyses. This permits us to target a range of parallel architecture classes from a single source specification. A major advantage of the approach is that cost models are user-definable and can be readily extended to new data or computation structures etc.},
file = {Viera et al. - 2018 - A Staged Embedding of Attribute Grammars in Haskel.pdf:/home/mrl/.local/share/zotero/storage/53D4HT9C/Viera et al. - 2018 - A Staged Embedding of Attribute Grammars in Haskel.pdf:application/pdf},
}
-@incollection{kiselyov_typed_2012,
- address = {Berlin, Heidelberg},
- title = {Typed {Tagless} {Final} {Interpreters}},
- isbn = {978-3-642-32202-0},
- abstract = {The so-called `typed tagless final' approach of [6] has collected and polished a number of techniques for representing typed higher-order languages in a typed metalanguage, along with type-preserving interpretation, compilation and partial evaluation. The approach is an alternative to the traditional, or `initial' encoding of an object language as a (generalized) algebraic data type. Both approaches permit multiple interpretations of an expression, to evaluate it, pretty-print, etc. The final encoding represents all and only typed object terms without resorting to generalized algebraic data types, dependent or other fancy types. The final encoding lets us add new language forms and interpretations without breaking the existing terms and interpreters.},
- booktitle = {Generic and {Indexed} {Programming}: {International} {Spring} {School}, {SSGIP} 2010, {Oxford}, {UK}, {March} 22-26, 2010, {Revised} {Lectures}},
- publisher = {Springer Berlin Heidelberg},
- author = {Kiselyov, Oleg},
- editor = {Gibbons, Jeremy},
- year = {2012},
- doi = {10.1007/978-3-642-32202-0_3},
- pages = {130--174},
- file = {Kiselyov - 2012 - Typed Tagless Final Interpreters.pdf:/home/mrl/.local/share/zotero/storage/9NBYZLRP/Kiselyov - 2012 - Typed Tagless Final Interpreters.pdf:application/pdf},
-}
-
@article{laufer_type_1996,
title = {Type classes with existential types},
volume = {6},
file = {CleanLanguageReport.pdf:/home/mrl/.local/share/zotero/storage/I2SDRIH6/CleanLanguageReport.pdf:application/pdf},
}
+@incollection{kiselyov_typed_2012,
+ address = {Berlin, Heidelberg},
+ title = {Typed {Tagless} {Final} {Interpreters}},
+ isbn = {978-3-642-32202-0},
+ abstract = {The so-called `typed tagless final' approach of [6] has collected and polished a number of techniques for representing typed higher-order languages in a typed metalanguage, along with type-preserving interpretation, compilation and partial evaluation. The approach is an alternative to the traditional, or `initial' encoding of an object language as a (generalized) algebraic data type. Both approaches permit multiple interpretations of an expression, to evaluate it, pretty-print, etc. The final encoding represents all and only typed object terms without resorting to generalized algebraic data types, dependent or other fancy types. The final encoding lets us add new language forms and interpretations without breaking the existing terms and interpreters.},
+ booktitle = {Generic and {Indexed} {Programming}: {International} {Spring} {School}, {SSGIP} 2010, {Oxford}, {UK}, {March} 22-26, 2010, {Revised} {Lectures}},
+ publisher = {Springer Berlin Heidelberg},
+ author = {Kiselyov, Oleg},
+ editor = {Gibbons, Jeremy},
+ year = {2012},
+ doi = {10.1007/978-3-642-32202-0_3},
+ pages = {130--174},
+ file = {Kiselyov - 2012 - Typed Tagless Final Interpreters.pdf:/home/mrl/.local/share/zotero/storage/9NBYZLRP/Kiselyov - 2012 - Typed Tagless Final Interpreters.pdf:application/pdf},
+}
+
@inproceedings{nocker_concurrent_1991,
address = {Berlin, Heidelberg},
title = {Concurrent clean},
file = {Cheney and Hinze - 2003 - First-class phantom types.pdf:/home/mrl/.local/share/zotero/storage/IBKGCFG2/Cheney and Hinze - 2003 - First-class phantom types.pdf:application/pdf},
}
+@article{mitchell_abstract_1988,
+ title = {Abstract {Types} {Have} {Existential} {Type}},
+ volume = {10},
+ issn = {0164-0925},
+ doi = {10.1145/44501.45065},
+ abstract = {Abstract data type declarations appear in typed programming languages like Ada, Alphard, CLU and ML. This form of declaration binds a list of identifiers to a type with associated operations, a composite “value” we call a data algebra. We use a second-order typed lambda calculus SOL to show how data algebras may be given types, passed as parameters, and returned as results of function calls. In the process, we discuss the semantics of abstract data type declarations and review a connection between typed programming languages and constructive logic.},
+ number = {3},
+ journal = {ACM Trans. Program. Lang. Syst.},
+ author = {Mitchell, John C. and Plotkin, Gordon D.},
+ month = jul,
+ year = {1988},
+ note = {Place: New York, NY, USA
+Publisher: Association for Computing Machinery},
+ pages = {470--502},
+ file = {Mitchell and Plotkin - 1988 - Abstract types have existential type.pdf:/home/mrl/.local/share/zotero/storage/QXDE5H7C/Mitchell and Plotkin - 1988 - Abstract types have existential type.pdf:application/pdf},
+}
+
@inproceedings{baars_typing_2002,
address = {New York, NY, USA},
series = {{ICFP} '02},
year = {2021},
note = {event-place: Copenhagen, Denmark},
pages = {20--36},
+ file = {Young et al. - 2021 - On Adding Pattern Matching to Haskell-Based Deeply.pdf:/home/mrl/.local/share/zotero/storage/XRYWKWPT/Young et al. - 2021 - On Adding Pattern Matching to Haskell-Based Deeply.pdf:application/pdf},
}
@incollection{hinze_generic_2003,
file = {Polak and Jarosz - Automatic Graphical User Interface Form Generation.pdf:/home/mrl/.local/share/zotero/storage/8VK3D8JQ/Polak and Jarosz - Automatic Graphical User Interface Form Generation.pdf:application/pdf},
}
+@inproceedings{koopman_executable_2011,
+ address = {Berlin, Heidelberg},
+ title = {An {Executable} and {Testable} {Semantics} for {iTasks}},
+ isbn = {978-3-642-24452-0},
+ abstract = {The iTask system is an easy to use combinator library for specifying dynamic data dependent workflows in a very flexible way. The specified workflows are executed as a multi-user web-application. The implementation of the iTask system is fairly complicated. Hence we cannot use it for reasoning about the semantics of workflows in the iTask system. In this paper we define an executable semantics that specifies how workflows react on events generated by the workers executing them. The semantics is used to explain iTask and to reason about iTask. Based on this semantics we define a mathematical notion of equivalence of tasks and show how this equivalence for tasks can be approximated automatically. Advantages of this executable semantics are: it is easy to validate the semantics by interactive simulation; properties of the semantics can be tested by our model-based test system Gþinspace∀þinspacest. Gþinspace∀þinspacest can test a large number of properties within seconds. These tests appeared to be a good indication about the consistency of the specified semantics and equivalence relation for tasks. The automatic testing of properties was very helpful in the development of the semantics. The contribution of this paper is a semantics for iTask as well as the method used to construct this operational semantics.},
+ booktitle = {Implementation and {Application} of {Functional} {Languages}},
+ publisher = {Springer Berlin Heidelberg},
+ author = {Koopman, Pieter and Plasmeijer, Rinus and Achten, Peter},
+ editor = {Scholz, Sven-Bodo and Chitil, Olaf},
+ year = {2011},
+ pages = {212--232},
+ file = {Koopman et al. - 2011 - An Executable and Testable Semantics for iTasks.pdf:/home/mrl/.local/share/zotero/storage/6LFA9MNU/Koopman et al. - 2011 - An Executable and Testable Semantics for iTasks.pdf:application/pdf},
+}
+
@phdthesis{antonova_mtask_2022,
address = {Nijmegen},
type = {Bachelor's {Thesis}},
@phdthesis{baaij_digital_2015,
address = {Netherlands},
type = {{PhD} {Thesis}},
- title = {Digital circuit in {C}\${\textbackslash}lambda\${aSH}: functional specifications and type-directed synthesis},
+ title = {Digital circuit in {C$\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},
year = {2022},
}
+@article{kiselyov_implementing_2011,
+ title = {Implementing {Explicit} and {Finding} {Implicit} {Sharing} in {Embedded} {DSLs}},
+ volume = {66},
+ doi = {10.4204/eptcs.66.11},
+ journal = {Electronic Proceedings in Theoretical Computer Science},
+ author = {Kiselyov, Oleg},
+ month = sep,
+ year = {2011},
+ note = {Publisher: Open Publishing Association},
+ pages = {210--225},
+}
+
@article{sun_compositional_2022,
title = {Compositional {Embeddings} of {Domain}-{Specific} {Languages}},
volume = {6},
pages = {122877},
}
-@inproceedings{santanna_safe_2013,
- title = {Safe system-level concurrency on resource-constrained nodes},
- booktitle = {Proceedings of the 11th {ACM} {Conference} on {Embedded} {Networked} {Sensor} {Systems}},
- publisher = {ACM},
- author = {Sant'Anna, Francisco and Rodriguez, Noemi and Ierusalimschy, Roberto and Landsiedel, Olaf and Tsigas, Philippas},
- year = {2013},
- pages = {11},
- file = {Sant'Anna et al. - 2013 - Safe system-level concurrency on resource-constrai.pdf:/home/mrl/.local/share/zotero/storage/4865FAU3/Sant'Anna et al. - 2013 - Safe system-level concurrency on resource-constrai.pdf:application/pdf},
-}
-
-@article{kiselyov_implementing_2011,
- title = {Implementing {Explicit} and {Finding} {Implicit} {Sharing} in {Embedded} {DSLs}},
- volume = {66},
- url = {https://doi.org/10.4204/eptcs.66.11},
- doi = {10.4204/eptcs.66.11},
- journal = {Electronic Proceedings in Theoretical Computer Science},
- author = {Kiselyov, Oleg},
- month = sep,
- year = {2011},
- note = {Publisher: Open Publishing Association},
- pages = {210--225},
-}
-
@article{shi_edge_2016,
title = {Edge {Computing}: {Vision} and {Challenges}},
volume = {3},
editor = {Zsók, Viktória and Hughes, John},
year = {2021},
pages = {44--66},
- file = {Koopman et al. - 2021 - Dynamic Editors for Well-Typed Expressions.pdf:/home/mrl/.local/share/zotero/storage/H8QJCNRK/Koopman et al. - 2021 - Dynamic Editors for Well-Typed Expressions.pdf:application/pdf},
+ file = {978-3-030-83978-9_3.pdf:/home/mrl/.local/share/zotero/storage/6654TJL7/978-3-030-83978-9_3.pdf:application/pdf},
}
@inproceedings{omar_hazelnut_2017,
series = {{POPL} '17},
title = {Hazelnut: {A} {Bidirectionally} {Typed} {Structure} {Editor} {Calculus}},
isbn = {978-1-4503-4660-3},
- url = {https://doi.org/10.1145/3009837.3009900},
doi = {10.1145/3009837.3009900},
abstract = {Structure editors allow programmers to edit the tree structure of a program directly. This can have cognitive benefits, particularly for novice and end-user programmers. It also simplifies matters for tool designers, because they do not need to contend with malformed program text. This paper introduces Hazelnut, a structure editor based on a small bidirectionally typed lambda calculus extended with holes and a cursor. Hazelnut goes one step beyond syntactic well-formedness: its edit actions operate over statically meaningful incomplete terms. Naïvely, this would force the programmer to construct terms in a rigid "outside-in" manner. To avoid this problem, the action semantics automatically places terms assigned a type that is inconsistent with the expected type inside a hole. This meaningfully defers the type consistency check until the term inside the hole is finished. Hazelnut is not intended as an end-user tool itself. Instead, it serves as a foundational account of typed structure editing. To that end, we describe how Hazelnut's rich metatheory, which we have mechanized using the Agda proof assistant, serves as a guide when we extend the calculus to include binary sum types. We also discuss various interpretations of holes, and in so doing reveal connections with gradual typing and contextual modal type theory, the Curry-Howard interpretation of contextual modal logic. Finally, we discuss how Hazelnut's semantics lends itself to implementation as an event-based functional reactive program. Our simple reference implementation is written using js\_of\_ocaml.},
booktitle = {Proceedings of the 44th {ACM} {SIGPLAN} {Symposium} on {Principles} of {Programming} {Languages}},
file = {Omar et al. - 2017 - Hazelnut A Bidirectionally Typed Structure Editor.pdf:/home/mrl/.local/share/zotero/storage/4DNRBZ4H/Omar et al. - 2017 - Hazelnut A Bidirectionally Typed Structure Editor.pdf:application/pdf},
}
-@phdthesis{serrano_type_2018,
- type = {{PhD} {Thesis}},
- title = {Type {Error} {Customization} for {Embedded} {Domain}-{Specific} {Languages}},
- school = {Utrecht University},
- author = {Serrano, Alejandro},
- year = {2018},
-}
-
@article{hester_batteries_2019,
title = {Batteries {Not} {Included}},
volume = {26},
issn = {1528-4972},
- url = {https://doi.org/10.1145/3351474},
doi = {10.1145/3351474},
abstract = {Getting things done amid frequent power failures, batteryless intermittent research is rethinking how we build computing systems and paving the way to a sustainable and scalable digital future. The next trillion devices might be a little weird.},
number = {1},
file = {Hester and Sorber - 2019 - Batteries Not Included.pdf:/home/mrl/.local/share/zotero/storage/LT53WV8K/Hester and Sorber - 2019 - Batteries Not Included.pdf:application/pdf},
}
-
-@inproceedings{koopman_executable_2011,
- address = {Berlin, Heidelberg},
- title = {An {Executable} and {Testable} {Semantics} for {iTasks}},
- isbn = {978-3-642-24452-0},
- abstract = {The iTask system is an easy to use combinator library for specifying dynamic data dependent workflows in a very flexible way. The specified workflows are executed as a multi-user web-application. The implementation of the iTask system is fairly complicated. Hence we cannot use it for reasoning about the semantics of workflows in the iTask system. In this paper we define an executable semantics that specifies how workflows react on events generated by the workers executing them. The semantics is used to explain iTask and to reason about iTask. Based on this semantics we define a mathematical notion of equivalence of tasks and show how this equivalence for tasks can be approximated automatically. Advantages of this executable semantics are: it is easy to validate the semantics by interactive simulation; properties of the semantics can be tested by our model-based test system Gþinspace∀þinspacest. Gþinspace∀þinspacest can test a large number of properties within seconds. These tests appeared to be a good indication about the consistency of the specified semantics and equivalence relation for tasks. The automatic testing of properties was very helpful in the development of the semantics. The contribution of this paper is a semantics for iTask as well as the method used to construct this operational semantics.},
- booktitle = {Implementation and {Application} of {Functional} {Languages}},
- publisher = {Springer Berlin Heidelberg},
- author = {Koopman, Pieter and Plasmeijer, Rinus and Achten, Peter},
- editor = {Scholz, Sven-Bodo and Chitil, Olaf},
- year = {2011},
- pages = {212--232},
- file = {Koopman et al. - 2011 - An Executable and Testable Semantics for iTasks.pdf:/home/mrl/.local/share/zotero/storage/6LFA9MNU/Koopman et al. - 2011 - An Executable and Testable Semantics for iTasks.pdf:application/pdf},
-}
-
@incollection{management_association_evaluating_2014,
address = {Hershey, PA, USA},
title = {Evaluating the {Usability} of {Domain}-{Specific} {Languages}},
isbn = {978-1-4666-4301-7},
- url = {https://services.igi-global.com/resolvedoi/resolve.aspx?doi=10.4018/978-1-4666-4301-7.ch098},
abstract = {Domain-Specific Languages (DSLs) can be regarded as User Interfaces (UIs) because they bridge the gap between the domain experts and the computation platforms. Usability of DSLs by domain experts is a key factor for their successful adoption. The few reports supporting improvement claims are persuasive, but mostly anecdotal. Systematic literature reviews show that evidences on the effects of the introduction of DSLs are actually very scarce. In particular, the evaluation of usability is often skipped, relaxed, or at least omitted from papers reporting the development of DSLs. The few exceptions mostly take place at the end of the development process, when fixing problems is already too expensive. A systematic approach, based on techniques for the experimental evaluation of UIs, should be used to assess suitability of new DSLs. This chapter presents a general experimental evaluation model, tailored for DSLs’ experimental evaluation, and instantiates it in several DSL’s evaluation examples.},
booktitle = {Software {Design} and {Development}: {Concepts}, {Methodologies}, {Tools}, and {Applications}},
publisher = {IGI Global},
title = {Workflow {Patterns}},
volume = {14},
issn = {1573-7578},
- url = {https://doi.org/10.1023/A:1022883727209},
doi = {10.1023/A:1022883727209},
abstract = {Differences in features supported by the various contemporary commercial workflow management systems point to different insights of suitability and different levels of expressive power. The challenge, which we undertake in this paper, is to systematically address workflow requirements, from basic to complex. Many of the more complex requirements identified, recur quite frequently in the analysis phases of workflow projects, however their implementation is uncertain in current products. Requirements for workflow languages are indicated through workflow patterns. In this context, patterns address business requirements in an imperative workflow style expression, but are removed from specific workflow languages. The paper describes a number of workflow patterns addressing what we believe identify comprehensive workflow functionality. These patterns provide the basis for an in-depth comparison of a number of commercially availablework flow management systems. As such, this paper can be seen as the academic response to evaluations made by prestigious consulting companies. Typically, these evaluations hardly consider the workflow modeling language and routing capabilities, and focus more on the purely technical and commercial aspects.},
number = {1},
pages = {5--51},
file = {van der Aalst et al. - 2003 - Workflow Patterns.pdf:/home/mrl/.local/share/zotero/storage/WXP2T4R7/van der Aalst et al. - 2003 - Workflow Patterns.pdf:application/pdf},
}
+
+@inproceedings{belwal_variable_2013,
+ address = {New York, NY, USA},
+ series = {{RACS} '13},
+ title = {Variable {Voltage} {Scheduling} with the {Priority}-{Based} {Functional} {Reactive} {Programming} {Language}},
+ isbn = {978-1-4503-2348-2},
+ doi = {10.1145/2513228.2513271},
+ abstract = {In this paper, we consider how energy consumption can be reduced in the Priority-based Functional Reactive Programming (P-FRP) execution model through the implementation of Dynamic Voltage and Frequency Scaling (DVFS), a technique for modifying circuit delays and altering the operating frequency of the CPU. Use of DVFS can have an impact on task execution time, which adversely affects the temporal guarantees required from the real-time scheduler. Most of the existing studies provide solutions which are suitable for the classical model of preemptive task scheduling. Tasks which are schedulable in the preemptive model cannot be guaranteed to be schedulable in P-FRP, since the abort-based preemptive approach often creates additional costs in terms of response times.},
+ booktitle = {Proceedings of the 2013 {Research} in {Adaptive} and {Convergent} {Systems}},
+ publisher = {Association for Computing Machinery},
+ author = {Belwal, Chaitanya and Cheng, Albert M. K. and Ras, J. and Wen, Yuanfeng},
+ year = {2013},
+ note = {event-place: Montreal, Quebec, Canada},
+ keywords = {embedded system, real-time},
+ pages = {440--445},
+}
+
+@article{alhirabi_security_2021,
+ title = {Security and {Privacy} {Requirements} for the {Internet} of {Things}: {A} {Survey}},
+ volume = {2},
+ issn = {2691-1914},
+ url = {https://doi.org/10.1145/3437537},
+ doi = {10.1145/3437537},
+ abstract = {The design and development process for internet of things (IoT) applications is more complicated than that for desktop, mobile, or web applications. First, IoT applications require both software and hardware to work together across many different types of nodes with different capabilities under different conditions. Second, IoT application development involves different types of software engineers such as desktop, web, embedded, and mobile to work together. Furthermore, non-software engineering personnel such as business analysts are also involved in the design process. In addition to the complexity of having multiple software engineering specialists cooperating to merge different hardware and software components together, the development process requires different software and hardware stacks to be integrated together (e.g., different stacks from different companies such as Microsoft Azure and IBM Bluemix). Due to the above complexities, non-functional requirements (such as security and privacy, which are highly important in the context of the IoT) tend to be ignored or treated as though they are less important in the IoT application development process. This article reviews techniques, methods, and tools to support security and privacy requirements in existing non-IoT application designs, enabling their use and integration into IoT applications. This article primarily focuses on design notations, models, and languages that facilitate capturing non-functional requirements (i.e., security and privacy). Our goal is not only to analyse, compare, and consolidate the empirical research but also to appreciate their findings and discuss their applicability for the IoT.},
+ number = {1},
+ journal = {ACM Trans. Internet Things},
+ author = {Alhirabi, Nada and Rana, Omer and Perera, Charith},
+ month = feb,
+ year = {2021},
+ note = {Place: New York, NY, USA
+Publisher: Association for Computing Machinery},
+ keywords = {design principles, Internet of Things, non functional requirements, notation, software design tools, software engineering},
+ file = {Alhirabi et al. - 2021 - Security and Privacy Requirements for the Internet.pdf:/home/mrl/.local/share/zotero/storage/7UN4IF62/Alhirabi et al. - 2021 - Security and Privacy Requirements for the Internet.pdf:text/html},
+}
series = {{IFL} '19},
title = {Interpreting {Task} {Oriented} {Programs} on {Tiny} {Computers}},
isbn = {978-1-4503-7562-7},
- url = {https://doi.org/10.1145/3412932.3412936},
doi = {10.1145/3412932.3412936},
abstract = {Small Microcontroller Units (MCUs) drive the omnipresent Internet of Things (IoT). These devices are small, cheap, and energy efficient. However, they are not very powerful and lack an Operating System. Hence it is difficult to apply high level abstractions and write software that stays close to the design.Task Oriented Programming (TOP) is a paradigm for creating multi-user collaborative systems. A program consists of tasks—descriptions of what needs to be done. The tasks represent the actual work and a task value is observable during execution. Furthermore, tasks can be combined and transformed using combinators.mTask is an embedded Domain Specific Language (eDSL) to program MCUs following the TOP paradigm. Previous work has described the mTask language, a static C code generator, and how to integrate mTask with TOP servers. This paper shows that for dynamic IOT applications, tasks must be sent at runtime to the devices for interpretation. It describes in detail how to compile specialized IOT TOP tasks to bytecode and how to interpret them on devices with very little memory. These additions allow the creation of complete, dynamic IOT applications arising from a single source using a mix of iTasks and mTask tasks. Details such as serialization and communication are captured in simple abstractions.},
booktitle = {Proceedings of the 31st {Symposium} on {Implementation} and {Application} of {Functional} {Languages}},
series = {{IoT} '20},
title = {Tiered versus {Tierless} {IoT} {Stacks}: {Comparing} {Smart} {Campus} {Software} {Architectures}},
isbn = {978-1-4503-8758-3},
- url = {https://doi.org/10.1145/3410992.3411002},
doi = {10.1145/3410992.3411002},
abstract = {Internet of Things (IoT) software stacks are notoriously complex, conventionally comprising multiple tiers/components and requiring that the developer not only uses multiple programming languages, but also correctly interoperate the components. A novel alternative is to use a single tierless language with a compiler that generates the code for each component, and for their correct interoperation.We report the first ever systematic comparison of tiered and tierless IoT software architectures. The comparison is based on two implementations of a non-trivial smart campus application. PRSS has a conventional tiered Python-based architecture, and Clean Wemos Super Sensors (CWSS) has a novel tierless architecture based on Clean and the iTask and mTask embedded DSLs. An operational comparison of CWSS and PRSS demonstrates that they have equivalent functionality, and that both meet the University of Glasgow (UoG) smart campus requirements.Crucially, the tierless CWSS stack requires 70\% less code than the tiered PRSS stack. We analyse the impact of the following three main factors. (1) Tierless developers need to manage less interoperation: CWSS uses two DSLs in a single paradigm where PRSS uses five languages and three paradigms. (2) Tierless developers benefit from automatically generated, and hence correct, communication. (3) Tierless developers can exploit the powerful high-level abstractions such as Task Oriented Programming (TOP) in CWSS. A far smaller and single paradigm codebase improves software quality, dramatically reduces development time, and improves the maintainability of tierless stacks.},
booktitle = {Proceedings of the 10th {International} {Conference} on the {Internet} of {Things}},
title = {A {Task}-{Based} {DSL} for {Microcomputers}},
copyright = {All rights reserved},
isbn = {978-1-4503-6355-6},
- url = {http://dl.acm.org/citation.cfm?doid=3183895.3183902},
doi = {10.1145/3183895.3183902},
abstract = {The Internet of Things, IoT, makes small connected computing devices almost omnipresent. These devices have typically very limited computing power and severe memory restrictions to make them cheap and power efficient. These devices can interact with the environment via special sensors and actuators. Since each device controls several peripherals running interleaved, the control software is quite complicated and hard to maintain. Task Oriented Programming, TOP, offers lightweight communicating threads that can inspect each other’s intermediate results. This makes it well suited for the IoT. In this paper presents a functional task-based domain specific language for these IoT devices. We show that it yields concise control programs. By restricting the datatypes and using strict evaluation these programs fit within the restrictions of microcontrollers.},
language = {en},
@inproceedings{lubbers_task_2018,
address = {Lowell, MA},
title = {Task {Oriented} {Programming} and the {Internet} of {Things}},
- copyright = {All rights reserved},
isbn = {978-1-4503-7143-8},
doi = {10.1145/3310232.3310239},
abstract = {In the omnipresent Internet of Things (IoT), tiny devices sense and alter the environment, process information and communicate with the world. These devices have limited amounts of processing power and memory. This imposes severe restrictions on their software and communication protocols. As a result, applications are composed of parts written in various programming languages that communicate in many different ways. This impedance mismatch hampers development and maintenance. In previous work we have shown how an IoT device can be programmed by defining an embedded Domain Specific Language (eDSL). In this paper we show how IoT tasks can be seemlessly integrated with a Task Oriented Programming (TOP) server such as iTasks. It allows the specification on a high-level of abstraction of arbitrary collaborations between human beings, large systems, and now also IoT devices. The implementation is made in three steps. First, there is an interface to connect devices dynamically to an iTasks server using various communication protocols. Next, we solve the communication problem between IoT devices and the server by porting Shared Data Sources (SDSs) from TOP. As a result, data can be shared, viewed and updated from the server or IoT device. Finally, we crack the maintenance problem by switching from generating fixed code for the IoT devices to dynamically shipping code. It makes it possible to run multiple tasks on an IoT device and to decide at runtime what tasks that should be.},
publisher = {ACM},
author = {Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
year = {2018},
- pages = {83--94},
- file = {Lubbers et al. - 2018 - Task Oriented Programming and the Internet of Thin.pdf:/home/mrl/.local/share/zotero/storage/3E5KLI5V/Lubbers et al. - 2018 - Task Oriented Programming and the Internet of Thin.pdf:application/pdf},
+ pages = {12},
+ file = {Lubbers et al. - 2018 - Task Oriented Programming and the Internet of Thin.pdf:/home/mrl/.local/share/zotero/storage/3E5KLI5V/Lubbers et al. - 2018 - Task Oriented Programming and the Internet of Thin.pdf:application/pdf;Lubbers et al. - 2019 - Task Oriented Programming and the Internet of Thin.pdf:/home/mrl/.local/share/zotero/storage/R7TFJGVR/Lubbers et al. - 2019 - Task Oriented Programming and the Internet of Thin.pdf:application/pdf},
}
@mastersthesis{lubbers_task_2017,
@misc{koopman_sustrainable_2022,
title = {{SusTrainable}: {Promoting} {Sustainability} as a {Fundamental} {Driver} in {Software} {Development} {Training} and {Education}. {Teacher} {Training}, {November} 1-5, {Nijmegen}, {The} {Netherlands}. {Revised} lecture notes},
copyright = {Creative Commons Attribution Non Commercial No Derivatives 4.0 International},
- url = {https://arxiv.org/abs/2204.13993},
publisher = {arXiv},
author = {Koopman, Pieter and Lubbers, Mart and Fernandes, João Paulo},
year = {2022},
@article{lubbers_could_2022,
title = {Could {Tierless} {Languages} {Reduce} {IoT} {Development} {Grief}?},
issn = {2691-1914},
- url = {https://doi.org/10.1145/3572901},
doi = {10.1145/3572901},
abstract = {Internet of Things (IoT) software is notoriously complex, conventionally comprising multiple tiers. Traditionally an IoT developer must use multiple programming languages and ensure that the components interoperate correctly. A novel alternative is to use a single tierless language with a compiler that generates the code for each component and ensures their correct interoperation. We report a systematic comparative evaluation of two tierless language technologies for IoT stacks: one for resource-rich sensor nodes (Clean with iTask), and one for resource-constrained sensor nodes (Clean with iTask and mTask). The evaluation is based on four implementations of a typical smart campus application: two tierless and two Python-based tiered. (1) We show that tierless languages have the potential to significantly reduce the development effort for IoT systems, requiring 70\% less code than the tiered implementations. Careful analysis attributes this code reduction to reduced interoperation (e.g. two embedded domain-specific languages (DSLs) and one paradigm versus seven languages and two paradigms), automatically generated distributed communication, and powerful IoT programming abstractions. (2) We show that tierless languages have the potential to significantly improve the reliability of IoT systems, describing how Clean iTask/mTask maintains type safety, provides higher order failure management, and simplifies maintainability. (3) We report the first comparison of a tierless IoT codebase for resource-rich sensor nodes with one for resource-constrained sensor nodes. The comparison shows that they have similar code size (within 7\%), and functional structure. (4) We present the first comparison of two tierless IoT languages, one for resource-rich sensor nodes, and the other for resource-constrained sensor nodes.},
journal = {ACM Trans. Internet Things},
editor = {Swierstra, Wouter and Wu, Nicolas},
year = {2022},
pages = {39--58},
+ file = {Lubbers - 2022 - Deep Embedding with Class.pdf:/home/mrl/.local/share/zotero/storage/KDFM73Z7/Lubbers - 2022 - Deep Embedding with Class.pdf:application/pdf},
}
@inproceedings{crooijmans_reducing_2022,
editor = {Swierstra, Wouter and Wu, Nicolas},
year = {2022},
pages = {80--99},
+ file = {Crooijmans et al. - 2022 - Reducing the Power Consumption of IoT with Task-Or.pdf:/home/mrl/.local/share/zotero/storage/6DPWZRNJ/Crooijmans et al. - 2022 - Reducing the Power Consumption of IoT with Task-Or.pdf:application/pdf},
}
\end{chapterabstract}
\section{Finale}
-The \gls{MTASK} system is a proof-of-concept system, though fully functioning, for integrating \gls{IOT} edge devices in \gls{TOP}.
-In conjunction with \gls{ITASK}, it is possible to program all layers of the \gls{IOT} from a single declarative specification.
-The \gls{ITASK} system is used to program the top layers of an \gls{IOT} system, providing the server and the web \gls{UI}.
-Then, \gls{MTASK} can be used to integrate edge devices.
-Tasks for edge devices are written in the \gls{MTASK} \gls{DSL} and can be integrated in \gls{ITASK} using only a few functions.
-\todo{extend}
-
-Deep embedding.
+Traditionally, \gls{IOT} have been programmed using layered architectures.
+Every layer has its own software and hardware characteristics, resulting in semantic friction.
+\Gls{TOP} is a declarative programming paradigm designed for specifying multi-tiered interactive systems.
+However, it is not straightforward to run \gls{TOP} systems on resource-constrained devices such as edge devices.
+
+The \gls{MTASK} system bridges this gap by providing a \gls{TOP} programming language for edge devices.
+It is a full-fledged \gls{TOP} language hosted in a tiny functional programming language containing basic tasks, task combinators, support for sensors and actuators, and interrupts.
+It is integrated seamlessly in \gls{ITASK}, a \gls{TOP} system for interactive web applications.
+Hence, all layers of an \gls{IOT} system can be programmed from a single declarative specification.
+\Gls{ITASK} abstracts away from the gritty details of interactive web applications such as program distribution, web applications, data storage, and user management.
+The engine of \gls{MTASK} abstracts away of all technicalities such as communication, abstractions for sensors and actuators, interrupts and (multi) task scheduling.
+
+Devices are connected to the \gls{ITASK} system at run time using a single function that takes care of all the communication and error handling.
+When connected to a device, tasks written in the \gls{MTASK} \gls{DSL} can be lifted to \gls{ITASK} tasks.
+The tasks are specified and compiled at run time, i.e.\ \gls{CLEAN} can be used as a macro language for constructing \gls{MTASK} tasks, tailor making them for the work that needs to be done.
+When lifted, other tasks in the system can interact with the task through the usual means.
+Furthermore, \gls{ITASK} \glspl{SDS} can be \emph{lowered} to \gls{MTASK} tasks as well, allowing for bidirectional automatic data sharing between \gls{MTASK} tasks and the \gls{ITASK} system.
+The \gls{MTASK} device is equipped with a domain-specific \gls{OS} that only needs to be programmed once after which the device can continuously receive new tasks.
+\todo[inline]{Uitbreiden}
\section{Future work}
\todo[inline]{De grens tussen future en related work is soms vaag maar ik heb het zo goed als mogelijk proberen te scheiden. Mis ik hier nog iets?}
There are many ways of extending the research on the \gls{MTASK} system that also concerns \gls{TOP} for resource constrained devices in general.
Some obvious routes would be to add features, support more platforms,
-\todo{security}
+\subsection{Security}
+\Gls{IOT} has reached the news many times regarding security and it is a big concern \citep{alhirabi_security_2021}.
+The fact that the devices are embedded in the fabric, are hard to reach and thus to update, and can only run limited cryptographic algorithms due to their constrained resources makes it difficult.
+The security of \gls{MTASK} and the used protocols are deliberately overlooked at the moment
+Though, because \gls{MTASK} is modular, for example, the communication channels are communication method agnostic, it should be fairly easy to apply standard security measures to them by replacing communication methods and applying standard authentication and encryption to the protocol.
+\Citet{de_boer_secure_2020} did preliminary research on securing the communication channels, which proved to be possible without many changes in the protocol.
+Nonetheless, this deserves much more attention.
+The future and related work for the security of \gls{MTASK} and tierless systems is more thoroughly presented in \cref{ssec_t4t:security}.
\subsection{Advanced edge devices techniques}
Edge devices may produce a lot of data and it is not always effective to send this data to the server for processing.
In \gls{MTASK}, all work expressed by tasks is already split up in atomic pieces of work.
Furthermore, creating checkpoints should be fairly straightforward as \gls{MTASK} tasks do not rely on any global state---all information required to execute a task is stored in the task tree.
It would be interesting to see what \gls{TOP} abstraction could be useful for intermittent computing and what solutions are required to make this work.
-An alternative to reducing the energy consumption by going to sleep is stepping down the processor frequency.
-So called \gls{DVFS} is a scheduling technique that slows down the processor in order to reach the goals as late as possible, reducing the power consumption.
-It would be interesting to investigate the possibilities for \gls{DVFS} in \gls{MTASK}.
Mesh networks allow for communication not only to-and-fro the device and server but also between devices.
The \gls{ITASK} system already contains primitives for distributed operation.
Later, \citet{steenvoorden_tophat_2019} created \gls{TOPHAT}, a \gls{TOP} language with a complete formal specification with similar features to \gls{MTASK} \citep{steenvoorden_tophat_2019}.
\Citet{antonova_mtask_2022} compared parts of \gls{MTASK} to the semantics of \gls{TOPHAT} semantics and created a preliminary semantics for a subset of \gls{MTASK}.
Future research into extending the formal semantics of \gls{MTASK} is useful to give more guarantees on \gls{MTASK} programs.
-Maybe this opens the door to real-time operation as well.
-\subsection{\texorpdfstring{\Gls{TOP}}{Task-oriented programming}}
+\subsection{\texorpdfstring{\Glsxtrlong{TOP}}{Task-oriented programming}}
In order to keep the resource constraints low, the \gls{MTASK} language contains only a minimal set of simple task combinators.
From these simple combinators, complex collaboration patterns can be described.
The \gls{ITASK} language is designed exactly the opposite.
When a peripheral is added, the programmer has to define the correct byte code, implement the instructions in the interpreter, add task tree nodes, and implement them in the rewrite system.
It would be interesting to investigate whether this can be automated or centralised in a way.
+\subsection{Scheduling}
+The scheduling in \gls{MTASK} works quite well but it is not real time.
+There is a variant of \gls{FRP} called \gls{PFRP} that allows for real-time operation \citep{belwal_variable_2013}.
+Furthermore, an alternative to reducing the energy consumption by going to sleep is stepping down the processor frequency.
+So called \gls{DVFS} is a scheduling technique that slows down the processor in order to reach the goals as late as possible, reducing the power consumption.
+\Citet{belwal_variable_2013} use \gls{PFRP} with \gls{DVFS} to reduce the energy consumption.
+It would be interesting to investigate the possibilities for \gls{DVFS} in \gls{MTASK} and \gls{TOP} in general.
+
\section{Related work}
The novelties of the \gls{MTASK} system can be compared to existing systems in several categories.
It is a interpreted (\cref{sec:related_int}) \gls{TOP} (\cref{sec:related_top}) \gls{DSL} (\cref{sec:related_dsl}) that may seem similar at first glance to \gls{FRP} (\cref{sec:related_frp}), it is implemented in a functional language (\cref{sec:related_fp}) and due to the execution semantics, multitasking is automatically supported (\cref{sec:related_multi}).
\subsection{\texorpdfstring{\Glsxtrlongpl{DSL}}{DSLs} for microcontrollers}\label{sec:related_dsl}
Many \glspl{DSL} provide higher-level programming abstractions for microcontrollers, for example providing strong typing or memory safety.
-For example Copilot \citep{hess_arduino-copilot_2020} and Ivory \citep{elliott_guilt_2015} are imperative \glspl{DSL} embedded in a functional language that compile to \ccpp{}.
-\todo{uit\-brei\-den?}
+Examples of this are Copilot \citep{hess_arduino-copilot_2020} and Ivory \citep{elliott_guilt_2015}, imperative \glspl{DSL} embedded in a functional language that compile to \ccpp{}.
\subsection{\texorpdfstring{\Glsxtrlong{FP}}{Functional programming}}\label{sec:related_fp}
\Citet{haenisch_case_2016} showed that there are major benefits to using functional languages for \gls{IOT} applications.
The characteristics are: sequential execution, local variable support, parallel composition, deterministic execution, bounded execution and safe shared memory (adapted from \citet[p.\ 12]{santanna_safe_2013}).
}\label{tbl:multithreadingcompare}
% \begin{tabular}{lc>{\columncolor[gray]{0.95}}cc>{\columncolor[gray]{0.95}}cc>{\columncolor[gray]{0.95}}cc}
- \small
+ \begingroup
+ \setlength\tabcolsep{4.5pt}
\begin{tabular}{lccccccc}
\toprule
\multicolumn{2}{c}{Language} & \multicolumn{3}{c}{Complexity} & \multicolumn{3}{c}{Safety}\\
\gls{MTASK} & 2022 & \CIRCLE{} & \CIRCLE{} & \CIRCLE{} & \CIRCLE{} & \LEFTcircle{}\tnote{1} & \LEFTcircle{}\tnote{2}\\
\bottomrule
\end{tabular}
+ \endgroup
\begin{tablenotes}
\item [1] Only for tasks, not for expressions.
\item [2] Using \glspl{SDS}.
It was shown by \citet{amazonas_cabral_de_andrade_developing_2018} that it was possible to build real-life \gls{IOT} systems with this integration.
Moreover, a course on the \gls{MTASK} simulator was provided at the 2018 \gls{CEFP}\slash\gls{3COWS} winter school in Ko\v{s}ice, Slovakia \citep{koopman_simulation_2018}.
-\subsection{Transition to \texorpdfstring{\gls{TOP}}{TOP}}
+\subsection{Transition to \texorpdfstring{\glsxtrlong{TOP}}{Task-oriented programming}}
The \gls{MTASK} language as it is now was introduced in 2018 \citep{koopman_task-based_2018}.
This paper updated the language to support functions, simple tasks, and \glspl{SDS} but still compiled to \gls{ARDUINO} \gls{CPP} code.
Later the byte code compiler and \gls{ITASK} integration was added to the language \citep{lubbers_interpreting_2019}.
One reason for this is that a lot of design patterns that are difficult using standard means are for free in \gls{TOP} (e.g.\ multithreading).
In 2019, the \gls{CEFP}\slash\gls{3COWS} summer school in Budapest, Hungary hosted a course on developing \gls{IOT} applications with \gls{MTASK} as well \citep{lubbers_writing_2019}.
-\subsection{\texorpdfstring{\Glsxtrshort{TOP}}{TOP}}
+\subsection{\texorpdfstring{\Glsxtrlong{TOP}}{Task-oriented programming}}
In 2022, the SusTrainable summer school in Rijeka, Croatia hosted a course on developing greener \gls{IOT} applications using \gls{MTASK} as well \citep{lubbers_green_2022}.
Several students worked on extending \gls{MTASK} with many useful features:
\Citet{van_der_veen_mutable_2020} did preliminary work on a green computing analysis, built a simulator, and explored the possibilities for adding bounded datatypes; \citet{de_boer_secure_2020} investigated the possibilities for secure communication channels; \citeauthor{crooijmans_reducing_2021} \citeyearpar{crooijmans_reducing_2021,crooijmans_reducing_2022} added abstractions for low-power operation to \gls{MTASK} such as hardware interrupts and power efficient scheduling; and \citet{antonova_mtask_2022} defined a preliminary formal semantics for a subset of \gls{MTASK}.
repositories / phd-thesis.git / commitdiff