-sProcessColorModel=DeviceGray \
-sColorConversionStrategy=Gray \
-dOverrideICC \
+ -dCompatibilityLevel=1.5 \
-o $@ \
-f $<
--- /dev/null
+
+@Article{ sethi2017internet,
+ title = {Internet of things: architectures, protocols, and
+ applications},
+ author = {Sethi, Pallavi and Sarangi, Smruti R},
+ journal = {Journal of Electrical and Computer Engineering},
+ volume = {2017},
+ year = {2017},
+ publisher = {Hindawi}
+}
+
+@InProceedings{ muccini2018iot,
+ author = "Muccini, Henry and Moghaddam, Mahyar Tourchi",
+ editor = "Cuesta, Carlos E. and Garlan, David and P{\'e}rez,
+ Jennifer",
+ title = "IoT Architectural Styles",
+ booktitle = "Software Architecture",
+ year = "2018",
+ publisher = "Springer International Publishing",
+ address = "Cham",
+ pages = "68--85",
+ abstract = "IoT components are becoming more and more ubiquitous.
+ Thus, the necessity of architecting IoT applications is
+ bringing a substantial attention towards software
+ engineering community. On this occasion, different styles
+ and patterns can facilitate shaping the IoT architectural
+ characteristics. This study aims at defining, identifying,
+ classifying, and re-designing a class of IoT styles and
+ patterns at the architectural level. Conforming a
+ systematic mapping study (SMS) selection procedure, we
+ picked out 63 papers among over 2,300 candidate studies. To
+ this end, we applied a rigorous classification and
+ extraction framework to select and analyze the most
+ influential domain-related information. Our analysis
+ revealed the following main findings: (i) facing by various
+ architectural styles that attempted to address various
+ aspects of IoT systems, cloud and fog are discerned as
+ their most important components. (ii) distributed patterns
+ are not widely discussed for IoT architecture, however,
+ there is foreseen a grow specially for their industrial
+ applications. (iii) starting from the last few years on,
+ there is still a growing scientific interest on IoT
+ architectural styles. This study gives a solid foundation
+ for classifying existing and future approaches for IoT
+ styles beneficial for academic and industrial researchers.
+ It provides a set of abstract IoT reference architectures
+ to be applicable on various architectural styles.",
+ isbn = "978-3-030-00761-4"
+}
+
+@InProceedings{ rosenberg1997some,
+ title = {Some misconceptions about lines of code},
+ author = {Rosenberg, Jarrett},
+ booktitle = {Proceedings fourth international software metrics
+ symposium},
+ pages = {137--142},
+ year = {1997},
+ organization = {IEEE},
+ publisher = {IEEE},
+ doi = {10.1109/METRIC.1997.637174},
+ address = {Albuquerque, NM, USA}
+}
+
+@InProceedings{ cooper2006links,
+ address = {Berlin, Heidelberg},
+ title = {Links: {Web} {Programming} {Without} {Tiers}},
+ isbn = {978-3-540-74792-5},
+ abstract = {Links is a programming language for web applications that
+ generates code for all three tiers of a web application
+ from a single source, compiling into JavaScript to run on
+ the client and into SQL to run on the database. Links
+ supports rich clients running in what has been dubbed
+ `Ajax' style, and supports concurrent processes with
+ statically-typed message passing. Links is scalable in the
+ sense that session state is preserved in the client rather
+ than the server, in contrast to other approaches such as
+ Java Servlets or PLT Scheme. Client-side concurrency in
+ JavaScript and transfer of computation between client and
+ server are both supported by translation into
+ continuation-passing style.},
+ booktitle = {Formal {Methods} for {Components} and {Objects}},
+ publisher = {Springer Berlin Heidelberg},
+ author = {Cooper, Ezra and Lindley, Sam and Wadler, Philip and
+ Yallop, Jeremy},
+ editor = {de Boer, Frank S. and Bonsangue, Marcello M. and Graf,
+ Susanne and de Roever, Willem-Paul},
+ year = {2007},
+ pages = {266--296}
+}
+
+@InProceedings{ serrano2006hop,
+ title = {Hop: a language for programming the web 2.0},
+ author = {Serrano, Manuel and Gallesio, Erick and Loitsch, Florian},
+ booktitle = {OOPSLA Companion},
+ pages = {975--985},
+ year = {2006},
+ publisher = {ACM},
+ address = {Portland, Oregon, USA}
+}
+
+@Article{ levis_mate_2002,
+ title = {Maté: {A} tiny virtual machine for sensor networks},
+ volume = {37},
+ number = {10},
+ journal = {ACM Sigplan Notices},
+ author = {Levis, Philip and Culler, David},
+ year = {2002},
+ publisher = {ACM},
+ pages = {85--95},
+ file = {Levis and Culler - Matd A Tiny Virtual Machine for Sensor
+ Networks.pdf:/home/mrl/.local/share/zotero/storage/RMPGY9NI/Levis
+ and Culler - Matd A Tiny Virtual Machine for Sensor
+ Networks.pdf:application/pdf}
+}
+
+@Article{ light2017mosquitto,
+ title = {Mosquitto: server and client implementation of the MQTT
+ protocol},
+ author = {Light, Roger},
+ journal = {Journal of Open Source Software},
+ volume = {2},
+ number = {13},
+ pages = {265},
+ year = {2017}
+}
+
+@Article{ hughes1989functional,
+ title = {Why functional programming matters},
+ author = {Hughes, John},
+ journal = {The computer journal},
+ volume = {32},
+ number = {2},
+ pages = {98--107},
+ year = {1989},
+ publisher = {Oxford University Press}
+}
+
+@InProceedings{ troyer_building_2018,
+ title = {Building {IoT} {Systems} {Using} {Distributed}
+ {First}-{Class} {Reactive} {Programming}},
+ booktitle = {2018 {IEEE} {International} {Conference} on {Cloud}
+ {Computing} {Technology} and {Science} ({CloudCom})},
+ author = {Troyer, de, Christophe and Nicolay, Jens and Meuter, de,
+ Wolfgang},
+ month = dec,
+ year = {2018},
+ pages = {185--192},
+ publisher = {IEEE},
+ address = {Nicosia, Cyprus}
+}
+
+@Article{ harth_predictive_2018,
+ author = {Natascha Harth and Christos Anagnostopoulos and Dimitrios
+ Pezaros},
+ title = {Predictive intelligence to the edge: impact on edge
+ analytics},
+ journal = {Evolving Systems},
+ volume = {9},
+ number = {2},
+ pages = {95--118},
+ year = {2018}
+}
+
+@Book{ guinard_building_2016,
+ address = {USA},
+ edition = {1st},
+ title = {Building the {Web} of {Things}: {With} {Examples} in
+ {Node}.{Js} and {Raspberry} {Pi}},
+ isbn = {1-61729-268-0},
+ publisher = {Manning Publications Co.},
+ author = {Guinard, Dominique and Trifa, Vlad},
+ year = {2016}
+}
+
+@Article{ maccormack2007impact,
+ title = {The impact of component modularity on design evolution:
+ Evidence from the software industry},
+ author = {MacCormack, Alan and Rusnak, John and Baldwin, Carliss Y},
+ journal = {Harvard Business School Technology \& Operations Mgt. Unit
+ Research Paper},
+ number = {038},
+ volume = {08},
+ year = {2007},
+ month = {dec},
+ doi = {10.2139/ssrn.1071720}
+}
+
+@InProceedings{ belle2013layered,
+ address = {Boston, MA, USA},
+ title = {The layered architecture revisited: {Is} it an
+ optimization problem?},
+ volume = {1},
+ isbn = {978-1-5108-4159-8},
+ shorttitle = {{SEKE} 2013},
+ booktitle = {Proceedings of the {Twenty}-{Fifth} {International}
+ {Conference} on {Software} {Engineering} \& {Knowledge}
+ {E}},
+ publisher = {KSI Research Inc},
+ author = {Belle, Alvine Boaye and El-Boussaidi, Ghizlane and
+ Desrosiers, Christian and Mili, Hafedh},
+ year = {2013},
+ pages = {344--349}
+}
+
+@InProceedings{ lee2001component,
+ title = {Component identification method with coupling and
+ cohesion},
+ author = {Lee, Jong Kook and Jung, Seung Jae and Kim, Soo Dong and
+ Jang, Woo Hyun and Ham, Dong Han},
+ booktitle = {Proceedings Eighth Asia-Pacific Software Engineering
+ Conference},
+ pages = {79--86},
+ year = {2001},
+ organization = {IEEE},
+ publisher = {IEEE},
+ address = {Macao, China}
+}
+
+@Article{ mazzei2018full,
+ title = {A full stack for quick prototyping of IoT solutions},
+ author = {Mazzei, Daniele and Baldi, Giacomo and Montelisciani,
+ Gabriele and Fantoni, Gualtiero},
+ journal = {Annals of Telecommunications},
+ volume = {73},
+ number = {7-8},
+ pages = {439--449},
+ year = {2018},
+ publisher = {Springer}
+}
+
+@Article{ mayer2017multi,
+ title = {On multi-language software development, cross-language
+ links and accompanying tools: a survey of professional
+ software developers},
+ author = {Mayer, Philip and Kirsch, Michael and Le, Minh Anh},
+ journal = {Journal of Software Engineering Research and Development},
+ volume = {5},
+ number = {1},
+ pages = {1},
+ year = {2017},
+ publisher = {Springer}
+}
+
+@InProceedings{ mayer2015empirical,
+ author = {Mayer, Philip and Bauer, Alexander},
+ title = {An Empirical Analysis of the Utilization of Multiple
+ Programming Languages in Open Source Projects},
+ year = {2015},
+ isbn = {9781450333504},
+ publisher = {Association for Computing Machinery},
+ address = {New York, NY, USA},
+ doi = {10.1145/2745802.2745805},
+ abstract = {Background: Anecdotal evidence suggests that software
+ applications are usually implemented using a combination of
+ (programming) languages. Aim: We want to provide empirical
+ evidence on the phenomenon of multi-language programming.
+ Methods: We use data mining of 1150 open source projects
+ selected for diversity from a public repository to a)
+ investigate the projects for number and type of languages
+ found and the relative sizes of the languages; b) report on
+ associations between the number of languages found and the
+ size, age, number of contributors, and number of commits of
+ a project using a (Quasi-)Poisson regression model, and c)
+ discuss concrete associations between the general-purpose
+ languages and domain-specific languages found using
+ frequent item set mining. Results: We found a) a mean
+ number of 5 languages per project with a clearly dominant
+ main general-purpose language and 5 often-used DSL types,
+ b) a significant influence of the size, number of commits,
+ and the main language on the number of languages as well as
+ no significant influence of age and number of contributors,
+ and c) three language ecosystems grouped around XML,
+ Shell/Make, and HTML/CSS. Conclusions: Multi-language
+ programming seems to be common in open-source projects and
+ is a factor which must be dealt with in tooling and when
+ assessing development and maintenance of such software
+ systems.},
+ booktitle = {Proceedings of the 19th International Conference on
+ Evaluation and Assessment in Software Engineering},
+ articleno = {4},
+ numpages = {10},
+ location = {Nanjing, China},
+ series = {EASE '15}
+}
+
+@InProceedings{ motta2018challenges,
+ author = {Motta, Rebeca C. and de Oliveira, K\'{a}thia M. and
+ Travassos, Guilherme H.},
+ title = {On Challenges in Engineering IoT Software Systems},
+ year = {2018},
+ isbn = {9781450365031},
+ publisher = {Association for Computing Machinery},
+ address = {New York, NY, USA},
+ doi = {10.1145/3266237.3266263},
+ abstract = {Contemporary software systems, such as the Internet of
+ Things (IoT), Industry 4.0, and Smart Cities are new
+ technology paradigms that offer challenges for their
+ construction since they are calling into question our
+ traditional form of developing software. They are a
+ promising paradigm for the integration of devices and
+ communications technologies. It is leading to a shift from
+ the classical monolithic view of development where
+ stakeholder receive a software product at the end (that we
+ have been doing for decades), to software systems
+ materialized through physical objects interconnected by
+ networks and with embedded software to support daily
+ activities. We need therefore to revisit our way of
+ developing software systems and start to consider the
+ particularities required by these new sorts of
+ applications. This paper presents research toward the
+ definition of a framework to support the systems
+ engineering of IoT applications, where we evolved the
+ Zachman's Framework as an alternative to the organization
+ of this architecture. The activities were two folded to
+ address this goal: a) we identified leading concerns of IoT
+ applications, recovered from technical literature,
+ practitioners and a Government Report, in different
+ studies; b) we structured the IoT paradigm in different
+ facets. These activities provided 14 significant concerns
+ and seven facets that together represent the engineering
+ challenges to be faced both by research and practice
+ towards the advancement of IoT in practice.},
+ booktitle = {Proceedings of the XXXII Brazilian Symposium on Software
+ Engineering},
+ pages = {42–51},
+ numpages = {10},
+ keywords = {challenges, concerns, internet of things, IoT, literature
+ review, empirical software engineering},
+ location = {Sao Carlos, Brazil},
+ series = {SBES '18}
+}
+
+@InProceedings{ kodali2016low,
+ title = {Low cost ambient monitoring using ESP8266},
+ author = {Kodali, Ravi Kishore and Mahesh, Kopulwar Shishir},
+ booktitle = {2016 2nd International Conference on Contemporary
+ Computing and Informatics (IC3I)},
+ pages = {779--782},
+ year = {2016},
+ organization = {IEEE},
+ publisher = {IEEE},
+ address = {Greater Noida, India}
+}
+
+@InProceedings{ alpernaswonderful,
+ author = {Alpernas, Kalev and Feldman, Yotam M. Y. and Peleg, Hila},
+ title = {The Wonderful Wizard of LoC: Paying Attention to the Man
+ behind the Curtain of Lines-of-Code Metrics},
+ year = {2020},
+ isbn = {9781450381789},
+ publisher = {Association for Computing Machinery},
+ address = {New York, NY, USA},
+ doi = {10.1145/3426428.3426921},
+ abstract = {Lines-of-code metrics (loc) are commonly reported in
+ Programming Languages (PL), Software Engineering (SE), and
+ Systems papers. This convention has several different,
+ often contradictory, goals, including demonstrating the
+ `hardness' of a problem, and demonstrating the `easiness'
+ of a problem. In many cases, the reporting of loc metrics
+ is done not with a clearly communicated intention, but
+ instead in an automatic, checkbox-ticking, manner. In this
+ paper we investigate the uses of code metrics in PL, SE,
+ and System papers. We consider the different goals that
+ reporting metrics aims to achieve, several various domains
+ wherein metrics are relevant, and various alternative
+ metrics and their pros and cons for the different goals and
+ domains. We argue that communicating claims about research
+ software is usually best achieved not by reporting
+ quantitative metrics, but by reporting the qualitative
+ experience of researchers, and propose guidelines for the
+ cases when quantitative metrics are appropriate. We end
+ with a case study of the one area in which lines of code
+ are not the default measurement---code produced by papers'
+ solutions---and identify how measurements offered are used
+ to support an explicit claim about the algorithm. Inspired
+ by this positive example, we call for other cogent measures
+ to be developed to support other claims authors wish to
+ make.},
+ booktitle = {Proceedings of the 2020 ACM SIGPLAN International
+ Symposium on New Ideas, New Paradigms, and Reflections on
+ Programming and Software},
+ pages = {146–156},
+ numpages = {11},
+ keywords = {research papers, loc, lines of code},
+ location = {Virtual, USA},
+ series = {Onward! 2020}
+}
+
+@InProceedings{ epstein2011towards,
+ author = {Epstein, Jeff and Black, Andrew P. and Peyton Jones,
+ Simon},
+ title = {Towards Haskell in the Cloud},
+ year = {2011},
+ isbn = {9781450308601},
+ publisher = {Association for Computing Machinery},
+ address = {New York, NY, USA},
+ doi = {10.1145/2034675.2034690},
+ abstract = {We present Cloud Haskell, a domain-specific language for
+ developing programs for a distributed computing
+ environment. Implemented as a shallow embedding in Haskell,
+ it provides a message-passing communication model, inspired
+ by Erlang, without introducing incompatibility with
+ Haskell's established shared-memory concurrency. A key
+ contribution is a method for serializing function closures
+ for transmission across the network. Cloud Haskell has been
+ implemented; we present example code and some preliminary
+ performance measurements.},
+ booktitle = {Proceedings of the 4th ACM Symposium on Haskell},
+ pages = {118–129},
+ numpages = {12},
+ keywords = {message-passing, haskell, erlang},
+ location = {Tokyo, Japan},
+ series = {Haskell '11}
+}
+
+@Book{ gupta2012akka,
+ title = {Akka essentials},
+ address = {Livery Place, 35 Livery Street, Birmingham B3 2PB, UK},
+ author = {Gupta, Munish},
+ year = {2012},
+ publisher = {Packt Publishing Ltd}
+}
+
+@Misc{ wiki:io,
+ author = "HaskellWiki",
+ title = "Introduction to IO --- HaskellWiki{,} ",
+ year = "2020",
+ url = "https://wiki.haskell.org/index.php?title=Introduction_to_IO&oldid=63493",
+ note = "[Online; accessed 19-January-2021]"
+}
+
+@Misc{ circuitpython,
+ author = {{CircuitPython Team}},
+ title = "CircuitPython",
+ year = "2022",
+ url = "https://circuitpython.org/",
+ note = "[Online; accessed 2-March-2022]"
+}
+
+@InProceedings{ genericprogrammingextensionforclean,
+ author = "Alimarine, Artem and Plasmeijer, Rinus",
+ editor = "Arts, Thomas and Mohnen, Markus",
+ title = "A Generic Programming Extension for Clean",
+ booktitle = "Implementation of Functional Languages",
+ year = "2002",
+ publisher = "Springer Berlin Heidelberg",
+ address = "Berlin, Heidelberg",
+ pages = "168--185",
+ abstract = "Generic programming enables the programmer to define
+ functions by induction on the structure of types. Defined
+ once, such a generic function can be used to generate a
+ specialized function for any user defined data type.
+ Several ways to support generic programming in functional
+ languages have been proposed, each with its own pros and
+ cons. In this paper we describe a combination of two
+ existing approaches, which has the advantages of both of
+ them. In our approach overloaded functions with class
+ variables of an arbitrary kind can be defined generically.
+ A single generic definition defines a kind-indexed family
+ of overloaded functions, one for each kind. For instance,
+ the generic mapping function generates an overloaded
+ mapping function for each kind.",
+ isbn = "978-3-540-46028-2"
+}
+
+@InProceedings{ hinzegenericfunctionalprogramming,
+ author = {Hinze, Ralf},
+ title = {A New Approach to Generic Functional Programming},
+ year = {2000},
+ isbn = {1581131259},
+ publisher = {Association for Computing Machinery},
+ address = {New York, NY, USA},
+ doi = {10.1145/325694.325709},
+ abstract = {This paper describes a new approach to generic functional
+ programming, which allows us to define functions
+ generically for all datatypes expressible in Haskell. A
+ generic function is one that is defined by induction on the
+ structure of types. Typical examples include pretty
+ printers, parsers, and comparison functions. The advanced
+ type system of Haskell presents a real challenge: datatypes
+ may be parameterized not only by types but also by type
+ constructors, type definitions may involve mutual
+ recursion, and recursive calls of type constructors can be
+ arbitrarily nested. We show that—despite this
+ complexity—a generic function is uniquely defined by
+ giving cases for primitive types and type constructors
+ (such as disjoint unions and cartesian products). Given
+ this information a generic function can be specialized to
+ arbitrary Haskell datatypes. The key idea of the approach
+ is to model types by terms of the simply typed
+ $\lambda-calculus augmented by a family of recursion
+ operators. While conceptually simple, our approach places
+ high demands on the type system: it requires polymorphic
+ recursion, rank-n types, and a strong form of type
+ constructor polymorphism. Finally, we point out connections
+ to Haskell's class system and show that our approach
+ generalizes type classes in some respects.},
+ booktitle = {Proceedings of the 27th ACM SIGPLAN-SIGACT Symposium on
+ Principles of Programming Languages},
+ pages = {119–132},
+ numpages = {14},
+ location = {Boston, MA, USA},
+ series = {POPL '00}
+}
+
+@InProceedings{ top-icfp07,
+ author = {Plasmeijer, Rinus and Achten, Peter and Koopman, Pieter},
+ title = {{iTasks}: {E}xecutable {S}pecifications of {I}nteractive
+ {W}ork {F}low {S}ystems for the {W}eb},
+ booktitle = {{P}roceedings of the 12th {ACM SIGPLAN} {I}nternational
+ {C}onference on {F}unctional {P}rogramming ({ICFP} 2007)},
+ address = {{F}reiburg, {G}ermany},
+ year = 2007,
+ month = {Oct 1--3},
+ publisher = {ACM},
+ isbn = "978-1-59593-815-2",
+ pages = {141-152}
+}
+
+@InProceedings{ oortgiese_distributed_2017,
+ title = {A {Distributed} {Dynamic} {Architecture} for {Task}
+ {Oriented} {Programming}},
+ booktitle = {Proceedings of the 29th {Symposium} on {Implementation}
+ and {Application} of {Functional} {Programming}
+ {Languages}},
+ publisher = {ACM},
+ author = {Oortgiese, Arjan and van Groningen, John and Achten, Peter
+ and Plasmeijer, Rinus},
+ year = {2017},
+ pages = {7},
+ address = {Bristol, UK}
+}
+
+@InProceedings{ parametriclenses,
+ author = {Domoszlai, L\'{a}szl\'{o} and Lijnse, Bas and Plasmeijer,
+ Rinus},
+ title = {Parametric Lenses: Change Notification for Bidirectional
+ Lenses},
+ year = {2014},
+ isbn = {9781450332842},
+ publisher = {Association for Computing Machinery},
+ address = {New York, NY, USA},
+ doi = {10.1145/2746325.2746333},
+ abstract = {Most complex applications inevitably need to maintain
+ dependencies between subsystems based on some shared data.
+ The dependent parts must be informed that the shared
+ information is changed. As every actual notification has
+ some communication cost, and every triggered task has
+ associated computation cost, it is crucial for the overall
+ performance of the application to reduce the number of
+ notifications as much as possible. To achieve this, one
+ must be able to define, with arbitrary precision, which
+ party is depending on which data. In this paper we offer a
+ general solution to this general problem. The solution is
+ based on an extension to bidirectional lenses, called
+ parametric lenses. With the help of parametric lenses one
+ can define compositional parametric views in a declarative
+ way to access some shared data. Parametric views, besides
+ providing read/write access to the shared data, also enable
+ to observe changes of some parts, given by an explicit
+ parameter, the focus domain. The focus domain can be
+ specified as a type-based query language defined over one
+ or more resources using predefined combinators of
+ parametric views.},
+ booktitle = {Proceedings of the 26th International Symposium on
+ Implementation and Application of Functional Languages},
+ articleno = {9},
+ numpages = {11},
+ keywords = {notification systems, parametric views, lenses, parametric
+ lenses, Bi-directional programming},
+ location = {Boston, MA, USA},
+ series = {IFL '14}
+}
+
+@InProceedings{ comparinggenericprogramming,
+ author = {Rodriguez, Alexey and Jeuring, Johan and Jansson, Patrik
+ and Gerdes, Alex and Kiselyov, Oleg and Oliveira, Bruno C.
+ d. S.},
+ title = {Comparing Libraries for Generic Programming in Haskell},
+ year = {2008},
+ isbn = {9781605580647},
+ publisher = {Association for Computing Machinery},
+ address = {New York, NY, USA},
+ doi = {10.1145/1411286.1411301},
+ abstract = {Datatype-generic programming is defining functions that
+ depend on the structure, or "shape", of datatypes. It has
+ been around for more than 10 years, and a lot of progress
+ has been made, in particular in the lazy functional
+ programming language Haskell. There are morethan 10
+ proposals for generic programming libraries orlanguage
+ extensions for Haskell. To compare and characterise the
+ many generic programming libraries in atyped functional
+ language, we introduce a set of criteria and develop a
+ generic programming benchmark: a set of characteristic
+ examples testing various facets of datatype-generic
+ programming. We have implemented the benchmark for nine
+ existing Haskell generic programming libraries and present
+ the evaluation of the libraries. The comparison is useful
+ for reaching a common standard for generic programming, but
+ also for a programmer who has to choose a particular
+ approach for datatype-generic programming.},
+ booktitle = {Proceedings of the First ACM SIGPLAN Symposium on
+ Haskell},
+ pages = {111–122},
+ numpages = {12},
+ keywords = {datatype-generic programming, libraries comparison},
+ location = {Victoria, BC, Canada},
+ series = {Haskell '08}
+}
+
+@InProceedings{ kochhar2016large,
+ author = {P. S. {Kochhar} and D. {Wijedasa} and D. {Lo}},
+ booktitle = {23rd International Conference on Software Analysis,
+ Evolution, and Reengineering},
+ title = {A Large Scale Study of Multiple Programming Languages and
+ Code Quality},
+ year = {2016},
+ pages = {563--573},
+ doi = {10.1109/SANER.2016.112},
+ address = {Osaka, Japan},
+ publisher = {IEEE}
+}
+
+@Article{ cass2020top,
+ title = {The top programming languages: Our latest rankings put
+ Python on top-again-[Careers]},
+ author = {Cass, Stephen},
+ journal = {IEEE Spectrum},
+ volume = {57},
+ number = {8},
+ pages = {22--22},
+ year = {2020},
+ publisher = {IEEE}
+}
+
+@InProceedings{ tanganelli2015coapthon,
+ title = {CoAPthon: Easy development of CoAP-based IoT applications
+ with Python},
+ author = {Tanganelli, Giacomo and Vallati, Carlo and Mingozzi,
+ Enzo},
+ booktitle = {2015 IEEE 2nd World Forum on Internet of Things (WF-IoT)},
+ pages = {63--68},
+ year = {2015},
+ publisher = {IEEE},
+ address = {Milan, Italy}
+}
+
+@Article{ jinn,
+ author = {Lee, Byeongcheol and Wiedermann, Ben and Hirzel, Martin
+ and Grimm, Robert and McKinley, Kathryn S.},
+ title = {Jinn: Synthesizing Dynamic Bug Detectors for Foreign
+ Language Interfaces},
+ year = {2010},
+ issue_date = {June 2010},
+ publisher = {Association for Computing Machinery},
+ address = {New York, NY, USA},
+ volume = {45},
+ number = {6},
+ issn = {0362-1340},
+ doi = {10.1145/1809028.1806601},
+ abstract = {Programming language specifications mandate static and
+ dynamic analyses to preclude syntactic and semantic errors.
+ Although individual languages are usually well-specified,
+ composing languages is not, and this poor specification is
+ a source of many errors in multilingual programs. For
+ example, virtually all Java programs compose Java and C
+ using the Java Native Interface (JNI). Since JNI is
+ informally specified, developers have difficulty using it
+ correctly, and current Java compilers and virtual machines
+ (VMs) inconsistently check only a subset of JNI
+ constraints.This paper's most significant contribution is
+ to show how to synthesize dynamic analyses from state
+ machines to detect foreign function interface (FFI)
+ violations. We identify three classes of FFI constraints
+ encoded by eleven state machines that capture thousands of
+ JNI and Python/C FFI rules. We use a mapping function to
+ specify which state machines, transitions, and program
+ entities (threads, objects, references) to check at each
+ FFI call and return. From this function, we synthesize a
+ context-specific dynamic analysis to find FFI bugs. We
+ build bug detection tools for JNI and Python/C using this
+ approach. For JNI, we dynamically and transparently
+ interpose the analysis on Java and C language transitions
+ through the JVM tools interface. The resulting tool, called
+ Jinn, is compiler and virtual machine independent. It
+ detects and diagnoses a wide variety of FFI bugs that other
+ tools miss. This approach greatly reduces the annotation
+ burden by exploiting common FFI constraints: whereas the
+ generated Jinn code is 22,000+ lines, we wrote only 1,400
+ lines of state machine and mapping code. Overall, this
+ paper lays the foundation for a more principled approach to
+ developing correct multilingual software and a more concise
+ and automated approach to FFI specification.},
+ journal = {SIGPLAN Not.},
+ month = jun,
+ pages = {36–49},
+ numpages = {14},
+ keywords = {specification generation, specification, python/C, dynamic
+ analysis, multilingual programs, java native interface
+ (jni), foreign function interfaces (FFI), ffi bugs}
+}
+
+@Article{ furr2005,
+ author = {Furr, Michael and Foster, Jeffrey S.},
+ title = {Checking Type Safety of Foreign Function Calls},
+ year = {2005},
+ issue_date = {June 2005},
+ publisher = {Association for Computing Machinery},
+ address = {New York, NY, USA},
+ volume = {40},
+ number = {6},
+ issn = {0362-1340},
+ doi = {10.1145/1064978.1065019},
+ abstract = {We present a multi-lingual type inference system for
+ checking type safety across a foreign function interface.
+ The goal of our system is to prevent foreign function calls
+ from introducing type and memory safety violations into an
+ otherwise safe language. Our system targets OCaml's FFI to
+ C, which is relatively lightweight and illustrates some
+ interesting challenges in multi-lingual type inference. The
+ type language in our system embeds OCaml types in C types
+ and vice-versa, which allows us to track type information
+ accurately even through the foreign language, where the
+ original types are lost. Our system uses representational
+ types that can model multiple OCaml types, because C
+ programs can observe that many OCaml types have the same
+ physical representation. Furthermore, because C has a
+ low-level view of OCaml data, our inference system includes
+ a dataflow analysis to track memory offsets and tag
+ information. Finally, our type system includes garbage
+ collection information to ensure that pointers from the FFI
+ to the OCaml heap are tracked properly. We have implemented
+ our inference system and applied it to a small set of
+ benchmarks. Our results show that programmers do misuse
+ these interfaces, and our implementation has found several
+ bugs and questionable coding practices in our benchmarks.},
+ journal = {SIGPLAN Not.},
+ month = jun,
+ pages = {62–72},
+ numpages = {11},
+ keywords = {foreign function calls, multi-lingual type system, OCaml,
+ multi-lingual type inference, flow-sensitive type system,
+ FFI, foreign function interface, dataflow analysis,
+ representational type}
+}
+
+@InProceedings{ plamauer2017evaluation,
+ title = {Evaluation of micropython as application layer programming
+ language on cubesats},
+ author = {Plamauer, Sebastian and Langer, Martin},
+ booktitle = {ARCS 2017; 30th International Conference on Architecture
+ of Computing Systems},
+ pages = {1--9},
+ year = {2017},
+ organization = {VDE},
+ publisher = {VDE},
+ address = {Vienna, Austria}
+}
+
+@Book{ ravulavaru18,
+ author = {Ravulavaru, Arvind},
+ isbn = {1-78883-378-3},
+ language = {eng},
+ publisher = {Packt Publishing},
+ title = {Enterprise internet of things handbook : build end-to-end
+ IoT solutions using popular IoT platforms},
+ year = {2018},
+ address = {Birmingham, UK}
+}
+
+@InProceedings{ alphonsa20,
+ author = "Alphonsa, Mandla",
+ editor = "Kumar, Amit and Mozar, Stefan",
+ title = "A Review on IOT Technology Stack, Architecture and Its
+ Cloud Applications in Recent Trends",
+ booktitle = "ICCCE 2020",
+ year = "2021",
+ publisher = "Springer Singapore",
+ address = "Singapore",
+ pages = "703--711",
+ abstract = "The Internet of Things (IoT) senses, gather and transmit
+ data over the internet without any human interference. This
+ technology is a mixture of embedded technology, network
+ technology and information technology. On various
+ advancement of huge network and the broadcasting of (IoT),
+ wireless sensored networks are considered to be part of the
+ huge heterogeneous network. IoT architecture is the system
+ of various rudiments like sensored networks, protocol,
+ actuators, cloud service and layers. Internet of Things can
+ also be called as an event-driven model. The IOT device is
+ connected to gateway through Radio Frequency, LORA-WAN,
+ Node MCU Pin-out. This review paper describes all protocol
+ stack including its types of sensors in IOT their
+ applications in real time environment and its architecture.
+ In this paper we come together with the two different
+ technologies Cloud Computing and IoT to observe the most
+ common features, and to determine the benefits of their
+ integration. The Cloud IoT prototype involves various
+ applications, research issues and challenges.",
+ isbn = "978-981-15-7961-5"
+}
+
+@InProceedings{ sivieri2012drop,
+ title = {Drop the phone and talk to the physical world: Programming
+ the internet of things with Erlang},
+ author = {Sivieri, Alessandro and Mottola, Luca and Cugola,
+ Gianpaolo},
+ booktitle = {2012 Third International Workshop on Software Engineering
+ for Sensor Network Applications (SESENA)},
+ pages = {8--14},
+ year = {2012},
+ organization = {IEEE}
+}
+
+@Article{ chong2007secure,
+ title = {Secure web applications via automatic partitioning},
+ author = {Chong, Stephen and Liu, Jed and Myers, Andrew C and Qi,
+ Xin and Vikram, Krishnaprasad and Zheng, Lantian and Zheng,
+ Xin},
+ journal = {ACM SIGOPS Operating Systems Review},
+ volume = {41},
+ number = {6},
+ pages = {31--44},
+ year = {2007},
+ publisher = {ACM New York, NY, USA}
+}
+
+@Article{ zdancewic2002secure,
+ title = {Secure program partitioning},
+ author = {Zdancewic, Steve and Zheng, Lantian and Nystrom, Nathaniel
+ and Myers, Andrew C},
+ journal = {ACM Transactions on Computer Systems (TOCS)},
+ volume = {20},
+ number = {3},
+ pages = {283--328},
+ year = {2002},
+ publisher = {ACM New York, NY, USA}
+}
+
+@Article{ 10.1145/2775050.2633367,
+ author = {Ekblad, Anton and Claessen, Koen},
+ title = {A Seamless, Client-Centric Programming Model for Type Safe
+ Web Applications},
+ year = {2014},
+ issue_date = {December 2014},
+ publisher = {Association for Computing Machinery},
+ address = {New York, NY, USA},
+ volume = {49},
+ number = {12},
+ issn = {0362-1340},
+ doi = {10.1145/2775050.2633367},
+ abstract = {We propose a new programming model for web applications
+ which is (1) seamless; one program and one language is used
+ to produce code for both client and server, (2)
+ client-centric; the programmer takes the viewpoint of the
+ client that runs code on the server rather than the other
+ way around, (3) functional and type-safe, and (4) portable;
+ everything is implemented as a Haskell library that
+ implicitly takes care of all networking code. Our aim is to
+ improve the painful and error-prone experience of today's
+ standard development methods, in which clients and servers
+ are coded in different languages and communicate with each
+ other using ad-hoc protocols. We present the design of our
+ library called Haste.App, an example web application that
+ uses it, and discuss the implementation and the compiler
+ technology on which it depends.},
+ journal = {SIGPLAN Not.},
+ month = {sep},
+ pages = {79–89},
+ numpages = {11},
+ keywords = {distributed systems, web applications, network
+ communication}
+}
+
+@InProceedings{ elliott_guilt_2015,
+ title = {Guilt free ivory},
+ volume = {50},
+ booktitle = {{ACM} {SIGPLAN} {Notices}},
+ publisher = {ACM},
+ author = {Elliott, Trevor and Pike, Lee and Winwood, Simon and
+ Hickey, Pat and Bielman, James and Sharp, Jamey and Seidel,
+ Eric and Launchbury, John},
+ year = {2015},
+ pages = {189--200},
+ file = {5678351608ae125516ee79c6.pdf:/home/mrl/.local/share/zotero/storage/KJMFUH7T/5678351608ae125516ee79c6.pdf:application/pdf}
+}
+
+@InProceedings{ sawada_emfrp:_2016,
+ title = {Emfrp: a functional reactive programming language for
+ small-scale embedded systems},
+ booktitle = {Companion {Proceedings} of the 15th {International}
+ {Conference} on {Modularity}},
+ publisher = {ACM},
+ author = {Sawada, Kensuke and Watanabe, Takuo},
+ year = {2016},
+ pages = {36--44},
+ file = {Sawada and Watanabe - 2016 - Emfrp a functional reactive
+ programming language
+ .pdf:/home/mrl/.local/share/zotero/storage/9U95ER5P/Sawada
+ and Watanabe - 2016 - Emfrp a functional reactive
+ programming language .pdf:application/pdf}
+}
+
+@InProceedings{ helbling_juniper:_2016,
+ title = {Juniper: a functional reactive programming language for
+ the {Arduino}},
+ booktitle = {Proceedings of the 4th {International} {Workshop} on
+ {Functional} {Art}, {Music}, {Modelling}, and {Design}},
+ publisher = {ACM},
+ author = {Helbling, Caleb and Guyer, Samuel Z},
+ year = {2016},
+ pages = {8--16},
+ file = {Helbling and Guyer - 2016 - Juniper a functional reactive
+ programming
+ languag.pdf:/home/mrl/.local/share/zotero/storage/M4UWK57F/Helbling
+ and Guyer - 2016 - Juniper a functional reactive
+ programming languag.pdf:application/pdf}
+}
+
+@InCollection{ valliappan_towards_2020,
+ address = {New York, NY, USA},
+ title = {Towards {Secure} {IoT} {Programming} in {Haskell}},
+ isbn = {978-1-4503-8050-8},
+ abstract = {IoT applications are often developed in programming
+ languages with low-level abstractions, where a seemingly
+ innocent mistake might lead to severe security
+ vulnerabilities. Current IoT development tools make it hard
+ to identify these vulnerabilities as they do not provide
+ end-to-end guarantees about how data flows within and
+ between appliances. In this work we present Haski, an
+ embedded domain specific language in Haskell (eDSL) for
+ secure programming of IoT devices. Haski enables developers
+ to write Haskell programs that generate C code without
+ falling into many of C’s pitfalls. Haski is designed
+ after the synchronous programming language Lustre, and
+ sports a backwards compatible information-flow control
+ extension to restrict how sensitive data is propagated and
+ modified within the application. We present a novel eDSL
+ design which uses recursive monadic bindings and allows a
+ natural use of functions and pattern-matching in Haskell to
+ write Haski programs. To showcase Haski, we implement a
+ simple smart house controller where communication is done
+ via low-energy Bluetooth on Zephyr OS.},
+ booktitle = {Proceedings of the 13th {ACM} {SIGPLAN} {International}
+ {Symposium} on {Haskell}},
+ publisher = {Association for Computing Machinery},
+ author = {Valliappan, Nachiappan and Krook, Robert and Russo,
+ Alejandro and Claessen, Koen},
+ year = {2020},
+ pages = {136--150},
+ file = {Valliappan et al. - 2020 - Towards Secure IoT Programming
+ in
+ Haskell.pdf:/home/mrl/.local/share/zotero/storage/BF6YIT2S/Valliappan
+ et al. - 2020 - Towards Secure IoT Programming in
+ Haskell.pdf:application/pdf}
+}
+
+@InProceedings{ sarkar_hailstorm_2020,
+ address = {New York, NY, USA},
+ series = {{PPDP} '20},
+ title = {Hailstorm: {A} {Statically}-{Typed}, {Purely} {Functional}
+ {Language} for {IoT} {Applications}},
+ isbn = {978-1-4503-8821-4},
+ doi = {10.1145/3414080.3414092},
+ abstract = {With the growing ubiquity of Internet of Things (IoT),
+ more complex logic is being programmed on
+ resource-constrained IoT devices, almost exclusively using
+ the C programming language. While C provides low-level
+ control over memory, it lacks a number of high-level
+ programming abstractions such as higher-order functions,
+ polymorphism, strong static typing, memory safety, and
+ automatic memory management. We present Hailstorm, a
+ statically-typed, purely functional programming language
+ that attempts to address the above problem. It is a
+ high-level programming language with a strict typing
+ discipline. It supports features like higher-order
+ functions, tail-recursion, and automatic memory management,
+ to program IoT devices in a declarative manner.
+ Applications running on these devices tend to be heavily
+ dominated by I/O. Hailstorm tracks side effects like I/O in
+ its type system using resource types. This choice allowed
+ us to explore the design of a purely functional standalone
+ language, in an area where it is more common to embed a
+ functional core in an imperative shell. The language
+ borrows the combinators of arrowized FRP, but has
+ discrete-time semantics. The design of the full set of
+ combinators is work in progress, driven by examples. So
+ far, we have evaluated Hailstorm by writing standard
+ examples from the literature (earthquake detection, a
+ railway crossing system and various other clocked systems),
+ and also running examples on the GRiSP embedded systems
+ board, through generation of Erlang.},
+ booktitle = {Proceedings of the 22nd {International} {Symposium} on
+ {Principles} and {Practice} of {Declarative}
+ {Programming}},
+ publisher = {Association for Computing Machinery},
+ author = {Sarkar, Abhiroop and Sheeran, Mary},
+ year = {2020},
+ note = {event-place: Bologna, Italy},
+ keywords = {functional programming, compilers, embedded systems, IoT},
+ file = {Sarkar and Sheeran - 2020 - Hailstorm A Statically-Typed,
+ Purely Functional
+ L.pdf:/home/mrl/.local/share/zotero/storage/BKFJKGQP/Sarkar
+ and Sheeran - 2020 - Hailstorm A Statically-Typed, Purely
+ Functional L.pdf:application/pdf}
+}
+
+@InProceedings{ 10.1145/3281366.3281370,
+ author = {Shibanai, Kazuhiro and Watanabe, Takuo},
+ title = {Distributed Functional Reactive Programming on Actor-Based
+ Runtime},
+ year = {2018},
+ isbn = {9781450360661},
+ publisher = {Association for Computing Machinery},
+ address = {New York, NY, USA},
+ doi = {10.1145/3281366.3281370},
+ abstract = {Reactive programming over a network is a challenging task
+ because efficient elimination of temporary violations of
+ data flow invariants, known as glitches, in a distributed
+ setting is still an open issue. In this paper, we propose a
+ method for constructing a distributed reactive programming
+ system of which runtime guarantees the properties of single
+ source glitch-freedom and the robustness against
+ out-of-order messages. Based on the method, we developed a
+ purely functional reactive programming language XFRP whose
+ compiler produces Erlang code. Using some examples, we show
+ that the proposed method is beneficial for constructing
+ distributed reactive applications without suffering from
+ inconsistencies.},
+ booktitle = {Proceedings of the 8th ACM SIGPLAN International Workshop
+ on Programming Based on Actors, Agents, and Decentralized
+ Control},
+ pages = {13–22},
+ numpages = {10},
+ keywords = {Distributed Functional Reactive Programming, Erlang,
+ Glitch Freedom, Synchronization, Actor-Based Runtime
+ System},
+ location = {Boston, MA, USA},
+ series = {AGERE 2018}
+}
+
+@InProceedings{ suzuki_cfrp_2017,
+ address = {The University of The Philippines Cebu, Cebu City, The
+ Philippines},
+ title = {{CFRP}: {A} {Functional} {Reactive} {Programming}
+ {Language} for {Small}-{Scale} {Embedded} {Systems}},
+ isbn = {978-981-323-406-2 978-981-323-407-9},
+ shorttitle = {{CFRP}},
+ url = {http://www.worldscientific.com/doi/abs/10.1142/9789813234079_0001},
+ doi = {10.1142/9789813234079_0001},
+ language = {en},
+ urldate = {2022-03-02},
+ booktitle = {Theory and {Practice} of {Computation}},
+ publisher = {WORLD SCIENTIFIC},
+ author = {Suzuki, Kohei and Nagayama, Kanato and Sawada, Kensuke and
+ Watanabe, Takuo},
+ month = dec,
+ year = {2017},
+ pages = {1--13},
+ file = {Suzuki et al. - 2017 - CFRP A Functional Reactive
+ Programming Language
+ f.pdf:/home/mrl/.local/share/zotero/storage/XHPSZCJH/Suzuki
+ et al. - 2017 - CFRP A Functional Reactive Programming
+ Language f.pdf:application/pdf}
+}
+
+@InProceedings{ shibanai_distributed_2018,
+ address = {New York, NY, USA},
+ series = {{AGERE} 2018},
+ title = {Distributed {Functional} {Reactive} {Programming} on
+ {Actor}-{Based} {Runtime}},
+ isbn = {978-1-4503-6066-1},
+ doi = {10.1145/3281366.3281370},
+ abstract = {Reactive programming over a network is a challenging task
+ because efficient elimination of temporary violations of
+ data flow invariants, known as glitches, in a distributed
+ setting is still an open issue. In this paper, we propose a
+ method for constructing a distributed reactive programming
+ system of which runtime guarantees the properties of single
+ source glitch-freedom and the robustness against
+ out-of-order messages. Based on the method, we developed a
+ purely functional reactive programming language XFRP whose
+ compiler produces Erlang code. Using some examples, we show
+ that the proposed method is beneficial for constructing
+ distributed reactive applications without suffering from
+ inconsistencies.},
+ booktitle = {Proceedings of the 8th {ACM} {SIGPLAN} {International}
+ {Workshop} on {Programming} {Based} on {Actors}, {Agents},
+ and {Decentralized} {Control}},
+ publisher = {Association for Computing Machinery},
+ author = {Shibanai, Kazuhiro and Watanabe, Takuo},
+ year = {2018},
+ note = {event-place: Boston, MA, USA},
+ keywords = {Actor-Based Runtime System, Distributed Functional
+ Reactive Programming, Erlang, Glitch Freedom,
+ Synchronization},
+ pages = {13--22},
+ file = {Shibanai and Watanabe - 2018 - Distributed Functional
+ Reactive Programming on
+ Act.pdf:/home/mrl/.local/share/zotero/storage/UJ5IG7R4/Shibanai
+ and Watanabe - 2018 - Distributed Functional Reactive
+ Programming on Act.pdf:application/pdf}
+}
+
+@InProceedings{ nilsson_functional_2002,
+ address = {New York, NY, USA},
+ series = {Haskell '02},
+ title = {Functional {Reactive} {Programming}, {Continued}},
+ isbn = {1-58113-605-6},
+ doi = {10.1145/581690.581695},
+ abstract = {Functional Reactive Programming (FRP) extends a host
+ programming language with a notion of time flow. Arrowized
+ FRP (AFRP) is a version of FRP embedded in Haskell based on
+ the arrow combinators. AFRP is a powerful synchronous
+ dataflow programming language with hybrid modeling
+ capabilities, combining advanced synchronous dataflow
+ features with the higher-order lazy functional abstractions
+ of Haskell. In this paper, we describe the AFRP programming
+ style and our Haskell-based implementation. Of particular
+ interest are the AFRP combinators that support dynamic
+ collections and continuation-based switching. We show how
+ these combinators can be used to express systems with an
+ evolving structure that are difficult to model in more
+ traditional dataflow languages.},
+ booktitle = {Proceedings of the 2002 {ACM} {SIGPLAN} {Workshop} on
+ {Haskell}},
+ publisher = {Association for Computing Machinery},
+ author = {Nilsson, Henrik and Courtney, Antony and Peterson, John},
+ year = {2002},
+ note = {event-place: Pittsburgh, Pennsylvania},
+ keywords = {functional programming, Haskell, domain-specific
+ languages, FRP, hybrid modeling, synchronous dataflow
+ languages},
+ pages = {51--64},
+ file = {Nilsson et al. - 2002 - Functional reactive programming,
+ continued.pdf:/home/mrl/.local/share/zotero/storage/X79J47NP/Nilsson
+ et al. - 2002 - Functional reactive programming,
+ continued.pdf:application/pdf}
+}
+
+@InProceedings{ 10.1145/2661136.2661146,
+ author = {Philips, Laure and De Roover, Coen and Van Cutsem, Tom and
+ De Meuter, Wolfgang},
+ title = {Towards Tierless Web Development without Tierless
+ Languages},
+ year = {2014},
+ isbn = {9781450332101},
+ publisher = {Association for Computing Machinery},
+ address = {New York, NY, USA},
+ doi = {10.1145/2661136.2661146},
+ abstract = {Tierless programming languages enable developing the
+ typical server, client and database tiers of a web
+ application as a single mono-linguistic program. This
+ development style is in stark contrast to the current
+ practice which requires combining multiple technologies and
+ programming languages. A myriad of tierless programming
+ languages has already been proposed, often featuring a
+ JavaScript-like syntax. Instead of introducing yet another,
+ we advocate that it should be possible to develop tierless
+ web applications in existing general-purpose languages.
+ This not only reduces the complexity that developers are
+ exposed to, but also precludes the need for new development
+ tools. We concretize this novel approach to tierless
+ programming by discussing requirements on its future
+ instantiations. We explore the design space of the program
+ analysis for determining and the program transformation for
+ realizing the tier split respectively. The former
+ corresponds to new adaptations of an old familiar, program
+ slicing, for tier splitting. The latter includes several
+ strategies for handling cross-tier function calls and data
+ accesses. Using a prototype instantiation for JavaScript,
+ we demonstrate the feasibility of our approach on an
+ example web application. We conclude with a discussion of
+ open questions and challenges for future research.},
+ booktitle = {Proceedings of the 2014 ACM International Symposium on New
+ Ideas, New Paradigms, and Reflections on Programming \&
+ Software},
+ pages = {69–81},
+ numpages = {13},
+ keywords = {tier splitting, program slicing, tierless programming,
+ javascript},
+ location = {Portland, Oregon, USA},
+ series = {Onward! 2014}
+}
+
+@Misc{ hess_arduino-copilot_2020,
+ title = {arduino-copilot: {Arduino} programming in haskell using
+ the {Copilot} stream {DSL}},
+ shorttitle = {arduino-copilot},
+ url = {//hackage.haskell.org/package/arduino-copilot},
+ urldate = {2020-02-14},
+ journal = {Hackage},
+ author = {Hess, Joey},
+ year = {2020},
+ file = {Snapshot:/home/mrl/.local/share/zotero/storage/PSHYKF52/arduino-copilot.html:text/html}
+}
+
+@Article{ sheetz2009understanding,
+ title = {Understanding developer and manager perceptions of
+ function points and source lines of code},
+ author = {Sheetz, Steven D and Henderson, David and Wallace, Linda},
+ journal = {Journal of Systems and Software},
+ volume = {82},
+ number = {9},
+ pages = {1540--1549},
+ year = {2009},
+ publisher = {Elsevier}
+}
+
+@InProceedings{ balat2006ocsigen,
+ title = {Ocsigen: Typing web interaction with objective caml},
+ author = {Balat, Vincent},
+ booktitle = {Proceedings of the 2006 Workshop on ML},
+ pages = {84--94},
+ year = {2006}
+}
+
+@InProceedings{ bjornson2010composing,
+ title = {Composing reactive GUIs in F\# using WebSharper},
+ author = {Bjornson, Joel and Tayanovskyy, Anton and Granicz, Adam},
+ booktitle = {Symposium on Implementation and Application of Functional
+ Languages},
+ pages = {203--216},
+ year = {2010},
+ organization = {Springer}
+}
+
+@Book{ strack2015getting,
+ title = {Getting Started with Meteor. js JavaScript Framework},
+ author = {Strack, Isaac},
+ year = {2015},
+ publisher = {Packt Publishing Ltd}
+}
+
+@InCollection{ hall1993glasgow,
+ title = {The Glasgow Haskell compiler: a retrospective},
+ author = {Hall, Cordelia and Hammond, Kevin and Partain, Will and
+ Peyton Jones, Simon L and Wadler, Philip},
+ booktitle = {Functional Programming, Glasgow 1992},
+ pages = {62--71},
+ year = {1993},
+ publisher = {Springer}
+}
+
+@Misc{ diffmicro,
+ title = "MicroPython Differences from CPython",
+ author = {{Micropython Team}},
+ year = "2022",
+ note = "https://docs.micropython.org/en/latest/genrst/index.html"
+}
+
+@Article{ weisenburger2020survey,
+ title = {A survey of multitier programming},
+ author = {Weisenburger, Pascal and Wirth, Johannes and Salvaneschi,
+ Guido},
+ journal = {ACM Computing Surveys (CSUR)},
+ volume = {53},
+ number = {4},
+ pages = {1--35},
+ year = {2020},
+ publisher = {ACM New York, NY, USA}
+}
+
+@InProceedings{ 203628,
+ author = {Manos Antonakakis and Tim April and Michael Bailey and
+ Matt Bernhard and Elie Bursztein and Jaime Cochran and
+ Zakir Durumeric and J. Alex Halderman and Luca Invernizzi
+ and Michalis Kallitsis and Deepak Kumar and Chaz Lever and
+ Zane Ma and Joshua Mason and Damian Menscher and Chad
+ Seaman and Nick Sullivan and Kurt Thomas and Yi Zhou},
+ title = {Understanding the Mirai Botnet},
+ booktitle = {26th USENIX Security Symposium (USENIX Security 17)},
+ year = {2017},
+ isbn = {978-1-931971-40-9},
+ address = {Vancouver, BC},
+ pages = {1093--1110},
+ url = {https://www.usenix.org/conference/usenixsecurity17/technical-sessions/presentation/antonakakis},
+ publisher = {USENIX Association},
+ month = aug
+}
+
+@InProceedings{ herwig_measurement_2019,
+ address = {San Diego, CA, USA},
+ title = {Measurement and {Analysis} of {Hajime}, a {Peer}-to-peer
+ {IoT} {Botnet}},
+ isbn = {1-891562-55-X},
+ url = {https://par.nsf.gov/biblio/10096257},
+ doi = {10.14722/ndss.2019.23488},
+ booktitle = {Network and {Distributed} {Systems} {Security} ({NDSS})
+ {Symposium} 2019},
+ author = {Herwig, Stephen and Harvey, Katura and Hughey, George and
+ Roberts, Richard and Levin, Dave},
+ year = {2019},
+ pages = {15},
+ file = {Herwig et al. - Measurement and Analysis of Hajime, a
+ Peer-to-peer.pdf:/home/mrl/.local/share/zotero/storage/YFB8C8CU/Herwig
+ et al. - Measurement and Analysis of Hajime, a
+ Peer-to-peer.pdf:application/pdf}
+}
+
+@PhDThesis{ wijkhuizen_security_2018,
+ address = {Nijmegen},
+ type = {Bachelor's {Thesis}},
+ title = {Security analysis of the {iTasks} framework},
+ url = {http://www.ru.nl/publish/pages/769526/arjan_oortgiese.pdf},
+ language = {English},
+ urldate = {2017-04-08},
+ school = {Radboud University},
+ author = {Wijkhuizen, Mark},
+ year = {2018},
+ file = {Wijkhuizen - 2018 - Security analysis of the iTasks
+ framework.pdf:/home/mrl/.local/share/zotero/storage/AWFT6PGL/Wijkhuizen
+ - 2018 - Security analysis of the iTasks
+ framework.pdf:application/pdf}
+}
+
+@InProceedings{ steenvoorden2019tophat,
+ author = {Steenvoorden, Tim and Naus, Nico and Klinik, Markus},
+ title = {TopHat: A Formal Foundation for Task-Oriented
+ Programming},
+ year = {2019},
+ isbn = {9781450372497},
+ publisher = {Association for Computing Machinery},
+ address = {New York, NY, USA},
+ doi = {10.1145/3354166.3354182},
+ booktitle = {Proceedings of the 21st International Symposium on
+ Principles and Practice of Declarative Programming},
+ articleno = {17},
+ numpages = {13},
+ location = {Porto, Portugal},
+ series = {PPDP '19}
+}
Some \gls{TOP} languages were created to fill a gap encountered in practise.
Toppyt \citep{lijnse_toppyt_2022} is a general purpose \gls{TOP} language written in \gls{PYTHON} used to host frameworks for modelling command \& control systems, and hTask \citep{lubbers_htask_2022}, a vessel for experimenting with asynchronous \glspl{SDS}.
Furthermore, some \gls{TOP} systems arose from Master's and Bachelor's thesis projects.
-For example, \textmu{}Task \citep{piers_task-oriented_2016}, a \gls{TOP} language for modelling non-interruptible embedded systems in \gls{HASKELL}, and LTasks \citep{van_gemert_task_2022}, a \gls{TOP} language written in the dynamically typed programming language {LUA}.
+For example, \textmu{}Task \citep{piers_task-oriented_2016}, a \gls{TOP} language for modelling non-interruptible embedded systems in \gls{HASKELL}, and LTasks \citep{van_gemert_task_2022}, a \gls{TOP} language written in the dynamically typed programming language Lua.
Finally, there are \gls{TOP} languages with strong academic foundations.
\Gls{TOPHAT} is a fully formally specified \gls{TOP} language designed to capture the essence of \gls{TOP} \citep{steenvoorden_tophat_2019}.
Such a formal specification allows for symbolic execution, hint generation, but also the translation to \gls{ITASK} for actually performing the work \citep{steenvoorden_tophat_2022}.
The \gls{MTASK} system is an \gls{EDSL} and during the development of it, several novel basal techniques for embedding \glspl{DSL} in \gls{FP} languages have been found.
This paper-based episode contains the following papers:
\begin{enumerate}
- \item \emph{Deep Embedding with Class} \citep{lubbers_deep_2022} is the basis for \cref{chp:classy_deep_embedding}.
+ \item \emph{Deep Embedding with Class} \citep*{lubbers_deep_2022} is the basis for \cref{chp:classy_deep_embedding}.
It shows a novel deep embedding technique for \glspl{DSL} where the resulting language is extendible both in constructs and in interpretation just using type classes and existential data types.
The related work section is updated with the research found after publication.
\Cref{sec:classy_reprise} was added after publication and contains a (yet) unpublished extension of the embedding technique for reducing the required boilerplate at the cost of requiring some advanced type system extensions.
- \item \emph{First-\kern-1ptClass Data Types in Shallow Embedded Domain-Specific Languages} \citep{lubbers_first-class_2022}\label{enum:first-class} is the basis for \cref{chp:first-class_datatypes}.
+ \item \emph{First-\kern-1ptClass Data Types in Shallow Embedded Domain-Specific Languages} \citep*{lubbers_first-class_2022}\label{enum:first-class} is the basis for \cref{chp:first-class_datatypes}.
It shows how to inherit data types from the host language in \glspl{EDSL} using metaprogramming by providing a proof-of-concept implementation using \gls{HASKELL}'s metaprogramming system: \glsxtrlong{TH}.
The paper also serves as a gentle introduction to, and contains a thorough literature study on \glsxtrlong{TH}.
\end{enumerate}
It is compiled from the following publications:
\begin{enumerate}[resume]
- \item \emph{A Task-\kern-1.25ptBased \glsxtrshort{DSL} for Microcomputers} \citep{koopman_task-based_2018}
+ \item \emph{A Task-\kern-1.25ptBased \glsxtrshort{DSL} for Microcomputers} \citep*{koopman_task-based_2018}
is the initial \gls{TOP}\slash{}\gls{MTASK} paper.
It provides an overview of the initial \gls{TOP} \gls{MTASK} language and shows first versions of some interpretations.
- \item \emph{Task Oriented Programming for the Internet of Things} \citep{lubbers_task_2018}\footnotetext{This work is an extension of my Master's thesis \citep{lubbers_task_2017}.}
+ \item \emph{Task Oriented Programming for the Internet of Things} \citep*{lubbers_task_2018}\footnote{This work is an extension of my Master's thesis \citep{lubbers_task_2017}.}
shows how a simple imperative variant of \gls{MTASK} was integrated with \gls{ITASK}.
While the language differs a lot from the current version, the integration mechanism is still used.
% \paragraph{Contribution}
% The research in this paper and writing the paper was performed by me, though there were weekly meetings with Pieter Koopman and Rinus Plasmeijer in which we discussed and refined the ideas.
- \item \emph{Multitasking on Microcontrollers using Task Oriented Programming} \citep{lubbers_multitasking_2019}\footnote{This work acknowledges the support of the \erasmusplus{} project ``Focusing Education on Composability, Comprehensibility and Correctness of Working Software'', no.\ 2017--1--SK01--KA203--035402.}
+ \item \emph{Multitasking on Microcontrollers using Task Oriented Programming} \citep*{lubbers_multitasking_2019}\footnote{This work acknowledges the support of the \erasmusplus{} project ``Focusing Education on Composability, Comprehensibility and Correctness of Working Software'', no.\ 2017--1--SK01--KA203--035402.}
is a short paper on the multitasking capabilities of \gls{MTASK} comparing it to traditional multitasking methods for \gls{ARDUINO}.
% \paragraph{Contribution}
% The research in this paper and writing the paper was performed by me, though there were weekly meetings with Pieter Koopman and Rinus Plasmeijer.
- \item \emph{Simulation of a Task-\kern-1.25ptBased Embedded Domain Specific Language for the Internet of Things} \citep{koopman_simulation_2023}\footnotemark[\value{footnote}]
+ \item \emph{Simulation of a Task-\kern-1.25ptBased Embedded Domain Specific Language for the Internet of Things} \citep*{koopman_simulation_2023}\footnotemark[\value{footnote}]
are the revised lecture notes for a course on the \gls{MTASK} simulator provided at the 2018 \gls{CEFP}\slash{}\gls{3COWS} winter school in Ko\v{s}ice, Slovakia, January 22--26, 2018.
% \paragraph{Contribution}
% Pieter Koopman wrote and taught it, I helped with the software and research.
- \item \emph{Writing Internet of Things Applications with Task Oriented Programming} \citep{lubbers_writing_2023}\footnotemark[\value{footnote}]
+ \item \emph{Writing Internet of Things Applications with Task Oriented Programming} \citep*{lubbers_writing_2023}\footnotemark[\value{footnote}]
are the revised lecture notes from a course on programming \gls{IOT} systems using \gls{MTASK} provided at the 2019 \gls{CEFP}\slash{}\gls{3COWS} summer school in Budapest, Hungary, June 17--21, 2019.
% \paragraph{Contribution}
% Pieter Koopman prepared and taught half of the lecture and supervised the practical session.
% I taught the other half of the lecture, wrote the lecture notes, made the assignments and supervised the practical session.
- \item \emph{Interpreting Task Oriented Programs on Tiny Computers} \citep{lubbers_interpreting_2019}
+ \item \emph{Interpreting Task Oriented Programs on Tiny Computers} \citep*{lubbers_interpreting_2019}
shows an implementation of the byte code compiler and \gls{RTS} of \gls{MTASK}.
% \paragraph{Contribution}
% The research in this paper and writing the paper was performed by me, though there were weekly meetings with Pieter Koopman and Rinus Plasmeijer.
- \item \emph{Reducing the Power Consumption of IoT with Task-Oriented Programming} \citep{crooijmans_reducing_2022}
+ \item \emph{Reducing the Power Consumption of IoT with Task-Oriented Programming} \citep*{crooijmans_reducing_2022}
shows how to create a scheduler so that devices running \gls{MTASK} tasks can go to sleep more automatically and how interrupts are incorporated in the language.
% \paragraph{Contribution}
% The research was carried out by \citet{crooijmans_reducing_2021} during his Master's thesis.
% I did the daily supervision and helped with the research, Pieter Koopman was the formal supervisor and wrote most of the paper.
- \item \emph{Green Computing for the Internet of Things} \citep{lubbers_green_2022}\footnote{This work acknowledges the support of the \erasmusplus{} project ``SusTrainable---Promoting Sustainability as a Fundamental Driver in Software Development Training and Education'', no.\ 2020--1--PT01--KA203--078646.}
+ \item \emph{Green Computing for the Internet of Things} \citep*{lubbers_green_2022}\footnote{This work acknowledges the support of the \erasmusplus{} project ``SusTrainable---Promoting Sustainability as a Fundamental Driver in Software Development Training and Education'', no.\ 2020--1--PT01--KA203--078646.}
are the revised lecture notes from a course on sustainable \gls{IOT} programming with \gls{MTASK} provided at the 2022 SusTrainable summer school in Rijeka, Croatia, July 4--8, 2022.
% \paragraph{Contribution}
\Cref{prt:tvt} is based on a journal paper that quantitatively and qualitatively compares traditional \gls{IOT} architectures with \gls{TOP} \gls{IOT} architectures.
This chapter is based on the conference paper and a journal paper extending it:
\begin{enumerate}[resume]
- \item \emph{Tiered versus Tierless \glsxtrshort{IOT} Stacks: Comparing Smart Campus Software Architectures} \citep{lubbers_tiered_2020}\footnote{This work was partly funded by the 2019 Radboud-Glasgow Collaboration Fund.}\label{enum:iot20} compares traditional tiered programming to tierless architectures by comparing two implementations of a smart-campus application.
- \item \emph{Could Tierless Programming Reduce IoT Development Grief?} \citep{lubbers_could_2022}
+ \item \emph{Tiered versus Tierless \glsxtrshort{IOT} Stacks: Comparing Smart Campus Software Architectures} \citep*{lubbers_tiered_2020}\footnote{This work was partly funded by the 2019 Radboud-Glasgow Collaboration Fund.}\label{enum:iot20} compares traditional tiered programming to tierless architectures by comparing two implementations of a smart-campus application.
+ \item \emph{Could Tierless Programming Reduce IoT Development Grief?} \citep*{lubbers_could_2022}
is an extended version of paper~\ref{enum:iot20}.
It compares programming traditional tiered architectures to tierless architectures by illustrating a qualitative and a quantitative four-way comparison of a smart-campus application.
\end{enumerate}
% Graphics
\input{preamble/graphics}
-% Crossreferences, hyperlinks and metadata
+% Crossreferences, urls and hyperlinks
\input{preamble/crossref}
% Glossaries and acronyms
% File structure, this must be last of the preamble
\usepackage{subfiles}
-% Metadata (only works in main document)
-\ifSubfilesClassLoaded{}{
- \usepackage{xmpincl}
- \includexmp{CC_Attribution-NoDerivatives_4.0_International}
-}
+% Metadata (only works in main document) and should go after subfiles
+\input{preamble/metadata}
%\setcitestyle{numbers}
%\bibliographystyle{alpha}
\bibliographystyle{abbrvnat}
-%\apptocmd{\thebibliography}{\raggedright}{}{}
-\usepackage{bibentry} % Cite bib entry completely
-\nobibliography*
-\newcommand{\citeentry}[1]{\begin{NoHyper}\bibentry{#1}\end{NoHyper}. \citep{#1}}
+\apptocmd{\thebibliography}{\raggedright}{}{}
+
+\makeatletter
+\let\saved@bibitem\@bibitem%
+\makeatother
+
\newcommand{\refurl}[2]{\url{#1}, accessed on: #2}
\makeatletter
\usepackage[hyphens]{url}
-\usepackage[pdflang={en-GB},pagebackref,breaklinks]{hyperref} % hyperlinks
+\usepackage[pdflang={en-GB},pagebackref,breaklinks,plainpages=false]{hyperref} % hyperlinks
\usepackage{xr} % hyperlinks
\renewcommand*{\backref}[1]{}
\renewcommand*{\backrefalt}[4]{[{%
}
\newglossaryentry{FREERTOS}{
name=FreeRTOS,
- description={- an open-source \gls{RTOS} for microcontrollers}
+ description={- an open-source \glsxtrshort{RTOS} for microcontrollers}
}
\newglossaryentry{ONEWIRE}{
name=1-wire,
+% chktex-file 15
+% chktex-file 9
+% chktex-file 17
\usepackage{geometry}
\geometry{
inner=25mm,
\let\titlesec@part\part%
\renewcommand{\part}{\@ifstar\part@star\part@nostar}
\def\part@star#1{\NR@gettitle{#1}\titlesec@part*{#1}}
-\def\part@nostar{\@ifnextchar[\part@nostar@opt\part@nostar@nopt} % chktex 9
+\def\part@nostar{\@ifnextchar[\part@nostar@opt\part@nostar@nopt}
\def\part@nostar@nopt#1{\NR@gettitle{#1}\titlesec@part{#1}}
\def\part@nostar@opt[#1]#2{\NR@gettitle{#1}\titlesec@part[#1]{#2}}
\makeatother
--- /dev/null
+\ifSubfilesClassLoaded{}{
+ \usepackage{xmpincl}
+ \includexmp{preamble/CC_Attribution-NoDerivatives_4.0_International}
+}
\usepackage{relsize} % \smaller command
\usepackage{xcolor} % colors
\usepackage{fnpct} % footnotekerning
-\usepackage[all]{nowidow} % Kill widows and orphans
+%\usepackage[all]{nowidow} % Kill widows and orphans
\usepackage{siunitx} % typeset units
\DeclareSIUnit\noop{\relax}
\ifSubfilesClassLoaded{%
\backmatter%
- \bibliography{../other,../self,../tiot}
+ \bibliography{../bib/other,../bib/self,../bib/tiot}
\begingroup%
\let\cleardoublepage\clearpage
\printglossary[style=mcolindex]%
\date{\mydate}
\begin{document}
+\begingroup
+\makeatletter
+\let\@bibitem\saved@bibitem%
+\endgroup
+
\selectlanguage{british}
\frontmatter%
\phantomsection{}%
\label{chp:bibliography}
\addcontentsline{toc}{chapter}{Bibliography}
-\bibliography{other,self,tiot}
+\bibliography{bib/other,bib/self,bib/tiot}
% Summary
\subfile{back/summary}
+++ /dev/null
-@article{sethi2017internet,
- title={Internet of things: architectures, protocols, and applications},
- author={Sethi, Pallavi and Sarangi, Smruti R},
- journal={Journal of Electrical and Computer Engineering},
- volume={2017},
- year={2017},
- publisher={Hindawi}
-}
-
-@inproceedings{muccini2018iot,
-author="Muccini, Henry and Moghaddam, Mahyar Tourchi",
-editor="Cuesta, Carlos E. and Garlan, David and P{\'e}rez, Jennifer",
-title="IoT Architectural Styles",
-booktitle="Software Architecture",
-year="2018",
-publisher="Springer International Publishing",
-address="Cham",
-pages="68--85",
-abstract="IoT components are becoming more and more ubiquitous. Thus, the necessity of architecting IoT applications is bringing a substantial attention towards software engineering community. On this occasion, different styles and patterns can facilitate shaping the IoT architectural characteristics. This study aims at defining, identifying, classifying, and re-designing a class of IoT styles and patterns at the architectural level. Conforming a systematic mapping study (SMS) selection procedure, we picked out 63 papers among over 2,300 candidate studies. To this end, we applied a rigorous classification and extraction framework to select and analyze the most influential domain-related information. Our analysis revealed the following main findings: (i) facing by various architectural styles that attempted to address various aspects of IoT systems, cloud and fog are discerned as their most important components. (ii) distributed patterns are not widely discussed for IoT architecture, however, there is foreseen a grow specially for their industrial applications. (iii) starting from the last few years on, there is still a growing scientific interest on IoT architectural styles. This study gives a solid foundation for classifying existing and future approaches for IoT styles beneficial for academic and industrial researchers. It provides a set of abstract IoT reference architectures to be applicable on various architectural styles.",
-isbn="978-3-030-00761-4"
-}
-
-@inproceedings{rosenberg1997some,
- title={Some misconceptions about lines of code},
- author={Rosenberg, Jarrett},
- booktitle={Proceedings fourth international software metrics symposium},
- pages={137--142},
- year={1997},
- organization={IEEE},
- publisher={IEEE},
- doi={10.1109/METRIC.1997.637174},
-address={Albuquerque, NM, USA}
-}
-
-@inproceedings{cooper2006links,
- address = {Berlin, Heidelberg},
- title = {Links: {Web} {Programming} {Without} {Tiers}},
- isbn = {978-3-540-74792-5},
- abstract = {Links is a programming language for web applications that generates code for all three tiers of a web application from a single source, compiling into JavaScript to run on the client and into SQL to run on the database. Links supports rich clients running in what has been dubbed `Ajax' style, and supports concurrent processes with statically-typed message passing. Links is scalable in the sense that session state is preserved in the client rather than the server, in contrast to other approaches such as Java Servlets or PLT Scheme. Client-side concurrency in JavaScript and transfer of computation between client and server are both supported by translation into continuation-passing style.},
- booktitle = {Formal {Methods} for {Components} and {Objects}},
- publisher = {Springer Berlin Heidelberg},
- author = {Cooper, Ezra and Lindley, Sam and Wadler, Philip and Yallop, Jeremy},
- editor = {de Boer, Frank S. and Bonsangue, Marcello M. and Graf, Susanne and de Roever, Willem-Paul},
- year = {2007},
- pages = {266--296}
-}
-
-@inproceedings{serrano2006hop,
- title={Hop: a language for programming the web 2.0},
- author={Serrano, Manuel and Gallesio, Erick and Loitsch, Florian},
- booktitle={OOPSLA Companion},
- pages={975--985},
- year={2006},
- publisher={ACM},
- address={Portland, Oregon, USA},
-}
-
-@inproceedings{lloyd1994practical,
- title={Practical Advtanages of Declarative Programming.},
- author={Lloyd, John W},
- booktitle={GULP-PRODE (1)},
- pages={18--30},
- year={1994}
-}
-
-@online{singer16,
-author ={Jeremy Singer, Dejice Jacob, Kristian Hentschel},
-year = {2016},
-title ={Anyscale Sensors},
-url ={https://bitbucket.org/jsinger/anyscale-sensors/src/master/Readme.md},
-month ={Apr},
-lastaccessed ={April 1, 2016},
-}
-
-@article{pechtchanski2005immutability,
- title={Immutability specification and its applications},
- author={Pechtchanski, Igor and Sarkar, Vivek},
- journal={Concurrency and Computation: Practice and Experience},
- volume={17},
- number={5-6},
- pages={639--662},
- year={2005},
- publisher={Wiley Online Library}
-}
-
-@inproceedings{steiner_firmata_2009,
- title = {Firmata: {Towards} {Making} {Microcontrollers} {Act} {Like} {Extensions} of the {Computer}.},
- booktitle = {{NIME}},
- author = {Steiner, Hans-Christoph},
- year = {2009},
- pages = {125--130},
-}
-
-@article{levis_mate_2002,
- title = {Maté: {A} tiny virtual machine for sensor networks},
- volume = {37},
- number = {10},
- journal = {ACM Sigplan Notices},
- author = {Levis, Philip and Culler, David},
- year = {2002},
- publisher = {ACM},
- pages = {85--95},
- file = {Levis and Culler - Matd A Tiny Virtual Machine for Sensor Networks.pdf:/home/mrl/.local/share/zotero/storage/RMPGY9NI/Levis and Culler - Matd A Tiny Virtual Machine for Sensor Networks.pdf:application/pdf}
-}
-
-@inproceedings{gill_remote_2015,
-author = {Gill, Andy and Sculthorpe, Neil and Dawson, Justin and Eskilson, Aleksander and Farmer, Andrew and Grebe, Mark and Rosenbluth, Jeffrey and Scott, Ryan and Stanton, James},
-title = {The Remote Monad Design Pattern},
-year = {2015},
-doi = {10.1145/2804302.2804311},
-booktitle = {Proceedings of the 2015 ACM SIGPLAN Symposium on Haskell},
-pages = {59–70},
-}
-
-@article{light2017mosquitto,
- title={Mosquitto: server and client implementation of the MQTT protocol},
- author={Light, Roger},
- journal={Journal of Open Source Software},
- volume={2},
- number={13},
- pages={265},
- year={2017}
-}
-
-@article{adl2006compiler,
- title={Compiler and runtime support for efficient software transactional memory},
- author={Adl-Tabatabai, Ali-Reza and Lewis, Brian T and Menon, Vijay and Murphy, Brian R and Saha, Bratin and Shpeisman, Tatiana},
- journal={ACM SIGPLAN Notices},
- volume={41},
- number={6},
- pages={26--37},
- year={2006},
- publisher={ACM}
-}
-
-@inproceedings{schwarz2002disassembly,
- title={Disassembly of executable code revisited},
- author={Schwarz, Benjamin and Debray, Saumya and Andrews, Gregory},
- booktitle={Ninth Working Conference on Reverse Engineering, 2002. Proceedings.},
- pages={45--54},
- year={2002},
- organization={IEEE}
-}
-
-@article{hughes1989functional,
- title={Why functional programming matters},
- author={Hughes, John},
- journal={The computer journal},
- volume={32},
- number={2},
- pages={98--107},
- year={1989},
- publisher={Oxford University Press}
-}
-
-@article{davidson2018expressiveness,
- title={Expressiveness, meanings and machines},
- author={Davidson, Joe and Michaelson, Greg},
- journal={Computability},
- volume={7},
- number={4},
- pages={367--394},
- year={2018},
- publisher={IOS Press}
-}
-
-@inproceedings{troyer_building_2018,
- title = {Building {IoT} {Systems} {Using} {Distributed} {First}-{Class} {Reactive} {Programming}},
- booktitle = {2018 {IEEE} {International} {Conference} on {Cloud} {Computing} {Technology} and {Science} ({CloudCom})},
- author = {Troyer, de, Christophe and Nicolay, Jens and Meuter, de, Wolfgang},
- month = dec,
- year = {2018},
- pages = {185--192},
- publisher = {IEEE},
- address = {Nicosia, Cyprus},
-}
-
-@article{harth_predictive_2018,
- author = {Natascha Harth and Christos Anagnostopoulos and Dimitrios Pezaros},
- title = {Predictive intelligence to the edge: impact on edge analytics},
- journal = {Evolving Systems},
- volume = {9},
- number = {2},
- pages = {95--118},
- year = {2018},
-}
-
-@inproceedings{naik2017choice,
- title={Choice of effective messaging protocols for IoT systems: MQTT, CoAP, AMQP and HTTP},
- author={Naik, Nitin},
- booktitle={2017 IEEE international systems engineering symposium (ISSE)},
- pages={1--7},
- year={2017},
- organization={IEEE}
-}
-
-@book{guinard_building_2016,
- address = {USA},
- edition = {1st},
- title = {Building the {Web} of {Things}: {With} {Examples} in {Node}.{Js} and {Raspberry} {Pi}},
- isbn = {1-61729-268-0},
- publisher = {Manning Publications Co.},
- author = {Guinard, Dominique and Trifa, Vlad},
- year = {2016}
-}
-@article{maccormack2007impact,
- title={The impact of component modularity on design evolution: Evidence from the software industry},
- author={MacCormack, Alan and Rusnak, John and Baldwin, Carliss Y},
- journal={Harvard Business School Technology \& Operations Mgt. Unit Research Paper},
- number={038},
- volume={08},
- year={2007},
- month={dec},
- doi={10.2139/ssrn.1071720},
-}
-
-
-@inproceedings{belle2013layered,
- address = {Boston, MA, USA},
- title = {The layered architecture revisited: {Is} it an optimization problem?},
- volume = {1},
- isbn = {978-1-5108-4159-8},
- shorttitle = {{SEKE} 2013},
- booktitle = {Proceedings of the {Twenty}-{Fifth} {International} {Conference} on {Software} {Engineering} \& {Knowledge} {E}},
- publisher = {KSI Research Inc},
- author = {Belle, Alvine Boaye and El-Boussaidi, Ghizlane and Desrosiers, Christian and Mili, Hafedh},
- year = {2013},
- pages = {344--349}
-}
-
-@inproceedings{lee2001component,
- title={Component identification method with coupling and cohesion},
- author={Lee, Jong Kook and Jung, Seung Jae and Kim, Soo Dong and Jang, Woo Hyun and Ham, Dong Han},
- booktitle={Proceedings Eighth Asia-Pacific Software Engineering Conference},
- pages={79--86},
- year={2001},
- organization={IEEE},
- publisher={IEEE},
- address={Macao, China},
-}
-
-@article{antoniu2007combining,
- title={Combining data sharing with the master--worker paradigm in the common component architecture},
- author={Antoniu, Gabriel and Bouziane, Hinde Lilia and Jan, Mathieu and P{\'e}rez, Christian and Priol, Thierry},
- journal={Cluster Computing},
- volume={10},
- number={3},
- pages={265--276},
- year={2007},
- publisher={Springer}
-}
-
-@inproceedings{grgic2016web,
- title={A web-based IoT solution for monitoring data using MQTT protocol},
- author={Grgi{\'c}, Kre{\v{s}}imir and {\v{S}}peh, Ivan and He{\dj}i, Ivan},
- booktitle={2016 international conference on smart systems and technologies (SST)},
- pages={249--253},
- year={2016},
- organization={IEEE}
-}
-
-@inproceedings{athanasopoulos2006interoperability,
- title={Interoperability among heterogeneous services},
- author={Athanasopoulos, George and Tsalgatidou, Aphrodite and Pantazoglou, Michael},
- booktitle={2006 IEEE International Conference on Services Computing (SCC'06)},
- pages={174--181},
- year={2006},
- organization={IEEE}
-}
-
-@article{mazzei2018full,
- title={A full stack for quick prototyping of IoT solutions},
- author={Mazzei, Daniele and Baldi, Giacomo and Montelisciani, Gabriele and Fantoni, Gualtiero},
- journal={Annals of Telecommunications},
- volume={73},
- number={7-8},
- pages={439--449},
- year={2018},
- publisher={Springer}
-}
-
-@article{barrett2015fine,
- title={Fine-grained language composition: A case study},
- author={Barrett, Edd and Bolz, Carl Friedrich and Diekmann, Lukas and Tratt, Laurence},
- journal={arXiv preprint arXiv:1503.08623},
- year={2015}
-}
-
-@inproceedings{patwardhan2004communication,
- title={Communication breakdown: analyzing cpu usage in commercial web workloads},
- author={Patwardhan, Jaidev P and Lebeck, Alvin R and Sorin, Daniel J},
- booktitle={IEEE International Symposium on-ISPASS Performance Analysis of Systems and Software, 2004},
- pages={12--19},
- year={2004},
- organization={IEEE}
-}
-
-@inproceedings{cooper2008essence,
- title={The essence of form abstraction},
- author={Cooper, Ezra and Lindley, Sam and Wadler, Philip and Yallop, Jeremy},
- booktitle={Asian Symposium on Programming Languages and Systems},
- pages={205--220},
- year={2008},
- organization={Springer}
-}
-
-@article{rinard2003credible,
- title={Credible compilation},
- author={Rinard, Martin C},
- year={2003}
-}
-
-@inproceedings{bucur2014prototyping,
- title={Prototyping symbolic execution engines for interpreted languages},
- author={Bucur, Stefan and Kinder, Johannes and Candea, George},
- booktitle={Proceedings of the 19th international conference on Architectural support for programming languages and operating systems},
- pages={239--254},
- year={2014}
-}
-
-@inproceedings{barany2014python,
- title={Python interpreter performance deconstructed},
- author={Barany, Gerg{\"o}},
- booktitle={Proceedings of the Workshop on Dynamic Languages and Applications},
- pages={1--9},
- year={2014}
-}
-
-@article{mayer2017multi,
- title={On multi-language software development, cross-language links and accompanying tools: a survey of professional software developers},
- author={Mayer, Philip and Kirsch, Michael and Le, Minh Anh},
- journal={Journal of Software Engineering Research and Development},
- volume={5},
- number={1},
- pages={1},
- year={2017},
- publisher={Springer}
-}
-
-@inproceedings{mayer2015empirical,
-author = {Mayer, Philip and Bauer, Alexander},
-title = {An Empirical Analysis of the Utilization of Multiple Programming Languages in Open Source Projects},
-year = {2015},
-isbn = {9781450333504},
-publisher = {Association for Computing Machinery},
-address = {New York, NY, USA},
-doi = {10.1145/2745802.2745805},
-abstract = {Background: Anecdotal evidence suggests that software applications are usually implemented using a combination of (programming) languages. Aim: We want to provide empirical evidence on the phenomenon of multi-language programming. Methods: We use data mining of 1150 open source projects selected for diversity from a public repository to a) investigate the projects for number and type of languages found and the relative sizes of the languages; b) report on associations between the number of languages found and the size, age, number of contributors, and number of commits of a project using a (Quasi-)Poisson regression model, and c) discuss concrete associations between the general-purpose languages and domain-specific languages found using frequent item set mining. Results: We found a) a mean number of 5 languages per project with a clearly dominant main general-purpose language and 5 often-used DSL types, b) a significant influence of the size, number of commits, and the main language on the number of languages as well as no significant influence of age and number of contributors, and c) three language ecosystems grouped around XML, Shell/Make, and HTML/CSS. Conclusions: Multi-language programming seems to be common in open-source projects and is a factor which must be dealt with in tooling and when assessing development and maintenance of such software systems.},
-booktitle = {Proceedings of the 19th International Conference on Evaluation and Assessment in Software Engineering},
-articleno = {4},
-numpages = {10},
-location = {Nanjing, China},
-series = {EASE '15}
-}
-
-@article{avizienis85n,
- author={A. {Avizienis}},
- journal={IEEE Transactions on Software Engineering},
- title={The N-Version Approach to Fault-Tolerant Software},
- year={1985},
- volume={SE-11},
- number={12},
- pages={1491-1501},
- doi={10.1109/TSE.1985.231893}
-}
-
-
-@inproceedings{motta2018challenges,
-author = {Motta, Rebeca C. and de Oliveira, K\'{a}thia M. and Travassos, Guilherme H.},
-title = {On Challenges in Engineering IoT Software Systems},
-year = {2018},
-isbn = {9781450365031},
-publisher = {Association for Computing Machinery},
-address = {New York, NY, USA},
-doi = {10.1145/3266237.3266263},
-abstract = {Contemporary software systems, such as the Internet of Things (IoT), Industry 4.0, and Smart Cities are new technology paradigms that offer challenges for their construction since they are calling into question our traditional form of developing software. They are a promising paradigm for the integration of devices and communications technologies. It is leading to a shift from the classical monolithic view of development where stakeholder receive a software product at the end (that we have been doing for decades), to software systems materialized through physical objects interconnected by networks and with embedded software to support daily activities. We need therefore to revisit our way of developing software systems and start to consider the particularities required by these new sorts of applications. This paper presents research toward the definition of a framework to support the systems engineering of IoT applications, where we evolved the Zachman's Framework as an alternative to the organization of this architecture. The activities were two folded to address this goal: a) we identified leading concerns of IoT applications, recovered from technical literature, practitioners and a Government Report, in different studies; b) we structured the IoT paradigm in different facets. These activities provided 14 significant concerns and seven facets that together represent the engineering challenges to be faced both by research and practice towards the advancement of IoT in practice.},
-booktitle = {Proceedings of the XXXII Brazilian Symposium on Software Engineering},
-pages = {42–51},
-numpages = {10},
-keywords = {challenges, concerns, internet of things, IoT, literature review, empirical software engineering},
-location = {Sao Carlos, Brazil},
-series = {SBES '18}
-}
-
-@article{gubbi2013internet,
- title={Internet of Things (IoT): A vision, architectural elements, and future directions},
- author={Gubbi, Jayavardhana and Buyya, Rajkumar and Marusic, Slaven and Palaniswami, Marimuthu},
- journal={Future generation computer systems},
- volume={29},
- number={7},
- pages={1645--1660},
- year={2013},
- publisher={Elsevier}
-}
-
-@article{guzman2018human,
- title={What is human-machine communication, anyway},
- author={Guzman, Andrea L},
- journal={Human-machine communication: Rethinking communication, technology, and ourselves},
- pages={1--28},
- year={2018},
- publisher={Peter Lang New York}
-}
-
-@article{wan2016software,
- title={Software-defined industrial internet of things in the context of industry 4.0},
- author={Wan, Jiafu and Tang, Shenglong and Shu, Zhaogang and Li, Di and Wang, Shiyong and Imran, Muhammad and Vasilakos, Athanasios V},
- journal={IEEE Sensors Journal},
- volume={16},
- number={20},
- pages={7373--7380},
- year={2016},
- publisher={IEEE}
-}
-
-@article{batory1992design,
- title={The design and implementation of hierarchical software systems with reusable components},
- author={Batory, Don and O'malley, Sean},
- journal={ACM Transactions on Software Engineering and Methodology (TOSEM)},
- volume={1},
- number={4},
- pages={355--398},
- year={1992},
- publisher={ACM New York, NY, USA}
-}
-
-@article{mockus2002two,
- title={Two case studies of open source software development: Apache and Mozilla},
- author={Mockus, Audris and Fielding, Roy T and Herbsleb, James D},
- journal={ACM Transactions on Software Engineering and Methodology (TOSEM)},
- volume={11},
- number={3},
- pages={309--346},
- year={2002},
- publisher={ACM New York, NY, USA}
-}
-
-@inproceedings{le2015microservice,
- title={Microservice-based architecture for the NRDC},
- author={Le, Vinh D and Neff, Melanie M and Stewart, Royal V and Kelley, Richard and Fritzinger, Eric and Dascalu, Sergiu M and Harris, Frederick C},
- booktitle={2015 IEEE 13th International Conference on Industrial Informatics (INDIN)},
- pages={1659--1664},
- year={2015},
- organization={IEEE},
- publisher={IEEE},
- address={Cambridge, UK},
-}
-
-@inproceedings{kodali2016low,
- title={Low cost ambient monitoring using ESP8266},
- author={Kodali, Ravi Kishore and Mahesh, Kopulwar Shishir},
- booktitle={2016 2nd International Conference on Contemporary Computing and Informatics (IC3I)},
- pages={779--782},
- year={2016},
- organization={IEEE},
- publisher={IEEE},
- address={Greater Noida, India}
-}
-
-@article{beaven1993explaining,
- title={Explaining type errors in polymorphic languages},
- author={Beaven, Mike and Stansifer, Ryan},
- journal={ACM Letters on Programming Languages and Systems (LOPLAS)},
- volume={2},
- number={1-4},
- pages={17--30},
- year={1993},
- publisher={ACM New York, NY, USA}
-}
-
-@phdthesis{armstrong2003making,
- title={Making reliable distributed systems in the presence of software errors},
- author={Armstrong, Joe},
- year={2003}
-}
-
-@article{madsen1990strong,
- title={Strong typing of object-oriented languages revisited},
- author={Madsen, Ole Lehrmann and Magnusson, Boris and M{\o}lier-Pedersen, Birger},
- journal={ACM SIGPLAN Notices},
- volume={25},
- number={10},
- pages={140--150},
- year={1990},
- publisher={ACM New York, NY, USA}
-}
-
-@article{cass20182017,
- title={The 2017 top programming languages},
- author={Cass, Stephen},
- journal={IEEE Spectrum},
- volume={31},
- year={2018}
-}
-
-@book{tollervey2017programming,
- title={Programming with MicroPython: Embedded Programming with Microcontrollers and Python},
- author={Tollervey, Nicholas H},
- year={2017},
- publisher={" O'Reilly Media, Inc."}
-}
-
-@inproceedings{alpernaswonderful,
-author = {Alpernas, Kalev and Feldman, Yotam M. Y. and Peleg, Hila},
-title = {The Wonderful Wizard of LoC: Paying Attention to the Man behind the Curtain of Lines-of-Code Metrics},
-year = {2020},
-isbn = {9781450381789},
-publisher = {Association for Computing Machinery},
-address = {New York, NY, USA},
-doi = {10.1145/3426428.3426921},
-abstract = {Lines-of-code metrics (loc) are commonly reported in Programming Languages (PL), Software Engineering (SE), and Systems papers. This convention has several different, often contradictory, goals, including demonstrating the `hardness' of a problem, and demonstrating the `easiness' of a problem. In many cases, the reporting of loc metrics is done not with a clearly communicated intention, but instead in an automatic, checkbox-ticking, manner. In this paper we investigate the uses of code metrics in PL, SE, and System papers. We consider the different goals that reporting metrics aims to achieve, several various domains wherein metrics are relevant, and various alternative metrics and their pros and cons for the different goals and domains. We argue that communicating claims about research software is usually best achieved not by reporting quantitative metrics, but by reporting the qualitative experience of researchers, and propose guidelines for the cases when quantitative metrics are appropriate. We end with a case study of the one area in which lines of code are not the default measurement---code produced by papers' solutions---and identify how measurements offered are used to support an explicit claim about the algorithm. Inspired by this positive example, we call for other cogent measures to be developed to support other claims authors wish to make.},
-booktitle = {Proceedings of the 2020 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software},
-pages = {146–156},
-numpages = {11},
-keywords = {research papers, loc, lines of code},
-location = {Virtual, USA},
-series = {Onward! 2020}
-}
-
-@inproceedings{epstein2011towards,
- author = {Epstein, Jeff and Black, Andrew P. and Peyton Jones, Simon},
- title = {Towards Haskell in the Cloud},
- year = {2011},
- isbn = {9781450308601},
- publisher = {Association for Computing Machinery},
- address = {New York, NY, USA},
- doi = {10.1145/2034675.2034690},
- abstract = {We present Cloud Haskell, a domain-specific language for developing programs for a distributed computing environment. Implemented as a shallow embedding in Haskell, it provides a message-passing communication model, inspired by Erlang, without introducing incompatibility with Haskell's established shared-memory concurrency. A key contribution is a method for serializing function closures for transmission across the network. Cloud Haskell has been implemented; we present example code and some preliminary performance measurements.},
- booktitle = {Proceedings of the 4th ACM Symposium on Haskell},
- pages = {118–129},
- numpages = {12},
- keywords = {message-passing, haskell, erlang},
- location = {Tokyo, Japan},
- series = {Haskell '11}
-}
-
-@book{gupta2012akka,
- title={Akka essentials},
- address={Livery Place, 35 Livery Street, Birmingham B3 2PB, UK},
- author={Gupta, Munish},
- year={2012},
- publisher={Packt Publishing Ltd}
-}
-
-@article{millman2011python,
- title={Python for scientists and engineers},
- author={Millman, K Jarrod and Aivazis, Michael},
- journal={Computing in Science \& Engineering},
- volume={13},
- number={2},
- pages={9--12},
- year={2011},
- publisher={IEEE}
-}
-
-@misc{pyforum,
- title = "Python Official Forum",
- author = "",
- year = "2021",
- note = "https://www.python.org/community/forums/"
-}
-
-@misc{microforum,
- title = "Micropython Official Forum",
- author = "",
- year = "2021",
- note = "https://forum.micropython.org/"
-}
-
-@misc{microdocs,
- title = "Official Micropython Docs",
- author = "",
- year = "2021",
- note = "https://docs.micropython.org/en/latest/"
-}
-
-@misc{ wiki:IO,
- author = "HaskellWiki",
- title = "Introduction to IO --- HaskellWiki{,} ",
- year = "2020",
- url = "https://wiki.haskell.org/index.php?title=Introduction_to_IO&oldid=63493",
- note = "[Online; accessed 19-January-2021]"
-}
-
-@misc{CircuitPython,
- author = {{CircuitPython Team}},
- title = "CircuitPython",
- year = "2022",
- url = "https://circuitpython.org/",
- note = "[Online; accessed 2-March-2022]"
-}
-
-@InProceedings{GenericProgrammingExtensionForClean,
- author = "Alimarine, Artem and Plasmeijer, Rinus",
- editor = "Arts, Thomas and Mohnen, Markus",
- title="A Generic Programming Extension for Clean",
- booktitle="Implementation of Functional Languages",
- year="2002",
- publisher="Springer Berlin Heidelberg",
- address="Berlin, Heidelberg",
- pages="168--185",
- abstract="Generic programming enables the programmer to define functions by induction on the structure of types. Defined once, such a generic function can be used to generate a specialized function for any user defined data type. Several ways to support generic programming in functional languages have been proposed, each with its own pros and cons. In this paper we describe a combination of two existing approaches, which has the advantages of both of them. In our approach overloaded functions with class variables of an arbitrary kind can be defined generically. A single generic definition defines a kind-indexed family of overloaded functions, one for each kind. For instance, the generic mapping function generates an overloaded mapping function for each kind.",
- isbn="978-3-540-46028-2"
-}
-@inproceedings{HinzeGenericFunctionalProgramming,
- author = {Hinze, Ralf},
- title = {A New Approach to Generic Functional Programming},
- year = {2000},
- isbn = {1581131259},
- publisher = {Association for Computing Machinery},
- address = {New York, NY, USA},
- doi = {10.1145/325694.325709},
- abstract = {This paper describes a new approach to generic functional programming, which allows us to define functions generically for all datatypes expressible in Haskell. A generic function is one that is defined by induction on the structure of types. Typical examples include pretty printers, parsers, and comparison functions. The advanced type system of Haskell presents a real challenge: datatypes may be parameterized not only by types but also by type constructors, type definitions may involve mutual recursion, and recursive calls of type constructors can be arbitrarily nested. We show that—despite this complexity—a generic function is uniquely defined by giving cases for primitive types and type constructors (such as disjoint unions and cartesian products). Given this information a generic function can be specialized to arbitrary Haskell datatypes. The key idea of the approach is to model types by terms of the simply typed $\lambda-calculus augmented by a family of recursion operators. While conceptually simple, our approach places high demands on the type system: it requires polymorphic recursion, rank-n types, and a strong form of type constructor polymorphism. Finally, we point out connections to Haskell's class system and show that our approach generalizes type classes in some respects.},
- booktitle = {Proceedings of the 27th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
- pages = {119–132},
- numpages = {14},
- location = {Boston, MA, USA},
- series = {POPL '00}
-}
-@inproceedings{TOP-PPDP12,
- author = {Plasmeijer, Rinus and Lijnse, Bas and Michels, Steffen and Achten, Peter and Koopman, Pieter},
- title = {Task-Oriented Programming in a Pure Functional Language},
- year = {2012},
- isbn = {9781450315227},
- publisher = {Association for Computing Machinery},
- address = {New York, NY, USA},
- doi = {10.1145/2370776.2370801},
- abstract = {Task-Oriented Programming (TOP) is a novel programming paradigm for the construction of distributed systems where users work together on the internet. When multiple users collaborate, they need to interact with each other frequently. TOP supports the definition of tasks that react to the progress made by others. With TOP, complex multi-user interactions can be programmed in a declarative style just by defining the tasks that have to be accomplished, thus eliminating the need to worry about the implementation detail that commonly frustrates the development of applications for this domain. TOP builds on four core concepts: tasks that represent computations or work to do which have an observable value that may change over time, data sharing enabling tasks to observe each other while the work is in progress, generic type driven generation of user interaction, and special combinators for sequential and parallel task composition. The semantics of these core concepts is defined in this paper. As an example we present the iTask3 framework, which embeds TOP in the functional programming language Clean.},
- booktitle = {Proceedings of the 14th Symposium on Principles and Practice of Declarative Programming},
- pages = {195–206},
- numpages = {12},
- keywords = {task-oriented programming, clean},
- location = {Leuven, Belgium},
- series = {PPDP '12}
-}
-@inproceedings{
- TOP-ICFP07,
- author = {Plasmeijer, Rinus and Achten, Peter and Koopman, Pieter},
- title = {{iTasks}: {E}xecutable {S}pecifications of {I}nteractive {W}ork {F}low {S}ystems for the {W}eb},
- booktitle = {{P}roceedings of the 12th {ACM SIGPLAN} {I}nternational {C}onference on {F}unctional {P}rogramming ({ICFP} 2007)},
- address = {{F}reiburg, {G}ermany},
- year = 2007,
- month = {Oct 1--3},
- publisher = {ACM},
- isbn = "978-1-59593-815-2",
- pages = {141-152}
-}
-@article{FinallyTagless,
- author = {Jacques Carette and Oleg Kiselyov and Chung{-}chieh Shan},
- title = {Finally tagless, partially evaluated: Tagless staged interpreters
- for simpler typed languages},
- journal = {J. Funct. Program.},
- volume = {19},
- number = {5},
- pages = {509--543},
- year = {2009},
- url = {https://doi.org/10.1017/S0956796809007205},
- doi = {10.1017/S0956796809007205},
- timestamp = {Sun, 02 Jun 2019 21:00:12 +0200},
- biburl = {https://dblp.org/rec/journals/jfp/CaretteKS09.bib},
- bibsource = {dblp computer science bibliography, https://dblp.org}
-}
-
-@inproceedings{oortgiese_distributed_2017,
- title = {A {Distributed} {Dynamic} {Architecture} for {Task} {Oriented} {Programming}},
- booktitle = {Proceedings of the 29th {Symposium} on {Implementation} and {Application} of {Functional} {Programming} {Languages}},
- publisher = {ACM},
- author = {Oortgiese, Arjan and van Groningen, John and Achten, Peter and Plasmeijer, Rinus},
- year = {2017},
- pages = {7},
- address = {Bristol, UK}
-}
-
-@inproceedings{stefik14programming,
- author = {Stefik, Andreas and Hanenberg, Stefan},
- title = {The Programming Language Wars: Questions and Responsibilities for the Programming Language Community},
- year = {2014},
- doi = {10.1145/2661136.2661156},
- booktitle = {Proceedings of the 2014 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming \& Software},
- pages = {283--299},
-}
-
-@inproceedings{ParametricLenses,
- author = {Domoszlai, L\'{a}szl\'{o} and Lijnse, Bas and Plasmeijer, Rinus},
- title = {Parametric Lenses: Change Notification for Bidirectional Lenses},
- year = {2014},
- isbn = {9781450332842},
- publisher = {Association for Computing Machinery},
- address = {New York, NY, USA},
- doi = {10.1145/2746325.2746333},
- abstract = {Most complex applications inevitably need to maintain dependencies between subsystems based on some shared data. The dependent parts must be informed that the shared information is changed. As every actual notification has some communication cost, and every triggered task has associated computation cost, it is crucial for the overall performance of the application to reduce the number of notifications as much as possible. To achieve this, one must be able to define, with arbitrary precision, which party is depending on which data. In this paper we offer a general solution to this general problem. The solution is based on an extension to bidirectional lenses, called parametric lenses. With the help of parametric lenses one can define compositional parametric views in a declarative way to access some shared data. Parametric views, besides providing read/write access to the shared data, also enable to observe changes of some parts, given by an explicit parameter, the focus domain. The focus domain can be specified as a type-based query language defined over one or more resources using predefined combinators of parametric views.},
- booktitle = {Proceedings of the 26th International Symposium on Implementation and Application of Functional Languages},
- articleno = {9},
- numpages = {11},
- keywords = {notification systems, parametric views, lenses, parametric lenses, Bi-directional programming},
- location = {Boston, MA, USA},
- series = {IFL '14}
-}
-
-@article{10.1145/1543134.1411301,
- author = {Rodriguez, Alexey and Jeuring, Johan and Jansson, Patrik and Gerdes, Alex and Kiselyov, Oleg and Oliveira, Bruno C. d. S.},
- title = {Comparing Libraries for Generic Programming in Haskell},
- year = {2008},
- issue_date = {February 2009},
- publisher = {Association for Computing Machinery},
- address = {New York, NY, USA},
- volume = {44},
- number = {2},
- issn = {0362-1340},
- doi = {10.1145/1543134.1411301},
- abstract = {Datatype-generic programming is defining functions that depend on the structure, or "shape", of datatypes. It has been around for more than 10 years, and a lot of progress has been made, in particular in the lazy functional programming language Haskell. There are morethan 10 proposals for generic programming libraries orlanguage extensions for Haskell. To compare and characterise the many generic programming libraries in atyped functional language, we introduce a set of criteria and develop a generic programming benchmark: a set of characteristic examples testing various facets of datatype-generic programming. We have implemented the benchmark for nine existing Haskell generic programming libraries and present the evaluation of the libraries. The comparison is useful for reaching a common standard for generic programming, but also for a programmer who has to choose a particular approach for datatype-generic programming.},
- journal = {SIGPLAN Not.},
- month = sep,
- pages = {111–122},
- numpages = {12},
- keywords = {datatype-generic programming, libraries comparison}
-}
-
-@inproceedings{ComparingGenericProgramming,
- author = {Rodriguez, Alexey and Jeuring, Johan and Jansson, Patrik and Gerdes, Alex and Kiselyov, Oleg and Oliveira, Bruno C. d. S.},
- title = {Comparing Libraries for Generic Programming in Haskell},
- year = {2008},
- isbn = {9781605580647},
- publisher = {Association for Computing Machinery},
- address = {New York, NY, USA},
- doi = {10.1145/1411286.1411301},
- abstract = {Datatype-generic programming is defining functions that depend on the structure, or "shape", of datatypes. It has been around for more than 10 years, and a lot of progress has been made, in particular in the lazy functional programming language Haskell. There are morethan 10 proposals for generic programming libraries orlanguage extensions for Haskell. To compare and characterise the many generic programming libraries in atyped functional language, we introduce a set of criteria and develop a generic programming benchmark: a set of characteristic examples testing various facets of datatype-generic programming. We have implemented the benchmark for nine existing Haskell generic programming libraries and present the evaluation of the libraries. The comparison is useful for reaching a common standard for generic programming, but also for a programmer who has to choose a particular approach for datatype-generic programming.},
- booktitle = {Proceedings of the First ACM SIGPLAN Symposium on Haskell},
- pages = {111–122},
- numpages = {12},
- keywords = {datatype-generic programming, libraries comparison},
- location = {Victoria, BC, Canada},
- series = {Haskell '08}
-}
-
-@InProceedings{ComposingReactiveGUIs,
- author="Bjornson, Joel
- and Tayanovskyy, Anton
- and Granicz, Adam",
- editor="Hage, Jurriaan
- and Moraz{\'a}n, Marco T.",
- title="Composing Reactive GUIs in F{\#} Using WebSharper",
- booktitle="Implementation and Application of Functional Languages",
- year="2011",
- publisher="Springer Berlin Heidelberg",
- address="Berlin, Heidelberg",
- pages="203--216",
- abstract="We present a generic library for constructing composable and interactive user interfaces in a declarative style. The paper introduces flowlets, an extension of formlets[3,2] providing interactivity. Real-world examples are given using the current implementation that compiles flowlets defined in F{\#} to JavaScript with WebSharper.",
- isbn="978-3-642-24276-2"
-}
-
-@inproceedings{FunctionalReactiveAnimation,
- author = {Elliott, Conal and Hudak, Paul},
- title = {Functional Reactive Animation},
- year = {1997},
- isbn = {0897919181},
- publisher = {Association for Computing Machinery},
- address = {New York, NY, USA},
- doi = {10.1145/258948.258973},
- abstract = {Fran (Functional Reactive Animation) is a collection of data types and functions for composing richly interactive, multimedia animations. The key ideas in Fran are its notions of behaviors and events. Behaviors are time-varying, reactive values, while events are sets of arbitrarily complex conditions, carrying possibly rich information. Most traditional values can be treated as behaviors, and when images are thus treated, they become animations. Although these notions are captured as data types rather than a programming language, we provide them with a denotational semantics, including a proper treatment of real time, to guide reasoning and implementation. A method to effectively and efficiently perform event detection using interval analysis is also described, which relies on the partial information structure on the domain of event times. Fran has been implemented in Hugs, yielding surprisingly good performance for an interpreter-based system. Several examples are given, including the ability to describe physical phenomena involving gravity, springs, velocity, acceleration, etc. using ordinary differential equations.},
- booktitle = {Proceedings of the Second ACM SIGPLAN International Conference on Functional Programming},
- pages = {263–273},
- numpages = {11},
- location = {Amsterdam, The Netherlands},
- series = {ICFP '97}
-}
-
-@inproceedings{kochhar2016large,
- author={P. S. {Kochhar} and D. {Wijedasa} and D. {Lo}},
- booktitle={23rd International Conference on Software Analysis, Evolution, and Reengineering},
- title={A Large Scale Study of Multiple Programming Languages and Code Quality},
- year={2016},
- pages={563--573},
- doi={10.1109/SANER.2016.112},
- address={Osaka, Japan},
- publisher={IEEE}
-}
-
-@inproceedings{hao2020approaching,
- author = {Rebecca L. Hao and Elena L. Glassman},
- title = {{Approaching Polyglot Programming: What Can We Learn from Bilingualism Studies?}},
- booktitle = {10th Workshop on Evaluation and Usability of Programming Languages and Tools (PLATEAU 2019)},
- pages = {1:1--1:7},
- year = {2020},
- volume = {76},
- doi = {10.4230/OASIcs.PLATEAU.2019.1},
-}
-
-@article{cass2020top,
- title={The top programming languages: Our latest rankings put Python on top-again-[Careers]},
- author={Cass, Stephen},
- journal={IEEE Spectrum},
- volume={57},
- number={8},
- pages={22--22},
- year={2020},
- publisher={IEEE}
-}
-
-@inproceedings{tanganelli2015coapthon,
- title={CoAPthon: Easy development of CoAP-based IoT applications with Python},
- author={Tanganelli, Giacomo and Vallati, Carlo and Mingozzi, Enzo},
- booktitle={2015 IEEE 2nd World Forum on Internet of Things (WF-IoT)},
- pages={63--68},
- year={2015},
- publisher={IEEE},
- address={Milan, Italy}
-}
-
-@INPROCEEDINGS{Wadler92comprehendingmonads,
-author = {Wadler, Philip},
-title = {Comprehending Monads},
-year = {1990},
-isbn = {089791368X},
-publisher = {Association for Computing Machinery},
-address = {New York, NY, USA},
-doi = {10.1145/91556.91592},
-abstract = {Category theorists invented monads in the 1960's to concisely express certain aspects of universal algebra. Functional programmers invented list comprehensions in the 1970's to concisely express certain programs involving lists. This paper shows how list comprehensions may be generalised to an arbitrary monad, and how the resulting programming feature can concisely express in a pure functional language some programs that manipulate state, handle exceptions, parse text, or invoke continuations. A new solution to the old problem of destructive array update is also presented. No knowledge of category theory is assumed.},
-booktitle = {Proceedings of the 1990 ACM Conference on LISP and Functional Programming},
-pages = {61–78},
-numpages = {18},
-location = {Nice, France},
-series = {LFP '90}
-}
-@misc{smartcampus,
- author = {Mott Macdonald},
- title = "University of Glasgow Smart Campus Digital Masterplan",
- year = "2019",
- note = "\url{https://www.gla.ac.uk/media/Media_702108_smxx.pdf}",
-}
-
-@misc{IIO,
- author = "Bijan Mottahedeh",
- title = "An Introduction to the io XXX uring Asynchronous I/O Framework",
- year = "2020",
- url = "https://blogs.oracle.com/linux/an-introduction-to-the-io XXX uring-asynchronous-io-framework",
- note = "[Online; accessed 13-May-2021]"
-}
-
-@inproceedings{10.1145/1806596.1806601,
-author = {Lee, Byeongcheol and Wiedermann, Ben and Hirzel, Martin and Grimm, Robert and McKinley, Kathryn S.},
-title = {Jinn: Synthesizing Dynamic Bug Detectors for Foreign Language Interfaces},
-year = {2010},
-isbn = {9781450300193},
-publisher = {Association for Computing Machinery},
-address = {New York, NY, USA},
-doi = {10.1145/1806596.1806601},
-abstract = {Programming language specifications mandate static and dynamic analyses to preclude syntactic and semantic errors. Although individual languages are usually well-specified, composing languages is not, and this poor specification is a source of many errors in multilingual programs. For example, virtually all Java programs compose Java and C using the Java Native Interface (JNI). Since JNI is informally specified, developers have difficulty using it correctly, and current Java compilers and virtual machines (VMs) inconsistently check only a subset of JNI constraints.This paper's most significant contribution is to show how to synthesize dynamic analyses from state machines to detect foreign function interface (FFI) violations. We identify three classes of FFI constraints encoded by eleven state machines that capture thousands of JNI and Python/C FFI rules. We use a mapping function to specify which state machines, transitions, and program entities (threads, objects, references) to check at each FFI call and return. From this function, we synthesize a context-specific dynamic analysis to find FFI bugs. We build bug detection tools for JNI and Python/C using this approach. For JNI, we dynamically and transparently interpose the analysis on Java and C language transitions through the JVM tools interface. The resulting tool, called Jinn, is compiler and virtual machine independent. It detects and diagnoses a wide variety of FFI bugs that other tools miss. This approach greatly reduces the annotation burden by exploiting common FFI constraints: whereas the generated Jinn code is 22,000+ lines, we wrote only 1,400 lines of state machine and mapping code. Overall, this paper lays the foundation for a more principled approach to developing correct multilingual software and a more concise and automated approach to FFI specification.},
-booktitle = {Proceedings of the 31st ACM SIGPLAN Conference on Programming Language Design and Implementation},
-pages = {36–49},
-numpages = {14},
-keywords = {dynamic analysis, multilingual programs, foreign function interfaces (FFI), python/C, java native interface (jni), specification, specification generation, ffi bugs},
-location = {Toronto, Ontario, Canada},
-series = {PLDI '10}
-}
-
-
-@article{Jinn
-,
-author = {Lee, Byeongcheol and Wiedermann, Ben and Hirzel, Martin and Grimm, Robert and McKinley, Kathryn S.},
-title = {Jinn: Synthesizing Dynamic Bug Detectors for Foreign Language Interfaces},
-year = {2010},
-issue_date = {June 2010},
-publisher = {Association for Computing Machinery},
-address = {New York, NY, USA},
-volume = {45},
-number = {6},
-issn = {0362-1340},
-doi = {10.1145/1809028.1806601},
-abstract = {Programming language specifications mandate static and dynamic analyses to preclude syntactic and semantic errors. Although individual languages are usually well-specified, composing languages is not, and this poor specification is a source of many errors in multilingual programs. For example, virtually all Java programs compose Java and C using the Java Native Interface (JNI). Since JNI is informally specified, developers have difficulty using it correctly, and current Java compilers and virtual machines (VMs) inconsistently check only a subset of JNI constraints.This paper's most significant contribution is to show how to synthesize dynamic analyses from state machines to detect foreign function interface (FFI) violations. We identify three classes of FFI constraints encoded by eleven state machines that capture thousands of JNI and Python/C FFI rules. We use a mapping function to specify which state machines, transitions, and program entities (threads, objects, references) to check at each FFI call and return. From this function, we synthesize a context-specific dynamic analysis to find FFI bugs. We build bug detection tools for JNI and Python/C using this approach. For JNI, we dynamically and transparently interpose the analysis on Java and C language transitions through the JVM tools interface. The resulting tool, called Jinn, is compiler and virtual machine independent. It detects and diagnoses a wide variety of FFI bugs that other tools miss. This approach greatly reduces the annotation burden by exploiting common FFI constraints: whereas the generated Jinn code is 22,000+ lines, we wrote only 1,400 lines of state machine and mapping code. Overall, this paper lays the foundation for a more principled approach to developing correct multilingual software and a more concise and automated approach to FFI specification.},
-journal = {SIGPLAN Not.},
-month = jun,
-pages = {36–49},
-numpages = {14},
-keywords = {specification generation, specification, python/C, dynamic analysis, multilingual programs, java native interface (jni), foreign function interfaces (FFI), ffi bugs}
-}
-@inproceedings{10.1145/1065010.1065019,
-author = {Furr, Michael and Foster, Jeffrey S.},
-title = {Checking Type Safety of Foreign Function Calls},
-year = {2005},
-isbn = {1595930566},
-publisher = {Association for Computing Machinery},
-address = {New York, NY, USA},
-doi = {10.1145/1065010.1065019},
-abstract = {We present a multi-lingual type inference system for checking type safety across a foreign function interface. The goal of our system is to prevent foreign function calls from introducing type and memory safety violations into an otherwise safe language. Our system targets OCaml's FFI to C, which is relatively lightweight and illustrates some interesting challenges in multi-lingual type inference. The type language in our system embeds OCaml types in C types and vice-versa, which allows us to track type information accurately even through the foreign language, where the original types are lost. Our system uses representational types that can model multiple OCaml types, because C programs can observe that many OCaml types have the same physical representation. Furthermore, because C has a low-level view of OCaml data, our inference system includes a dataflow analysis to track memory offsets and tag information. Finally, our type system includes garbage collection information to ensure that pointers from the FFI to the OCaml heap are tracked properly. We have implemented our inference system and applied it to a small set of benchmarks. Our results show that programmers do misuse these interfaces, and our implementation has found several bugs and questionable coding practices in our benchmarks.},
-booktitle = {Proceedings of the 2005 ACM SIGPLAN Conference on Programming Language Design and Implementation},
-pages = {62–72},
-numpages = {11},
-keywords = {dataflow analysis, multi-lingual type system, representational type, flow-sensitive type system, foreign function interface, FFI, multi-lingual type inference, foreign function calls, OCaml},
-location = {Chicago, IL, USA},
-series = {PLDI '05}
-}
-
-@article{Furr2005,
-author = {Furr, Michael and Foster, Jeffrey S.},
-title = {Checking Type Safety of Foreign Function Calls},
-year = {2005},
-issue_date = {June 2005},
-publisher = {Association for Computing Machinery},
-address = {New York, NY, USA},
-volume = {40},
-number = {6},
-issn = {0362-1340},
-doi = {10.1145/1064978.1065019},
-abstract = {We present a multi-lingual type inference system for checking type safety across a foreign function interface. The goal of our system is to prevent foreign function calls from introducing type and memory safety violations into an otherwise safe language. Our system targets OCaml's FFI to C, which is relatively lightweight and illustrates some interesting challenges in multi-lingual type inference. The type language in our system embeds OCaml types in C types and vice-versa, which allows us to track type information accurately even through the foreign language, where the original types are lost. Our system uses representational types that can model multiple OCaml types, because C programs can observe that many OCaml types have the same physical representation. Furthermore, because C has a low-level view of OCaml data, our inference system includes a dataflow analysis to track memory offsets and tag information. Finally, our type system includes garbage collection information to ensure that pointers from the FFI to the OCaml heap are tracked properly. We have implemented our inference system and applied it to a small set of benchmarks. Our results show that programmers do misuse these interfaces, and our implementation has found several bugs and questionable coding practices in our benchmarks.},
-journal = {SIGPLAN Not.},
-month = jun,
-pages = {62–72},
-numpages = {11},
-keywords = {foreign function calls, multi-lingual type system, OCaml, multi-lingual type inference, flow-sensitive type system, FFI, foreign function interface, dataflow analysis, representational type}
-}
-
-@inproceedings{plamauer2017evaluation,
- title={Evaluation of micropython as application layer programming language on cubesats},
- author={Plamauer, Sebastian and Langer, Martin},
- booktitle={ARCS 2017; 30th International Conference on Architecture of Computing Systems},
- pages={1--9},
- year={2017},
- organization={VDE},
- publisher={VDE},
- address={Vienna, Austria}
-}
-
-@inproceedings{egyed1999automatically,
- title={Automatically detecting mismatches during component-based and model-based development},
- author={Egyed, Alexander and Gacek, Cristina},
- booktitle={14th IEEE International Conference on Automated Software Engineering},
- pages={191--198},
- year={1999},
- organization={IEEE}
-}
-
-@book{Ravulavaru18,
-author = {Ravulavaru, Arvind},
-isbn = {1-78883-378-3},
-language = {eng},
-publisher = {Packt Publishing},
-title = {Enterprise internet of things handbook : build end-to-end IoT solutions using popular IoT platforms},
-year = {2018},
-address = {Birmingham, UK},
-}
-
-@InProceedings{Alphonsa20,
-author="Alphonsa, Mandla",
-editor="Kumar, Amit
-and Mozar, Stefan",
-title="A Review on IOT Technology Stack, Architecture and Its Cloud Applications in Recent Trends",
-booktitle="ICCCE 2020",
-year="2021",
-publisher="Springer Singapore",
-address="Singapore",
-pages="703--711",
-abstract="The Internet of Things (IoT) senses, gather and transmit data over the internet without any human interference. This technology is a mixture of embedded technology, network technology and information technology. On various advancement of huge network and the broadcasting of (IoT), wireless sensored networks are considered to be part of the huge heterogeneous network. IoT architecture is the system of various rudiments like sensored networks, protocol, actuators, cloud service and layers. Internet of Things can also be called as an event-driven model. The IOT device is connected to gateway through Radio Frequency, LORA-WAN, Node MCU Pin-out. This review paper describes all protocol stack including its types of sensors in IOT their applications in real time environment and its architecture. In this paper we come together with the two different technologies Cloud Computing and IoT to observe the most common features, and to determine the benefits of their integration. The Cloud IoT prototype involves various applications, research issues and challenges.",
-isbn="978-981-15-7961-5"
-}
-@inproceedings{jones_clean_io,
-author = {Jones, Simon B},
-title = {Experiences with Clean I/O},
-year = {1995},
-publisher = {BCS Learning \& Development Ltd.},
-address = {Swindon, GBR},
-abstract = {The Clean system is a powerful functional programming tool. It contains experiments
-in a number of different areas of functional language design. In particular, it has
-a novel proposal for the organization of input and output, and contains impressive
-libraries of facilities for programming graphical user interfaces.Clean I/O is based
-on collections of operations that act to cause side effects on multiple explicit abstract
-values representing physical I/O entities, such as files and graphical interfaces.
-A system of unique types is used to ensure that these values are individually single
-threaded through the program; and the side effecting I/O operations are therefore
-well controlled. This approach is distinct from monadic I/O, which is being widely
-adopted; monadic I/O schemes are based on a single, implicit environment, and guarantee
-that this is single threaded.In this paper we will show that the Clean and monadic
-approaches to I/O merge nicely. The functionality provided by the Clean and its I/O
-libraries allows libraries for monadic I/O to be implemented. The paper presents an
-implementation of a basic I/O monad library in Clean that can serve for future development.
-In itself, the fact that the monadic approach can be implemented in Clean is unsurprising.
-However, some interesting technical difficulties arose during implementation of the
-monad; these and their solutions are discussed. The opportunity to express programs
-using the implicit environments of monadic I/O allows us to simplify Clean programs
-by removing some of the spaghetti, whilst retaining the generality of the explicit
-environments where it is the most appropriate approach.},
-booktitle = {Proceedings of the 1995 International Conference on Functional Programming},
-pages = {167–177},
-numpages = {11},
-location = {Glasgow, UK},
-series = {FP'95}
-}
-
-@inproceedings{sivieri2012drop,
- title={Drop the phone and talk to the physical world: Programming the internet of things with Erlang},
- author={Sivieri, Alessandro and Mottola, Luca and Cugola, Gianpaolo},
- booktitle={2012 Third International Workshop on Software Engineering for Sensor Network Applications (SESENA)},
- pages={8--14},
- year={2012},
- organization={IEEE}
-}
-
-@article{chong2007secure,
- title={Secure web applications via automatic partitioning},
- author={Chong, Stephen and Liu, Jed and Myers, Andrew C and Qi, Xin and Vikram, Krishnaprasad and Zheng, Lantian and Zheng, Xin},
- journal={ACM SIGOPS Operating Systems Review},
- volume={41},
- number={6},
- pages={31--44},
- year={2007},
- publisher={ACM New York, NY, USA}
-}
-
-@article{zdancewic2002secure,
- title={Secure program partitioning},
- author={Zdancewic, Steve and Zheng, Lantian and Nystrom, Nathaniel and Myers, Andrew C},
- journal={ACM Transactions on Computer Systems (TOCS)},
- volume={20},
- number={3},
- pages={283--328},
- year={2002},
- publisher={ACM New York, NY, USA}
-}
-
-@article{bhatt2012analysis,
- title={Analysis of source lines of code (SLOC) metric},
- author={Bhatt, Kaushal and Tarey, Vinit and Patel, Pushpraj and Mits, Kaushal Bhatt and Ujjain, Datana},
- journal={International Journal of Emerging Technology and Advanced Engineering},
- volume={2},
- number={5},
- pages={150--154},
- year={2012},
- publisher={Citeseer}
-}
-
-@article{10.1145/2775050.2633367,
-author = {Ekblad, Anton and Claessen, Koen},
-title = {A Seamless, Client-Centric Programming Model for Type Safe Web Applications},
-year = {2014},
-issue_date = {December 2014},
-publisher = {Association for Computing Machinery},
-address = {New York, NY, USA},
-volume = {49},
-number = {12},
-issn = {0362-1340},
-doi = {10.1145/2775050.2633367},
-abstract = {We propose a new programming model for web applications which is (1) seamless; one program and one language is used to produce code for both client and server, (2) client-centric; the programmer takes the viewpoint of the client that runs code on the server rather than the other way around, (3) functional and type-safe, and (4) portable; everything is implemented as a Haskell library that implicitly takes care of all networking code. Our aim is to improve the painful and error-prone experience of today's standard development methods, in which clients and servers are coded in different languages and communicate with each other using ad-hoc protocols. We present the design of our library called Haste.App, an example web application that uses it, and discuss the implementation and the compiler technology on which it depends.},
-journal = {SIGPLAN Not.},
-month = {sep},
-pages = {79–89},
-numpages = {11},
-keywords = {distributed systems, web applications, network communication}
-}
-
-@article{jones_1992, title={Implementing lazy functional languages on stock
- hardware: the Spineless Tagless G-machine}, volume={2},
- DOI={10.1017/S0956796800000319}, number={2}, journal={Journal of Functional
- Programming},
-publisher={Cambridge University Press}, author={Peyton Jones, Simon}, year={1992}, pages={127–202}}
-
-
-@article{domoszlai_implementing_2011,
- title = {Implementing a non-strict purely functional language in {JavaScript}},
- volume = {3},
- url = {https://www.researchgate.net/profile/Jan_Martin_Jansen2/publication/230607075_Implementing_a_non-strict_purely_functional_language_in_JavaScript/links/53fc40190cf22f21c2f3b28a.pdf},
- urldate = {2017-05-23},
- journal = {Acta Universitatis Sapientiae},
- author = {Domoszlai, Laszlo and Bruel, Eddy and Jansen, Jan Martin},
- year = {2011},
- pages = {76--98},
- file = {53fc40190cf22f21c2f3b28a.pdf:/home/mrl/.local/share/zotero/storage/2EVHREI3/53fc40190cf22f21c2f3b28a.pdf:application/pdf},
-}
-@Inbook{Domoszlai2013,
-author={Domoszlai, L{\'a}szl{\'o} and Kozsik, Tam{\'a}s},
-editor={Achten, Peter and Koopman, Pieter},
-title={Clean Up the Web!},
-bookTitle={The Beauty of Functional Code: Essays Dedicated to Rinus Plasmeijer on the Occasion of His 61st Birthday},
-year=2013,
-publisher={Springer Berlin Heidelberg},
-address={Berlin, Heidelberg},
-pages={133--150},
-abstract={Programming in Clean is much more appealing than programming in JavaScript. Therefore, solutions that can replace JavaScript with Clean in client-side web development are widely welcomed. This paper describes a technology for the cross-compilation of Clean to JavaScript and for the tight integration of the generated code into a web application. Our solution is based on the iTask framework and its extension, the so-called Tasklets. The application server approach provides simple and easy deployment, thus supporting rapid development. Examples are shown to illustrate how communication between the Clean and JavaScript code can be established.},
-isbn={978-3-642-40355-2},
-doi={10.1007/978-3-642-40355-2_10},
-url={https://doi.org/10.1007/978-3-642-40355-2_10}
-}
-
-@inproceedings{10.1145/3412932.3412941,
-author = {Staps, Camil and van Groningen, John and Plasmeijer, Rinus},
-title = {Lazy Interworking of Compiled and Interpreted Code for Sandboxing and Distributed Systems},
-year = {2019},
-isbn = {9781450375627},
-publisher = {Association for Computing Machinery},
-address = {New York, NY, USA},
-doi = {10.1145/3412932.3412941},
-abstract = {More and more applications rely on the safe execution of code unknown at compile-time, for example in the implementation of web browsers and plugin systems. Furthermore, these applications usually require some form of communication between the added code and its embedder, and hence a communication channel must be set up in which values are serialized and deserialized. This paper shows that in a functional programming language we can solve these two problems at once, if we realize that the execution of extra code is nothing more than the deserialization of a value which happens to be a function. To demonstrate this, we describe the implementation of a serialization library for the language Clean, which internally uses an interpreter to evaluate added code in a separate, sandboxed environment. Remarkable is that despite the conceptual asymmetry between "host" and "interpreter", lazy interworking must be implemented in a highly symmetric fashion, much akin to distributed systems. The library interworks on a low level with the native Clean program, but has been implemented without any changes to the native runtime system. It can therefore easily be ported to other programming languages.We can use the same technique in the context of the web, where we want to be able to share possibly lazy values between a server and a client. In this case the interpreter runs in WebAssembly in the browser and communicates seamlessly with the server, written in Clean. We use this in the iTasks web framework to handle communication and offload computations to the client to reduce stress on the server-side. Previously, this framework cross-compiled the Clean source code to JavaScript and used JSON for communication. The interpreter has a more predictable and better performance, and integration is much simpler because it interworks on a lower level with the web server.},
-booktitle = {Proceedings of the 31st Symposium on Implementation and Application of Functional Languages},
-articleno = {9},
-numpages = {12},
-keywords = {functional programming, sandboxing, web-assembly, laziness, interpreters},
-location = {Singapore, Singapore},
-series = {IFL '19}
-}
-
-@inproceedings{elliott_guilt_2015,
- title = {Guilt free ivory},
- volume = {50},
- booktitle = {{ACM} {SIGPLAN} {Notices}},
- publisher = {ACM},
- author = {Elliott, Trevor and Pike, Lee and Winwood, Simon and Hickey, Pat and Bielman, James and Sharp, Jamey and Seidel, Eric and Launchbury, John},
- year = {2015},
- pages = {189--200},
- file = {5678351608ae125516ee79c6.pdf:/home/mrl/.local/share/zotero/storage/KJMFUH7T/5678351608ae125516ee79c6.pdf:application/pdf},
-}
-
-@inproceedings{sawada_emfrp:_2016,
- title = {Emfrp: a functional reactive programming language for small-scale embedded systems},
- booktitle = {Companion {Proceedings} of the 15th {International} {Conference} on {Modularity}},
- publisher = {ACM},
- author = {Sawada, Kensuke and Watanabe, Takuo},
- year = {2016},
- pages = {36--44},
- file = {Sawada and Watanabe - 2016 - Emfrp a functional reactive programming language .pdf:/home/mrl/.local/share/zotero/storage/9U95ER5P/Sawada and Watanabe - 2016 - Emfrp a functional reactive programming language .pdf:application/pdf},
-}
-
-@inproceedings{lv_designing_2018,
- title = {Designing of {IoT} {Platform} {Based} on {Functional} {Reactive} {Pattern}},
- booktitle = {2018 {International} {Conference} on {Computer} {Science}, {Electronics} and {Communication} {Engineering} ({CSECE} 2018)},
- publisher = {Atlantis Press},
- author = {Lv, Haidong and Ge, Xiaolong and Zhu, Hongzhi and Yuan, Zhiwei and Wang, Zhen and Zhu, Yongkang},
- year = {2018},
- file = {Lv et al. - 2018 - Designing of IoT Platform Based on Functional Reac.pdf:/home/mrl/.local/share/zotero/storage/IBVT6MHW/Lv et al. - 2018 - Designing of IoT Platform Based on Functional Reac.pdf:application/pdf},
-}
-
-@inproceedings{helbling_juniper:_2016,
- title = {Juniper: a functional reactive programming language for the {Arduino}},
- booktitle = {Proceedings of the 4th {International} {Workshop} on {Functional} {Art}, {Music}, {Modelling}, and {Design}},
- publisher = {ACM},
- author = {Helbling, Caleb and Guyer, Samuel Z},
- year = {2016},
- pages = {8--16},
- file = {Helbling and Guyer - 2016 - Juniper a functional reactive programming languag.pdf:/home/mrl/.local/share/zotero/storage/M4UWK57F/Helbling and Guyer - 2016 - Juniper a functional reactive programming languag.pdf:application/pdf},
-}
-
-@incollection{wang_functional_2020,
- address = {Cham},
- title = {Functional {Reactive} {EDSL} with {Asynchronous} {Execution} for {Resource}-{Constrained} {Embedded} {Systems}},
- isbn = {978-3-030-26428-4},
- abstract = {This paper presents a functionalWang, Sheng reactive embedded domain-specific language (EDSL) for resource-constrained embedded systems and its efficient execution method. In the language, time-varying values changes at discrete points of time rather than continuously. Combined with a mechanismWatanabe, Takuo to let users designate the update interval of values, it is possible to derive the minimal value-updates required to produce the user-desired output. Also, the event-driven backend asynchronously updates an input value when its value is required. In this way, we can greatly reduce the number of updates.},
- booktitle = {Software {Engineering}, {Artificial} {Intelligence}, {Networking} and {Parallel}/{Distributed} {Computing}},
- publisher = {Springer International Publishing},
- author = {Wang, Sheng and Watanabe, Takuo},
- editor = {Lee, Roger},
- year = {2020},
- doi = {10.1007/978-3-030-26428-4_12},
- pages = {171--190},
- file = {Wang and Watanabe - 2020 - Functional Reactive EDSL with Asynchronous Executi.pdf:/home/mrl/.local/share/zotero/storage/5JUBWXYV/Wang and Watanabe - 2020 - Functional Reactive EDSL with Asynchronous Executi.pdf:application/pdf},
-}
-
-@incollection{valliappan_towards_2020,
- address = {New York, NY, USA},
- title = {Towards {Secure} {IoT} {Programming} in {Haskell}},
- isbn = {978-1-4503-8050-8},
- abstract = {IoT applications are often developed in programming languages with low-level abstractions, where a seemingly innocent mistake might lead to severe security vulnerabilities. Current IoT development tools make it hard to identify these vulnerabilities as they do not provide end-to-end guarantees about how data flows within and between appliances. In this work we present Haski, an embedded domain specific language in Haskell (eDSL) for secure programming of IoT devices. Haski enables developers to write Haskell programs that generate C code without falling into many of C’s pitfalls. Haski is designed after the synchronous programming language Lustre, and sports a backwards compatible information-flow control extension to restrict how sensitive data is propagated and modified within the application. We present a novel eDSL design which uses recursive monadic bindings and allows a natural use of functions and pattern-matching in Haskell to write Haski programs. To showcase Haski, we implement a simple smart house controller where communication is done via low-energy Bluetooth on Zephyr OS.},
- booktitle = {Proceedings of the 13th {ACM} {SIGPLAN} {International} {Symposium} on {Haskell}},
- publisher = {Association for Computing Machinery},
- author = {Valliappan, Nachiappan and Krook, Robert and Russo, Alejandro and Claessen, Koen},
- year = {2020},
- pages = {136--150},
- file = {Valliappan et al. - 2020 - Towards Secure IoT Programming in Haskell.pdf:/home/mrl/.local/share/zotero/storage/BF6YIT2S/Valliappan et al. - 2020 - Towards Secure IoT Programming in Haskell.pdf:application/pdf},
-}
-
-@inproceedings{sarkar_hailstorm_2020,
- address = {New York, NY, USA},
- series = {{PPDP} '20},
- title = {Hailstorm: {A} {Statically}-{Typed}, {Purely} {Functional} {Language} for {IoT} {Applications}},
- isbn = {978-1-4503-8821-4},
- doi = {10.1145/3414080.3414092},
- abstract = {With the growing ubiquity of Internet of Things (IoT), more complex logic is being programmed on resource-constrained IoT devices, almost exclusively using the C programming language. While C provides low-level control over memory, it lacks a number of high-level programming abstractions such as higher-order functions, polymorphism, strong static typing, memory safety, and automatic memory management. We present Hailstorm, a statically-typed, purely functional programming language that attempts to address the above problem. It is a high-level programming language with a strict typing discipline. It supports features like higher-order functions, tail-recursion, and automatic memory management, to program IoT devices in a declarative manner. Applications running on these devices tend to be heavily dominated by I/O. Hailstorm tracks side effects like I/O in its type system using resource types. This choice allowed us to explore the design of a purely functional standalone language, in an area where it is more common to embed a functional core in an imperative shell. The language borrows the combinators of arrowized FRP, but has discrete-time semantics. The design of the full set of combinators is work in progress, driven by examples. So far, we have evaluated Hailstorm by writing standard examples from the literature (earthquake detection, a railway crossing system and various other clocked systems), and also running examples on the GRiSP embedded systems board, through generation of Erlang.},
- booktitle = {Proceedings of the 22nd {International} {Symposium} on {Principles} and {Practice} of {Declarative} {Programming}},
- publisher = {Association for Computing Machinery},
- author = {Sarkar, Abhiroop and Sheeran, Mary},
- year = {2020},
- note = {event-place: Bologna, Italy},
- keywords = {functional programming, compilers, embedded systems, IoT},
- file = {Sarkar and Sheeran - 2020 - Hailstorm A Statically-Typed, Purely Functional L.pdf:/home/mrl/.local/share/zotero/storage/BKFJKGQP/Sarkar and Sheeran - 2020 - Hailstorm A Statically-Typed, Purely Functional L.pdf:application/pdf},
-}
-@inproceedings{10.1145/3281366.3281370,
-author = {Shibanai, Kazuhiro and Watanabe, Takuo},
-title = {Distributed Functional Reactive Programming on Actor-Based Runtime},
-year = {2018},
-isbn = {9781450360661},
-publisher = {Association for Computing Machinery},
-address = {New York, NY, USA},
-doi = {10.1145/3281366.3281370},
-abstract = {Reactive programming over a network is a challenging task because efficient elimination of temporary violations of data flow invariants, known as glitches, in a distributed setting is still an open issue. In this paper, we propose a method for constructing a distributed reactive programming system of which runtime guarantees the properties of single source glitch-freedom and the robustness against out-of-order messages. Based on the method, we developed a purely functional reactive programming language XFRP whose compiler produces Erlang code. Using some examples, we show that the proposed method is beneficial for constructing distributed reactive applications without suffering from inconsistencies.},
-booktitle = {Proceedings of the 8th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control},
-pages = {13–22},
-numpages = {10},
-keywords = {Distributed Functional Reactive Programming, Erlang, Glitch Freedom, Synchronization, Actor-Based Runtime System},
-location = {Boston, MA, USA},
-series = {AGERE 2018}
-}
-
-@inproceedings{suzuki_cfrp_2017,
- address = {The University of The Philippines Cebu, Cebu City, The Philippines},
- title = {{CFRP}: {A} {Functional} {Reactive} {Programming} {Language} for {Small}-{Scale} {Embedded} {Systems}},
- isbn = {978-981-323-406-2 978-981-323-407-9},
- shorttitle = {{CFRP}},
- url = {http://www.worldscientific.com/doi/abs/10.1142/9789813234079_0001},
- doi = {10.1142/9789813234079_0001},
- language = {en},
- urldate = {2022-03-02},
- booktitle = {Theory and {Practice} of {Computation}},
- publisher = {WORLD SCIENTIFIC},
- author = {Suzuki, Kohei and Nagayama, Kanato and Sawada, Kensuke and Watanabe, Takuo},
- month = dec,
- year = {2017},
- pages = {1--13},
- file = {Suzuki et al. - 2017 - CFRP A Functional Reactive Programming Language f.pdf:/home/mrl/.local/share/zotero/storage/XHPSZCJH/Suzuki et al. - 2017 - CFRP A Functional Reactive Programming Language f.pdf:application/pdf},
-}
-
-
-@inproceedings{shibanai_distributed_2018,
- address = {New York, NY, USA},
- series = {{AGERE} 2018},
- title = {Distributed {Functional} {Reactive} {Programming} on {Actor}-{Based} {Runtime}},
- isbn = {978-1-4503-6066-1},
- doi = {10.1145/3281366.3281370},
- abstract = {Reactive programming over a network is a challenging task because efficient elimination of temporary violations of data flow invariants, known as glitches, in a distributed setting is still an open issue. In this paper, we propose a method for constructing a distributed reactive programming system of which runtime guarantees the properties of single source glitch-freedom and the robustness against out-of-order messages. Based on the method, we developed a purely functional reactive programming language XFRP whose compiler produces Erlang code. Using some examples, we show that the proposed method is beneficial for constructing distributed reactive applications without suffering from inconsistencies.},
- booktitle = {Proceedings of the 8th {ACM} {SIGPLAN} {International} {Workshop} on {Programming} {Based} on {Actors}, {Agents}, and {Decentralized} {Control}},
- publisher = {Association for Computing Machinery},
- author = {Shibanai, Kazuhiro and Watanabe, Takuo},
- year = {2018},
- note = {event-place: Boston, MA, USA},
- keywords = {Actor-Based Runtime System, Distributed Functional Reactive Programming, Erlang, Glitch Freedom, Synchronization},
- pages = {13--22},
- file = {Shibanai and Watanabe - 2018 - Distributed Functional Reactive Programming on Act.pdf:/home/mrl/.local/share/zotero/storage/UJ5IG7R4/Shibanai and Watanabe - 2018 - Distributed Functional Reactive Programming on Act.pdf:application/pdf},
-}
-
-@inproceedings{nilsson_functional_2002,
- address = {New York, NY, USA},
- series = {Haskell '02},
- title = {Functional {Reactive} {Programming}, {Continued}},
- isbn = {1-58113-605-6},
- doi = {10.1145/581690.581695},
- abstract = {Functional Reactive Programming (FRP) extends a host programming language with a notion of time flow. Arrowized FRP (AFRP) is a version of FRP embedded in Haskell based on the arrow combinators. AFRP is a powerful synchronous dataflow programming language with hybrid modeling capabilities, combining advanced synchronous dataflow features with the higher-order lazy functional abstractions of Haskell. In this paper, we describe the AFRP programming style and our Haskell-based implementation. Of particular interest are the AFRP combinators that support dynamic collections and continuation-based switching. We show how these combinators can be used to express systems with an evolving structure that are difficult to model in more traditional dataflow languages.},
- booktitle = {Proceedings of the 2002 {ACM} {SIGPLAN} {Workshop} on {Haskell}},
- publisher = {Association for Computing Machinery},
- author = {Nilsson, Henrik and Courtney, Antony and Peterson, John},
- year = {2002},
- note = {event-place: Pittsburgh, Pennsylvania},
- keywords = {functional programming, Haskell, domain-specific languages, FRP, hybrid modeling, synchronous dataflow languages},
- pages = {51--64},
- file = {Nilsson et al. - 2002 - Functional reactive programming, continued.pdf:/home/mrl/.local/share/zotero/storage/X79J47NP/Nilsson et al. - 2002 - Functional reactive programming, continued.pdf:application/pdf},
-}
-@inproceedings{10.1145/2661136.2661146,
-author = {Philips, Laure and De Roover, Coen and Van Cutsem, Tom and De Meuter, Wolfgang},
-title = {Towards Tierless Web Development without Tierless Languages},
-year = {2014},
-isbn = {9781450332101},
-publisher = {Association for Computing Machinery},
-address = {New York, NY, USA},
-doi = {10.1145/2661136.2661146},
-abstract = {Tierless programming languages enable developing the typical server, client and database tiers of a web application as a single mono-linguistic program. This development style is in stark contrast to the current practice which requires combining multiple technologies and programming languages. A myriad of tierless programming languages has already been proposed, often featuring a JavaScript-like syntax. Instead of introducing yet another, we advocate that it should be possible to develop tierless web applications in existing general-purpose languages. This not only reduces the complexity that developers are exposed to, but also precludes the need for new development tools. We concretize this novel approach to tierless programming by discussing requirements on its future instantiations. We explore the design space of the program analysis for determining and the program transformation for realizing the tier split respectively. The former corresponds to new adaptations of an old familiar, program slicing, for tier splitting. The latter includes several strategies for handling cross-tier function calls and data accesses. Using a prototype instantiation for JavaScript, we demonstrate the feasibility of our approach on an example web application. We conclude with a discussion of open questions and challenges for future research.},
-booktitle = {Proceedings of the 2014 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming \& Software},
-pages = {69–81},
-numpages = {13},
-keywords = {tier splitting, program slicing, tierless programming, javascript},
-location = {Portland, Oregon, USA},
-series = {Onward! 2014}
-}
-
-@misc{hess_arduino-copilot_2020,
- title = {arduino-copilot: {Arduino} programming in haskell using the {Copilot} stream {DSL}},
- shorttitle = {arduino-copilot},
- url = {//hackage.haskell.org/package/arduino-copilot},
- urldate = {2020-02-14},
- journal = {Hackage},
- author = {Hess, Joey},
- year = {2020},
- file = {Snapshot:/home/mrl/.local/share/zotero/storage/PSHYKF52/arduino-copilot.html:text/html},
-}
-@INPROCEEDINGS{5558637,
-
- author={Axelsson, Emil and Claessen, Koen and Dévai, Gergely and Horváth, Zoltán and Keijzer, Karin and Lyckegård, Bo and Persson, Anders and Sheeran, Mary and Svenningsson, Josef and Vajdax, András},
-
- booktitle={Eighth ACM/IEEE International Conference on Formal Methods and Models for Codesign (MEMOCODE 2010)},
-
- title={Feldspar: A domain specific language for digital signal processing algorithms},
-
- year={2010},
-
- volume={},
-
- number={},
-
- pages={169-178},
-
- abstract={A new language, Feldspar, is presented, enabling high-level and platform-independent description of digital signal processing (DSP) algorithms. Feldspar is a pure functional language embedded in Haskell. It offers a high-level dataflow style of programming, as well as a more mathematical style based on vector indices. The key to generating efficient code from such descriptions is a high-level optimization technique called vector fusion. Feldspar is based on a low-level, functional core language which has a relatively small semantic gap to machine-oriented languages like C. The core language serves as the interface to the back-end code generator, which produces C. For very small examples, the generated code performs comparably to hand-written C code when run on a DSP target. While initial results are promising, to achieve good performance on larger examples, issues related to memory access patterns and array copying will have to be addressed.},
-
- keywords={},
-
- doi={10.1109/MEMCOD.2010.5558637},
-
- ISSN={},
-
- month={July},}
-
-@article{sheetz2009understanding,
- title={Understanding developer and manager perceptions of function points and source lines of code},
- author={Sheetz, Steven D and Henderson, David and Wallace, Linda},
- journal={Journal of Systems and Software},
- volume={82},
- number={9},
- pages={1540--1549},
- year={2009},
- publisher={Elsevier}
-}
-
-@article{fichera2017python,
- title={A Python framework for programming autonomous robots using a declarative approach},
- author={Fichera, Loris and Messina, Fabrizio and Pappalardo, Giuseppe and Santoro, Corrado},
- journal={Science of Computer Programming},
- volume={139},
- pages={36--55},
- year={2017},
- publisher={Elsevier}
-}
-
-@inproceedings{balat2006ocsigen,
- title={Ocsigen: Typing web interaction with objective caml},
- author={Balat, Vincent},
- booktitle={Proceedings of the 2006 Workshop on ML},
- pages={84--94},
- year={2006}
-}
-
-@inproceedings{bjornson2010composing,
- title={Composing reactive GUIs in F\# using WebSharper},
- author={Bjornson, Joel and Tayanovskyy, Anton and Granicz, Adam},
- booktitle={Symposium on Implementation and Application of Functional Languages},
- pages={203--216},
- year={2010},
- organization={Springer}
-}
-
-@book{strack2015getting,
- title={Getting Started with Meteor. js JavaScript Framework},
- author={Strack, Isaac},
- year={2015},
- publisher={Packt Publishing Ltd}
-}
-
-@incollection{hall1993glasgow,
- title={The Glasgow Haskell compiler: a retrospective},
- author={Hall, Cordelia and Hammond, Kevin and Partain, Will and Peyton Jones, Simon L and Wadler, Philip},
- booktitle={Functional Programming, Glasgow 1992},
- pages={62--71},
- year={1993},
- publisher={Springer}
-}
-
-@misc{diffmicro,
- title = "MicroPython Differences from CPython",
- author = {{Micropython Team}},
- year = "2022",
- note = "https://docs.micropython.org/en/latest/genrst/index.html",
-}
-
-@article{weisenburger2020survey,
- title={A survey of multitier programming},
- author={Weisenburger, Pascal and Wirth, Johannes and Salvaneschi, Guido},
- journal={ACM Computing Surveys (CSUR)},
- volume={53},
- number={4},
- pages={1--35},
- year={2020},
- publisher={ACM New York, NY, USA}
-}
-
-@inproceedings {203628,
-author = {Manos Antonakakis and Tim April and Michael Bailey and Matt Bernhard and Elie Bursztein and Jaime Cochran and Zakir Durumeric and J. Alex Halderman and Luca Invernizzi and Michalis Kallitsis and Deepak Kumar and Chaz Lever and Zane Ma and Joshua Mason and Damian Menscher and Chad Seaman and Nick Sullivan and Kurt Thomas and Yi Zhou},
-title = {Understanding the Mirai Botnet},
-booktitle = {26th USENIX Security Symposium (USENIX Security 17)},
-year = {2017},
-isbn = {978-1-931971-40-9},
-address = {Vancouver, BC},
-pages = {1093--1110},
-url = {https://www.usenix.org/conference/usenixsecurity17/technical-sessions/presentation/antonakakis},
-publisher = {USENIX Association},
-month = aug,
-}
-
-@inproceedings{herwig_measurement_2019,
- address = {San Diego, CA, USA},
- title = {Measurement and {Analysis} of {Hajime}, a {Peer}-to-peer {IoT} {Botnet}},
- isbn = {1-891562-55-X},
- url = {https://par.nsf.gov/biblio/10096257},
- doi = {10.14722/ndss.2019.23488},
- booktitle = {Network and {Distributed} {Systems} {Security} ({NDSS}) {Symposium} 2019},
- author = {Herwig, Stephen and Harvey, Katura and Hughey, George and Roberts, Richard and Levin, Dave},
- year = {2019},
- pages = {15},
- file = {Herwig et al. - Measurement and Analysis of Hajime, a Peer-to-peer.pdf:/home/mrl/.local/share/zotero/storage/YFB8C8CU/Herwig et al. - Measurement and Analysis of Hajime, a Peer-to-peer.pdf:application/pdf},
-}
-@phdthesis{wijkhuizen_security_2018,
- address = {Nijmegen},
- type = {Bachelor's {Thesis}},
- title = {Security analysis of the {iTasks} framework},
- url = {http://www.ru.nl/publish/pages/769526/arjan_oortgiese.pdf},
- language = {English},
- urldate = {2017-04-08},
- school = {Radboud University},
- author = {Wijkhuizen, Mark},
- year = {2018},
- file = {Wijkhuizen - 2018 - Security analysis of the iTasks framework.pdf:/home/mrl/.local/share/zotero/storage/AWFT6PGL/Wijkhuizen - 2018 - Security analysis of the iTasks framework.pdf:application/pdf},
-}
-@inproceedings{Steenvoorden2019tophat,
-author = {Steenvoorden, Tim and Naus, Nico and Klinik, Markus},
-title = {TopHat: A Formal Foundation for Task-Oriented Programming},
-year = {2019},
-isbn = {9781450372497},
-publisher = {Association for Computing Machinery},
-address = {New York, NY, USA},
-doi = {10.1145/3354166.3354182},
-booktitle = {Proceedings of the 21st International Symposium on Principles and Practice of Declarative Programming},
-articleno = {17},
-numpages = {13},
-location = {Porto, Portugal},
-series = {PPDP '19}
-}
-
-
-
-
\end{chapterabstract}
\section{Finale}
-Traditionally, \gls{IOT} has been programmed using layered, or tiered, architectures.
+Traditionally, the \gls{IOT} has been programmed using layered, or tiered, architectures.
Every layer has its own software and hardware characteristics, resulting in semantic friction.
\Gls{TOP} is a declarative programming paradigm designed to describe multi-tiered interactive systems from a single source.
However, it is not straightforward to run \gls{TOP} systems on resource-constrained devices such as edge devices.
It is a full-fledged \gls{TOP} language hosted in a tiny \gls{FP} language.
Besides the usual \gls{FP} constructs, it contains basic tasks, task combinators, support for sensors and actuators, and interrupts.
It integrates 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.
-In \gls{ITASK}, abstraction are available for the gritty details of interactive web applications such as program distribution, web applications, data storage, and user management.
+In \gls{ITASK}, abstractions are available for the gritty details of interactive web applications such as program distribution, web applications, data storage, and user management.
The \gls{MTASK} system abstracts away of all technicalities specific to edge devices such as communication, abstractions for sensors and actuators, interrupts and (multi) task scheduling.
+With \gls{ITASK} and \gls{MTASK}, all layers of an \gls{IOT} system can be programmed from a single declarative specification.
Any device equipped with the \gls{MTASK} \gls{RTS} can be used in the system and dynamically receive tasks for execution.
-This domain-specific \gls{OS} only needs to be uploaded once, hence saving precious write cycles on the program memory.
+This domain-specific \gls{OS} only is uploaded once, hence saving precious write cycles on the program memory.
The \gls{MTASK} 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.
Once 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 current work requirements.
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 irrespective of task relations.
+Furthermore, \gls{ITASK} \glspl{SDS} can be lowered to \gls{MTASK} tasks as well, allowing for automatic bidirectional data sharing between \gls{MTASK} tasks and the \gls{ITASK} system irrespective of task relations.
\section{Related work}
The novelties of the \gls{MTASK} system can be compared to existing systems in several categories.
\Cref{sec_t4t:TiredvsTierless} contains an elaborate related work section regarding tierless systems in general.
\subsection{Interpretation}\label{sec:related_int}
-There are a myriad of interpreted programming languages available for some of the bigger more powerful edge devices.
-For example, for the popular ESP8266 chip there are ports of \gls{MICROPYTHON}, LUA, Basic, JavaScript and Lisp.
+There are a myriad of interpreted programming languages available for more powerful edge devices.
+For example, for the popular ESP8266 chip there are ports of \gls{MICROPYTHON}, Lua, BASIC, JavaScript and Lisp.
All of these languages, except the Lisp dialect uLisp (see \cref{sec:related_fp}), are imperative and do not support multitasking out of the box.
They lay pretty hefty constraints on the memory and as a result do not work on smaller microcontrollers.
-Another interpretation solution for the tiniest devices is Firmata, a protocol for remotely controlling the microcontroller and using a server as the interpreter host \citep{steiner_firmata:_2009}.
+Another interpretation solution for the tiniest devices is Firmata, a protocol for remotely controlling the microcontroller using a server as the interpreter host \citep{steiner_firmata:_2009}.
\citet{grebe_haskino:_2016} wrapped this in a remote monad for integration with \gls{HASKELL} that allowed imperative code to be interpreted on the microprocessors.
Later this system was extended to support multithreading as well, stepping away from Firmata as the basis and using their own \gls{RTS} \citep{grebe_threading_2019}.
It differs from our approach because continuation points need to be defined by hand there is no automatic safe data communication.
However, there is no integration between the client and the server other than that they are programmed from a single source.
Mat\`e is an example of an early tierless sensor network framework where devices are provided with a virtual machine using TinyOS for dynamic provisioning \citep{levis_mate_2002}.
-\subsection{\texorpdfstring{\Glsxtrlongpl{DSL}}{DSLs} for microcontrollers}\label{sec:related_dsl}
+\subsection{\texorpdfstring{\Glsxtrlongpl{DSL}}{DSLs}}\label{sec:related_dsl}
Many \glspl{DSL} provide higher-level programming abstractions for microcontrollers, for example providing strong typing or memory safety.
-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{}.
+Examples of this are Copilot \citep{hess_arduino-copilot_2020} and Ivory \citep{elliott_guilt_2015}.
+Both 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.
-They showed that using function languages increased the security and maintainability of the applications.
-Traditional implementations of general purpose functional languages have high memory requirements rendering them unusable for tiny computers.
+\Citet{haenisch_case_2016} showed that there are major benefits to using functional languages on edge devices.
+They show that using function languages increased the security and maintainability of the applications.
+Traditional implementations of general purpose functional languages have high memory requirements rendering them unusable for resource-constrained computers.
There have been many efforts to create a general purpose functional language that does fit in small memory environments, albeit with some concessions.
For example, there has been a history of creating tiny Scheme implementations for specific microcontrollers.
It started with BIT \citep{dube_bit:_2000} that only required \qty{64}{\kibi\byte} of memory, followed by {PICBIT} \citep{feeley_picbit:_2003} and {PICOBIT} \citep{st-amour_picobit:_2009} that lowered the memory requirements even more.
\Citet{suchocki_microscheme:_2015} created Microscheme, a functional language targeting \gls{ARDUINO} compatible microcontrollers.
-The {*BIT} languages all compile to assembly while Microscheme compiles to \gls{CPP}, heavily supported by \gls{CPP} lambdas available even on \gls{ARDUINO} AVR targets.
-An interpreted Lisp implementation called uLisp also exists that runs on microcontrollers with as small as the \gls{ARDUINO} {UNO} \citep{johnson-davies_lisp_2020}.
+The {*BIT} languages all compile to assembly while Microscheme compiles to \gls{CPP}.
+Their implementation leans heavily on \gls{CPP} lambdas, that are available even on \gls{ARDUINO} AVR targets.
+An interpreted Lisp implementation called uLisp also exists that runs on microcontrollers as small as the \gls{ARDUINO} {UNO} \citep{johnson-davies_lisp_2020}.
\subsection{Multitasking}\label{sec:related_multi}
Applications for tiny computers are often parallel in nature.
Tasks like reading sensors, watching input devices, operating actuators and maintaining communication are often loosely dependent on each other and are preferably executed in parallel.
Microcontrollers often do not benefit from an \gls{OS} due to memory and processing constraints.
Therefore, writing multitasking applications in an imperative language is possible but the tasks have to be interleaved by hand \citep{feijs_multi-tasking_2013}.
-This results in hard to maintain, error prone and unscalable spaghetti code.
+This results in hard to maintain, error-prone and unscalable spaghetti code.
There are many solutions to overcome this problem in imperative languages.
If the host language is a functional language (e.g.\ the aforementioned scheme variants) multitasking can be achieved without this burden relatively easy using continuation style multiprocessing \citep{wand_continuation-based_1980}.
Writing in this style is complicated and converting an existing program in this continuation passing style results in relatively large programs.
Furthermore, there is no built-in thread-safe communication possible between the tasks.
-A \gls{TOP} or \gls{FRP} based language benefits even more because the programmer is not required to explicitly define continuation points.
+A \gls{TOP} or \gls{FRP} based language is superior to manual threading because the programmer is not required to explicitly define continuation points.
Regular preemptive multithreading is too memory intensive for smaller microcontrollers and therefore not suitable.
Manual interleaving of imperative code can be automated to certain extents.
\end{table}
\subsection{\texorpdfstring{\Glsxtrlong{FRP}}{Functional reactive programming}}\label{sec:related_frp}
-The \gls{TOP} paradigm is often compared to \gls{FRP} and they appear to be similar.
+The \gls{TOP} paradigm is often compared to \gls{FRP} because they appear similar.
\Gls{FRP} was introduced by \citet{elliott_functional_1997}.
-The paradigm strives to make modelling systems safer, more efficient, composable.
+The paradigm strives to make modelling systems safer, more efficient, and composable.
The core concepts are behaviours and events.
A behaviour is a value that varies over time.
Events are happenings in the real world and can trigger behaviours.
Events and behaviours may be combined using combinators.
Tasks in \gls{TOP} are also event driven and can be combined with combinators.
\Gls{TOP} allows for more complex collaboration patterns than \gls{FRP} \citep{wang_maintaining_2018}.
-In consequence is unable to provide the strong guarantees on memory usage available in a restricted variant of \gls{FRP} such as arrowised \gls{FRP} \citep{nilsson_functional_2002}.
+Consequently, \gls{TOP} is unable to provide strong guarantees on memory usage, something \gls{FRP} is capable of.
+For example, arrowised \gls{FRP} can give guarantees on upper memory bounds \citep{nilsson_functional_2002}.
The way \gls{FRP}, and for that matter \gls{TOP}, systems are programmed stays close to the design when the domain matches suits the paradigm.
The \gls{IOT} domain seems to suit this style of programming very well in just the device layer but also for entire \gls{IOT} systems.
Other examples are CFRP \citep{suzuki_cfrp_2017}, XFRP \citep{10.1145/3281366.3281370}, Juniper \citep{helbling_juniper:_2016}, Hailstorm \citep{sarkar_hailstorm_2020}, Haski \citep{valliappan_towards_2020}, arduino-copilot \citep{hess_arduino-copilot_2020}.
\subsection{\texorpdfstring{\Glsxtrlong{TOP}}{Task-oriented programming}}\label{sec:related_top}
-\Gls{TOP} as a paradigm with has been proven to be effective for implementing distributed, multi-user applications in many domains.
+\Gls{TOP} as a paradigm has proven to be effective for implementing distributed, multi-user applications in many domains.
Examples are conference management \citep{plasmeijer_conference_2006}, coastal protection \citep{lijnse_capturing_2011}, incident coordination \citep{lijnse_incidone:_2012}, crisis management \citep{jansen_towards_2010} and telemedicine \citep{van_der_heijden_managing_2011}.
-In general, \gls{TOP} results in a higher maintainability, a high separation of concerns and more effective handling of interruptions of workflow.
+In general, \gls{TOP} results in a higher maintainability, a high separation of concerns, and more effective handling of interruptions of workflow.
\Gls{IOT} applications contain a distributed and multi-user component, but the software on the device is mostly follows multiple loosely dependent workflows.
The only other \gls{TOP} language for embedded systems is $\mu$Tasks \citep{piers_task-oriented_2016}.
It is a non-distributed \gls{TOP} \gls{EDSL} hosted in \gls{HASKELL} designed for embedded systems such as payment terminals.
-They showed that applications tend to be able to cope well with interruptions and be more maintainable.
+They show that applications tend to be able to cope well with interruptions and are more maintainable.
However, the hardware requirements for running the standard \gls{HASKELL} system are high.
\section{Future work}
-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 is to add features, support more platforms,
+There are many ways of extending the research on the \gls{MTASK} system that also concerns \gls{TOP} for resource-constrained devices in general.
\subsection{Security}
-\Gls{IOT} has reached the news many times regarding security and it is a big concern \citep{alhirabi_security_2021}.
+The \gls{IOT} has reached the news concerningly many times regarding the lack of security \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 security difficult.
The security of \gls{MTASK} and the used protocols are deliberately overlooked at the moment
The \gls{MTASK} language and \gls{RTS} are modular.
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.
-Leaving the produced data and computations on the edge device is called \emph{edge computing} \citep{shi_edge_2016}.
-The \gls{MTASK} exhibits many properties of edge computing because it is possible to run entire workflows on the device.
+Edge devices produce a lot of data and it is not always effective to send this data to the server for processing.
+Leaving the produced data and computations on the edge device is called edge computing \citep{shi_edge_2016}.
+The \gls{MTASK} system exhibits many properties of edge computing because it is possible to run entire workflows on the device.
However, it is interesting to see how far this can be extended.
The \gls{MTASK} language is a high-level \gls{DSL}, so it is obvious to introduce abstractions for edge computations.
For example, add \gls{TOP} support for machine learning on the edge device using TinyML \citep{sanchez-iborra_tinyml-enabled_2020}.
\Citet{van_der_veen_mutable_2020} did preliminary work for embedding bounded datastructures such as arrays to the language.
This could be continued and extended with support for sum types.
-Another recent advance in \gls{IOT} programming is battery-less or even battery-free computing.
-Instead of equipping the edge device with a battery, a capacitor is used in conjunction with some energy harvesting systems such as a solar panel.
-With the use of intermittent computing, resuming the computation after a, possibly unexpected, power loss, operation can still be achieved \citep{hester_batteries_2019}.
+Another recent advance in \gls{IOT} edge device programming is battery-less or even battery-free computing.
+Instead of equipping the edge device with a battery, a capacitor is used in conjunction with energy harvesting systems such as a solar panel.
After a reset, the program state is resumed from a checkpoint that was stored in some non-volatile memory.
-Many intermittent computing solutions rely on annotations from the programmer to divide the program into atomic blocks, sometimes called \emph{tasks} as well.
-These blocks are marked as such because in the case of an reset of the system, the work must be done again.
+This technique is called intermittent computing \citep{hester_batteries_2019}.
+Many intermittent computing solutions rely on annotations from the programmer to divide the program into atomic blocks, sometimes called tasks as well.
+These blocks are marked as such, because in the case of an reset of the system, the work must be done again.
Examples of such blocks are \gls{I2C} transmissions or calculations that rely on recent sensor data.
In \gls{MTASK}, all work expressed by tasks is already split up in atomic pieces of work, i.e.\ the work is a side effect of rewriting.
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 is interesting to see what \gls{TOP} abstraction could be useful for intermittent computing and what solutions are required to make this work.
+It is interesting to see what \gls{TOP} abstraction are useful for intermittent computing and what solutions are required to make this work.
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.
-For example, it is possible to run tasks or share data with \glspl{SDS} on a different machine.
+For example, it is possible to run tasks or share data with \glspl{SDS} on different machines.
It is interesting to investigate how this networking technique can be utilised in \gls{MTASK}.
Finally, \glspl{FPGA} have been becoming cheaper and faster recently, allowing for purely functional code to be translated to \glspl{FPGA} code efficiently \citep{baaij_digital_2015}.
\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.
+From these simple combinators, complex collaboration patterns can be expressed.
The \gls{ITASK} language is designed exactly the opposite.
From just a few super combinators, all other combinators are derived.
However, this approach requires a very powerful host language in which task combinators can be defined in terms of the host language.
Recent approaches in interactive editors for programming language source code such as dynamic editors \citep{koopman_dynamic_2021} or typed tree editors such as Hazelnut \citep{omar_hazelnut_2017} could prove useful for supporting the \gls{DSL} programmer in using \gls{MTASK}.
If the editor produces correct \gls{MTASK} code by construction, much of the problems could be avoided.
In the same respect, as \gls{MTASK} is a tagless-final \gls{EDSL} and uses \gls{HOAS}, the error messages are complex and larded with host language features.
-Much research has gone into simplifying these error messages by translating them to the \gls{DSL} domain, see for example \citep{serrano_type_2018}.
+Much research has gone into simplifying these error messages by translating them to the \gls{DSL} domain, see for example the work by \citep{serrano_type_2018}.
De Roos briefly investigated these methods in their research internship.
A future directions could be to extend these findings and apply more \gls{EDSL} error message techniques on \gls{MTASK} as well.
More elaborate features in the type systems of modern functional programming languages allow for more type safety.
The \gls{MTASK} language relies a lot on these features such as (multi-parameter) type classes and existential data types with class constraints.
-However, it should be possible to make abstractions over more stuff to make it safer.
-For example, the pin mode could be made a type parameter of the \gls{GPIO} pins, or interrupt handling could be made safer by incorporating the capabilities of the devices.
+However, it should be possible to make abstractions over an increasing number of features to make it safer still.
+For example, the pin mode could be made a type parameter of the \gls{GPIO} pins, or interrupt handling could be made safer by incorporating the capabilities of the devices in order to reduce run-time errors.
\subsection{Scheduling}
The scheduling in \gls{MTASK} works quite well but it is not real time.
A first throw at a class-based shallowly \gls{EDSL} for microcontrollers was made by \citet{plasmeijer_shallow_2016}.
The language was called \gls{ARDSL} and offered a type safe interface to \gls{ARDUINO} \gls{CPP} dialect.
A \gls{CPP} code generation backend was available together with an \gls{ITASK} simulation backend.
-There was no support for tasks nor even functions.
+There was no support for tasks nor functions.
Some time later in the 2015 \gls{CEFP} summer school, an extended version was created that allowed the creation of imperative tasks, local \glspl{SDS} and the usage of functions \citep{koopman_type-safe_2019}.
The name then changed from \gls{ARDSL} to \gls{MTASK}.
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_2023}.
\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}.
+In 2022, the SusTrainable summer school in Rijeka, Croatia hosted a course on developing greener \gls{IOT} applications using \gls{MTASK} \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; de Roos explored beautifying error messages; \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}.
-In 2023, the SusTrainable summer school in Coimbra, Portugal will host a course on \gls{MTASK} as well.
+\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; de Roos explored beautifying error messages; \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}.
+In 2023, the SusTrainable summer school in Coimbra, Portugal will host a course on \gls{MTASK}.
\subsection{\texorpdfstring{\gls{MTASK}}{mTask} in practise}
Funded by the Radboud-Glasgow Collaboration Fund, collaborative work was executed with Phil Trinder, Jeremy Singer, and Adrian Ravi Kishore Ramsingh.
An existing smart campus application was developed using \gls{MTASK} and quantitatively and qualitatively compared to the original application that was developed using a traditional \gls{IOT} stack \citep{lubbers_tiered_2020}.
This research was later extended to include a four-way comparison: \gls{PYTHON}, \gls{MICROPYTHON}, \gls{ITASK}, and \gls{MTASK} \citep{lubbers_could_2022}.
-Currently, power efficiency behaviour of traditional versus \gls{TOP} \gls{IOT} stacks is being compared as well adding a \gls{FREERTOS}, and an elixer/potato implementation to the mix as well.
+Currently, power efficiency behaviour of traditional versus \gls{TOP} \gls{IOT} stacks is being compared as well adding a \gls{FREERTOS}, and an Elixir implementation to the mix as well.
\input{subfilepostamble}
\end{document}
repositories / phd-thesis.git / commitdiff