title={Coding to Cope: Teaching Programming to Children with Emotional and Behavioral Disorders},
year={2024},
isbn={9798400704987},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/3639474.3640078},
doi={10.1145/3639474.3640078},
abstract={Digital and computing literacy are essential skills in our modern society, but children with emotional and behavioral disorders are often left out, especially during their treatment in a clinic for child and adolescent psychiatry. This paper explores addressing this exclusionary gap by introducing children with emotional and behavioral disorders to programming at an early age, using the popular programming environments Scratch and Sonic Pi. The primary aim of this initiative is to provide children with such disorders an opportunity to develop critical skills through programming, ultimately promoting their affections and empowering them. Overall, our programming courses demonstrate that it is feasible to successfully teach children with emotional and behavioral disorders basic programming skills while having fun and significantly increasing their self-efficacy. There are, however, unique challenges in running such courses. Based on our experiences, we therefore provide recommendations for educators and researchers working with children with emotional and behavioral disorders in programming education.},
booktitle={Proceedings of the 46th International Conference on Software Engineering: Software Engineering Education and Training},
author={De Roover, Coen and Brichau, Johan and D'Hondt, Theo},
title={Combining fuzzy logic and behavioral similarity for non-strict program validation},
year={2006},
isbn={1595933883},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/1140335.1140339},
doi={10.1145/1140335.1140339},
abstract={The quality of an application's implementation can be assured by validating the presence or absence of a set of user-prescribed software patterns such as software engineering best practices, programming conventions and indications of poor programming. Most of the existing pattern detection techniques, however, interpret pattern descriptions in an inflexible manner, leaving the quality assurance tool to approve only the most strictly adhering pattern implementations. In order to detect various concrete pattern implementations using a single pattern description, we have combined logic meta programming ---wherein patterns can be expressed as constraints over facts representing a program's source code---, fuzzy logic and static program analysis in a way that is completely transparent to the end-user. We have achieved this by having the conditions in a logic rule interpreted as constraints over the run-time behavior source code constructs give rise to instead of as constraints over the literal source code constructs themselves. This way, a pattern's abstract description often suffices to recognize various concrete implementation variants with an indication of the similarity between the recognized implementation and the abstract pattern description},
booktitle={Proceedings of the 8th ACM SIGPLAN International Conference on Principles and Practice of Declarative Programming},
pages={15–26},
numpages={12},
keywords={fuzzy logic programming, logic meta programming, points-to analysis, program analysis, program validation, quality assurance of object-oriented programs},
location={Venice, Italy},
series={PPDP '06}
}
@inproceedings{10.1145/2414639.2414648,
author={Marron, Assaf and Weiss, Gera and Wiener, Guy},
title={A decentralized approach for programming interactive applications with JavaScript and blockly},
year={2012},
isbn={9781450316309},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/2414639.2414648},
doi={10.1145/2414639.2414648},
abstract={We present a decentralized-control methodology and a tool-set for developing interactive user interfaces. We focus on the common case of developing the client side of Web applications. Our approach is to combine visual programming using Google Blockly with a single-threaded implementation of behavioral programming in JavaScript. We show how the behavioral programming principles can be implemented with minimal programming resources, i.e., with a single-threaded environment using coroutines. We give initial, yet full, examples of how behavioral programming is instrumental in addressing common issues in this application domain, e.g., that it facilitates separation of graphical representation from logic and handling of complex inter-object scenarios. The implementation in JavaScript and Blockly (separately and together) expands the availability of behavioral programming capabilities, previously implemented in LSC, Java, Erlang and C++, to audiences with different skill-sets and design approaches.},
booktitle={Proceedings of the 2nd Edition on Programming Systems, Languages and Applications Based on Actors, Agents, and Decentralized Control Abstractions},
author={Harel, David and Marron, Assaf and Wiener, Guy and Weiss, Gera},
title={Behavioral programming, decentralized control, and multiple time scales},
...
...
@@ -70,42 +16,6 @@
series={SPLASH '11 Workshops}
}
@inproceedings{10.1145/3314221.3322484,
author={Scalas, Alceste and Yoshida, Nobuko and Benussi, Elias},
title={Verifying message-passing programs with dependent behavioural types},
year={2019},
isbn={9781450367127},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/3314221.3322484},
doi={10.1145/3314221.3322484},
abstract={Concurrent and distributed programming is notoriously hard. Modern languages and toolkits ease this difficulty by offering message-passing abstractions, such as actors (e.g., Erlang, Akka, Orleans) or processes (e.g., Go): they allow for simpler reasoning w.r.t. shared-memory concurrency, but do not ensure that a program implements a given specification. To address this challenge, it would be desirable to specify and verify the intended behaviour of message-passing applications using types, and ensure that, if a program type-checks and compiles, then it will run and communicate as desired. We develop this idea in theory and practice. We formalise a concurrent functional language λ≤π, with a new blend of behavioural types (from π-calculus theory), and dependent function types (from the Dotty programming language, a.k.a. the future Scala 3). Our theory yields four main payoffs: (1) it verifies safety and liveness properties of programs via type-level model checking; (2) unlike previous work, it accurately verifies channel-passing (covering a typical pattern of actor programs) and higher-order interaction (i.e., sending/receiving mobile code); (3) it is directly embedded in Dotty, as a toolkit called Effpi, offering a simplified actor-based API; (4) it enables an efficient runtime system for Effpi, for highly concurrent programs with millions of processes/actors.},
booktitle={Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation},
title={Challenges of Scaling Programming-based Behavioral Metrics},
year={2022},
isbn={9781450391580},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/3491140.3528290},
doi={10.1145/3491140.3528290},
abstract={Small previous studies exploring student programming process have demonstrated behavioral metrics' (i.e., EQ, Watwin, RED) ability to predict grades. However, this relationship deteriorates when scaled across contexts [1]. This paper replicates Price et al's finding on anonymized data collected from thousands of learners across the globe that use the Codio platform and discusses the context-dependent nature of these behavioral metrics and grades noted in previous work as potential reasons for this finding.We predicted that these metrics would be more consistent across programming assignments than grades. However, we found that behavioral metrics vary more, possibly an artifact of students struggling before achieving success - a pattern not captured by grades. This shows the promise of these metrics and their ability to act as a real-time indicator of student process instead of a predictor of grade performance.},
booktitle={Proceedings of the Ninth ACM Conference on Learning @ Scale},
author={Bar-Sinai, Michael and Weiss, Gera and Shmuel, Reut},
title={BPjs: an extensible, open infrastructure for behavioral programming research},
...
...
@@ -157,96 +67,6 @@
series={GECCO '14}
}
@inproceedings{10.1145/2371401.2371411,
author={Spacek, Petr and Dony, Christophe and Tibermacine, Chouki and Fabresse, Luc},
title={An inheritance system for structural \& behavioral reuse in component-based software programming},
year={2012},
isbn={9781450311298},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/2371401.2371411},
doi={10.1145/2371401.2371411},
abstract={In the context of Component-based Programming, which addresses the implementation stage of a component-based software engineering development process, this paper describes a specification and an operational integration of an inheritance system into a self-contained new component-based programming language named Compo. Our proposal completes and extends related works by making it possible to apply inheritance to the full description of components, i.e. both to structural (description of provisions and requirements, of component architecture) and behavioral (full implementations of services) parts in component descriptions. Inheritance in Compo is designed to be used in conjunction with composition to maximize reuse capabilities and expressive power. Compo implementation proposes a clear operational solution for inheritance and for achieving and testing substitutions.},
booktitle={Proceedings of the 11th International Conference on Generative Programming and Component Engineering},
author={King, Peter and Schmitz, Patrick and Thompson, Simon},
title={Behavioral reactivity and real time programming in XML: functional programming meets SMIL animation},
year={2004},
isbn={1581139381},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/1030397.1030411},
doi={10.1145/1030397.1030411},
abstract={XML and its associated languages are emerging as powerful authoring tools for multimedia and hypermedia web content. Furthermore intelligent presentation generation engines have begun to appear as have models and platforms for adaptive presentations. However XML-based models are limited by their lack of expressiveness in presentation and animation. As a result authors of dynamic adaptive web content must often use considerable amounts of script or code. The use of such script or code has two serious drawbacks. First such code undermines the declarative description possible in the original presentation language and second the scripting/coding approach does not readily lend itself to authoring by non programmers. In this paper we describe a set of XML language extensions inspired by features from the functional programming world which are designed to widen the class of reactive systems which could be described in languages such as SMIL. The described features extend the power of declarative modeling for the web by allowing the introduction of web media items which may dynamically react to continuously varying inputs both in a continuous way and by triggering discrete user-defined events. The two extensions described herein are discussed in the context of SMIL Animation and SVG but could be applied to many XML-based languages.},
booktitle={Proceedings of the 2004 ACM Symposium on Document Engineering},
author={Szubert, Marcin and Kodali, Anuradha and Ganguly, Sangram and Das, Kamalika and Bongard, Josh C.},
title={Reducing Antagonism between Behavioral Diversity and Fitness in Semantic Genetic Programming},
year={2016},
isbn={9781450342063},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/2908812.2908939},
doi={10.1145/2908812.2908939},
abstract={Maintaining population diversity has long been considered fundamental to the effectiveness of evolutionary algorithms. Recently, with the advent of novelty search, there has been an increasing interest in sustaining behavioral diversity by using both fitness and behavioral novelty as separate search objectives. However, since the novelty objective explicitly rewards diverging from other individuals, it can antagonize the original fitness objective that rewards convergence toward the solution(s). As a result, fostering behavioral diversity may prevent proper exploitation of the most interesting regions of the behavioral space, and thus adversely affect the overall search performance. In this paper, we argue that an antagonism between behavioral diversity and fitness can indeed exist in semantic genetic programming applied to symbolic regression. Minimizing error draws individuals toward the target semantics but promoting novelty, defined as a distance in the semantic space, scatters them away from it. We introduce a less conflicting novelty metric, defined as an angular distance between two program semantics with respect to the target semantics. The experimental results show that this metric, in contrast to the other considered diversity promoting objectives, allows to consistently improve the performance of genetic programming regardless of whether it employs a syntactic or a semantic search operator.},
booktitle={Proceedings of the Genetic and Evolutionary Computation Conference 2016},
title={Programming abstractions for integrating autonomous and reactive behaviors: an agent-oriented approach},
year={2012},
isbn={9781450316309},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/2414639.2414650},
doi={10.1145/2414639.2414650},
abstract={The integration of autonomous and reactive behavior is a relevant problem in the context of concurrent programming, related to the integration of thread-based and event-driven programming. From a programming paradigm perspective, the problem can not be easily solved by approaches based on object-oriented concurrent programming or by the actor model, being them natively based on the reactivity principle only. In this paper we tackle the problem with agent-oriented programming, using an agent-oriented programming language called simpAL.},
booktitle={Proceedings of the 2nd Edition on Programming Systems, Languages and Applications Based on Actors, Agents, and Decentralized Control Abstractions},
author={Al Chawa, Mohamad Moner and Tetzlaff, Ronald and Tjortjis, Christos and Stavrinides, Stavros G. and De Benito, Carol and Picos, Rodrigo},
title={A Behavioural Compact Model for Programmable Neuromorphic ReRAM},
year={2024},
isbn={9798400703256},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/3611315.3633237},
doi={10.1145/3611315.3633237},
abstract={In this work, we present a compact memristor model for bipolar neuromorphic ReRAM devices. The proposed model focuses on a behavioural high level description of the device, and it reproduces some of the most important characteristics (i.e. conductance, energy dissipation), using the number of pulses as the input variable instead of any electrical. Its functionality is shown by using it to model the behavior of three different ReRAM devices that were fabricated and measured at the CNR-IMM, Agrate Brianza. Considering a train of identical pulses as an input voltage signal consisting of N pulses and where m is the pulse number. The conductance during depression or potentiation can be described.},
booktitle={Proceedings of the 18th ACM International Symposium on Nanoscale Architectures},
author={Harel, David and Lampert, Robby and Marron, Assaf and Weiss, Gera},
title={Model-checking behavioral programs},
...
...
@@ -265,43 +85,6 @@
series={EMSOFT '11}
}
@article{10.1145/2480361.2371411,
author={Spacek, Petr and Dony, Christophe and Tibermacine, Chouki and Fabresse, Luc},
title={An inheritance system for structural \& behavioral reuse in component-based software programming},
year={2012},
issue_date={March 2013},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
volume={48},
number={3},
issn={0362-1340},
url={https://doi.org/10.1145/2480361.2371411},
doi={10.1145/2480361.2371411},
abstract={In the context of Component-based Programming, which addresses the implementation stage of a component-based software engineering development process, this paper describes a specification and an operational integration of an inheritance system into a self-contained new component-based programming language named Compo. Our proposal completes and extends related works by making it possible to apply inheritance to the full description of components, i.e. both to structural (description of provisions and requirements, of component architecture) and behavioral (full implementations of services) parts in component descriptions. Inheritance in Compo is designed to be used in conjunction with composition to maximize reuse capabilities and expressive power. Compo implementation proposes a clear operational solution for inheritance and for achieving and testing substitutions.},
author={Li, Sihan and Xiao, Xusheng and Bassett, Blake and Xie, Tao and Tillmann, Nikolai},
title={Measuring code behavioral similarity for programming and software engineering education},
year={2016},
isbn={9781450342056},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/2889160.2889204},
doi={10.1145/2889160.2889204},
abstract={In recent years, online programming and software engineering education via information technology has gained a lot of popularity. Typically, popular courses often have hundreds or thousands of students but only a few course staff members. Tool automation is needed to maintain the quality of education. In this paper, we envision that the capability of quantifying behavioral similarity between programs is helpful for teaching and learning programming and software engineering, and propose three metrics that approximate the computation of behavioral similarity. Specifically, we leverage random testing and dynamic symbolic execution (DSE) to generate test inputs, and run programs on these test inputs to compute metric values of the behavioral similarity. We evaluate our metrics on three real-world data sets from the Pex4Fun platform (which so far has accumulated more than 1.7 million game-play interactions). The results show that our metrics provide highly accurate approximation to the behavioral similarity. We also demonstrate a number of practical applications of our metrics including hint generation, progress indication, and automatic grading.},
booktitle={Proceedings of the 38th International Conference on Software Engineering Companion},
pages={501–510},
numpages={10},
location={Austin, Texas},
series={ICSE '16}
}
@inproceedings{10.1145/2687357.2687359,
author={Harel, David and Katz, Guy},
title={Scaling-Up Behavioral Programming: Steps from Basic Principles to Application Architectures},
...
...
@@ -334,39 +117,4 @@
numpages={9},
location={Munich, Germany},
series={MODELS '19}
}
@inproceedings{10.1109/ICSE-C.2017.158,
author={Campusano, Miguel},
title={Live programming the behavioral layer of robots},
year={2017},
isbn={9781538615898},
publisher={IEEE Press},
url={https://doi.org/10.1109/ICSE-C.2017.158},
doi={10.1109/ICSE-C.2017.158},
abstract={Robotic development suffers from a long cognitive distance between the code and the resulting behavior. This is due to the several steps necessary to build robotic behaviors: writing the code, compiling it, deploying it and finally testing it on the robot. All this slows down development and can make experimentation prohibitively expensive. In contrast, Live Programming tightens the feedback loop, minimizing the cognitive distance. As a result, programmers benefit from an immediate connection with the program that they are making thanks to an immediate, 'live' feedback of program behavior. This allows for extremely rapid creation, or variation, of robot behavior and for dramatically increased debugging speed.In this research, we fist explore the concept of live programming in the development of robot behaviors. Second, we present how we can validate our approach to improve the development of robotic behaviors.},
booktitle={Proceedings of the 39th International Conference on Software Engineering Companion},
pages={85–87},
numpages={3},
keywords={live programming, live robot programming, nested state machines, robot},
location={Buenos Aires, Argentina},
series={ICSE-C '17}
}
@inproceedings{10.1145/3502718.3524797,
author={Yeni, Sabiha and van der Meulen, Anna},
title={Students' Behavioral Intention to Use Gradual Programming Language Hedy: A Technology Acceptance Model},
year={2022},
isbn={9781450392013},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/3502718.3524797},
doi={10.1145/3502718.3524797},
abstract={Programming is generally considered a cognitively challenging subject by beginners because it involves acquiring complex new knowledge, strategies, and practical skills. Effective instructional strategies and programming platforms are important in providing the student with optimal learner support. As a new approach, the first gradual programming language Hedy was launched to overcome issues with syntax and cognitive overload when learning to program by teaching syntax and semantic knowledge in steps, rather than at once. In this paper, we aim to investigate students' acceptance of Hedy, by analyzing their behavioral intentions from the theoretical background of the Technology Acceptance Model (TAM). We conducted a qualitative case study combining a survey and group interviews to capture the dimensions of TAM. 18 students between the ages of 10 and 12 attended four days of summer camp on Hedy during which data were gathered. The results indicate that several of the participants have a positive attitude towards Hedy, and their experience of "not too difficult but real programming" appears in line with the intention of the gradual programming language. However, some other children found Hedy too limited and restricted or expressed a desire for a different type of output. Overall, learners' experience appeared embedded in their previous programming experience as well as expectation beforehand of Hedy and of programming in general. Finally, a trend could be seen where learners from under-resourced communities (about half of the participants) overall were less positive about their experience and behavioral intention.},
booktitle={Proceedings of the 27th ACM Conference on on Innovation and Technology in Computer Science Education Vol. 1},
pages={331–336},
numpages={6},
keywords={gradual programming language, hedy, the technology acceptance model},
