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},
year={2011},
isbn={9781450311830},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/2095050.2095079},
doi={10.1145/2095050.2095079},
abstract={Behavioral programming is a recently proposed approach for non-intrusive incremental software development. We propose that behavioral programming concepts, such as behavioral decomposition, synchronized execution of independent behaviors, and event blocking, can help in the incremental and natural coding of complex decentralized systems, complementing actor-oriented and agent-oriented approaches. We also contribute to the existing research on behavioral programming a method for coordinating behaviorally-programmed components which, due to different time scales or interaction with the external environment, cannot synchronize and thus cannot employ event blocking. We show that the resulting decentralized system retains many of the advantages present in a purely behavioral, fully synchronized system.},
booktitle={Proceedings of the Compilation of the Co-Located Workshops on DSM'11, TMC'11, AGERE! 2011, AOOPES'11, NEAT'11, \& VMIL'11},
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},
year={2018},
isbn={9781450359658},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/3270112.3270126},
doi={10.1145/3270112.3270126},
abstract={We present unified and extensible semantics for Behavioral Programming (BP). The presented semantics support a direct embedding of executable models in regular software systems. We further present BPjs --- a tool-set for executing, embedding, and verifying behavioral models, based on the proposed semantics. Being extensible, embeddable, and supporting verification, BPjs can serve as a common infrastructure for BP and executable modeling research.},
booktitle={Proceedings of the 21st ACM/IEEE International Conference on Model Driven Engineering Languages and Systems: Companion Proceedings},
pages={59–60},
numpages={2},
keywords={executable models, javascript, scenario based models},
location={Copenhagen, Denmark},
series={MODELS '18}
}
@inproceedings{10.5555/1883978.1883995,
author={Harel, David and Marron, Assaf and Weiss, Gera},
title={Programming coordinated behavior in java},
year={2010},
isbn={3642141064},
publisher={Springer-Verlag},
address={Berlin, Heidelberg},
abstract={Following the scenario-based approach to programming which centered around live sequence charts (LSCs), we propose a general approach to software development in Java. A program will consist of modules called behavior threads (b-threads), each of which independently describes a scenario that may cross object boundaries. We identify a protocol and a coordination mechanism that allow such behavioral programming. Essentially, runs of programs are sequences of events that result from three kinds of b-thread actions: requesting that events be considered for triggering, waiting for triggered events, and blocking events requested by other b-threads. The coordination mechanism synchronizes and interlaces b-threads execution yielding composite, integrated system behavior. The protocol idioms and the coordination mechanism of b-threads are implemented as a Java library called BPJ. Throughout the exposition we illustrate benefits of the approach and discuss the merits of behavioral programming as a broad, implementation-independent paradigm.},
booktitle={Proceedings of the 24th European Conference on Object-Oriented Programming},
pages={250–274},
numpages={25},
location={Maribor, Slovenia},
series={ECOOP'10}
}
@inproceedings{10.1145/2576768.2598288,
author={Krawiec, Krzysztof and O'Reilly, Una-May},
title={Behavioral programming: a broader and more detailed take on semantic GP},
year={2014},
isbn={9781450326629},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/2576768.2598288},
doi={10.1145/2576768.2598288},
abstract={In evolutionary computation, the fitness of a candidate solution conveys sparse feedback. Yet in many cases, candidate solutions can potentially yield more information. In genetic programming (GP), one can easily examine program behavior on particular fitness cases or at intermediate execution states. However, how to exploit it to effectively guide the search remains unclear. In this study we apply machine learning algorithms to features describing the intermediate behavior of the executed program. We then drive the standard evolutionary search with additional objectives reflecting this intermediate behavior. The machine learning functions independent of task-specific knowledge and discovers potentially useful components of solutions (subprograms), which we preserve in an archive and use as building blocks when composing new candidate solutions. In an experimental assessment on a suite of benchmarks, the proposed approach proves more capable of finding optimal and/or well-performing solutions than control methods.},
booktitle={Proceedings of the 2014 Annual Conference on Genetic and Evolutionary Computation},
pages={935–942},
numpages={8},
keywords={archive, behavioral evaluation, genetic programming, multiobjective evolutionary computation, program semantics, program synthesis, search operators},
location={Vancouver, BC, Canada},
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},
year={2011},
isbn={9781450307147},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/2038642.2038686},
doi={10.1145/2038642.2038686},
abstract={System specifications are often structured as collections of scenarios and use-cases that describe desired and forbidden sequences of events. A recently proposed behavioral programming approach, which evolved from the visual language of live sequence charts (LSCs), calls for coding software modules in alignment with such scenarios. We present a methodology and a supporting model-checking tool for verifying behavioral Java programs, without having to first translate them into a specific input language for the model checker. Our method facilitates early discovery of conflicting or under-specified scenarios, which can often be resolved by adding new scenarios rather than by changing existing code. Also, counterexamples provided by the tool are themselves event sequences that can serve directly for refinements and corrections. Our tool reduces the size of the execution state-space using an abstraction that focuses on behaviorally interesting states and treats transitions between them as atomic.},
booktitle={Proceedings of the Ninth ACM International Conference on Embedded Software},
pages={279–288},
numpages={10},
keywords={behavioral programming, java},
location={Taipei, Taiwan},
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},
year={2014},
isbn={9781450321891},
publisher={Association for Computing Machinery},
address={New York, NY, USA},
url={https://doi.org/10.1145/2687357.2687359},
doi={10.1145/2687357.2687359},
abstract={Behavioral programming (BP) is a decentralized scenario-based paradigm for the programming of reactive software, geared towards incremental and intuitive development. In this work we apply the principles of BP to a large, real-world case-study: a web-server. We discuss the conclusions learned from our attempt and propose several extension idioms to BP, aimed at improving the framework's scalability. Specifically, we propose extending BP with a timeout idiom for handling various time constraints, program-specific execution strategies, dynamic thread creation for efficiently allocating system resources, and support for parameterized events to handle inputs with infinite domains. Our extensions and case-study are implemented in a new framework for behavioral programming in C++.},
booktitle={Proceedings of the 4th International Workshop on Programming Based on Actors Agents \& Decentralized Control},
pages={95–108},
numpages={14},
keywords={behavioral programming, c++, http, reactive systems, tcp, time constraints},
location={Portland, Oregon, USA},
series={AGERE! '14}
}
@inproceedings{10.1109/MODELS-C.2019.00039,
author={Elyasaf, Achiya and Sadon, Aviran and Weiss, Gera and Yaacov, Tom},
title={Using behavioural programming with solver, context, and deep reinforcement learning for playing a simplified RoboCup-type game},
abstract={We describe four scenario-based implementations of controllers for a player in a simplified RoboCup-type game. All four implementations are based on the behavioural programming (BP) approach. We first describe a simple controller for the player using the state-of-the-art BPjs tool and then show how it can be extended in various ways. The first extension is based on a version of BP where the Z3 SMT solver is used to provide mechanisms for richer composition of modules within the BP model. This allows for modules with higher cohesion and lower coupling. It also allows incrementality: we could use the scenarios we developed for the challenge of MDETOOLS'18 and extend the model to handle the new system. The second extension of BP demonstrated in this paper is a set of idioms for subjecting model components to context. One of the differences between this year's challenge and the challenge we dealt with last year is that following the ball is not the only task that a player needs to handle, there is much more to care for. We demonstrate how we used the idioms for handling context to parametrize scenarios like "go to a target" in a dynamic and natural fashion such that modelers can efficiently specify reusable components similar to the way modern user manuals for advanced products are written. Lastly, in an attempt to make the instructions to the robot even more natural, we demonstrate a third extension based on deep reinforcement learning. Towards substantiating the observation that it is easier to explain things to an intelligent agent than to dumb compiler, we demonstrate how the combination of BP and deep reinforcement learning (DRL) allows for giving abstract instructions to the robot and for teaching it to follow them after a short training session.},
booktitle={Proceedings of the 22nd International Conference on Model Driven Engineering Languages and Systems},
pages={243–251},
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},
