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},
}
isbn = {978-90-386-3462-3},
abstract = {In this article I argue that it is important to develop experiential prototypes which have multi-tasking capabilities. At the same time I show that for embedded prototype software based on the popular Arduino platform this is not too difficult. The approach is explained and illustrated using technical examples – practical and hands-on, down to the code level. At the same time a few helpful notations for designing and documenting the software are introduced and illustrated by the same examples. Finally a few case studies of the technical approach are listed.},
language = {English},
- booktitle = {Design and semantics of form and movement. 8th {International} {Conference} on {Design} and {Semantics} of {Form} and {Movement} ({DeSForM} 2013)},
+ booktitle = {8th {International} {Conference} on {Design} and {Semantics} of {Form} and {Movement} ({DeSForM} 2013)},
author = {Feijs, Loe},
editor = {Chen, L. L. and Djajadiningrat, T. and Feijs, L. M. G. and Fraser, S. and Hu, J. and Kyffin, S. and Steffen, D.},
year = {2013},
shorttitle = {Exchanging sources between {Clean} and {Haskell}},
number = {11},
journal = {ACM Sigplan Notices},
- author = {van Groningen, John van and van Noort, Thomas van and Achten, Peter and Koopman, Pieter and Plasmeijer, Rinus},
+ author = {van Groningen, John and van Noort, Thomas and Achten, Peter and Koopman, Pieter and Plasmeijer, Rinus},
year = {2010},
pages = {49--60},
file = {groj10-Haskell_front_end_Clean.pdf:/home/mrl/.local/share/zotero/storage/WVZWX8WT/groj10-Haskell_front_end_Clean.pdf:application/pdf},
year = {2008},
note = {Place: New York, NY, USA
Publisher: Association for Computing Machinery},
- keywords = {compile-time meta-programming, domain specific languages, Syntax extension},
+ keywords = {domain specific languages, compile-time meta-programming, 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},
}
file = {Fowler - 2010 - Domain-specific languages.pdf:/home/mrl/.local/share/zotero/storage/YYMYXTZ5/Fowler - 2010 - Domain-specific languages.pdf:application/pdf},
}
-@misc{peter_t_lewis_speech_1985,
+@misc{lewis_speech_1985,
address = {Washington, D.C.},
type = {Speech},
title = {Speech},
url = {http://www.chetansharma.com/correcting-the-iot-history/},
- author = {{Peter T. Lewis}},
+ author = {Lewis, Peter T.},
month = sep,
year = {1985},
}
file = {Hinze and Jeuring - Generic Haskell practice and theory.pdf:/home/mrl/.local/share/zotero/storage/QDRNI5VB/Hinze and Jeuring - Generic Haskell practice and theory.pdf:application/pdf},
}
+@article{alhirabi_security_2021,
+ title = {Security and {Privacy} {Requirements} for the {Internet} of {Things}: {A} {Survey}},
+ volume = {2},
+ issn = {2691-1914},
+ 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 = {Internet of Things, design principles, 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},
+}
+
@inproceedings{torrano_strictness_2005,
address = {Bristol, UK},
series = {Trends in {Functional} {Programming}},
abstract = {We present a new model, based on monads, for performing input/output in a non-strict, purely functional language. It is composable, extensible, efficient, requires no extensions to the type system, and extends smoothly to incorporate mixed-language working and in-place array updates.},
booktitle = {Proceedings of the 20th {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
publisher = {Association for Computing Machinery},
- author = {Peyton Jones, Simon L. and Wadler, Philip},
+ author = {Peyton Jones, Simon and Wadler, Philip},
year = {1993},
note = {event-place: Charleston, South Carolina, USA},
pages = {71--84},
title = {Staging with {Class}: {A} {Specification} for {Typed} {Template} {Haskell}},
volume = {6},
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.},
+ 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 $\lambda$⇒ 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},
address = {Netherlands},
type = {{PhD} {Thesis}},
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.},
+ 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$\lambda$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$\lambda$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.},
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},
+ file = {Baaij - 2015 - Digital circuit in C$\lambda$aSH functional specification.pdf:/home/mrl/.local/share/zotero/storage/MYJ33ISL/Baaij - 2015 - Digital circuit in C$\lambda$aSH functional specification.pdf:application/pdf},
}
@inproceedings{mcdonell_embedded_2022,
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.},
+@techreport{transforma_insights_current_2023,
+ title = {Current {IoT} {Forecast} {Highlights}},
+ url = {https://transformainsights.com/research/forecast/highlights},
+ institution = {{Transforma Insights}},
+ author = {{Transforma Insights}},
+ month = jan,
+ year = {2023},
+ note = {accessed-on: 2023-01-19},
+}
+
+@misc{top_software_viia_2023,
+ title = {{VIIA} ({Vessel} {Information} {Integrating} {Application})},
+ url = {https://www.top-software.nl/VIIA.html},
+ urldate = {2023-02-06},
+ author = {{TOP Software}},
+ year = {2023},
+}
+
+@article{hinze_derivable_2001,
+ title = {Derivable {Type} {Classes}},
+ volume = {41},
+ issn = {1571-0661},
+ url = {https://www.sciencedirect.com/science/article/pii/S1571066105805420},
+ doi = {https://doi.org/10.1016/S1571-0661(05)80542-0},
+ abstract = {Generic programming allows you to write a function once, and use it many times at different types. A lot of good foundational work on generic programming has been done. The goal of this paper is to propose a practical way of supporting generic programming within the Haskell language, without radically changing the language or its type system. The key idea is to present generic programming as a richer language in which to write default method definitions in a class declaration. On the way, we came across a separate issue, concerning type-class overloading where higher kinds are involved. We propose a simple type-class system extension to allow the programmer to write richer contexts than is currently possible.},
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},
+ journal = {Electronic Notes in Theoretical Computer Science},
+ author = {Hinze, Ralf and Jones, Simon Peyton},
+ year = {2001},
+ pages = {5--35},
+ file = {Hinze and Jones - 2001 - Derivable Type Classes.pdf:/home/mrl/.local/share/zotero/storage/33IF2HMZ/Hinze and Jones - 2001 - Derivable Type Classes.pdf:application/pdf},
}
repositories / phd-thesis.git / blobdiff