Program Behavior Research Articles

Justifying the Inclusion of Organizational Theory and Behavior (OTB) in PhD Programs in Educational Leadership and Policy (ELP)

This literature focused on an emerging construct in justifying the inclusion of organizational theory and behavior (OTB) in PhD programs in educational leadership and policy (ELP), and comparing this construct in relation to the rationale for inclusion, key organizational theories and behaviors for leadership and policy, and the benefits of organizational theory and behavior to PhD graduates that share a common concern in the dimension of effective leadership and policy in organizations. Drawing broadly from the interconnections and intersections of the organization theory and behavior literature, I offer a justification about the qualifications and benefits of OTB in ELP programs. The study likewise identified the concerns and questions to be addressed in the future and discuss their implications for research, leadership and practice. The present review indicated that OTB remains largely beneficial by offering insights into the evolution, functioning, process, progress, and research opportunities for new discoveries in leadership and policymaking to improve organizational effectiveness. Effective integration of organizational theory and behavior enhances graduate outcomes and preparing them to handle organizational challenges as future leaders and policymakers.

“In your face!” Do family communication patterns influence U.S. tween’s imitation of disrespectful talk and behavior found in their favorite television shows?

ABSTRACT This two-part study looks at disrespectful talk and behavior in tween’s television programming (study 1) and its relationship to disrespectful talk and behavior by young viewers (study 2). First, a content analysis was conducted to examine the amount of disrespectful talk and disrespectful behavior in the top programs that children aged 6–12 watched in two different samples of programming from 2006 and 2012 (N = 173). Results revealed that 98% of the programs contained some disrespectful talk or behavior. Second, survey data was collected among current emerging adults, who reported watching these shows during their tween years, to explore the relationship between viewing these shows and disrespectful mannerisms during their tween years, family communication during tween years and current family satisfaction. Through analyses linking both studies, we found positive relationships between viewing the highly disrespectful television shows signaled in the content analysis and tween disrespectful talk and behavior. Tween family communication patterns were linked to later family satisfaction in emerging adulthood and conversation oriented families may be able to better weather increased negativity from tween disrespect. Findings are discussed in terms of information processing theory and social cognitive theory.

Fuzzing trusted execution environments with Rust

Fuzzing, a software testing technique, aims to uncover bugs by subjecting the target program to random inputs, thus discerning abnormal program behaviors such as crashes. In this paper, we present the design and implementation of a fuzzing framework designed to test TEEs (Trusted Execution Environment). Our framework leverages established software tools in a novel way: (1) We employ the Rust programming language in a two-way code generator: to translate fuzzer output to a sequence of system calls and in a “reverse translation” process, where sample code snippets are used to seed the fuzzer – a single API specification suffices for both endeavors; (2) Our fuzzer exhibits the ability to iteratively traverse the API's specification, scrutinize object dependencies, and judiciously reuse objects. These features significantly amplify its bug-finding prowess. (3) A versatile Rust proc macro mechanism is used to process the API specification. The fuzzer's code is built with the Rust compiler sans the necessity for additional specialized tools. (4) To enable the efficient stateful execution of TEEs, we have tailored the QEMU system emulator accordingly. To verify the usability and performance of our fuzzer, and to test various configuration options we conducted a series of tests with a popular open-source OP-TEE trusted operating system.

Investigating students’ programming behaviors, interaction qualities and perceptions through prompt-based learning in ChatGPT

ChatGPT has proven to facilitate computer programming tasks through the strategic use of prompts, which effectively steer the interaction with the language model towards eliciting relevant information. However, the impact of specifically designed prompts on programming learning outcomes has not been rigorously examined through empirical research. This study adopted a quasi-experimental framework to investigate the differential effects of prompt-based learning (PbL) versus unprompted learning (UL) conditions on the programming behaviors, interaction qualities, and perceptions of college students. The study sample consisted of 30 college students who were randomly assigned to two groups. A mixed-methods approach was employed to gather multi-faceted data. Results revealed notable distinctions between the two learning conditions. First, the PbL group students frequently engaged in coding with Python and employed debugging strategies to verify their work, whereas their UL counterparts typically transferred Python code from PyCharm into ChatGPT and posed new questions within ChatGPT. Second, PbL participants were inclined to formulate more complex queries independently, prompted by the guiding questions, and consequently received more precise feedback from ChatGPT compared to the UL group. UL students tended to participate in more superficial-level interactions with ChatGPT, yet they also obtained accurate feedback. Third, there were noticeable differences in perception observed before and after the ChatGPT implementation, UL group reported a more favorable perception in the perceived ease of use in the pre-test, while the PbL group experienced an improvement in their mean scores for perceived usefulness, ease of use, behavioral intention to utilize, and a significant difference regarding the attitude towards utilizing ChatGPT. Specifically, the use of structured output and delimiters enhanced learners’ understanding of problem-solving steps and made learning more efficient with ChatGPT. Drawing on these outcomes, the study offers recommendations for the incorporation of ChatGPT into future instructional designs, highlighting the structured prompting benefits in enhancing programming learning experience.

Real-Time Collaborative Programming in Undergraduate Education: A Comprehensive Empirical Analysis of Its Impact on Knowledge, Behaviors, and Attitudes

Real-time collaborative programming (RCP), which allows multiple programmers to work concurrently on the same codebase with changes instantly visible to all participants, has garnered considerable popularity in higher education. Despite this trend, little work has rigorously examined how undergraduates engage in collaborative programming when using RCP. This study utilized a quasi-experimental design to investigate the impact of RCP on undergraduates’ programming knowledge and skills, behaviors, and attitudes toward collaboration. Eighty-two participants were randomly assigned to either the RCP group or the Traditional Collaborative Programming (TCP) group. The data analysis yielded noteworthy findings. First, RCP significantly improved learners’ problem-solving skills and led to higher knowledge test scores compared to TCP. Second, there were no significant differences in attitudes toward collaboration between the two groups. Third, analysis of programming behaviors indicated that the RCP group exhibited more efficient coding practices, including producing a greater volume of code and executing it more successfully. Additionally, the RCP group’s code-testing activities were predominantly concentrated at the first half of the class sessions. Based on the empirical research results, three major pedagogical implications were proposed. These findings highlight the benefits of integrating RCP into programming education and suggest avenues for future research into collaborative learning dynamics.

TaPaFuzz: Hardware-accelerated RISC-V bare-metal firmware fuzzing using rapid job launches

Fuzz testing serves as a key technique in software security aimed at identifying unexpected program behaviors by repeatedly executing the target program with auto-generated random inputs. Testing is integral to IoT device security but is hampered by the minimal observability features of typical in-market IoT devices. Moreover, the slow nature of a RISC-V software emulation on x86 host CPUs and the inaccuracies introduced by compiling IoT applications to a different ISA for execution on host systems pose significant challenges. Our software-hardware co-design surmounts these hurdles. Fuzzing jobs are prepared and evaluated on a host computer, while the actual execution with high-throughput tracing is performed on an FPGA. Advances in the host-to-FPGA interface together with an accelerated reset procedure between Fuzzer jobs effectively hide the costly host-FPGA communication, increasing the single-thread fuzzing performance by up to factor 11.7x that of the leading QEMU-based fuzzer AFL++ running on a very fast x86 CPU. We demonstrate practical usability by evaluating our framework on a collection of applications in a bare-metal environment.

A Comparative Analysis of Memory Models: SC, TSO, and ARM in Concurrent Programming

Concurrent programming has long been a challenge due to the complex interactions between processors and shared memory. The intuition of programmers often diverges from the actual behavior of concurrent programs due to factors such as modern processor technologies, compiler optimizations, and performance-driven data store implementations. To address this discrepancy, memory models were introduced to formally define the permissible and prohibited behaviors in concurrent program execution. Memory models can be broadly categorized into strong and weak models. Sequential Consistency (SC) is a strong model that preserves the order of events in each thread or process, aligning with programmers' expectations. In contrast, weak models, such as Total Store Order (TSO) and ARM, allow for relaxed ordering, potentially leading to unexpected behaviors. This paper presents a practical comparison of SC, TSO, and ARM memory models. A suite of six litmus tests were executed on architectures implementing each model to highlight their differences. The results were analyzed using the axiomatic models of each architecture to understand why certain behaviors were accepted or rejected. The herd tool was employed to simulate memory model behavior. The findings revealed a significant disparity in the acceptance of behaviors across the three models. SC emerged as the most restrictive, followed by TSO, while ARM demonstrated the least stringent acceptance criteria. These results underscore the importance of understanding memory model nuances when developing concurrent programs to ensure correct and predictable behavior.

Semantics of Remote Direct Memory Access: Operational and Declarative Models of RDMA on TSO Architectures

Remote direct memory access (RDMA) is a modern technology enabling networked machines to exchange information without involving the operating system of either side, and thus significantly speeding up data transfer in computer clusters. While RDMA is extensively used in practice and studied in various research papers, a formal underlying model specifying the allowed behaviours of concurrent RDMA programs running in modern multicore architectures is still missing. This paper aims to close this gap and provide semantic foundations of RDMA on x86-TSO machines. We propose three equivalent formal models, two operational models in different levels of abstraction and one declarative model, and prove that the three characterisations are equivalent. To gain confidence in the proposed semantics, the more concrete operational model has been reviewed by NVIDIA experts, a major vendor of RDMA systems, and we have empirically validated the declarative formalisation on various subtle litmus tests by extensive testing. We believe that this work is a necessary initial step for formally addressing RDMA-based systems by proposing language-level models, verifying their mapping to hardware, and developing reasoning techniques for concurrent RDMA programs.

WhiteFox: White-Box Compiler Fuzzing Empowered by Large Language Models

Compiler correctness is crucial, as miscompilation can falsify program behaviors, leading to serious consequences over the software supply chain. In the literature, fuzzing has been extensively studied to uncover compiler defects. However, compiler fuzzing remains challenging: Existing arts focus on black- and grey-box fuzzing, which generates test programs without sufficient understanding of internal compiler behaviors. As such, they often fail to construct test programs to exercise intricate optimizations. Meanwhile, traditional white-box techniques, such as symbolic execution, are computationally inapplicable to the giant codebase of compiler systems. Recent advances demonstrate that Large Language Models (LLMs) excel in code generation/understanding tasks and even have achieved state-of-the-art performance in black-box fuzzing. Nonetheless, guiding LLMs with compiler source-code information remains a missing piece of research in compiler testing. To this end, we propose WhiteFox, the first white-box compiler fuzzer using LLMs with source-code information to test compiler optimization, with a spotlight on detecting deep logic bugs in the emerging deep learning (DL) compilers. WhiteFox adopts a multi-agent framework: (i) an LLM-based analysis agent examines the low-level optimization source code and produces requirements on the high-level test programs that can trigger the optimization; (ii) an LLM-based generation agent produces test programs based on the summarized requirements. Additionally, optimization-triggering tests are also used as feedback to further enhance the test generation prompt on the fly. Our evaluation on the three most popular DL compilers (i.e., PyTorch Inductor, TensorFlow-XLA, and TensorFlow Lite) shows that WhiteFox can generate high-quality test programs to exercise deep optimizations requiring intricate conditions, practicing up to 8 times more optimizations than state-of-the-art fuzzers. To date, WhiteFox has found in total 101 bugs for the compilers under test, with 92 confirmed as previously unknown and 70 already fixed. Notably, WhiteFox has been recently acknowledged by the PyTorch team, and is in the process of being incorporated into its development workflow. Finally, beyond DL compilers, WhiteFox can also be adapted for compilers in different domains, such as LLVM, where WhiteFox has already found multiple bugs.

Nutritional Support and Physical Activity Intervention Programs with a Person-Centred Approach in People with Chronic Obstructive Pulmonary Disease: a Scoping Review.

The knowledge is sparse in the literature on intervention programs using nutritional support and physical activity for patients with chronic obstructive pulmonary disease within a person-centred approach. We aimed to explore and map the existing evidence on intervention programs with a person-centred approach, focusing on nutritional support and physical activity for people with COPD. A scoping review was conducted using Arksey & O'Malley's methodological framework. A search in the databases CINAHL and PubMed, and a grey literature search, was conducted in June 2022 and updated in June 2023. We identified studies published between 2012 and 2023. The PRISMA checklist for scoping reviews, supported by The PAGER framework was used for reporting the method. A total of 15 studies were included. The primary interventions comprised behavior of change or self-management, addressing needs assessment, motivation, personal goals, education, and physical activity. Health-related quality of life and hospital stay displayed no clinically significant variances. However, eight studies demonstrated differences in physical function and activity levels. Nutritional outcomes were addressed in one study, and three studies involved relatives. This scoping review addresses a knowledge gap in nutritional support interventions with a person-centred approach. It indicates that there is a need to increase nutritional support and consider the patient's physical and social environmental resources within Behavior of change or Self-management intervention programs for patients with COPD. The review found no clinical effect on health-related quality of life, although there were some effects on physical activity. The results highlight how the interdisciplinary team can include the patients' resources when structuring the management of COPD by applying a person-centred approach.

Using Hardware Events to Detect Side-Channel Attacks

The article discusses the monitoring system being developed by authors for the detection of Side-Channel Attacks, SCA. The theoretical justification of the chosen method of detecting SCA attacks is given: analysis of hardware events of the target system. The architecture of the monitoring system is described, including low-level data collection processes and an expert system that analyzes the collected data. The results of the proof-of-concept on various classes of SCA-attacks are presented. The paper considers a class of attacks on side-channels that use the processor cache to obtain secret information. A method of countering attacks of this class based on the use of a hardware event mechanism is proposed. As a result of the analysis of existing hardware events, predicates have been built for the Intel architecture, allowing one to identify the suspicious behavior of programs in the Linux OS environment. To test the proposed method, a prototype monitoring system was implemented that successfully coped with the detection of simulated SCA-attacks. The advantages and disadvantages of this method are considered, and the direction of further research is indicated.

Intelligent Method for Mutation of Input Cases with Feedback

Relevance. Fuzzing is one of the effective ways to improve the software reliability and is included in the mandatory list of research carried out at the stage of qualification testing according to national standard GOST R 56939-2016. The use of standard mutators reduces the fuzzing process to brute force, which negatively affects the time of incorrect program behavior detection. In this regard, it is important to rationalize the selection of input data, which takes into account the data corpus specifics, as well as the context describing the software response under test and allowing to determine the mutations at the next iteration of testing. Purpose of the research is to increase the efficiency of fuzzing by intellectualizing the standard mutator using neural networks, which takes into account the syntactic and semantic features of the input corpus and uses program feedback.Methods. The methods of analysis and synthesis, theory of algorithms, discrete and computational mathematics, machine learning were used.Result. The advantages and disadvantages of the standard module for AFL fuzzer’s input corpus mutation are considered. The justification of neural network choice with LSTM-architecture as a mechanism that realizes the intelligent control of input corpora’s’ generation and transformation is given. The proposed mutation method is described, which implies the integration of decision making mechanism on the amount and format of necessary mutations to increase the code coverage into the standard mutator, as well as the subsequent refinement of input data by shell-code to check the operability of the fragment that caused abnormal software’s behavior. The scheme of the mutation module is presented, which includes a component of input corporas conversion for generation of program execution traces and a component aimed at concept confirmation and re-call of abnormal software behavior using the generated shell-code.Novelty. Unlike the known ones, the proposed method uses feedback, fixing the software reaction, when forming the data mutation strategy, which determines the scientific novelty of the obtained results.Significance. The proposed solution allows reducing the program testing time while maintaining the code coverage. The results obtained in the research are universal and, in the future, can be used in white, black and gray box fuzzing methods.

A Survey and Content Analysis of the Quality of Behavior Guidance Policies in Tennessee Early Childhood Programs

Developmentally and culturally appropriate program behavior policies that are clearly communicated and implemented successfully can prevent exclusion and positively impact teachers, children, and families. However, it is unclear if policies are high quality or designed to equitably support positive behavior. We examined behavior policies from 41 child care programs in Tennessee. Using a rating tool, we found that policies were very low quality and lacked information on family engagement, staff training, and the use of data. Policies also exhibited several red flags, including using euphemisms for exclusion, using soft exclusion, and articulating three strikes or zero tolerance policies for certain child behaviors. Finally, leaders reported no formal staff training on the policy, though staff were expected to discuss policies with families. From these findings, it is clear that we need to provide more support and guidance to program leaders and other staff related to creating and implementing behavior policies.

Understanding and Detecting Annotation-Induced Faults of Static Analyzers

Static analyzers can reason about the properties and behaviors of programs and detect various issues without executing them. Hence, they should extract the necessary information to understand the analyzed program well. Annotation has been a widely used feature for different purposes in Java since the introduction of Java 5. Annotations can change program structures and convey semantics information without awareness of static analyzers, consequently leading to imprecise analysis results. This paper presents the first comprehensive study of annotation-induced faults (AIF) by analyzing 246 issues in six open-source and popular static analyzers (i.e., PMD, SpotBugs, CheckStyle, Infer, SonarQube, and Soot). We analyzed the issues' root causes, symptoms, and fix strategies and derived ten findings and some practical guidelines for detecting and repairing annotation-induced faults. Moreover, we developed an automated testing framework called AnnaTester based on three metamorphic relations originating from the findings. AnnaTester generated new tests based on the official test suites of static analyzers and unveiled 43 new faults, 20 of which have been fixed. The results confirm the value of our study and its findings.

Development model for assessing the structural complexity of programs

The research is devoted to the estimation the structural complexity of programs. The algorithm of finding cyclomatic routes for program executions is described. By now, two directions of obtaining estimates for the complexity estimates in software modules have been defined: structural and statistical. Both directions connect the value of program complexity with the labor intensity related to their development. The structural complexity of program modules is determined by the number of interacting components, the number and complexity of links between them. The complexity of a program's behavior depends to a large extent on the set of routes through which it is executed. The complexity metric obtained from these positions allows us to determine estimates of the cost of designing the program as a whole, as well as to identify the modules that are likely to contain the most errors, especially the logical ones.

Verification of declarative LTL-specification of control programs behavior

Verification of declarative LTL-specification of control programs behavior

Limits and Difficulties in the Design of Under-Approximation Abstract Domains

The main goal of most static analyses is to prove the absence of bugs : if the analysis reports no alarms then the program will not exhibit any unwanted behaviours. For this reason, they are designed to over-approximate program behaviours and, consequently, they can report some false alarms. O’Hearn’s recent work on incorrectness has renewed the interest in the use of under-approximations for bug finding , because they only report true alarms. In principle, Abstract Interpretation techniques can handle under-approximations as well as over-approximations, but, in practice, few attempts were developed for the former, notwithstanding the much wider literature on the latter. In this paper we investigate the possibility of exploiting under-approximation abstract domains for bug-finding analyses. First we restrict to consider concrete powerset domains and highlight some intuitive asymmetries between over- and under-approximations. Then, we prove that the effectiveness of abstract domains defined by Under-approximation Galois connection is limited, because the analysis is likely to return trivial results whenever common transfer functions are encoded in the program. To this aim, we introduce the original concepts of non-emptying functions and highly surjective function family and we prove the nonexistence of abstract domains able to under-approximate such functions in a non-trivial way. We show many examples of finite and infinite numerical domains, as well as other generic domains. In all such cases, we prove the impossibility of performing nontrivial analyses via under-approximating Galois connections.

Fine-grained Coverage-based Fuzzing

Fuzzing is a popular software testing method that discovers bugs by massively feeding target applications with automatically generated inputs. Many state-of-the-art fuzzers use branch coverage as a feedback metric to guide the fuzzing process. The fuzzer retains inputs for further mutation only if branch coverage is increased. However, branch coverage only provides a shallow sampling of program behaviors and hence may discard interesting inputs to mutate. This work aims to take advantage of the large body of research in defining finer-grained code coverage metrics (such as control-flow, data-flow, or mutation coverage) and to evaluate how fuzzing performance is impacted when using these metrics to select interesting inputs for mutation. We propose to make branch coverage-based fuzzers support most fine-grained coverage metrics out of the box (i.e., without changing fuzzer internals). We achieve this by making the test objectives defined by these metrics (such as conditions to activate or mutants to kill) explicit as new branches in the target program. Fuzzing such a modified target is then equivalent to fuzzing the original target, but the fuzzer will also retain inputs covering the additional metric objectives for mutation. In addition, all the fuzzer mechanisms to penetrate hard-to-cover branches will help in covering the additional metric objectives. We use this approach to evaluate the impact of supporting two fine-grained coverage metrics (multiple condition coverage and weak mutation) over the performance of two state-of-the-art fuzzers (AFL++ and QSYM) with the standard LAVA-M and MAGMA benchmarks. This evaluation suggests that our mechanism for runtime fuzzer guidance, where the fuzzed code is instrumented with additional branches, is effective and could be leveraged to encode guidance from human users or static analyzers. Our results also show that the impact of fine-grained metrics over fuzzing performance is hard to predict before fuzzing and most of the time either neutral or negative. As a consequence, we do not recommend using them to guide fuzzers, except maybe in some possibly favorable circumstances yet to be investigated, like for limited parts of the code or to complement classical fuzzing campaigns.

Camouflage: Utility-Aware Obfuscation for Accurate Simulation of Sensitive Program Traces

Trace-based simulation is a widely used methodology for system design exploration. It relies on realistic traces that represent a range of behaviors necessary to be evaluated, containing a lot of information about the application, its inputs and the underlying system on which it was generated. Consequently, generating traces from real-world executions risks leakage of sensitive information. To prevent this, traces can be obfuscated before release. However, this can undermine their ideal utility, i.e., how realistically a program behavior was captured. To address this, we propose Camouflage, a novel obfuscation framework, designed with awareness of the necessary architectural properties required to preserve trace utility , while ensuring secrecy of the inputs used to generate the trace. Focusing on memory access traces, our extensive evaluation on various benchmarks shows that camouflaged traces preserve the performance measurements of the original execution, with an average τ correlation of 0.66. We model input secrecy as an input indistinguishability problem and show that the average security loss is 7.8%, which is better than traces generated from the state-of-the-art.

TerGEC: A graph enhanced contrastive approach for program termination analysis

ContextPrograms with non-termination behavior induce various bugs, such as denial-of-service vulnerability and memory exhaustion. Hence the ability to detect non-termination programs before software deployment is crucial. Existing detection methods are either execution-based or deep learning-based. Despite great advances, their limitations are evident. The former requires complex sandbox environments for execution, while the latter lacks fine-grained analysis. ObjectiveTo overcome the above limitations, this paper proposes a graph-enhanced contrastive approach, namely TerGEC, which combines both inter-class and intra-class semantics to carry out a more fine-grained analysis and exempt execution during the detection process. MethodsIn detail, TerGEC analyzes behaviors of programs from Abstract Syntax Trees (ASTs), thereby capturing intra-class semantics both syntactically and lexically. Besides, it incorporates contrastive learning to learn the discrepancy between program behaviors of termination and non-termination, thereby acquiring inter-class semantics. In addition, graph augmentation is designed to improve the robustness. Weighted contrastive loss and focal loss are also equipped in TerGEC to alleviate the classes-imbalance problem during the non-termination detection. Consequently, the whole detection process can be handled more fine-grained, and the execution can also be exempted due to the nature of deep learning. ResultsWe evaluate TerGEC on five datasets of both Python and C languages. Extensive experiments demonstrate TerGEC achieves the best performance overall. Among all experimented datasets, TerGEC outperforms state-of-the-art baselines by 8.20% in terms of mAP and by 17.07% in terms of AUC on average. ConclusionTerGEC is capable of detecting non-terminating programs with high precision, showing that the combination of inter-class and intra-class learning, along with our proposed classes-imbalance solutions, is significantly effective in practice.