tiot.bib

   1 @article{sethi2017internet,
   2   title={Internet of things: architectures, protocols, and applications},
   3   author={Sethi, Pallavi and Sarangi, Smruti R},
   4   journal={Journal of Electrical and Computer Engineering},
   5   volume={2017},
   6   year={2017},
   7   publisher={Hindawi}
   8 }
   9
  10 @inproceedings{muccini2018iot,
  11 author="Muccini, Henry and Moghaddam, Mahyar Tourchi",
  12 editor="Cuesta, Carlos E.  and Garlan, David and P{\'e}rez, Jennifer",
  13 title="IoT Architectural Styles",
  14 booktitle="Software Architecture",
  15 year="2018",
  16 publisher="Springer International Publishing",
  17 address="Cham",
  18 pages="68--85",
  19 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.",
  20 isbn="978-3-030-00761-4"
  21 }
  22
  23 @inproceedings{rosenberg1997some,
  24   title={Some misconceptions about lines of code},
  25   author={Rosenberg, Jarrett},
  26   booktitle={Proceedings fourth international software metrics symposium},
  27   pages={137--142},
  28   year={1997},
  29   organization={IEEE},
  30   publisher={IEEE},
  31   doi={10.1109/METRIC.1997.637174},
  32 address={Albuquerque, NM, USA}
  33 }
  34
  35 @inproceedings{cooper2006links,
  36         address = {Berlin, Heidelberg},
  37         title = {Links: {Web} {Programming} {Without} {Tiers}},
  38         isbn = {978-3-540-74792-5},
  39         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.},
  40         booktitle = {Formal {Methods} for {Components} and {Objects}},
  41         publisher = {Springer Berlin Heidelberg},
  42         author = {Cooper, Ezra and Lindley, Sam and Wadler, Philip and Yallop, Jeremy},
  43         editor = {de Boer, Frank S. and Bonsangue, Marcello M. and Graf, Susanne and de Roever, Willem-Paul},
  44         year = {2007},
  45         pages = {266--296}
  46 }
  47
  48 @inproceedings{serrano2006hop,
  49   title={Hop: a language for programming the web 2.0},
  50   author={Serrano, Manuel and Gallesio, Erick and Loitsch, Florian},
  51   booktitle={OOPSLA Companion},
  52   pages={975--985},
  53   year={2006},
  54   publisher={ACM},
  55   address={Portland, Oregon, USA},
  56 }
  57
  58 @inproceedings{lloyd1994practical,
  59   title={Practical Advtanages of Declarative Programming.},
  60   author={Lloyd, John W},
  61   booktitle={GULP-PRODE (1)},
  62   pages={18--30},
  63   year={1994}
  64 }
  65
  66 @online{singer16,
  67 author ={Jeremy Singer, Dejice Jacob, Kristian Hentschel},
  68 year = {2016},
  69 title ={Anyscale Sensors},
  70 url ={https://bitbucket.org/jsinger/anyscale-sensors/src/master/Readme.md},
  71 month ={Apr},
  72 lastaccessed ={April 1, 2016},
  73 }
  74
  75 @article{pechtchanski2005immutability,
  76   title={Immutability specification and its applications},
  77   author={Pechtchanski, Igor and Sarkar, Vivek},
  78   journal={Concurrency and Computation: Practice and Experience},
  79   volume={17},
  80   number={5-6},
  81   pages={639--662},
  82   year={2005},
  83   publisher={Wiley Online Library}
  84 }
  85
  86 @inproceedings{steiner_firmata_2009,
  87         title = {Firmata: {Towards} {Making} {Microcontrollers} {Act} {Like} {Extensions} of the {Computer}.},
  88         booktitle = {{NIME}},
  89         author = {Steiner, Hans-Christoph},
  90         year = {2009},
  91         pages = {125--130},
  92 }
  93
  94 @article{levis_mate_2002,
  95         title = {Maté: {A} tiny virtual machine for sensor networks},
  96         volume = {37},
  97         number = {10},
  98         journal = {ACM Sigplan Notices},
  99         author = {Levis, Philip and Culler, David},
 100         year = {2002},
 101         publisher = {ACM},
 102         pages = {85--95},
 103         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}
 104 }
 105
 106 @inproceedings{gill_remote_2015,
 107 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},
 108 title = {The Remote Monad Design Pattern},
 109 year = {2015},
 110 doi = {10.1145/2804302.2804311},
 111 booktitle = {Proceedings of the 2015 ACM SIGPLAN Symposium on Haskell},
 112 pages = {59–70},
 113 }
 114
 115 @article{light2017mosquitto,
 116   title={Mosquitto: server and client implementation of the MQTT protocol},
 117   author={Light, Roger},
 118   journal={Journal of Open Source Software},
 119   volume={2},
 120   number={13},
 121   pages={265},
 122   year={2017}
 123 }
 124
 125 @article{adl2006compiler,
 126   title={Compiler and runtime support for efficient software transactional memory},
 127   author={Adl-Tabatabai, Ali-Reza and Lewis, Brian T and Menon, Vijay and Murphy, Brian R and Saha, Bratin and Shpeisman, Tatiana},
 128   journal={ACM SIGPLAN Notices},
 129   volume={41},
 130   number={6},
 131   pages={26--37},
 132   year={2006},
 133   publisher={ACM}
 134 }
 135
 136 @inproceedings{schwarz2002disassembly,
 137   title={Disassembly of executable code revisited},
 138   author={Schwarz, Benjamin and Debray, Saumya and Andrews, Gregory},
 139   booktitle={Ninth Working Conference on Reverse Engineering, 2002. Proceedings.},
 140   pages={45--54},
 141   year={2002},
 142   organization={IEEE}
 143 }
 144
 145 @article{hughes1989functional,
 146   title={Why functional programming matters},
 147   author={Hughes, John},
 148   journal={The computer journal},
 149   volume={32},
 150   number={2},
 151   pages={98--107},
 152   year={1989},
 153   publisher={Oxford University Press}
 154 }
 155
 156 @article{davidson2018expressiveness,
 157   title={Expressiveness, meanings and machines},
 158   author={Davidson, Joe and Michaelson, Greg},
 159   journal={Computability},
 160   volume={7},
 161   number={4},
 162   pages={367--394},
 163   year={2018},
 164   publisher={IOS Press}
 165 }
 166
 167 @inproceedings{troyer_building_2018,
 168         title = {Building {IoT} {Systems} {Using} {Distributed} {First}-{Class} {Reactive} {Programming}},
 169         booktitle = {2018 {IEEE} {International} {Conference} on {Cloud} {Computing} {Technology} and {Science} ({CloudCom})},
 170         author = {Troyer, de, Christophe and Nicolay, Jens and Meuter, de, Wolfgang},
 171         month = dec,
 172         year = {2018},
 173         pages = {185--192},
 174         publisher = {IEEE},
 175         address = {Nicosia, Cyprus},
 176 }
 177
 178 @article{harth_predictive_2018,
 179   author    = {Natascha Harth and Christos Anagnostopoulos and Dimitrios Pezaros},
 180   title     = {Predictive intelligence to the edge: impact on edge analytics},
 181   journal   = {Evolving Systems},
 182   volume    = {9},
 183   number    = {2},
 184   pages     = {95--118},
 185   year      = {2018},
 186 }
 187
 188 @inproceedings{naik2017choice,
 189   title={Choice of effective messaging protocols for IoT systems: MQTT, CoAP, AMQP and HTTP},
 190   author={Naik, Nitin},
 191   booktitle={2017 IEEE international systems engineering symposium (ISSE)},
 192   pages={1--7},
 193   year={2017},
 194   organization={IEEE}
 195 }
 196
 197 @book{guinard_building_2016,
 198         address = {USA},
 199         edition = {1st},
 200         title = {Building the {Web} of {Things}: {With} {Examples} in {Node}.{Js} and {Raspberry} {Pi}},
 201         isbn = {1-61729-268-0},
 202         publisher = {Manning Publications Co.},
 203         author = {Guinard, Dominique and Trifa, Vlad},
 204         year = {2016}
 205 }
 206
 207 @inproceedings{ireland2009classification,
 208   title={A classification of object-relational impedance mismatch},
 209   author={Ireland, Christopher and Bowers, David and Newton, Michael and Waugh, Kevin},
 210   booktitle={2009 First International Confernce on Advances in Databases, Knowledge, and Data Applications},
 211   pages={36--43},
 212   year={2009},
 213   organization={IEEE},
 214   publisher={IEEE},
 215         doi={10.1109/DBKDA.2009.11},
 216         address={Gosier, France}
 217 }
 218
 219 @article{maccormack2007impact,
 220   title={The impact of component modularity on design evolution: Evidence from the software industry},
 221   author={MacCormack, Alan and Rusnak, John and Baldwin, Carliss Y},
 222   journal={Harvard Business School Technology \& Operations Mgt. Unit Research Paper},
 223   number={038},
 224   volume={08},
 225   year={2007},
 226   month={dec},
 227   doi={10.2139/ssrn.1071720},
 228 }
 229
 230
 231 @inproceedings{belle2013layered,
 232         address = {Boston, MA, USA},
 233         title = {The layered architecture revisited: {Is} it an optimization problem?},
 234         volume = {1},
 235         isbn = {978-1-5108-4159-8},
 236         shorttitle = {{SEKE} 2013},
 237         booktitle = {Proceedings of the {Twenty}-{Fifth} {International} {Conference} on {Software} {Engineering} \& {Knowledge} {E}},
 238         publisher = {KSI Research Inc},
 239         author = {Belle, Alvine Boaye and El-Boussaidi, Ghizlane and Desrosiers, Christian and Mili, Hafedh},
 240         year = {2013},
 241         pages = {344--349}
 242 }
 243
 244 @inproceedings{lee2001component,
 245   title={Component identification method with coupling and cohesion},
 246   author={Lee, Jong Kook and Jung, Seung Jae and Kim, Soo Dong and Jang, Woo Hyun and Ham, Dong Han},
 247   booktitle={Proceedings Eighth Asia-Pacific Software Engineering Conference},
 248   pages={79--86},
 249   year={2001},
 250   organization={IEEE},
 251   publisher={IEEE},
 252   address={Macao, China},
 253 }
 254
 255 @article{antoniu2007combining,
 256   title={Combining data sharing with the master--worker paradigm in the common component architecture},
 257   author={Antoniu, Gabriel and Bouziane, Hinde Lilia and Jan, Mathieu and P{\'e}rez, Christian and Priol, Thierry},
 258   journal={Cluster Computing},
 259   volume={10},
 260   number={3},
 261   pages={265--276},
 262   year={2007},
 263   publisher={Springer}
 264 }
 265
 266 @inproceedings{grgic2016web,
 267   title={A web-based IoT solution for monitoring data using MQTT protocol},
 268   author={Grgi{\'c}, Kre{\v{s}}imir and {\v{S}}peh, Ivan and He{\dj}i, Ivan},
 269   booktitle={2016 international conference on smart systems and technologies (SST)},
 270   pages={249--253},
 271   year={2016},
 272   organization={IEEE}
 273 }
 274
 275 @inproceedings{athanasopoulos2006interoperability,
 276   title={Interoperability among heterogeneous services},
 277   author={Athanasopoulos, George and Tsalgatidou, Aphrodite and Pantazoglou, Michael},
 278   booktitle={2006 IEEE International Conference on Services Computing (SCC'06)},
 279   pages={174--181},
 280   year={2006},
 281   organization={IEEE}
 282 }
 283
 284 @article{mazzei2018full,
 285   title={A full stack for quick prototyping of IoT solutions},
 286   author={Mazzei, Daniele and Baldi, Giacomo and Montelisciani, Gabriele and Fantoni, Gualtiero},
 287   journal={Annals of Telecommunications},
 288   volume={73},
 289   number={7-8},
 290   pages={439--449},
 291   year={2018},
 292   publisher={Springer}
 293 }
 294
 295 @article{barrett2015fine,
 296   title={Fine-grained language composition: A case study},
 297   author={Barrett, Edd and Bolz, Carl Friedrich and Diekmann, Lukas and Tratt, Laurence},
 298   journal={arXiv preprint arXiv:1503.08623},
 299   year={2015}
 300 }
 301
 302 @inproceedings{patwardhan2004communication,
 303   title={Communication breakdown: analyzing cpu usage in commercial web workloads},
 304   author={Patwardhan, Jaidev P and Lebeck, Alvin R and Sorin, Daniel J},
 305   booktitle={IEEE International Symposium on-ISPASS Performance Analysis of Systems and Software, 2004},
 306   pages={12--19},
 307   year={2004},
 308   organization={IEEE}
 309 }
 310
 311 @inproceedings{cooper2008essence,
 312   title={The essence of form abstraction},
 313   author={Cooper, Ezra and Lindley, Sam and Wadler, Philip and Yallop, Jeremy},
 314   booktitle={Asian Symposium on Programming Languages and Systems},
 315   pages={205--220},
 316   year={2008},
 317   organization={Springer}
 318 }
 319
 320 @article{rinard2003credible,
 321   title={Credible compilation},
 322   author={Rinard, Martin C},
 323   year={2003}
 324 }
 325
 326 @inproceedings{bucur2014prototyping,
 327   title={Prototyping symbolic execution engines for interpreted languages},
 328   author={Bucur, Stefan and Kinder, Johannes and Candea, George},
 329   booktitle={Proceedings of the 19th international conference on Architectural support for programming languages and operating systems},
 330   pages={239--254},
 331   year={2014}
 332 }
 333
 334 @inproceedings{barany2014python,
 335   title={Python interpreter performance deconstructed},
 336   author={Barany, Gerg{\"o}},
 337   booktitle={Proceedings of the Workshop on Dynamic Languages and Applications},
 338   pages={1--9},
 339   year={2014}
 340 }
 341
 342 @article{mayer2017multi,
 343   title={On multi-language software development, cross-language links and accompanying tools: a survey of professional software developers},
 344   author={Mayer, Philip and Kirsch, Michael and Le, Minh Anh},
 345   journal={Journal of Software Engineering Research and Development},
 346   volume={5},
 347   number={1},
 348   pages={1},
 349   year={2017},
 350   publisher={Springer}
 351 }
 352
 353 @inproceedings{mayer2015empirical,
 354 author = {Mayer, Philip and Bauer, Alexander},
 355 title = {An Empirical Analysis of the Utilization of Multiple Programming Languages in Open Source Projects},
 356 year = {2015},
 357 isbn = {9781450333504},
 358 publisher = {Association for Computing Machinery},
 359 address = {New York, NY, USA},
 360 doi = {10.1145/2745802.2745805},
 361 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.},
 362 booktitle = {Proceedings of the 19th International Conference on Evaluation and Assessment in Software Engineering},
 363 articleno = {4},
 364 numpages = {10},
 365 location = {Nanjing, China},
 366 series = {EASE '15}
 367 }
 368
 369 @article{avizienis85n,
 370   author={A. {Avizienis}},
 371   journal={IEEE Transactions on Software Engineering},
 372   title={The N-Version Approach to Fault-Tolerant Software},
 373   year={1985},
 374   volume={SE-11},
 375   number={12},
 376   pages={1491-1501},
 377   doi={10.1109/TSE.1985.231893}
 378 }
 379
 380
 381 @inproceedings{motta2018challenges,
 382 author = {Motta, Rebeca C. and de Oliveira, K\'{a}thia M. and Travassos, Guilherme H.},
 383 title = {On Challenges in Engineering IoT Software Systems},
 384 year = {2018},
 385 isbn = {9781450365031},
 386 publisher = {Association for Computing Machinery},
 387 address = {New York, NY, USA},
 388 doi = {10.1145/3266237.3266263},
 389 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.},
 390 booktitle = {Proceedings of the XXXII Brazilian Symposium on Software Engineering},
 391 pages = {42–51},
 392 numpages = {10},
 393 keywords = {challenges, concerns, internet of things, IoT, literature review, empirical software engineering},
 394 location = {Sao Carlos, Brazil},
 395 series = {SBES '18}
 396 }
 397
 398 @article{gubbi2013internet,
 399   title={Internet of Things (IoT): A vision, architectural elements, and future directions},
 400   author={Gubbi, Jayavardhana and Buyya, Rajkumar and Marusic, Slaven and Palaniswami, Marimuthu},
 401   journal={Future generation computer systems},
 402   volume={29},
 403   number={7},
 404   pages={1645--1660},
 405   year={2013},
 406   publisher={Elsevier}
 407 }
 408
 409 @article{guzman2018human,
 410   title={What is human-machine communication, anyway},
 411   author={Guzman, Andrea L},
 412   journal={Human-machine communication: Rethinking communication, technology, and ourselves},
 413   pages={1--28},
 414   year={2018},
 415   publisher={Peter Lang New York}
 416 }
 417
 418 @article{wan2016software,
 419   title={Software-defined industrial internet of things in the context of industry 4.0},
 420   author={Wan, Jiafu and Tang, Shenglong and Shu, Zhaogang and Li, Di and Wang, Shiyong and Imran, Muhammad and Vasilakos, Athanasios V},
 421   journal={IEEE Sensors Journal},
 422   volume={16},
 423   number={20},
 424   pages={7373--7380},
 425   year={2016},
 426   publisher={IEEE}
 427 }
 428
 429 @article{batory1992design,
 430   title={The design and implementation of hierarchical software systems with reusable components},
 431   author={Batory, Don and O'malley, Sean},
 432   journal={ACM Transactions on Software Engineering and Methodology (TOSEM)},
 433   volume={1},
 434   number={4},
 435   pages={355--398},
 436   year={1992},
 437   publisher={ACM New York, NY, USA}
 438 }
 439
 440 @article{mockus2002two,
 441   title={Two case studies of open source software development: Apache and Mozilla},
 442   author={Mockus, Audris and Fielding, Roy T and Herbsleb, James D},
 443   journal={ACM Transactions on Software Engineering and Methodology (TOSEM)},
 444   volume={11},
 445   number={3},
 446   pages={309--346},
 447   year={2002},
 448   publisher={ACM New York, NY, USA}
 449 }
 450
 451 @inproceedings{le2015microservice,
 452   title={Microservice-based architecture for the NRDC},
 453   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},
 454   booktitle={2015 IEEE 13th International Conference on Industrial Informatics (INDIN)},
 455   pages={1659--1664},
 456   year={2015},
 457   organization={IEEE},
 458   publisher={IEEE},
 459   address={Cambridge, UK},
 460 }
 461
 462 @inproceedings{kodali2016low,
 463   title={Low cost ambient monitoring using ESP8266},
 464   author={Kodali, Ravi Kishore and Mahesh, Kopulwar Shishir},
 465   booktitle={2016 2nd International Conference on Contemporary Computing and Informatics (IC3I)},
 466   pages={779--782},
 467   year={2016},
 468   organization={IEEE},
 469   publisher={IEEE},
 470  address={Greater Noida, India}
 471 }
 472
 473 @article{beaven1993explaining,
 474   title={Explaining type errors in polymorphic languages},
 475   author={Beaven, Mike and Stansifer, Ryan},
 476   journal={ACM Letters on Programming Languages and Systems (LOPLAS)},
 477   volume={2},
 478   number={1-4},
 479   pages={17--30},
 480   year={1993},
 481   publisher={ACM New York, NY, USA}
 482 }
 483
 484 @phdthesis{armstrong2003making,
 485   title={Making reliable distributed systems in the presence of software errors},
 486   author={Armstrong, Joe},
 487   year={2003}
 488 }
 489
 490 @article{madsen1990strong,
 491   title={Strong typing of object-oriented languages revisited},
 492   author={Madsen, Ole Lehrmann and Magnusson, Boris and M{\o}lier-Pedersen, Birger},
 493   journal={ACM SIGPLAN Notices},
 494   volume={25},
 495   number={10},
 496   pages={140--150},
 497   year={1990},
 498   publisher={ACM New York, NY, USA}
 499 }
 500
 501 @article{cass20182017,
 502   title={The 2017 top programming languages},
 503   author={Cass, Stephen},
 504   journal={IEEE Spectrum},
 505   volume={31},
 506   year={2018}
 507 }
 508
 509 @book{tollervey2017programming,
 510   title={Programming with MicroPython: Embedded Programming with Microcontrollers and Python},
 511   author={Tollervey, Nicholas H},
 512   year={2017},
 513   publisher={" O'Reilly Media, Inc."}
 514 }
 515
 516 @inproceedings{alpernaswonderful,
 517 author = {Alpernas, Kalev and Feldman, Yotam M. Y. and Peleg, Hila},
 518 title = {The Wonderful Wizard of LoC: Paying Attention to the Man behind the Curtain of Lines-of-Code Metrics},
 519 year = {2020},
 520 isbn = {9781450381789},
 521 publisher = {Association for Computing Machinery},
 522 address = {New York, NY, USA},
 523 doi = {10.1145/3426428.3426921},
 524 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.},
 525 booktitle = {Proceedings of the 2020 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software},
 526 pages = {146–156},
 527 numpages = {11},
 528 keywords = {research papers, loc, lines of code},
 529 location = {Virtual, USA},
 530 series = {Onward! 2020}
 531 }
 532
 533 @inproceedings{epstein2011towards,
 534         author = {Epstein, Jeff and Black, Andrew P. and Peyton Jones, Simon},
 535         title = {Towards Haskell in the Cloud},
 536         year = {2011},
 537         isbn = {9781450308601},
 538         publisher = {Association for Computing Machinery},
 539         address = {New York, NY, USA},
 540         doi = {10.1145/2034675.2034690},
 541         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.},
 542         booktitle = {Proceedings of the 4th ACM Symposium on Haskell},
 543         pages = {118–129},
 544         numpages = {12},
 545         keywords = {message-passing, haskell, erlang},
 546         location = {Tokyo, Japan},
 547         series = {Haskell '11}
 548 }
 549
 550 @book{gupta2012akka,
 551   title={Akka essentials},
 552   address={Livery Place, 35 Livery Street, Birmingham B3 2PB, UK},
 553   author={Gupta, Munish},
 554   year={2012},
 555   publisher={Packt Publishing Ltd}
 556 }
 557
 558 @article{millman2011python,
 559   title={Python for scientists and engineers},
 560   author={Millman, K Jarrod and Aivazis, Michael},
 561   journal={Computing in Science \& Engineering},
 562   volume={13},
 563   number={2},
 564   pages={9--12},
 565   year={2011},
 566   publisher={IEEE}
 567 }
 568
 569 @misc{pyforum,
 570  title = "Python Official Forum",
 571  author = "",
 572  year = "2021",
 573  note = "https://www.python.org/community/forums/"
 574 }
 575
 576 @misc{microforum,
 577  title = "Micropython Official Forum",
 578  author = "",
 579  year = "2021",
 580  note = "https://forum.micropython.org/"
 581 }
 582
 583 @misc{microdocs,
 584  title = "Official Micropython Docs",
 585  author = "",
 586  year = "2021",
 587  note = "https://docs.micropython.org/en/latest/"
 588 }
 589
 590 @misc{ wiki:IO,
 591         author = "HaskellWiki",
 592         title = "Introduction to IO --- HaskellWiki{,} ",
 593         year = "2020",
 594         url = "https://wiki.haskell.org/index.php?title=Introduction_to_IO&oldid=63493",
 595         note = "[Online; accessed 19-January-2021]"
 596 }
 597
 598 @misc{CircuitPython,
 599         author = "CircuitPython Team",
 600         title = "CircuitPython",
 601         year = "2022",
 602         url = "https://circuitpython.org/",
 603         note = "[Online; accessed 2-March-2022]"
 604 }
 605
 606 @article{barendsen_smetsers_1996,
 607         title={Uniqueness typing for functional languages with graph rewriting semantics},
 608         volume={6},
 609         DOI={10.1017/S0960129500070109},
 610         number={6},
 611         journal={Mathematical Structures in Computer Science},
 612         publisher={Cambridge University Press},
 613         author={Barendsen, Erik and Smetsers, Sjaak},
 614         year={1996},
 615         pages={579–612}
 616 }
 617 @InProceedings{GenericProgrammingExtensionForClean,
 618         author = "Alimarine, Artem and Plasmeijer, Rinus",
 619         editor = "Arts, Thomas and Mohnen, Markus",
 620         title="A Generic Programming Extension for Clean",
 621         booktitle="Implementation of Functional Languages",
 622         year="2002",
 623         publisher="Springer Berlin Heidelberg",
 624         address="Berlin, Heidelberg",
 625         pages="168--185",
 626         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.",
 627         isbn="978-3-540-46028-2"
 628 }
 629 @inproceedings{HinzeGenericFunctionalProgramming,
 630         author = {Hinze, Ralf},
 631         title = {A New Approach to Generic Functional Programming},
 632         year = {2000},
 633         isbn = {1581131259},
 634         publisher = {Association for Computing Machinery},
 635         address = {New York, NY, USA},
 636         doi = {10.1145/325694.325709},
 637         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 λ-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.},
 638         booktitle = {Proceedings of the 27th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
 639         pages = {119–132},
 640         numpages = {14},
 641         location = {Boston, MA, USA},
 642         series = {POPL '00}
 643 }
 644 @inproceedings{TOP-PPDP12,
 645         author = {Plasmeijer, Rinus and Lijnse, Bas and Michels, Steffen and Achten, Peter and Koopman, Pieter},
 646         title = {Task-Oriented Programming in a Pure Functional Language},
 647         year = {2012},
 648         isbn = {9781450315227},
 649         publisher = {Association for Computing Machinery},
 650         address = {New York, NY, USA},
 651         doi = {10.1145/2370776.2370801},
 652         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.},
 653         booktitle = {Proceedings of the 14th Symposium on Principles and Practice of Declarative Programming},
 654         pages = {195–206},
 655         numpages = {12},
 656         keywords = {task-oriented programming, clean},
 657         location = {Leuven, Belgium},
 658         series = {PPDP '12}
 659 }
 660 @inproceedings{
 661         TOP-ICFP07,
 662         author      = {Plasmeijer, Rinus and Achten, Peter and Koopman, Pieter},
 663         title       = {{iTasks}: {E}xecutable {S}pecifications of {I}nteractive {W}ork {F}low {S}ystems for the {W}eb},
 664         booktitle   = {{P}roceedings of the 12th {ACM SIGPLAN} {I}nternational {C}onference on {F}unctional {P}rogramming ({ICFP} 2007)},
 665         address     = {{F}reiburg, {G}ermany},
 666         year        = 2007,
 667         month       = {Oct 1--3},
 668         publisher   = {ACM},
 669         isbn        = "978-1-59593-815-2",
 670         pages       = {141-152}
 671 }
 672 @article{FinallyTagless,
 673         author    = {Jacques Carette and Oleg Kiselyov and Chung{-}chieh Shan},
 674         title     = {Finally tagless, partially evaluated: Tagless staged interpreters
 675         for simpler typed languages},
 676         journal   = {J. Funct. Program.},
 677         volume    = {19},
 678         number    = {5},
 679         pages     = {509--543},
 680         year      = {2009},
 681         url       = {https://doi.org/10.1017/S0956796809007205},
 682         doi       = {10.1017/S0956796809007205},
 683         timestamp = {Sun, 02 Jun 2019 21:00:12 +0200},
 684         biburl    = {https://dblp.org/rec/journals/jfp/CaretteKS09.bib},
 685         bibsource = {dblp computer science bibliography, https://dblp.org}
 686 }
 687
 688 @inproceedings{oortgiese_distributed_2017,
 689         title = {A {Distributed} {Dynamic} {Architecture} for {Task} {Oriented} {Programming}},
 690         booktitle = {Proceedings of the 29th {Symposium} on {Implementation} and {Application} of {Functional} {Programming} {Languages}},
 691         publisher = {ACM},
 692         author = {Oortgiese, Arjan and van Groningen, John and Achten, Peter and Plasmeijer, Rinus},
 693         year = {2017},
 694         pages = {7},
 695         address = {Bristol, UK}
 696 }
 697
 698 @inproceedings{stefik14programming,
 699  author = {Stefik, Andreas and Hanenberg, Stefan},
 700  title = {The Programming Language Wars: Questions and Responsibilities for the Programming Language Community},
 701  year = {2014},
 702  doi = {10.1145/2661136.2661156},
 703  booktitle = {Proceedings of the 2014 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming \& Software},
 704  pages = {283--299},
 705 }
 706
 707 @inproceedings{ParametricLenses,
 708     author = {Domoszlai, L\'{a}szl\'{o} and Lijnse, Bas and Plasmeijer, Rinus},
 709     title = {Parametric Lenses: Change Notification for Bidirectional Lenses},
 710     year = {2014},
 711     isbn = {9781450332842},
 712     publisher = {Association for Computing Machinery},
 713     address = {New York, NY, USA},
 714     doi = {10.1145/2746325.2746333},
 715     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.},
 716     booktitle = {Proceedings of the 26th  International Symposium on Implementation and Application of Functional Languages},
 717     articleno = {9},
 718     numpages = {11},
 719     keywords = {notification systems, parametric views, lenses, parametric lenses, Bi-directional programming},
 720     location = {Boston, MA, USA},
 721     series = {IFL '14}
 722 }
 723
 724 @article{10.1145/1543134.1411301,
 725     author = {Rodriguez, Alexey and Jeuring, Johan and Jansson, Patrik and Gerdes, Alex and Kiselyov, Oleg and Oliveira, Bruno C. d. S.},
 726     title = {Comparing Libraries for Generic Programming in Haskell},
 727     year = {2008},
 728     issue_date = {February 2009},
 729     publisher = {Association for Computing Machinery},
 730     address = {New York, NY, USA},
 731     volume = {44},
 732     number = {2},
 733     issn = {0362-1340},
 734     doi = {10.1145/1543134.1411301},
 735     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.},
 736     journal = {SIGPLAN Not.},
 737     month = sep,
 738     pages = {111–122},
 739     numpages = {12},
 740     keywords = {datatype-generic programming, libraries comparison}
 741 }
 742
 743 @inproceedings{ComparingGenericProgramming,
 744     author = {Rodriguez, Alexey and Jeuring, Johan and Jansson, Patrik and Gerdes, Alex and Kiselyov, Oleg and Oliveira, Bruno C. d. S.},
 745     title = {Comparing Libraries for Generic Programming in Haskell},
 746     year = {2008},
 747     isbn = {9781605580647},
 748     publisher = {Association for Computing Machinery},
 749     address = {New York, NY, USA},
 750     doi = {10.1145/1411286.1411301},
 751     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.},
 752     booktitle = {Proceedings of the First ACM SIGPLAN Symposium on Haskell},
 753     pages = {111–122},
 754     numpages = {12},
 755     keywords = {datatype-generic programming, libraries comparison},
 756     location = {Victoria, BC, Canada},
 757     series = {Haskell '08}
 758 }
 759
 760 @InProceedings{ComposingReactiveGUIs,
 761     author="Bjornson, Joel
 762     and Tayanovskyy, Anton
 763     and Granicz, Adam",
 764     editor="Hage, Jurriaan
 765     and Moraz{\'a}n, Marco T.",
 766     title="Composing Reactive GUIs in F{\#} Using WebSharper",
 767     booktitle="Implementation and Application of Functional Languages",
 768     year="2011",
 769     publisher="Springer Berlin Heidelberg",
 770     address="Berlin, Heidelberg",
 771     pages="203--216",
 772     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.",
 773     isbn="978-3-642-24276-2"
 774 }
 775
 776 @inproceedings{FunctionalReactiveAnimation,
 777     author = {Elliott, Conal and Hudak, Paul},
 778     title = {Functional Reactive Animation},
 779     year = {1997},
 780     isbn = {0897919181},
 781     publisher = {Association for Computing Machinery},
 782     address = {New York, NY, USA},
 783     doi = {10.1145/258948.258973},
 784     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.},
 785     booktitle = {Proceedings of the Second ACM SIGPLAN International Conference on Functional Programming},
 786     pages = {263–273},
 787     numpages = {11},
 788     location = {Amsterdam, The Netherlands},
 789     series = {ICFP '97}
 790 }
 791
 792 @inproceedings{kochhar2016large,
 793  author={P. S. {Kochhar} and D. {Wijedasa} and D. {Lo}},
 794  booktitle={23rd International Conference on Software Analysis, Evolution, and Reengineering},
 795  title={A Large Scale Study of Multiple Programming Languages and Code Quality},
 796  year={2016},
 797  pages={563--573},
 798  doi={10.1109/SANER.2016.112},
 799  address={Osaka, Japan},
 800  publisher={IEEE}
 801 }
 802
 803 @inproceedings{hao2020approaching,
 804   author =      {Rebecca L. Hao and Elena L. Glassman},
 805   title =       {{Approaching Polyglot Programming: What Can We Learn from Bilingualism Studies?}},
 806   booktitle =   {10th Workshop on Evaluation and Usability of Programming Languages and Tools (PLATEAU 2019)},
 807   pages =       {1:1--1:7},
 808   year =        {2020},
 809   volume =      {76},
 810   doi =         {10.4230/OASIcs.PLATEAU.2019.1},
 811 }
 812
 813 @article{cass2020top,
 814   title={The top programming languages: Our latest rankings put Python on top-again-[Careers]},
 815   author={Cass, Stephen},
 816   journal={IEEE Spectrum},
 817   volume={57},
 818   number={8},
 819   pages={22--22},
 820   year={2020},
 821   publisher={IEEE}
 822 }
 823
 824 @inproceedings{tanganelli2015coapthon,
 825   title={CoAPthon: Easy development of CoAP-based IoT applications with Python},
 826   author={Tanganelli, Giacomo and Vallati, Carlo and Mingozzi, Enzo},
 827   booktitle={2015 IEEE 2nd World Forum on Internet of Things (WF-IoT)},
 828   pages={63--68},
 829   year={2015},
 830   publisher={IEEE},
 831   address={Milan, Italy}
 832 }
 833
 834 @INPROCEEDINGS{Wadler92comprehendingmonads,
 835 author = {Wadler, Philip},
 836 title = {Comprehending Monads},
 837 year = {1990},
 838 isbn = {089791368X},
 839 publisher = {Association for Computing Machinery},
 840 address = {New York, NY, USA},
 841 doi = {10.1145/91556.91592},
 842 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.},
 843 booktitle = {Proceedings of the 1990 ACM Conference on LISP and Functional Programming},
 844 pages = {61–78},
 845 numpages = {18},
 846 location = {Nice, France},
 847 series = {LFP '90}
 848 }
 849 @misc{smartcampus,
 850  author = {Mott Macdonald},
 851  title = "University of Glasgow Smart Campus Digital Masterplan",
 852  year = "2019",
 853  note = "\url{https://www.gla.ac.uk/media/Media_702108_smxx.pdf}",
 854 }
 855
 856 @misc{IIO,
 857         author = "Bijan Mottahedeh",
 858         title = "An Introduction to the io XXX uring Asynchronous I/O Framework",
 859         year = "2020",
 860         url = "https://blogs.oracle.com/linux/an-introduction-to-the-io XXX uring-asynchronous-io-framework",
 861         note = "[Online; accessed 13-May-2021]"
 862 }
 863
 864 @inproceedings{10.1145/1806596.1806601,
 865 author = {Lee, Byeongcheol and Wiedermann, Ben and Hirzel, Martin and Grimm, Robert and McKinley, Kathryn S.},
 866 title = {Jinn: Synthesizing Dynamic Bug Detectors for Foreign Language Interfaces},
 867 year = {2010},
 868 isbn = {9781450300193},
 869 publisher = {Association for Computing Machinery},
 870 address = {New York, NY, USA},
 871 doi = {10.1145/1806596.1806601},
 872 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.},
 873 booktitle = {Proceedings of the 31st ACM SIGPLAN Conference on Programming Language Design and Implementation},
 874 pages = {36–49},
 875 numpages = {14},
 876 keywords = {dynamic analysis, multilingual programs, foreign function interfaces (FFI), python/C, java native interface (jni), specification, specification generation, ffi bugs},
 877 location = {Toronto, Ontario, Canada},
 878 series = {PLDI '10}
 879 }
 880
 881
 882 @article{Jinn
 883 ,
 884 author = {Lee, Byeongcheol and Wiedermann, Ben and Hirzel, Martin and Grimm, Robert and McKinley, Kathryn S.},
 885 title = {Jinn: Synthesizing Dynamic Bug Detectors for Foreign Language Interfaces},
 886 year = {2010},
 887 issue_date = {June 2010},
 888 publisher = {Association for Computing Machinery},
 889 address = {New York, NY, USA},
 890 volume = {45},
 891 number = {6},
 892 issn = {0362-1340},
 893 doi = {10.1145/1809028.1806601},
 894 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.},
 895 journal = {SIGPLAN Not.},
 896 month = jun,
 897 pages = {36–49},
 898 numpages = {14},
 899 keywords = {specification generation, specification, python/C, dynamic analysis, multilingual programs, java native interface (jni), foreign function interfaces (FFI), ffi bugs}
 900 }
 901 @inproceedings{10.1145/1065010.1065019,
 902 author = {Furr, Michael and Foster, Jeffrey S.},
 903 title = {Checking Type Safety of Foreign Function Calls},
 904 year = {2005},
 905 isbn = {1595930566},
 906 publisher = {Association for Computing Machinery},
 907 address = {New York, NY, USA},
 908 doi = {10.1145/1065010.1065019},
 909 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.},
 910 booktitle = {Proceedings of the 2005 ACM SIGPLAN Conference on Programming Language Design and Implementation},
 911 pages = {62–72},
 912 numpages = {11},
 913 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},
 914 location = {Chicago, IL, USA},
 915 series = {PLDI '05}
 916 }
 917
 918 @article{Furr2005,
 919 author = {Furr, Michael and Foster, Jeffrey S.},
 920 title = {Checking Type Safety of Foreign Function Calls},
 921 year = {2005},
 922 issue_date = {June 2005},
 923 publisher = {Association for Computing Machinery},
 924 address = {New York, NY, USA},
 925 volume = {40},
 926 number = {6},
 927 issn = {0362-1340},
 928 doi = {10.1145/1064978.1065019},
 929 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.},
 930 journal = {SIGPLAN Not.},
 931 month = jun,
 932 pages = {62–72},
 933 numpages = {11},
 934 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}
 935 }
 936
 937 @INPROCEEDINGS{LubbersMIPRO,
 938   author={Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
 939   booktitle={2019 42nd International Convention on Information and Communication Technology, Electronics and Microelectronics (MIPRO)},
 940   title={Multitasking on Microcontrollers using Task Oriented Programming},
 941   year={2019},
 942   volume={},
 943   number={},
 944   pages={1587-1592},
 945   publisher={IEEE},
 946   address={Opatija, Croatia},
 947   doi={10.23919/MIPRO.2019.8756711}}
 948
 949 @inproceedings{plamauer2017evaluation,
 950   title={Evaluation of micropython as application layer programming language on cubesats},
 951   author={Plamauer, Sebastian and Langer, Martin},
 952   booktitle={ARCS 2017; 30th International Conference on Architecture of Computing Systems},
 953   pages={1--9},
 954   year={2017},
 955   organization={VDE},
 956   publisher={VDE},
 957   address={Vienna, Austria}
 958 }
 959
 960 @inproceedings{egyed1999automatically,
 961   title={Automatically detecting mismatches during component-based and model-based development},
 962   author={Egyed, Alexander and Gacek, Cristina},
 963   booktitle={14th IEEE International Conference on Automated Software Engineering},
 964   pages={191--198},
 965   year={1999},
 966   organization={IEEE}
 967 }
 968
 969 @book{Ravulavaru18,
 970 author = {Ravulavaru, Arvind},
 971 isbn = {1-78883-378-3},
 972 language = {eng},
 973 publisher = {Packt Publishing},
 974 title = {Enterprise internet of things handbook : build end-to-end IoT solutions using popular IoT platforms},
 975 year = {2018},
 976 address = {Birmingham, UK},
 977 }
 978
 979 @InProceedings{Alphonsa20,
 980 author="Alphonsa, Mandla",
 981 editor="Kumar, Amit
 982 and Mozar, Stefan",
 983 title="A Review on IOT Technology Stack, Architecture and Its Cloud Applications in Recent Trends",
 984 booktitle="ICCCE 2020",
 985 year="2021",
 986 publisher="Springer Singapore",
 987 address="Singapore",
 988 pages="703--711",
 989 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.",
 990 isbn="978-981-15-7961-5"
 991 }
 992 @inproceedings{jones_clean_io,
 993 author = {Jones, Simon B},
 994 title = {Experiences with Clean I/O},
 995 year = {1995},
 996 publisher = {BCS Learning \& Development Ltd.},
 997 address = {Swindon, GBR},
 998 abstract = {The Clean system is a powerful functional programming tool. It contains experiments
 999 in a number of different areas of functional language design. In particular, it has
1000 a novel proposal for the organization of input and output, and contains impressive
1001 libraries of facilities for programming graphical user interfaces.Clean I/O is based
1002 on collections of operations that act to cause side effects on multiple explicit abstract
1003 values representing physical I/O entities, such as files and graphical interfaces.
1004 A system of unique types is used to ensure that these values are individually single
1005 threaded through the program; and the side effecting I/O operations are therefore
1006 well controlled. This approach is distinct from monadic I/O, which is being widely
1007 adopted; monadic I/O schemes are based on a single, implicit environment, and guarantee
1008 that this is single threaded.In this paper we will show that the Clean and monadic
1009 approaches to I/O merge nicely. The functionality provided by the Clean and its I/O
1010 libraries allows libraries for monadic I/O to be implemented. The paper presents an
1011 implementation of a basic I/O monad library in Clean that can serve for future development.
1012 In itself, the fact that the monadic approach can be implemented in Clean is unsurprising.
1013 However, some interesting technical difficulties arose during implementation of the
1014 monad; these and their solutions are discussed. The opportunity to express programs
1015 using the implicit environments of monadic I/O allows us to simplify Clean programs
1016 by removing some of the spaghetti, whilst retaining the generality of the explicit
1017 environments where it is the most appropriate approach.},
1018 booktitle = {Proceedings of the 1995 International Conference on Functional Programming},
1019 pages = {167–177},
1020 numpages = {11},
1021 location = {Glasgow, UK},
1022 series = {FP'95}
1023 }
1024
1025 @inproceedings{sivieri2012drop,
1026   title={Drop the phone and talk to the physical world: Programming the internet of things with Erlang},
1027   author={Sivieri, Alessandro and Mottola, Luca and Cugola, Gianpaolo},
1028   booktitle={2012 Third International Workshop on Software Engineering for Sensor Network Applications (SESENA)},
1029   pages={8--14},
1030   year={2012},
1031   organization={IEEE}
1032 }
1033
1034 @article{chong2007secure,
1035   title={Secure web applications via automatic partitioning},
1036   author={Chong, Stephen and Liu, Jed and Myers, Andrew C and Qi, Xin and Vikram, Krishnaprasad and Zheng, Lantian and Zheng, Xin},
1037   journal={ACM SIGOPS Operating Systems Review},
1038   volume={41},
1039   number={6},
1040   pages={31--44},
1041   year={2007},
1042   publisher={ACM New York, NY, USA}
1043 }
1044
1045 @article{zdancewic2002secure,
1046   title={Secure program partitioning},
1047   author={Zdancewic, Steve and Zheng, Lantian and Nystrom, Nathaniel and Myers, Andrew C},
1048   journal={ACM Transactions on Computer Systems (TOCS)},
1049   volume={20},
1050   number={3},
1051   pages={283--328},
1052   year={2002},
1053   publisher={ACM New York, NY, USA}
1054 }
1055
1056 @article{bhatt2012analysis,
1057   title={Analysis of source lines of code (SLOC) metric},
1058   author={Bhatt, Kaushal and Tarey, Vinit and Patel, Pushpraj and Mits, Kaushal Bhatt and Ujjain, Datana},
1059   journal={International Journal of Emerging Technology and Advanced Engineering},
1060   volume={2},
1061   number={5},
1062   pages={150--154},
1063   year={2012},
1064   publisher={Citeseer}
1065 }
1066
1067 @article{10.1145/2775050.2633367,
1068 author = {Ekblad, Anton and Claessen, Koen},
1069 title = {A Seamless, Client-Centric Programming Model for Type Safe Web Applications},
1070 year = {2014},
1071 issue_date = {December 2014},
1072 publisher = {Association for Computing Machinery},
1073 address = {New York, NY, USA},
1074 volume = {49},
1075 number = {12},
1076 issn = {0362-1340},
1077 doi = {10.1145/2775050.2633367},
1078 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.},
1079 journal = {SIGPLAN Not.},
1080 month = {sep},
1081 pages = {79–89},
1082 numpages = {11},
1083 keywords = {distributed systems, web applications, network communication}
1084 }
1085
1086 @article{jones_1992, title={Implementing lazy functional languages on stock
1087         hardware: the Spineless Tagless G-machine}, volume={2},
1088         DOI={10.1017/S0956796800000319}, number={2}, journal={Journal of Functional
1089                                                                                                            Programming},
1090 publisher={Cambridge University Press}, author={Peyton Jones, Simon}, year={1992}, pages={127–202}}
1091
1092
1093 @article{domoszlai_implementing_2011,
1094         title = {Implementing a non-strict purely functional language in {JavaScript}},
1095         volume = {3},
1096         url = {https://www.researchgate.net/profile/Jan_Martin_Jansen2/publication/230607075_Implementing_a_non-strict_purely_functional_language_in_JavaScript/links/53fc40190cf22f21c2f3b28a.pdf},
1097         urldate = {2017-05-23},
1098         journal = {Acta Universitatis Sapientiae},
1099         author = {Domoszlai, Laszlo and Bruel, Eddy and Jansen, Jan Martin},
1100         year = {2011},
1101         pages = {76--98},
1102         file = {53fc40190cf22f21c2f3b28a.pdf:/home/mrl/.local/share/zotero/storage/2EVHREI3/53fc40190cf22f21c2f3b28a.pdf:application/pdf},
1103 }
1104 @Inbook{Domoszlai2013,
1105 author={Domoszlai, L{\'a}szl{\'o} and Kozsik, Tam{\'a}s},
1106 editor={Achten, Peter and Koopman, Pieter},
1107 title={Clean Up the Web!},
1108 bookTitle={The Beauty of Functional Code: Essays Dedicated to Rinus Plasmeijer on the Occasion of His 61st Birthday},
1109 year=2013,
1110 publisher={Springer Berlin Heidelberg},
1111 address={Berlin, Heidelberg},
1112 pages={133--150},
1113 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.},
1114 isbn={978-3-642-40355-2},
1115 doi={10.1007/978-3-642-40355-2_10},
1116 url={https://doi.org/10.1007/978-3-642-40355-2_10}
1117 }
1118
1119 @inproceedings{10.1145/3412932.3412941,
1120 author = {Staps, Camil and van Groningen, John and Plasmeijer, Rinus},
1121 title = {Lazy Interworking of Compiled and Interpreted Code for Sandboxing and Distributed Systems},
1122 year = {2019},
1123 isbn = {9781450375627},
1124 publisher = {Association for Computing Machinery},
1125 address = {New York, NY, USA},
1126 doi = {10.1145/3412932.3412941},
1127 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.},
1128 booktitle = {Proceedings of the 31st Symposium on Implementation and Application of Functional Languages},
1129 articleno = {9},
1130 numpages = {12},
1131 keywords = {functional programming, sandboxing, web-assembly, laziness, interpreters},
1132 location = {Singapore, Singapore},
1133 series = {IFL '19}
1134 }
1135
1136 @inproceedings{elliott_guilt_2015,
1137         title = {Guilt free ivory},
1138         volume = {50},
1139         booktitle = {{ACM} {SIGPLAN} {Notices}},
1140         publisher = {ACM},
1141         author = {Elliott, Trevor and Pike, Lee and Winwood, Simon and Hickey, Pat and Bielman, James and Sharp, Jamey and Seidel, Eric and Launchbury, John},
1142         year = {2015},
1143         pages = {189--200},
1144         file = {5678351608ae125516ee79c6.pdf:/home/mrl/.local/share/zotero/storage/KJMFUH7T/5678351608ae125516ee79c6.pdf:application/pdf},
1145 }
1146
1147 @inproceedings{sawada_emfrp:_2016,
1148         title = {Emfrp: a functional reactive programming language for small-scale embedded systems},
1149         booktitle = {Companion {Proceedings} of the 15th {International} {Conference} on {Modularity}},
1150         publisher = {ACM},
1151         author = {Sawada, Kensuke and Watanabe, Takuo},
1152         year = {2016},
1153         pages = {36--44},
1154         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},
1155 }
1156
1157 @inproceedings{lv_designing_2018,
1158         title = {Designing of {IoT} {Platform} {Based} on {Functional} {Reactive} {Pattern}},
1159         booktitle = {2018 {International} {Conference} on {Computer} {Science}, {Electronics} and {Communication} {Engineering} ({CSECE} 2018)},
1160         publisher = {Atlantis Press},
1161         author = {Lv, Haidong and Ge, Xiaolong and Zhu, Hongzhi and Yuan, Zhiwei and Wang, Zhen and Zhu, Yongkang},
1162         year = {2018},
1163         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},
1164 }
1165
1166 @inproceedings{helbling_juniper:_2016,
1167         title = {Juniper: a functional reactive programming language for the {Arduino}},
1168         booktitle = {Proceedings of the 4th {International} {Workshop} on {Functional} {Art}, {Music}, {Modelling}, and {Design}},
1169         publisher = {ACM},
1170         author = {Helbling, Caleb and Guyer, Samuel Z},
1171         year = {2016},
1172         pages = {8--16},
1173         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},
1174 }
1175
1176 @incollection{wang_functional_2020,
1177         address = {Cham},
1178         title = {Functional {Reactive} {EDSL} with {Asynchronous} {Execution} for {Resource}-{Constrained} {Embedded} {Systems}},
1179         isbn = {978-3-030-26428-4},
1180         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.},
1181         booktitle = {Software {Engineering}, {Artificial} {Intelligence}, {Networking} and {Parallel}/{Distributed} {Computing}},
1182         publisher = {Springer International Publishing},
1183         author = {Wang, Sheng and Watanabe, Takuo},
1184         editor = {Lee, Roger},
1185         year = {2020},
1186         doi = {10.1007/978-3-030-26428-4_12},
1187         pages = {171--190},
1188         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},
1189 }
1190
1191 @incollection{valliappan_towards_2020,
1192         address = {New York, NY, USA},
1193         title = {Towards {Secure} {IoT} {Programming} in {Haskell}},
1194         isbn = {978-1-4503-8050-8},
1195         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.},
1196         booktitle = {Proceedings of the 13th {ACM} {SIGPLAN} {International} {Symposium} on {Haskell}},
1197         publisher = {Association for Computing Machinery},
1198         author = {Valliappan, Nachiappan and Krook, Robert and Russo, Alejandro and Claessen, Koen},
1199         year = {2020},
1200         pages = {136--150},
1201         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},
1202 }
1203
1204 @inproceedings{sarkar_hailstorm_2020,
1205         address = {New York, NY, USA},
1206         series = {{PPDP} '20},
1207         title = {Hailstorm: {A} {Statically}-{Typed}, {Purely} {Functional} {Language} for {IoT} {Applications}},
1208         isbn = {978-1-4503-8821-4},
1209         doi = {10.1145/3414080.3414092},
1210         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.},
1211         booktitle = {Proceedings of the 22nd {International} {Symposium} on {Principles} and {Practice} of {Declarative} {Programming}},
1212         publisher = {Association for Computing Machinery},
1213         author = {Sarkar, Abhiroop and Sheeran, Mary},
1214         year = {2020},
1215         note = {event-place: Bologna, Italy},
1216         keywords = {functional programming, compilers, embedded systems, IoT},
1217         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},
1218 }
1219 @inproceedings{10.1145/3281366.3281370,
1220 author = {Shibanai, Kazuhiro and Watanabe, Takuo},
1221 title = {Distributed Functional Reactive Programming on Actor-Based Runtime},
1222 year = {2018},
1223 isbn = {9781450360661},
1224 publisher = {Association for Computing Machinery},
1225 address = {New York, NY, USA},
1226 doi = {10.1145/3281366.3281370},
1227 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.},
1228 booktitle = {Proceedings of the 8th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control},
1229 pages = {13–22},
1230 numpages = {10},
1231 keywords = {Distributed Functional Reactive Programming, Erlang, Glitch Freedom, Synchronization, Actor-Based Runtime System},
1232 location = {Boston, MA, USA},
1233 series = {AGERE 2018}
1234 }
1235
1236 @inproceedings{suzuki_cfrp_2017,
1237         address = {The University of The Philippines Cebu, Cebu City, The Philippines},
1238         title = {{CFRP}: {A} {Functional} {Reactive} {Programming} {Language} for {Small}-{Scale} {Embedded} {Systems}},
1239         isbn = {978-981-323-406-2 978-981-323-407-9},
1240         shorttitle = {{CFRP}},
1241         url = {http://www.worldscientific.com/doi/abs/10.1142/9789813234079_0001},
1242         doi = {10.1142/9789813234079_0001},
1243         language = {en},
1244         urldate = {2022-03-02},
1245         booktitle = {Theory and {Practice} of {Computation}},
1246         publisher = {WORLD SCIENTIFIC},
1247         author = {Suzuki, Kohei and Nagayama, Kanato and Sawada, Kensuke and Watanabe, Takuo},
1248         month = dec,
1249         year = {2017},
1250         pages = {1--13},
1251         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},
1252 }
1253
1254
1255 @inproceedings{shibanai_distributed_2018,
1256         address = {New York, NY, USA},
1257         series = {{AGERE} 2018},
1258         title = {Distributed {Functional} {Reactive} {Programming} on {Actor}-{Based} {Runtime}},
1259         isbn = {978-1-4503-6066-1},
1260         doi = {10.1145/3281366.3281370},
1261         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.},
1262         booktitle = {Proceedings of the 8th {ACM} {SIGPLAN} {International} {Workshop} on {Programming} {Based} on {Actors}, {Agents}, and {Decentralized} {Control}},
1263         publisher = {Association for Computing Machinery},
1264         author = {Shibanai, Kazuhiro and Watanabe, Takuo},
1265         year = {2018},
1266         note = {event-place: Boston, MA, USA},
1267         keywords = {Actor-Based Runtime System, Distributed Functional Reactive Programming, Erlang, Glitch Freedom, Synchronization},
1268         pages = {13--22},
1269         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},
1270 }
1271
1272 @inproceedings{nilsson_functional_2002,
1273         address = {New York, NY, USA},
1274         series = {Haskell '02},
1275         title = {Functional {Reactive} {Programming}, {Continued}},
1276         isbn = {1-58113-605-6},
1277         doi = {10.1145/581690.581695},
1278         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.},
1279         booktitle = {Proceedings of the 2002 {ACM} {SIGPLAN} {Workshop} on {Haskell}},
1280         publisher = {Association for Computing Machinery},
1281         author = {Nilsson, Henrik and Courtney, Antony and Peterson, John},
1282         year = {2002},
1283         note = {event-place: Pittsburgh, Pennsylvania},
1284         keywords = {functional programming, Haskell, domain-specific languages, FRP, hybrid modeling, synchronous dataflow languages},
1285         pages = {51--64},
1286         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},
1287 }
1288 @inproceedings{10.1145/2661136.2661146,
1289 author = {Philips, Laure and De Roover, Coen and Van Cutsem, Tom and De Meuter, Wolfgang},
1290 title = {Towards Tierless Web Development without Tierless Languages},
1291 year = {2014},
1292 isbn = {9781450332101},
1293 publisher = {Association for Computing Machinery},
1294 address = {New York, NY, USA},
1295 doi = {10.1145/2661136.2661146},
1296 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.},
1297 booktitle = {Proceedings of the 2014 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming \& Software},
1298 pages = {69–81},
1299 numpages = {13},
1300 keywords = {tier splitting, program slicing, tierless programming, javascript},
1301 location = {Portland, Oregon, USA},
1302 series = {Onward! 2014}
1303 }
1304
1305 @misc{hess_arduino-copilot_2020,
1306         title = {arduino-copilot: {Arduino} programming in haskell using the {Copilot} stream {DSL}},
1307         shorttitle = {arduino-copilot},
1308         url = {//hackage.haskell.org/package/arduino-copilot},
1309         urldate = {2020-02-14},
1310         journal = {Hackage},
1311         author = {Hess, Joey},
1312         year = {2020},
1313         file = {Snapshot:/home/mrl/.local/share/zotero/storage/PSHYKF52/arduino-copilot.html:text/html},
1314 }
1315 @INPROCEEDINGS{5558637,
1316
1317   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},
1318
1319   booktitle={Eighth ACM/IEEE International Conference on Formal Methods and Models for Codesign (MEMOCODE 2010)},
1320
1321   title={Feldspar: A domain specific language for digital signal processing algorithms},
1322
1323   year={2010},
1324
1325   volume={},
1326
1327   number={},
1328
1329   pages={169-178},
1330
1331   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.},
1332
1333   keywords={},
1334
1335   doi={10.1109/MEMCOD.2010.5558637},
1336
1337   ISSN={},
1338
1339   month={July},}
1340
1341 @article{sheetz2009understanding,
1342   title={Understanding developer and manager perceptions of function points and source lines of code},
1343   author={Sheetz, Steven D and Henderson, David and Wallace, Linda},
1344   journal={Journal of Systems and Software},
1345   volume={82},
1346   number={9},
1347   pages={1540--1549},
1348   year={2009},
1349   publisher={Elsevier}
1350 }
1351
1352 @article{fichera2017python,
1353   title={A Python framework for programming autonomous robots using a declarative approach},
1354   author={Fichera, Loris and Messina, Fabrizio and Pappalardo, Giuseppe and Santoro, Corrado},
1355   journal={Science of Computer Programming},
1356   volume={139},
1357   pages={36--55},
1358   year={2017},
1359   publisher={Elsevier}
1360 }
1361
1362 @inproceedings{balat2006ocsigen,
1363   title={Ocsigen: Typing web interaction with objective caml},
1364   author={Balat, Vincent},
1365   booktitle={Proceedings of the 2006 Workshop on ML},
1366   pages={84--94},
1367   year={2006}
1368 }
1369
1370 @inproceedings{bjornson2010composing,
1371   title={Composing reactive GUIs in F\# using WebSharper},
1372   author={Bjornson, Joel and Tayanovskyy, Anton and Granicz, Adam},
1373   booktitle={Symposium on Implementation and Application of Functional Languages},
1374   pages={203--216},
1375   year={2010},
1376   organization={Springer}
1377 }
1378
1379 @book{strack2015getting,
1380   title={Getting Started with Meteor. js JavaScript Framework},
1381   author={Strack, Isaac},
1382   year={2015},
1383   publisher={Packt Publishing Ltd}
1384 }
1385
1386 @incollection{hall1993glasgow,
1387   title={The Glasgow Haskell compiler: a retrospective},
1388   author={Hall, Cordelia and Hammond, Kevin and Partain, Will and Peyton Jones, Simon L and Wadler, Philip},
1389   booktitle={Functional Programming, Glasgow 1992},
1390   pages={62--71},
1391   year={1993},
1392   publisher={Springer}
1393 }
1394
1395 @misc{diffmicro,
1396  title = "MicroPython Differences from CPython",
1397  author = "Micropython Official Website",
1398  year = "2022",
1399  note = "https://docs.micropython.org/en/latest/genrst/index.html",
1400 }
1401
1402 @article{weisenburger2020survey,
1403   title={A survey of multitier programming},
1404   author={Weisenburger, Pascal and Wirth, Johannes and Salvaneschi, Guido},
1405   journal={ACM Computing Surveys (CSUR)},
1406   volume={53},
1407   number={4},
1408   pages={1--35},
1409   year={2020},
1410   publisher={ACM New York, NY, USA}
1411 }
1412
1413 @inproceedings {203628,
1414 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},
1415 title = {Understanding the Mirai Botnet},
1416 booktitle = {26th USENIX Security Symposium (USENIX Security 17)},
1417 year = {2017},
1418 isbn = {978-1-931971-40-9},
1419 address = {Vancouver, BC},
1420 pages = {1093--1110},
1421 url = {https://www.usenix.org/conference/usenixsecurity17/technical-sessions/presentation/antonakakis},
1422 publisher = {USENIX Association},
1423 month = aug,
1424 }
1425
1426 @inproceedings{herwig_measurement_2019,
1427         address = {San Diego, CA, USA},
1428         title = {Measurement and {Analysis} of {Hajime}, a {Peer}-to-peer {IoT} {Botnet}},
1429         isbn = {1-891562-55-X},
1430         url = {https://par.nsf.gov/biblio/10096257},
1431         doi = {10.14722/ndss.2019.23488},
1432         booktitle = {Network and {Distributed} {Systems} {Security} ({NDSS}) {Symposium} 2019},
1433         author = {Herwig, Stephen and Harvey, Katura and Hughey, George and Roberts, Richard and Levin, Dave},
1434         year = {2019},
1435         pages = {15},
1436         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},
1437 }
1438 @article{10.1145/3437537,
1439 author = {Alhirabi, Nada and Rana, Omer and Perera, Charith},
1440 title = {Security and Privacy Requirements for the Internet of Things: A Survey},
1441 year = {2021},
1442 issue_date = {February 2021},
1443 publisher = {Association for Computing Machinery},
1444 address = {New York, NY, USA},
1445 volume = {2},
1446 number = {1},
1447 issn = {2691-1914},
1448 doi = {10.1145/3437537},
1449 abstract = {The design and development process for internet of things (IoT) applications is more complicated than that for desktop, mobile, or web applications. First, IoT applications require both software and hardware to work together across many different types of nodes with different capabilities under different conditions. Second, IoT application development involves different types of software engineers such as desktop, web, embedded, and mobile to work together. Furthermore, non-software engineering personnel such as business analysts are also involved in the design process. In addition to the complexity of having multiple software engineering specialists cooperating to merge different hardware and software components together, the development process requires different software and hardware stacks to be integrated together (e.g., different stacks from different companies such as Microsoft Azure and IBM Bluemix). Due to the above complexities, non-functional requirements (such as security and privacy, which are highly important in the context of the IoT) tend to be ignored or treated as though they are less important in the IoT application development process. This article reviews techniques, methods, and tools to support security and privacy requirements in existing non-IoT application designs, enabling their use and integration into IoT applications. This article primarily focuses on design notations, models, and languages that facilitate capturing non-functional requirements (i.e., security and privacy). Our goal is not only to analyse, compare, and consolidate the empirical research but also to appreciate their findings and discuss their applicability for the IoT.},
1450 journal = {ACM Trans. Internet Things},
1451 month = {feb},
1452 articleno = {6},
1453 numpages = {37},
1454 keywords = {design principles, software design tools, Internet of Things, non functional requirements, notation, software engineering}
1455 }
1456
1457 @phdthesis{wijkhuizen_security_2018,
1458         address = {Nijmegen},
1459         type = {Bachelor's {Thesis}},
1460         title = {Security analysis of the {iTasks} framework},
1461         url = {http://www.ru.nl/publish/pages/769526/arjan_oortgiese.pdf},
1462         language = {English},
1463         urldate = {2017-04-08},
1464         school = {Radboud University},
1465         author = {Wijkhuizen, Mark},
1466         year = {2018},
1467         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},
1468 }
1469 @inproceedings{Steenvoorden2019tophat,
1470 author = {Steenvoorden, Tim and Naus, Nico and Klinik, Markus},
1471 title = {TopHat: A Formal Foundation for Task-Oriented Programming},
1472 year = {2019},
1473 isbn = {9781450372497},
1474 publisher = {Association for Computing Machinery},
1475 address = {New York, NY, USA},
1476 doi = {10.1145/3354166.3354182},
1477 booktitle = {Proceedings of the 21st International Symposium on Principles and Practice of Declarative Programming},
1478 articleno = {17},
1479 numpages = {13},
1480 location = {Porto, Portugal},
1481 series = {PPDP '19}
1482 }
1483
1484
1485
1486