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
},
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"
,
16 publisher="Springer International Publishing"
,
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"
23 @inproceedings
{rosenberg1997some
,
24 title={Some misconceptions about lines of code
},
25 author={Rosenberg
, Jarrett
},
26 booktitle={Proceedings fourth international software metrics symposium
},
31 doi
={10.1109/METRIC
.1997.637174},
32 address={Albuquerque
, NM
, USA
}
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
},
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
},
55 address={Portland
, Oregon
, USA
},
58 @inproceedings
{lloyd1994practical
,
59 title={Practical Advtanages of Declarative Programming.
},
60 author={Lloyd
, John W
},
61 booktitle={GULP
-PRODE
(1)},
67 author ={Jeremy Singer
, Dejice Jacob
, Kristian Hentschel
},
69 title ={Anyscale Sensors
},
70 url
={https
://bitbucket.org
/jsinger
/anyscale
-sensors
/src
/master
/Readme.md
},
72 lastaccessed
={April
1, 2016},
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
},
83 publisher={Wiley Online Library
}
86 @inproceedings
{steiner_firmata_2009
,
87 title = {Firmata
: {Towards
} {Making
} {Microcontrollers
} {Act
} {Like
} {Extensions
} of the
{Computer
}.
},
89 author = {Steiner
, Hans
-Christoph
},
94 @article
{levis_mate_2002
,
95 title = {Maté
: {A
} tiny virtual machine for sensor networks
},
98 journal = {ACM Sigplan Notices
},
99 author = {Levis
, Philip and Culler
, David
},
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
}
106 @inproceedings
{grebe_threading_2019
,
108 title = {Threading the
{Arduino
} with
{Haskell
}},
109 isbn
= {978-3-030-14805-8},
110 abstract = {Programming embedded microcontrollers often requires the scheduling of independent threads of execution
, specifying the interaction and sequencing of actions in the multiple threads. Developing and debugging such multi
-threaded systems can be especially challenging in highly resource constrained systems such as the Arduino line of microcontroller boards. The Haskino library
, developed at the University of Kansas
, allows programmers to develop code for Arduino
-based microcontrollers using monadic Haskell program fragments. This paper describes our efforts to extend the Haskino library to translate monadic Haskell code to multi
-threaded code executing on Arduino boards.
},
111 booktitle = {Trends in
{Functional
} {Programming
}},
112 publisher = {Springer
},
113 author = {Grebe
, Mark and Gill
, Andy
},
114 editor = {Van Horn
, David and Hughes
, John
},
117 file
= {Grebe and Gill
- Threading the Arduino with Haskell.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/DW5PS9ZA
/Grebe and Gill
- Threading the Arduino with Haskell.pdf
:application
/pdf
}
120 @inproceedings
{grebe_haskino_2016
,
121 title = {Haskino
: {A
} remote monad for programming the arduino
},
122 shorttitle
= {Haskino
},
123 booktitle = {International
{Symposium
} on
{Practical
} {Aspects
} of
{Declarative
} {Languages
}},
124 publisher = {Springer
},
125 author = {Grebe
, Mark and Gill
, Andy
},
128 file
= {Grebe
-16-Haskino.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/ABG7TTLV
/Grebe
-16-Haskino.pdf
:application
/pdf
}
131 @inproceedings
{gill_remote_2015
,
132 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
},
133 title = {The Remote Monad Design Pattern
},
135 doi
= {10.1145/2804302.2804311},
136 booktitle = {Proceedings of the
2015 ACM SIGPLAN Symposium on Haskell
},
140 @article
{light2017mosquitto
,
141 title={Mosquitto
: server and client implementation of the MQTT protocol
},
142 author={Light
, Roger
},
143 journal={Journal of Open Source Software
},
150 @article
{adl2006compiler
,
151 title={Compiler and runtime support for efficient software transactional memory
},
152 author={Adl
-Tabatabai
, Ali
-Reza and Lewis
, Brian T and Menon
, Vijay and Murphy
, Brian R and Saha
, Bratin and Shpeisman
, Tatiana
},
153 journal={ACM SIGPLAN Notices
},
161 @inproceedings
{schwarz2002disassembly
,
162 title={Disassembly of executable code revisited
},
163 author={Schwarz
, Benjamin and Debray
, Saumya and Andrews
, Gregory
},
164 booktitle={Ninth Working Conference on Reverse Engineering
, 2002. Proceedings.
},
170 @article
{hughes1989functional
,
171 title={Why functional programming matters
},
172 author={Hughes
, John
},
173 journal={The computer
journal},
178 publisher={Oxford University Press
}
181 @article
{davidson2018expressiveness
,
182 title={Expressiveness
, meanings and machines
},
183 author={Davidson
, Joe and Michaelson
, Greg
},
184 journal={Computability
},
189 publisher={IOS Press
}
192 @inproceedings
{troyer_building_2018
,
193 title = {Building
{IoT
} {Systems
} {Using
} {Distributed
} {First
}-{Class
} {Reactive
} {Programming
}},
194 booktitle = {2018 {IEEE
} {International
} {Conference
} on
{Cloud
} {Computing
} {Technology
} and
{Science
} ({CloudCom
})},
195 author = {Troyer
, de
, Christophe and Nicolay
, Jens and Meuter
, de
, Wolfgang
},
200 address = {Nicosia
, Cyprus
},
203 @article
{harth_predictive_2018
,
204 author = {Natascha Harth and Christos Anagnostopoulos and Dimitrios Pezaros
},
205 title = {Predictive intelligence to the edge
: impact on edge analytics
},
206 journal = {Evolving Systems
},
213 @inproceedings
{naik2017choice
,
214 title={Choice of effective messaging protocols for IoT systems
: MQTT
, CoAP
, AMQP and HTTP
},
215 author={Naik
, Nitin
},
216 booktitle={2017 IEEE international systems engineering symposium
(ISSE
)},
222 @book
{guinard_building_2016
,
225 title = {Building the
{Web
} of
{Things
}: {With
} {Examples
} in
{Node
}.
{Js
} and
{Raspberry
} {Pi
}},
226 isbn
= {1-61729-268-0},
227 publisher = {Manning Publications Co.
},
228 author = {Guinard
, Dominique and Trifa
, Vlad
},
232 @inproceedings
{ireland2009classification
,
233 title={A classification of object
-relational impedance mismatch
},
234 author={Ireland
, Christopher and Bowers
, David and Newton
, Michael and Waugh
, Kevin
},
235 booktitle={2009 First International Confernce on Advances in Databases
, Knowledge
, and Data Applications
},
240 doi
={10.1109/DBKDA
.2009.11},
241 address={Gosier
, France
}
244 @article
{maccormack2007impact
,
245 title={The impact of component modularity on design evolution
: Evidence from the software industry
},
246 author={MacCormack
, Alan and Rusnak
, John and Baldwin
, Carliss Y
},
247 journal={Harvard Business School Technology \
& Operations Mgt. Unit Research Paper
},
252 doi
={10.2139/ssrn
.1071720},
256 @inproceedings
{belle2013layered
,
257 address = {Boston
, MA
, USA
},
258 title = {The layered architecture revisited
: {Is
} it an optimization problem?
},
260 isbn
= {978-1-5108-4159-8},
261 shorttitle
= {{SEKE
} 2013},
262 booktitle = {Proceedings of the
{Twenty
}-{Fifth
} {International
} {Conference
} on
{Software
} {Engineering
} \
& {Knowledge
} {E
}},
263 publisher = {KSI Research Inc
},
264 author = {Belle
, Alvine Boaye and El
-Boussaidi
, Ghizlane and Desrosiers
, Christian and Mili
, Hafedh
},
269 @inproceedings
{lee2001component
,
270 title={Component identification method with coupling and cohesion
},
271 author={Lee
, Jong Kook and Jung
, Seung Jae and Kim
, Soo Dong and Jang
, Woo Hyun and Ham
, Dong Han
},
272 booktitle={Proceedings Eighth Asia
-Pacific Software Engineering Conference
},
277 address={Macao
, China
},
280 @article
{antoniu2007combining
,
281 title={Combining data sharing with the master
--worker paradigm in the common component architecture
},
282 author={Antoniu
, Gabriel and Bouziane
, Hinde Lilia and Jan
, Mathieu and P
{\'e
}rez
, Christian and Priol
, Thierry
},
283 journal={Cluster Computing
},
291 @inproceedings
{grgic2016web
,
292 title={A web
-based IoT solution for monitoring data using MQTT protocol
},
293 author={Grgi
{\'c
}, Kre
{\v
{s
}}imir and
{\v
{S
}}peh
, Ivan and He
{\dj
}i
, Ivan
},
294 booktitle={2016 international conference on smart systems and technologies
(SST
)},
300 @inproceedings
{athanasopoulos2006interoperability
,
301 title={Interoperability among heterogeneous services
},
302 author={Athanasopoulos
, George and Tsalgatidou
, Aphrodite and Pantazoglou
, Michael
},
303 booktitle={2006 IEEE International Conference on Services Computing
(SCC'
06)},
309 @article
{mazzei2018full
,
310 title={A full stack for quick prototyping of IoT solutions
},
311 author={Mazzei
, Daniele and Baldi
, Giacomo and Montelisciani
, Gabriele and Fantoni
, Gualtiero
},
312 journal={Annals of Telecommunications
},
320 @article
{barrett2015fine
,
321 title={Fine
-grained language composition
: A case study
},
322 author={Barrett
, Edd and Bolz
, Carl Friedrich and Diekmann
, Lukas and Tratt
, Laurence
},
323 journal={arXiv preprint arXiv
:1503.08623},
327 @inproceedings
{patwardhan2004communication
,
328 title={Communication breakdown
: analyzing cpu usage in commercial web workloads
},
329 author={Patwardhan
, Jaidev P and Lebeck
, Alvin R and Sorin
, Daniel J
},
330 booktitle={IEEE International Symposium on
-ISPASS Performance Analysis of Systems and Software
, 2004},
336 @inproceedings
{cooper2008essence
,
337 title={The essence of form abstraction
},
338 author={Cooper
, Ezra and Lindley
, Sam and Wadler
, Philip and Yallop
, Jeremy
},
339 booktitle={Asian Symposium on Programming Languages and Systems
},
342 organization={Springer
}
345 @article
{rinard2003credible
,
346 title={Credible compilation
},
347 author={Rinard
, Martin C
},
351 @inproceedings
{bucur2014prototyping
,
352 title={Prototyping symbolic execution engines for interpreted languages
},
353 author={Bucur
, Stefan and Kinder
, Johannes and Candea
, George
},
354 booktitle={Proceedings of the
19th international conference on Architectural support for programming languages and operating systems
},
359 @inproceedings
{barany2014python
,
360 title={Python interpreter performance deconstructed
},
361 author={Barany
, Gerg
{\"o
}},
362 booktitle={Proceedings of the Workshop on Dynamic Languages and Applications
},
367 @article
{mayer2017multi
,
368 title={On multi
-language software development
, cross
-language links and accompanying tools
: a survey of professional software developers
},
369 author={Mayer
, Philip and Kirsch
, Michael and Le
, Minh Anh
},
370 journal={Journal of Software Engineering Research and Development
},
378 @inproceedings
{mayer2015empirical
,
379 author = {Mayer
, Philip and Bauer
, Alexander
},
380 title = {An Empirical Analysis of the Utilization of Multiple Programming Languages in Open Source Projects
},
382 isbn
= {9781450333504},
383 publisher = {Association for Computing Machinery
},
384 address = {New York
, NY
, USA
},
385 url
= {https
://doi.org
/10.1145/2745802.2745805},
386 doi
= {10.1145/2745802.2745805},
387 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.
},
388 booktitle = {Proceedings of the
19th International Conference on Evaluation and Assessment in Software Engineering
},
391 location
= {Nanjing
, China
},
395 @article
{avizienis85n
,
396 author={A.
{Avizienis
}},
397 journal={IEEE Transactions on Software Engineering
},
398 title={The N
-Version Approach to Fault
-Tolerant Software
},
403 doi
={10.1109/TSE
.1985.231893}
407 @inproceedings
{motta2018challenges
,
408 author = {Motta
, Rebeca C. and de Oliveira
, K\'
{a
}thia M. and Travassos
, Guilherme H.
},
409 title = {On Challenges in Engineering IoT Software Systems
},
411 isbn
= {9781450365031},
412 publisher = {Association for Computing Machinery
},
413 address = {New York
, NY
, USA
},
414 url
= {https
://doi.org
/10.1145/3266237.3266263},
415 doi
= {10.1145/3266237.3266263},
416 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.
},
417 booktitle = {Proceedings of the XXXII Brazilian Symposium on Software Engineering
},
420 keywords = {challenges
, concerns
, internet of things
, IoT
, literature review
, empirical software engineering
},
421 location
= {Sao Carlos
, Brazil
},
425 @article
{gubbi2013internet
,
426 title={Internet of Things
(IoT
): A vision
, architectural elements
, and future directions
},
427 author={Gubbi
, Jayavardhana and Buyya
, Rajkumar and Marusic
, Slaven and Palaniswami
, Marimuthu
},
428 journal={Future generation computer systems
},
436 @article
{guzman2018human
,
437 title={What is human
-machine communication
, anyway
},
438 author={Guzman
, Andrea L
},
439 journal={Human
-machine communication
: Rethinking communication
, technology
, and ourselves
},
442 publisher={Peter Lang New York
}
445 @article
{wan2016software
,
446 title={Software
-defined industrial internet of things in the context of industry
4.0},
447 author={Wan
, Jiafu and Tang
, Shenglong and Shu
, Zhaogang and Li
, Di and Wang
, Shiyong and Imran
, Muhammad and Vasilakos
, Athanasios V
},
448 journal={IEEE Sensors Journal
},
456 @article
{batory1992design
,
457 title={The design and implementation of hierarchical software systems with reusable components
},
458 author={Batory
, Don and O'malley
, Sean
},
459 journal={ACM Transactions on Software Engineering and Methodology
(TOSEM
)},
464 publisher={ACM New York
, NY
, USA
}
467 @article
{mockus2002two
,
468 title={Two case studies of open source software development
: Apache and Mozilla
},
469 author={Mockus
, Audris and Fielding
, Roy T and Herbsleb
, James D
},
470 journal={ACM Transactions on Software Engineering and Methodology
(TOSEM
)},
475 publisher={ACM New York
, NY
, USA
}
478 @inproceedings
{le2015microservice
,
479 title={Microservice
-based architecture for the NRDC
},
480 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
},
481 booktitle={2015 IEEE
13th International Conference on Industrial Informatics
(INDIN
)},
486 address={Cambridge
, UK
},
489 @inproceedings
{kodali2016low
,
490 title={Low cost ambient monitoring using ESP8266
},
491 author={Kodali
, Ravi Kishore and Mahesh
, Kopulwar Shishir
},
492 booktitle={2016 2nd International Conference on Contemporary Computing and Informatics
(IC3I
)},
497 address={Greater Noida
, India
}
500 @article
{beaven1993explaining
,
501 title={Explaining
type errors in polymorphic languages
},
502 author={Beaven
, Mike and Stansifer
, Ryan
},
503 journal={ACM Letters on Programming Languages and Systems
(LOPLAS
)},
508 publisher={ACM New York
, NY
, USA
}
511 @phdthesis
{armstrong2003making
,
512 title={Making reliable distributed systems in the presence of software errors
},
513 author={Armstrong
, Joe
},
517 @article
{madsen1990strong
,
518 title={Strong typing of object
-oriented languages revisited
},
519 author={Madsen
, Ole Lehrmann and Magnusson
, Boris and M
{\o
}lier
-Pedersen
, Birger
},
520 journal={ACM SIGPLAN Notices
},
525 publisher={ACM New York
, NY
, USA
}
528 @article
{cass20182017
,
529 title={The
2017 top programming languages
},
530 author={Cass
, Stephen
},
531 journal={IEEE Spectrum
},
536 @book
{tollervey2017programming
,
537 title={Programming with MicroPython
: Embedded Programming with Microcontrollers and Python
},
538 author={Tollervey
, Nicholas H
},
540 publisher={" O'Reilly Media
, Inc."
}
543 @inproceedings
{alpernaswonderful
,
544 author = {Alpernas
, Kalev and Feldman
, Yotam M. Y. and Peleg
, Hila
},
545 title = {The Wonderful Wizard of LoC
: Paying Attention to the Man behind the Curtain of Lines
-of
-Code Metrics
},
547 isbn
= {9781450381789},
548 publisher = {Association for Computing Machinery
},
549 address = {New York
, NY
, USA
},
550 url
= {https
://doi.org
/10.1145/3426428.3426921},
551 doi
= {10.1145/3426428.3426921},
552 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.
},
553 booktitle = {Proceedings of the
2020 ACM SIGPLAN International Symposium on New Ideas
, New Paradigms
, and Reflections on Programming and Software
},
556 keywords = {research papers
, loc
, lines of code
},
557 location
= {Virtual
, USA
},
558 series = {Onward
! 2020}
561 @inproceedings
{epstein2011towards
,
562 author = {Epstein
, Jeff and Black
, Andrew P. and Peyton
-Jones
, Simon
},
563 title = {Towards Haskell in the Cloud
},
565 isbn
= {9781450308601},
566 publisher = {Association for Computing Machinery
},
567 address = {New York
, NY
, USA
},
568 url
= {https
://doi.org
/10.1145/2034675.2034690},
569 doi
= {10.1145/2034675.2034690},
570 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.
},
571 booktitle = {Proceedings of the
4th ACM Symposium on Haskell
},
574 keywords = {message
-passing
, haskell
, erlang
},
575 location
= {Tokyo
, Japan
},
576 series = {Haskell '
11}
580 title={Akka essentials
},
581 address={Livery Place
, 35 Livery Street
, Birmingham B3
2PB
, UK
},
582 author={Gupta
, Munish
},
584 publisher={Packt Publishing Ltd
}
587 @article
{millman2011python
,
588 title={Python for scientists and engineers
},
589 author={Millman
, K Jarrod and Aivazis
, Michael
},
590 journal={Computing in Science \
& Engineering
},
599 title = "Python Official Forum"
,
602 note = "https
://www.python.org
/community
/forums
/"
606 title = "Micropython Official Forum"
,
609 note = "https
://forum.micropython.org
/"
613 title = "Official Micropython Docs"
,
616 note = "https
://docs.micropython.org
/en
/latest
/"
620 author = "HaskellWiki"
,
621 title = "Introduction to IO
--- HaskellWiki
{,} "
,
623 url
= "https
://wiki.haskell.org
/index.php?
title=Introduction_to_IO
&oldid
=63493"
,
624 note = "
[Online
; accessed
19-January
-2021]"
628 author = "CircuitPython Team"
,
629 title = "CircuitPython"
,
631 url
= "https
://circuitpython.org
/"
,
632 note = "
[Online
; accessed
2-March
-2022]"
635 @article
{barendsen_smetsers_1996
,
636 title={Uniqueness typing for functional languages with graph rewriting semantics
},
638 DOI
={10.1017/S0960129500070109
},
640 journal={Mathematical Structures in Computer Science
},
641 publisher={Cambridge University Press
},
642 author={Barendsen
, Erik and Smetsers
, Sjaak
},
646 @InProceedings
{GenericProgrammingExtensionForClean
,
647 author = "Alimarine
, Artem and Plasmeijer
, Rinus"
,
648 editor = "Arts
, Thomas and Mohnen
, Markus"
,
649 title="A Generic Programming Extension for Clean"
,
650 booktitle="Implementation of Functional Languages"
,
652 publisher="Springer Berlin Heidelberg"
,
653 address="Berlin
, Heidelberg"
,
655 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."
,
656 isbn
="
978-3-540-46028-2"
658 @inproceedings
{HinzeGenericFunctionalProgramming
,
659 author = {Hinze
, Ralf
},
660 title = {A New Approach to Generic Functional Programming
},
663 publisher = {Association for Computing Machinery
},
664 address = {New York
, NY
, USA
},
665 url
= {https
://doi.org
/10.1145/325694.325709},
666 doi
= {10.1145/325694.325709},
667 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.
},
668 booktitle = {Proceedings of the
27th ACM SIGPLAN
-SIGACT Symposium on Principles of Programming Languages
},
671 location
= {Boston
, MA
, USA
},
674 @inproceedings
{TOP
-PPDP12
,
675 author = {Plasmeijer
, Rinus and Lijnse
, Bas and Michels
, Steffen and Achten
, Peter and Koopman
, Pieter
},
676 title = {Task
-Oriented Programming in a Pure Functional Language
},
678 isbn
= {9781450315227},
679 publisher = {Association for Computing Machinery
},
680 address = {New York
, NY
, USA
},
681 url
= {https
://doi.org
/10.1145/2370776.2370801},
682 doi
= {10.1145/2370776.2370801},
683 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.
},
684 booktitle = {Proceedings of the
14th Symposium on Principles and Practice of Declarative Programming
},
687 keywords = {task
-oriented programming
, clean
},
688 location
= {Leuven
, Belgium
},
693 author = {Plasmeijer
, Rinus and Achten
, Peter and Koopman
, Pieter
},
694 title = {{iTasks
}: {E
}xecutable
{S
}pecifications of
{I
}nteractive
{W
}ork
{F
}low
{S
}ystems for the
{W
}eb
},
695 booktitle = {{P
}roceedings of the
12th
{ACM SIGPLAN
} {I
}nternational
{C
}onference on
{F
}unctional
{P
}rogramming
({ICFP
} 2007)},
696 address = {{F
}reiburg
, {G
}ermany
},
700 isbn
= "
978-1-59593-815-2"
,
703 @article
{FinallyTagless
,
704 author = {Jacques Carette and Oleg Kiselyov and Chung
{-}chieh Shan
},
705 title = {Finally tagless
, partially evaluated
: Tagless staged interpreters
706 for simpler typed languages
},
707 journal = {J. Funct. Program.
},
712 url
= {https
://doi.org
/10.1017/S0956796809007205
},
713 doi
= {10.1017/S0956796809007205
},
714 timestamp
= {Sun
, 02 Jun
2019 21:00:12 +0200},
715 biburl
= {https
://dblp.org
/rec
/journals
/jfp
/CaretteKS09.bib
},
716 bibsource
= {dblp computer science bibliography
, https
://dblp.org
}
719 @inproceedings
{oortgiese_distributed_2017
,
720 title = {A
{Distributed
} {Dynamic
} {Architecture
} for
{Task
} {Oriented
} {Programming
}},
721 booktitle = {Proceedings of the
29th
{Symposium
} on
{Implementation
} and
{Application
} of
{Functional
} {Programming
} {Languages
}},
723 author = {Oortgiese
, Arjan and van Groningen
, John and Achten
, Peter and Plasmeijer
, Rinus
},
726 address = {Bristol
, UK
}
729 @inproceedings
{stefik14programming
,
730 author = {Stefik
, Andreas and Hanenberg
, Stefan
},
731 title = {The Programming Language Wars
: Questions and Responsibilities for the Programming Language Community
},
733 doi
= {10.1145/2661136.2661156},
734 booktitle = {Proceedings of the
2014 ACM International Symposium on New Ideas
, New Paradigms
, and Reflections on Programming \
& Software
},
738 @inproceedings
{ParametricLenses
,
739 author = {Domoszlai
, L\'
{a
}szl\'
{o
} and Lijnse
, Bas and Plasmeijer
, Rinus
},
740 title = {Parametric Lenses
: Change Notification for Bidirectional Lenses
},
742 isbn
= {9781450332842},
743 publisher = {Association for Computing Machinery
},
744 address = {New York
, NY
, USA
},
745 url
= {https
://doi.org
/10.1145/2746325.2746333},
746 doi
= {10.1145/2746325.2746333},
747 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.
},
748 booktitle = {Proceedings of the
26th International Symposium on Implementation and Application of Functional Languages
},
751 keywords = {notification systems
, parametric views
, lenses
, parametric lenses
, Bi
-directional programming
},
752 location
= {Boston
, MA
, USA
},
756 @inproceedings
{steenvoorden_tophat_2019
,
757 address = {New York
, NY
, USA
},
758 series = {{PPDP
} '
19},
759 title = {{TopHat
}: {A
} {Formal
} {Foundation
} for
{Task
}-{Oriented
} {Programming
}},
760 isbn
= {978-1-4503-7249-7},
761 url
= {https
://doi.org
/10.1145/3354166.3354182},
762 doi
= {10.1145/3354166.3354182},
763 abstract = {Software that models how people work is omnipresent in today's society. Current languages and frameworks often focus on usability by non
-programmers
, sacrificing flexibility and high level abstraction. Task
-oriented programming
(TOP
) is a programming paradigm that aims to provide the desired level of abstraction while still being expressive enough to describe real world collaboration. It prescribes a declarative programming style to specify multi
-user workflows. Workflows can be higher
-order. They communicate through typed values on a local and global level. Such specifications can be turned into interactive applications for different platforms
, supporting collaboration during execution. TOP has been around for more than a decade
, in the forms of iTasks and mTasks
, which are tailored for real
-world usability. So far
, it has not been given a formalisation which is suitable for formal reasoning.In this paper we give a description of the TOP paradigm and then decompose its rich features into elementary language elements
, which makes them suitable for formal treatment. We use the simply typed lambda
-calculus
, extended with pairs and references
, as a base language. On top of this language
, we develop TopHat
, a language for modular interactive workflows. We describe TopHat by means of a layered semantics. These layers consist of multiple big
-step evaluations on expressions
, and two labelled transition systems
, handling user inputs.With TopHat we prepare a way to formally reason about TOP languages and programs. This approach allows for comparison with other work in the field. We have implemented the semantic rules of TopHat in Haskell
, and the task layer on top of the iTasks framework. This shows that our approach is feasible
, and lets us demonstrate the concepts by means of illustrative case studies. TOP has been applied in projects with the Dutch coast guard
, tax office
, and navy. Our work matters because formal program verification is important for mission
-critical software
, especially for systems with concurrency.
},
764 booktitle = {Proceedings of the
21st
{International
} {Symposium
} on
{Principles
} and
{Practice
} of
{Declarative
} {Programming
}},
765 publisher = {Association for Computing Machinery
},
766 author = {Steenvoorden
, Tim and Naus
, Nico and Klinik
, Markus
},
768 note = {event
-place
: Porto
, Portugal
},
769 file
= {Steenvoorden et al.
- 2019 - TopHat A Formal Foundation for Task
-Oriented Prog.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/W7HJ5MEF
/Steenvoorden et al.
- 2019 - TopHat A Formal Foundation for Task
-Oriented Prog.pdf
:application
/pdf
}
772 @article
{10.1145/1543134.1411301,
773 author = {Rodriguez
, Alexey and Jeuring
, Johan and Jansson
, Patrik and Gerdes
, Alex and Kiselyov
, Oleg and Oliveira
, Bruno C. d. S.
},
774 title = {Comparing Libraries for Generic Programming in Haskell
},
776 issue_date
= {February
2009},
777 publisher = {Association for Computing Machinery
},
778 address = {New York
, NY
, USA
},
782 url
= {https
://doi.org
/10.1145/1543134.1411301},
783 doi
= {10.1145/1543134.1411301},
784 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.
},
785 journal = {SIGPLAN Not.
},
789 keywords = {datatype
-generic programming
, libraries comparison
}
792 @inproceedings
{ComparingGenericProgramming
,
793 author = {Rodriguez
, Alexey and Jeuring
, Johan and Jansson
, Patrik and Gerdes
, Alex and Kiselyov
, Oleg and Oliveira
, Bruno C. d. S.
},
794 title = {Comparing Libraries for Generic Programming in Haskell
},
796 isbn
= {9781605580647},
797 publisher = {Association for Computing Machinery
},
798 address = {New York
, NY
, USA
},
799 url
= {https
://doi.org
/10.1145/1411286.1411301},
800 doi
= {10.1145/1411286.1411301},
801 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.
},
802 booktitle = {Proceedings of the First ACM SIGPLAN Symposium on Haskell
},
805 keywords = {datatype
-generic programming
, libraries comparison
},
806 location
= {Victoria
, BC
, Canada
},
807 series = {Haskell '
08}
810 @InProceedings
{ComposingReactiveGUIs
,
811 author="Bjornson
, Joel
812 and Tayanovskyy
, Anton
814 editor="Hage
, Jurriaan
815 and Moraz
{\'a
}n
, Marco T."
,
816 title="Composing Reactive GUIs in F
{\#
} Using WebSharper"
,
817 booktitle="Implementation and Application of Functional Languages"
,
819 publisher="Springer Berlin Heidelberg"
,
820 address="Berlin
, Heidelberg"
,
822 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."
,
823 isbn
="
978-3-642-24276-2"
826 @inproceedings
{FunctionalReactiveAnimation
,
827 author = {Elliott
, Conal and Hudak
, Paul
},
828 title = {Functional Reactive Animation
},
831 publisher = {Association for Computing Machinery
},
832 address = {New York
, NY
, USA
},
833 url
= {https
://doi.org
/10.1145/258948.258973},
834 doi
= {10.1145/258948.258973},
835 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.
},
836 booktitle = {Proceedings of the Second ACM SIGPLAN International Conference on Functional Programming
},
839 location
= {Amsterdam
, The Netherlands
},
843 @inproceedings
{kochhar2016large
,
844 author={P. S.
{Kochhar
} and D.
{Wijedasa
} and D.
{Lo
}},
845 booktitle={23rd International Conference on Software Analysis
, Evolution
, and Reengineering
},
846 title={A Large Scale Study of Multiple Programming Languages and Code Quality
},
849 doi
={10.1109/SANER
.2016.112},
850 address={Osaka
, Japan
},
854 @inproceedings
{hao2020approaching
,
855 author = {Rebecca L. Hao and Elena L. Glassman
},
856 title = {{Approaching Polyglot Programming
: What Can We Learn from Bilingualism Studies?
}},
857 booktitle = {10th Workshop on Evaluation and Usability of Programming Languages and Tools
(PLATEAU
2019)},
861 doi
= {10.4230/OASIcs.PLATEAU
.2019.1},
864 @article
{cass2020top
,
865 title={The top programming languages
: Our latest rankings put Python on top
-again
-[Careers
]},
866 author={Cass
, Stephen
},
867 journal={IEEE Spectrum
},
875 @inproceedings
{tanganelli2015coapthon
,
876 title={CoAPthon
: Easy development of CoAP
-based IoT applications with Python
},
877 author={Tanganelli
, Giacomo and Vallati
, Carlo and Mingozzi
, Enzo
},
878 booktitle={2015 IEEE
2nd World Forum on Internet of Things
(WF
-IoT
)},
882 address={Milan
, Italy
}
885 @INPROCEEDINGS
{Wadler92comprehendingmonads
,
886 author = {Wadler
, Philip
},
887 title = {Comprehending Monads
},
890 publisher = {Association for Computing Machinery
},
891 address = {New York
, NY
, USA
},
892 url
= {https
://doi.org
/10.1145/91556.91592},
893 doi
= {10.1145/91556.91592},
894 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.
},
895 booktitle = {Proceedings of the
1990 ACM Conference on LISP and Functional Programming
},
898 location
= {Nice
, France
},
902 author = {Mott Macdonald
},
903 title = "University of Glasgow Smart Campus Digital Masterplan"
,
905 note = "\url
{https
://www.gla.ac.uk
/media
/Media_702108_smxx.pdf
}"
,
909 author = "Bijan Mottahedeh"
,
910 title = "An Introduction to the io XXX uring Asynchronous I
/O Framework"
,
912 url
= "https
://blogs.oracle.com
/linux
/an
-introduction
-to
-the
-io XXX uring
-asynchronous
-io
-framework"
,
913 note = "
[Online
; accessed
13-May
-2021]"
916 @inproceedings
{10.1145/1806596.1806601,
917 author = {Lee
, Byeongcheol and Wiedermann
, Ben and Hirzel
, Martin and Grimm
, Robert and McKinley
, Kathryn S.
},
918 title = {Jinn
: Synthesizing Dynamic Bug Detectors for Foreign Language Interfaces
},
920 isbn
= {9781450300193},
921 publisher = {Association for Computing Machinery
},
922 address = {New York
, NY
, USA
},
923 url
= {https
://doi.org
/10.1145/1806596.1806601},
924 doi
= {10.1145/1806596.1806601},
925 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.
},
926 booktitle = {Proceedings of the
31st ACM SIGPLAN Conference on Programming Language Design and Implementation
},
929 keywords = {dynamic analysis
, multilingual programs
, foreign function interfaces
(FFI
), python
/C
, java native interface
(jni
), specification
, specification generation
, ffi bugs
},
930 location
= {Toronto
, Ontario
, Canada
},
937 author = {Lee
, Byeongcheol and Wiedermann
, Ben and Hirzel
, Martin and Grimm
, Robert and McKinley
, Kathryn S.
},
938 title = {Jinn
: Synthesizing Dynamic Bug Detectors for Foreign Language Interfaces
},
940 issue_date
= {June
2010},
941 publisher = {Association for Computing Machinery
},
942 address = {New York
, NY
, USA
},
946 url
= {https
://doi.org
/10.1145/1809028.1806601},
947 doi
= {10.1145/1809028.1806601},
948 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.
},
949 journal = {SIGPLAN Not.
},
953 keywords = {specification generation
, specification
, python
/C
, dynamic analysis
, multilingual programs
, java native interface
(jni
), foreign function interfaces
(FFI
), ffi bugs
}
955 @inproceedings
{10.1145/1065010.1065019,
956 author = {Furr
, Michael and Foster
, Jeffrey S.
},
957 title = {Checking Type Safety of Foreign Function Calls
},
960 publisher = {Association for Computing Machinery
},
961 address = {New York
, NY
, USA
},
962 url
= {https
://doi.org
/10.1145/1065010.1065019},
963 doi
= {10.1145/1065010.1065019},
964 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.
},
965 booktitle = {Proceedings of the
2005 ACM SIGPLAN Conference on Programming Language Design and Implementation
},
968 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
},
969 location
= {Chicago
, IL
, USA
},
974 author = {Furr
, Michael and Foster
, Jeffrey S.
},
975 title = {Checking Type Safety of Foreign Function Calls
},
977 issue_date
= {June
2005},
978 publisher = {Association for Computing Machinery
},
979 address = {New York
, NY
, USA
},
983 url
= {https
://doi.org
/10.1145/1064978.1065019},
984 doi
= {10.1145/1064978.1065019},
985 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.
},
986 journal = {SIGPLAN Not.
},
990 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}
993 @INPROCEEDINGS
{LubbersMIPRO
,
994 author={Lubbers
, Mart and Koopman
, Pieter and Plasmeijer
, Rinus
},
995 booktitle={2019 42nd International Convention on Information and Communication Technology
, Electronics and Microelectronics
(MIPRO
)},
996 title={Multitasking on Microcontrollers using Task Oriented Programming
},
1002 address={Opatija
, Croatia
},
1003 doi
={10.23919/MIPRO
.2019.8756711}}
1005 @inproceedings
{plamauer2017evaluation
,
1006 title={Evaluation of micropython as application layer programming language on cubesats
},
1007 author={Plamauer
, Sebastian and Langer
, Martin
},
1008 booktitle={ARCS
2017; 30th International Conference on Architecture of Computing Systems
},
1013 address={Vienna
, Austria
}
1016 @inproceedings
{egyed1999automatically
,
1017 title={Automatically detecting mismatches during component
-based and model
-based development
},
1018 author={Egyed
, Alexander and Gacek
, Cristina
},
1019 booktitle={14th IEEE International Conference on Automated Software Engineering
},
1025 @inproceedings
{suchocki_microscheme
:_2015
,
1026 title = {Microscheme
: {Functional
} programming for the
{Arduino
}},
1027 booktitle = {Proceedings of the
2014 {Scheme
} and
{Functional
} {Programming
} {Workshop
}},
1028 author = {Suchocki
, Ryan and Kalvala
, Sara
},
1029 publisher = {University of Indiana
},
1030 address = {Washington DC
, USA
},
1035 @misc
{johnson
-davies_lisp_2020
,
1036 title = {Lisp for microcontrollers
},
1037 url
= {https
://ulisp.com
},
1038 urldate
= {2020-02-14},
1039 journal = {Lisp for microcontrollers
},
1040 author = {Johnson
-Davies
, David
},
1042 address = {Boston
, MA
, USA
},
1045 @article
{dube_bit
:_2000
,
1046 title = {{BIT
}: {A
} very compact
{Scheme
} system for embedded applications
},
1047 journal = {Proceedings of the Fourth Workshop on Scheme and Functional Programming
},
1048 author = {Dubé
, Danny
},
1050 file
= {dube.ps
:/home
/mrl
/.local
/share
/zotero
/storage
/RNG6V7HT
/dube.ps
:application
/postscript
},
1053 @inproceedings
{feeley_picbit
:_2003
,
1054 title = {{PICBIT
}: {A
} {Scheme
} system for the
{PIC
} microcontroller
},
1055 booktitle = {Proceedings of the
{Fourth
} {Workshop
} on
{Scheme
} and
{Functional
} {Programming
}},
1056 publisher = {Citeseer
},
1057 author = {Feeley
, Marc and Dubé
, Danny
},
1060 address = {Boston
, MA
, USA
},
1063 @inproceedings
{st
-amour_picobit
:_2009
,
1064 title = {{PICOBIT
}: a compact scheme system for microcontrollers
},
1065 booktitle = {International
{Symposium
} on
{Implementation
} and
{Application
} of
{Functional
} {Languages
}},
1066 publisher = {Springer
},
1067 author = {St
-Amour
, Vincent and Feeley
, Marc
},
1070 address = {South Orange
, NJ
, USA
},
1073 author = {Ravulavaru
, Arvind
},
1074 isbn
= {1-78883-378-3},
1076 publisher = {Packt Publishing
},
1077 title = {Enterprise internet of things handbook
: build end
-to
-end IoT solutions using popular IoT platforms
},
1079 address = {Birmingham
, UK
},
1082 @InProceedings
{Alphonsa20
,
1083 author="Alphonsa
, Mandla"
,
1086 title="A Review on IOT Technology Stack
, Architecture and Its Cloud Applications in Recent Trends"
,
1087 booktitle="ICCCE
2020"
,
1089 publisher="Springer Singapore"
,
1090 address="Singapore"
,
1092 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."
,
1093 isbn
="
978-981-15-7961-5"
1095 @inproceedings
{jones_clean_io
,
1096 author = {Jones
, Simon B
},
1097 title = {Experiences with Clean I
/O
},
1099 publisher = {BCS Learning \
& Development Ltd.
},
1100 address = {Swindon
, GBR
},
1101 abstract = {The Clean system is a powerful functional programming tool. It contains experiments
1102 in a
number of different areas of functional language design. In particular
, it has
1103 a novel proposal for the
organization of input and output
, and contains impressive
1104 libraries of facilities for programming graphical user interfaces.Clean I
/O is based
1105 on collections of operations that act to cause side effects on multiple explicit
abstract
1106 values representing physical I
/O entities
, such as files and graphical interfaces.
1107 A system of unique types is used to ensure that these values are individually single
1108 threaded through the program
; and the side effecting I
/O operations are therefore
1109 well controlled. This approach is distinct from monadic I
/O
, which is being widely
1110 adopted
; monadic I
/O schemes are based on a single
, implicit environment
, and guarantee
1111 that this is single threaded.In this paper we will show that the Clean and monadic
1112 approaches to I
/O merge nicely. The functionality provided by the Clean and its I
/O
1113 libraries allows libraries for monadic I
/O to be implemented. The paper presents an
1114 implementation of a basic I
/O monad library in Clean that can serve for future development.
1115 In itself
, the fact that the monadic approach can be implemented in Clean is unsurprising.
1116 However
, some interesting technical difficulties arose during implementation of the
1117 monad
; these and their solutions are discussed. The opportunity to express programs
1118 using the implicit environments of monadic I
/O allows us to simplify Clean programs
1119 by removing some of the spaghetti
, whilst retaining the generality of the explicit
1120 environments where it is the most appropriate approach.
},
1121 booktitle = {Proceedings of the
1995 International Conference on Functional Programming
},
1124 location
= {Glasgow
, UK
},
1128 @inproceedings
{sivieri2012drop
,
1129 title={Drop the phone and talk to the physical world
: Programming the internet of things with Erlang
},
1130 author={Sivieri
, Alessandro and Mottola
, Luca and Cugola
, Gianpaolo
},
1131 booktitle={2012 Third International Workshop on Software Engineering for Sensor Network Applications
(SESENA
)},
1137 @article
{chong2007secure
,
1138 title={Secure web applications via automatic partitioning
},
1139 author={Chong
, Stephen and Liu
, Jed and Myers
, Andrew C and Qi
, Xin and Vikram
, Krishnaprasad and Zheng
, Lantian and Zheng
, Xin
},
1140 journal={ACM SIGOPS Operating Systems Review
},
1145 publisher={ACM New York
, NY
, USA
}
1148 @article
{zdancewic2002secure
,
1149 title={Secure program partitioning
},
1150 author={Zdancewic
, Steve and Zheng
, Lantian and Nystrom
, Nathaniel and Myers
, Andrew C
},
1151 journal={ACM Transactions on Computer Systems
(TOCS
)},
1156 publisher={ACM New York
, NY
, USA
}
1159 @article
{bhatt2012analysis
,
1160 title={Analysis of source lines of code
(SLOC
) metric
},
1161 author={Bhatt
, Kaushal and Tarey
, Vinit and Patel
, Pushpraj and Mits
, Kaushal Bhatt and Ujjain
, Datana
},
1162 journal={International Journal of Emerging Technology and Advanced Engineering
},
1167 publisher={Citeseer
}
1170 @article
{10.1145/2775050.2633367,
1171 author = {Ekblad
, Anton and Claessen
, Koen
},
1172 title = {A Seamless
, Client
-Centric Programming Model for Type Safe Web Applications
},
1174 issue_date
= {December
2014},
1175 publisher = {Association for Computing Machinery
},
1176 address = {New York
, NY
, USA
},
1180 url
= {https
://doi.org
/10.1145/2775050.2633367},
1181 doi
= {10.1145/2775050.2633367},
1182 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.
},
1183 journal = {SIGPLAN Not.
},
1187 keywords = {distributed systems
, web applications
, network communication
}
1190 @article
{jones_1992
, title={Implementing lazy functional languages on stock hardware
: the Spineless Tagless G
-machine
}, volume={2}, DOI
={10.1017/S0956796800000319
}, number={2}, journal={Journal of Functional Programming
}, publisher={Cambridge University Press
}, author={Jones
, Simon L. Peyton
}, year={1992}, pages={127–
202}}
1193 @article
{domoszlai_implementing_2011
,
1194 title = {Implementing a non
-strict purely functional language in
{JavaScript
}},
1196 url
= {https
://www.researchgate.net
/profile
/Jan_Martin_Jansen2
/publication
/230607075_Implementing_a_non
-strict_purely_functional_language_in_JavaScript
/links
/53fc40190cf22f21c2f3b28a.pdf
},
1197 urldate
= {2017-05-23},
1198 journal = {Acta Universitatis Sapientiae
},
1199 author = {Domoszlai
, Laszlo and Bruel
, Eddy and Jansen
, Jan Martin
},
1202 file
= {53fc40190cf22f21c2f3b28a.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/2EVHREI3
/53fc40190cf22f21c2f3b28a.pdf
:application
/pdf
},
1204 @Inbook
{Domoszlai2013
,
1205 author={Domoszlai
, L
{\'a
}szl
{\'o
} and Kozsik
, Tam
{\'a
}s
},
1206 editor={Achten
, Peter and Koopman
, Pieter
},
1207 title={Clean Up the Web
!},
1208 bookTitle
={The Beauty of Functional Code
: Essays Dedicated to Rinus Plasmeijer on the Occasion of His
61st Birthday
},
1210 publisher={Springer Berlin Heidelberg
},
1211 address={Berlin
, Heidelberg
},
1213 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.
},
1214 isbn
={978-3-642-40355-2},
1215 doi
={10.1007/978-3-642-40355-2_10
},
1216 url
={https
://doi.org
/10.1007/978-3-642-40355-2_10
}
1219 @inproceedings
{10.1145/3412932.3412941,
1220 author = {Staps
, Camil and van Groningen
, John and Plasmeijer
, Rinus
},
1221 title = {Lazy Interworking of Compiled and Interpreted Code for Sandboxing and Distributed Systems
},
1223 isbn
= {9781450375627},
1224 publisher = {Association for Computing Machinery
},
1225 address = {New York
, NY
, USA
},
1226 url
= {https
://doi.org
/10.1145/3412932.3412941},
1227 doi
= {10.1145/3412932.3412941},
1228 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.
},
1229 booktitle = {Proceedings of the
31st Symposium on Implementation and Application of Functional Languages
},
1232 keywords = {functional programming
, sandboxing
, web
-assembly
, laziness
, interpreters
},
1233 location
= {Singapore
, Singapore
},
1237 @inproceedings
{elliott_guilt_2015
,
1238 title = {Guilt free ivory
},
1240 booktitle = {{ACM
} {SIGPLAN
} {Notices
}},
1242 author = {Elliott
, Trevor and Pike
, Lee and Winwood
, Simon and Hickey
, Pat and Bielman
, James and Sharp
, Jamey and Seidel
, Eric and Launchbury
, John
},
1245 file
= {5678351608ae125516ee79c6.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/KJMFUH7T
/5678351608ae125516ee79c6.pdf
:application
/pdf
},
1248 @inproceedings
{sawada_emfrp
:_2016
,
1249 title = {Emfrp
: a functional reactive programming language for small
-scale embedded systems
},
1250 booktitle = {Companion
{Proceedings
} of the
15th
{International
} {Conference
} on
{Modularity
}},
1252 author = {Sawada
, Kensuke and Watanabe
, Takuo
},
1255 file
= {Sawada and Watanabe
- 2016 - Emfrp a functional reactive programming language .pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/9U95ER
5P
/Sawada and Watanabe
- 2016 - Emfrp a functional reactive programming language .pdf
:application
/pdf
},
1258 @inproceedings
{lv_designing_2018
,
1259 title = {Designing of
{IoT
} {Platform
} {Based
} on
{Functional
} {Reactive
} {Pattern
}},
1260 booktitle = {2018 {International
} {Conference
} on
{Computer
} {Science
}, {Electronics
} and
{Communication
} {Engineering
} ({CSECE
} 2018)},
1261 publisher = {Atlantis Press
},
1262 author = {Lv
, Haidong and Ge
, Xiaolong and Zhu
, Hongzhi and Yuan
, Zhiwei and Wang
, Zhen and Zhu
, Yongkang
},
1264 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
},
1267 @inproceedings
{helbling_juniper
:_2016
,
1268 title = {Juniper
: a functional reactive programming language for the
{Arduino
}},
1269 booktitle = {Proceedings of the
4th
{International
} {Workshop
} on
{Functional
} {Art
}, {Music
}, {Modelling
}, and
{Design
}},
1271 author = {Helbling
, Caleb and Guyer
, Samuel Z
},
1274 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
},
1277 @incollection
{wang_functional_2020
,
1279 title = {Functional
{Reactive
} {EDSL
} with
{Asynchronous
} {Execution
} for
{Resource
}-{Constrained
} {Embedded
} {Systems
}},
1280 isbn
= {978-3-030-26428-4},
1281 url
= {https
://doi.org
/10.1007/978-3-030-26428-4_12
},
1282 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.
},
1283 booktitle = {Software
{Engineering
}, {Artificial
} {Intelligence
}, {Networking
} and
{Parallel
}/{Distributed
} {Computing
}},
1284 publisher = {Springer International Publishing
},
1285 author = {Wang
, Sheng and Watanabe
, Takuo
},
1286 editor = {Lee
, Roger
},
1288 doi
= {10.1007/978-3-030-26428-4_12
},
1290 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
},
1293 @incollection
{valliappan_towards_2020
,
1294 address = {New York
, NY
, USA
},
1295 title = {Towards
{Secure
} {IoT
} {Programming
} in
{Haskell
}},
1296 isbn
= {978-1-4503-8050-8},
1297 url
= {https
://doi.org
/10.1145/3406088.3409027},
1298 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.
},
1299 booktitle = {Proceedings of the
13th
{ACM
} {SIGPLAN
} {International
} {Symposium
} on
{Haskell
}},
1300 publisher = {Association for Computing Machinery
},
1301 author = {Valliappan
, Nachiappan and Krook
, Robert and Russo
, Alejandro and Claessen
, Koen
},
1304 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
},
1307 @inproceedings
{sarkar_hailstorm_2020
,
1308 address = {New York
, NY
, USA
},
1309 series = {{PPDP
} '
20},
1310 title = {Hailstorm
: {A
} {Statically
}-{Typed
}, {Purely
} {Functional
} {Language
} for
{IoT
} {Applications
}},
1311 isbn
= {978-1-4503-8821-4},
1312 url
= {https
://doi.org
/10.1145/3414080.3414092},
1313 doi
= {10.1145/3414080.3414092},
1314 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.
},
1315 booktitle = {Proceedings of the
22nd
{International
} {Symposium
} on
{Principles
} and
{Practice
} of
{Declarative
} {Programming
}},
1316 publisher = {Association for Computing Machinery
},
1317 author = {Sarkar
, Abhiroop and Sheeran
, Mary
},
1319 note = {event
-place
: Bologna
, Italy
},
1320 keywords = {functional programming
, compilers
, embedded systems
, IoT
},
1321 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
},
1323 @inproceedings
{10.1145/3281366.3281370,
1324 author = {Shibanai
, Kazuhiro and Watanabe
, Takuo
},
1325 title = {Distributed Functional Reactive Programming on Actor
-Based Runtime
},
1327 isbn
= {9781450360661},
1328 publisher = {Association for Computing Machinery
},
1329 address = {New York
, NY
, USA
},
1330 url
= {https
://doi.org
/10.1145/3281366.3281370},
1331 doi
= {10.1145/3281366.3281370},
1332 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.
},
1333 booktitle = {Proceedings of the
8th ACM SIGPLAN International Workshop on Programming Based on Actors
, Agents
, and Decentralized Control
},
1336 keywords = {Distributed Functional Reactive Programming
, Erlang
, Glitch Freedom
, Synchronization
, Actor
-Based Runtime System
},
1337 location
= {Boston
, MA
, USA
},
1338 series = {AGERE
2018}
1341 @inproceedings
{suzuki_cfrp_2017
,
1342 address = {The University of The Philippines Cebu
, Cebu City
, The Philippines
},
1343 title = {{CFRP
}: {A
} {Functional
} {Reactive
} {Programming
} {Language
} for
{Small
}-{Scale
} {Embedded
} {Systems
}},
1344 isbn
= {978-981-323-406-2 978-981-323-407-9},
1345 shorttitle
= {{CFRP
}},
1346 url
= {http
://www.worldscientific.com
/doi
/abs
/10.1142/9789813234079_0001
},
1347 doi
= {10.1142/9789813234079_0001
},
1349 urldate
= {2022-03-02},
1350 booktitle = {Theory and
{Practice
} of
{Computation
}},
1351 publisher = {WORLD SCIENTIFIC
},
1352 author = {Suzuki
, Kohei and Nagayama
, Kanato and Sawada
, Kensuke and Watanabe
, Takuo
},
1356 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
},
1360 @inproceedings
{shibanai_distributed_2018
,
1361 address = {New York
, NY
, USA
},
1362 series = {{AGERE
} 2018},
1363 title = {Distributed
{Functional
} {Reactive
} {Programming
} on
{Actor
}-{Based
} {Runtime
}},
1364 isbn
= {978-1-4503-6066-1},
1365 url
= {https
://doi.org
/10.1145/3281366.3281370},
1366 doi
= {10.1145/3281366.3281370},
1367 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.
},
1368 booktitle = {Proceedings of the
8th
{ACM
} {SIGPLAN
} {International
} {Workshop
} on
{Programming
} {Based
} on
{Actors
}, {Agents
}, and
{Decentralized
} {Control
}},
1369 publisher = {Association for Computing Machinery
},
1370 author = {Shibanai
, Kazuhiro and Watanabe
, Takuo
},
1372 note = {event
-place
: Boston
, MA
, USA
},
1373 keywords = {Actor
-Based Runtime System
, Distributed Functional Reactive Programming
, Erlang
, Glitch Freedom
, Synchronization
},
1375 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
},
1378 @inproceedings
{nilsson_functional_2002
,
1379 address = {New York
, NY
, USA
},
1380 series = {Haskell '
02},
1381 title = {Functional
{Reactive
} {Programming
}, {Continued
}},
1382 isbn
= {1-58113-605-6},
1383 url
= {https
://doi.org
/10.1145/581690.581695},
1384 doi
= {10.1145/581690.581695},
1385 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.
},
1386 booktitle = {Proceedings of the
2002 {ACM
} {SIGPLAN
} {Workshop
} on
{Haskell
}},
1387 publisher = {Association for Computing Machinery
},
1388 author = {Nilsson
, Henrik and Courtney
, Antony and Peterson
, John
},
1390 note = {event
-place
: Pittsburgh
, Pennsylvania
},
1391 keywords = {functional programming
, Haskell
, domain
-specific languages
, FRP
, hybrid modeling
, synchronous dataflow languages
},
1393 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
},
1395 @inproceedings
{10.1145/2661136.2661146,
1396 author = {Philips
, Laure and De Roover
, Coen and Van Cutsem
, Tom and De Meuter
, Wolfgang
},
1397 title = {Towards Tierless Web Development without Tierless Languages
},
1399 isbn
= {9781450332101},
1400 publisher = {Association for Computing Machinery
},
1401 address = {New York
, NY
, USA
},
1402 url
= {https
://doi.org
/10.1145/2661136.2661146},
1403 doi
= {10.1145/2661136.2661146},
1404 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.
},
1405 booktitle = {Proceedings of the
2014 ACM International Symposium on New Ideas
, New Paradigms
, and Reflections on Programming \
& Software
},
1408 keywords = {tier splitting
, program slicing
, tierless programming
, javascript
},
1409 location
= {Portland
, Oregon
, USA
},
1410 series = {Onward
! 2014}
1413 @misc
{hess_arduino
-copilot_2020
,
1414 title = {arduino
-copilot
: {Arduino
} programming in haskell using the
{Copilot
} stream
{DSL
}},
1415 shorttitle
= {arduino
-copilot
},
1416 url
= {//hackage.haskell.org
/package
/arduino
-copilot
},
1417 urldate
= {2020-02-14},
1418 journal = {Hackage
},
1419 author = {Hess
, Joey
},
1421 file
= {Snapshot
:/home
/mrl
/.local
/share
/zotero
/storage
/PSHYKF52
/arduino
-copilot.html
:text
/html
},
1423 @INPROCEEDINGS
{5558637,
1425 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
},
1427 booktitle={Eighth ACM
/IEEE International Conference on Formal Methods and Models for Codesign
(MEMOCODE
2010)},
1429 title={Feldspar
: A domain specific language for digital signal processing algorithms
},
1439 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.
},
1443 doi
={10.1109/MEMCOD
.2010.5558637},
1449 @article
{sheetz2009understanding
,
1450 title={Understanding developer and manager perceptions of function points and source lines of code
},
1451 author={Sheetz
, Steven D and Henderson
, David and Wallace
, Linda
},
1452 journal={Journal of Systems and Software
},
1457 publisher={Elsevier
}
1460 @article
{fichera2017python
,
1461 title={A Python framework for programming autonomous robots using a declarative approach
},
1462 author={Fichera
, Loris and Messina
, Fabrizio and Pappalardo
, Giuseppe and Santoro
, Corrado
},
1463 journal={Science of Computer Programming
},
1467 publisher={Elsevier
}
1470 @inproceedings
{balat2006ocsigen
,
1471 title={Ocsigen
: Typing web interaction with objective caml
},
1472 author={Balat
, Vincent
},
1473 booktitle={Proceedings of the
2006 Workshop on ML
},
1478 @inproceedings
{bjornson2010composing
,
1479 title={Composing reactive GUIs in F\# using WebSharper
},
1480 author={Bjornson
, Joel and Tayanovskyy
, Anton and Granicz
, Adam
},
1481 booktitle={Symposium on Implementation and Application of Functional Languages
},
1484 organization={Springer
}
1487 @book
{strack2015getting
,
1488 title={Getting Started with Meteor. js JavaScript Framework
},
1489 author={Strack
, Isaac
},
1491 publisher={Packt Publishing Ltd
}
1494 @incollection
{hall1993glasgow
,
1495 title={The Glasgow Haskell compiler
: a retrospective
},
1496 author={Hall
, Cordelia and Hammond
, Kevin and Partain
, Will and Peyton Jones
, Simon L and Wadler
, Philip
},
1497 booktitle={Functional Programming
, Glasgow
1992},
1500 publisher={Springer
}
1504 title = "MicroPython Differences from CPython"
,
1505 author = "Micropython Official Website"
,
1507 note = "https
://docs.micropython.org
/en
/latest
/genrst
/index.html"
,
1510 @article
{weisenburger2020survey
,
1511 title={A survey of multitier programming
},
1512 author={Weisenburger
, Pascal and Wirth
, Johannes and Salvaneschi
, Guido
},
1513 journal={ACM Computing Surveys
(CSUR
)},
1518 publisher={ACM New York
, NY
, USA
}
1521 @inproceedings
{203628,
1522 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
},
1523 title = {Understanding the Mirai Botnet
},
1524 booktitle = {26th USENIX Security Symposium
(USENIX Security
17)},
1526 isbn
= {978-1-931971-40-9},
1527 address = {Vancouver
, BC
},
1528 pages = {1093--1110},
1529 url
= {https
://www.usenix.org
/conference
/usenixsecurity17
/technical
-sessions
/presentation
/antonakakis
},
1530 publisher = {USENIX Association
},
1534 @inproceedings
{herwig_measurement_2019
,
1535 address = {San Diego
, CA
, USA
},
1536 title = {Measurement and
{Analysis
} of
{Hajime
}, a
{Peer
}-to
-peer
{IoT
} {Botnet
}},
1537 isbn
= {1-891562-55-X
},
1538 url
= {https
://par.nsf.gov
/biblio
/10096257},
1539 doi
= {10.14722/ndss
.2019.23488},
1540 booktitle = {Network and
{Distributed
} {Systems
} {Security
} ({NDSS
}) {Symposium
} 2019},
1541 author = {Herwig
, Stephen and Harvey
, Katura and Hughey
, George and Roberts
, Richard and Levin
, Dave
},
1544 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
},
1546 @article
{10.1145/3437537,
1547 author = {Alhirabi
, Nada and Rana
, Omer and Perera
, Charith
},
1548 title = {Security and Privacy Requirements for the Internet of Things
: A Survey
},
1550 issue_date
= {February
2021},
1551 publisher = {Association for Computing Machinery
},
1552 address = {New York
, NY
, USA
},
1556 url
= {https
://doi.org
/10.1145/3437537},
1557 doi
= {10.1145/3437537},
1558 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.
},
1559 journal = {ACM Trans. Internet Things
},
1563 keywords = {design principles
, software design tools
, Internet of Things
, non functional requirements
, notation
, software engineering
}
1566 @phdthesis
{wijkhuizen_security_2018
,
1567 address = {Nijmegen
},
1568 type = {Bachelor's
{Thesis
}},
1569 title = {Security analysis of the
{iTasks
} framework
},
1570 url
= {http
://www.ru.nl
/publish
/pages/769526/arjan_oortgiese.pdf
},
1571 language
= {English
},
1572 urldate
= {2017-04-08},
1573 school = {Radboud University
},
1574 author = {Wijkhuizen
, Mark
},
1576 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
},
1578 @inproceedings
{Steenvoorden2019tophat
,
1579 author = {Steenvoorden
, Tim and Naus
, Nico and Klinik
, Markus
},
1580 title = {TopHat
: A Formal Foundation for Task
-Oriented Programming
},
1582 isbn
= {9781450372497},
1583 publisher = {Association for Computing Machinery
},
1584 address = {New York
, NY
, USA
},
1585 url
= {https
://doi.org
/10.1145/3354166.3354182},
1586 doi
= {10.1145/3354166.3354182},
1587 booktitle = {Proceedings of the
21st International Symposium on Principles and Practice of Declarative Programming
},
1590 location
= {Porto
, Portugal
},