Science of Computer Programming最新文献

Background and Context

In today's tech-driven world, programming courses are crucial. Yet, teaching programming is challenging, leading to high student failure rates. Understanding student learning patterns is key, but there's a lack of research utilizing tools to automatically collect and analyze interaction data for insights into student performance and behaviors.

Objectives

Study aims to compare problem-solving behaviors of novice and competent programmers during coding tests, identifying patterns and exploring relationships with program correctness.

Method

We built an online system with programming challenges to collect behavior data from novice and competent programmers. Our system analyzed data using various metrics to explore behavior-program correctness relationships.

Findings

Analysis showed distinct problem-solving behavior patterns. Competent programmers had fewer syntax errors, spent less time fixing bugs, and had higher program correctness. Novices made more syntax errors and spent more time fixing coding errors. Both groups used tabs for code structure, but competent programmers introduced unfamiliar variables more often and commented on them afterward. Emphasizing iterative revisions and active engagement enhances problem-solving skills and programming proficiency. Radar charts are effective for identifying improvement areas in teaching programming. The relationship between behavior and program correctness was positively correlated for competent programmers but not novices.

Implications

Study findings have implications for programming education. Radar charts help teachers identify course improvement areas. Novices can learn from competent programmers' behavior. Instructors should encourage continuous skill improvement through revisions and engagement. Identified unfamiliar programming aspects offer insights for targeted learning.

The field of model-based testing has witnessed the development of several test strategies on finite state machines. Although these strategies are often related, little effort has been made to explicitly identify patterns shared between them, and their concrete implementations as well as completeness proofs regularly exhibit redundancy. In this paper, we propose an approach for the systematic verification and implementation of strategies for the language-equivalence conformance relation. We present frameworks in the form of higher order functions that implement shared behaviour once and encapsulate diverging behaviour in procedural parameters, thus reducing duplication and improving maintainability and extensibility. We show that this simplifies completeness proofs by proving complete all considered strategies using the same argument. All presented frameworks, proofs, and concrete strategy implementations have been mechanised using the proof assistant Isabelle.

The Web of Things (WoT) is a new paradigm in which everyday objects are connected to the Internet using popular Web technologies. The smart things are abstracted into RESTful Web services to facilitate their manipulation. The composition of these objects within the same business process creates an automated, time-synchronized routine that can perform even the most complex tasks. BPEL is an orchestration language that defines the process responsible for coordinating the Web services involved. However, this language presents some limitations in this context. BPEL 2.0 does not support RESTful Web services; its specification is incompatible with this architectural style of services. Moreover, its temporal expressivity is insufficient to cover all the constraints that may arise when composing services. This work aims to adapt BPEL to the requirements of the WoT environment, enabling it to create processes that invoke the smart things in precise time intervals. The solution is to exploit one of BPEL's strengths: its extensibility. The BPEL specification is enriched with four activities that reflect the REST uniform interface. They include the necessary attributes to send the request to the target object and receive the response in convened format representation. Also, temporal attributes are added to BPEL elements to schedule their start, end, and duration of execution. The manual addition of these temporal values requires a verification of their accuracy. The BPEL process must be reviewed to ensure its validity before its execution. A temporal Petri Net is proposed to detect any conflicts or inconsistencies between BPEL activities. As a result, associating the formal model with the extension allows BPEL to orchestrate smart things represented by RESTful Web services according to a well-defined temporal scenario. They respect the REST constraints and provide the BPEL activities with temporal attributes for efficient time management. The approach can be applied in all application areas to create temporal scenarios.

We present the Software Tool for the Analysis of Robustness in the unKnown environment (Stark), our Java tool for the specification, analysis and verification of robustness properties of Cyber-Physical Systems (CPSs). Stark includes: (i) a specification language for systems behaviour, perturbations, distances on systems behaviours, and requirements on systems behaviour expressed in the Robustness Temporal Logic (RobTL), a temporal logic for the specification and verification of properties on the evolution of distances between the behaviours of CPSs, and thus also of robustness properties; (ii) a module for the simulation of system behaviours and their perturbed versions; (iii) a module for the evaluation of distances between behaviours; (iv) a statistical model checker for RobTL formulae.

Neural networks (NNs) are increasingly applied in safety-critical systems such as autonomous vehicles. However, they are fragile and are often ill-behaved. Consequently, their behaviors should undergo rigorous guarantees before deployment in practice. In this paper, we propose a set-boundary reachability method to investigate the safety verification problem of NNs from topological perspectives. Given an NN with an input set and a safe set, the safety verification problem is to determine whether all outputs of the NN resulting from the input set fall within the safe set. In our method, the homeomorphism property of NNs is first exploited, which establishes rigorous guarantees between the boundaries of the input set and the boundaries of the output set. A homeomorphism is a special case of open maps, and consequently our set-boundary method is considered to be generalized to situations with open map property then². The exploitation of these two properties facilitates reachability computations via extracting subsets of the input set rather than the entire input set, thus controlling the wrapping effect in reachability analysis and facilitating the reduction of computation burdens for safety verification. The homeomorphism property exists in some widely used NNs such as invertible residual networks (i-ResNets) and Neural ordinary differential equations (Neural ODEs), and the open map is a less strict topological property and is easier to satisfy compared with homeomorphisms. For NNs establishing either of these two properties, our set-boundary reachability method only needs to perform reachability analysis on the boundary of the input set. Moreover, for NNs that do not feature these properties with respect to the input set, we also explore subsets of the input set for establishing the local homeomorphism property and then abandon these subsets for reachability computations. Finally, some examples demonstrate the performance of our proposed method.

Quantum computers promise exponential speed ups over classical computers for various tasks. This emerging technology is expected to have its first huge impact in High Performance Computing (HPC), as it can solve problems beyond the reach of HPC. To that end, HPC will require quantum accelerators, which will enable applications to run on both classical and quantum devices, via hybrid quantum-classical nodes. Hybrid quantum-HPC applications should be scalable, executable on Quantum Error Corrected (QEC) devices, and could use quantum-classical primitives. However, the lack of scalability, poor performances, and inability to insert classical schemes within quantum applications has prevented current quantum frameworks from being adopted by the HPC community.

This paper specifies the requirements of a hybrid quantum-classical framework compatible with HPC environments, and introduces a novel hardware-agnostic framework called Q-Pragma. This framework extends the classical programming language C++ heavily used in HPC via the addition of pragma directives to manage quantum computations.

A growing range of applications use AI and other autonomous agents to perform tasks that raise social, legal, ethical, empathetic, and cultural (SLEEC) concerns. To support a framework for the consideration of these concerns, we introduce SLEEC-TK, a toolkit for specification, validation, and verification of SLEEC requirements. SLEEC-TK is an Eclipse-based environment for defining SLEEC rules in a domain-specific language with a timed process algebraic semantics. SLEEC-TK uses model checking to identify redundant and conflicting rules, and to verify conformance of design models with SLEEC rules. We illustrate the use of SLEEC-TK for an assistive-care robot.

Code smells tend to have an impact on software quality attributes such as reusability, maintainability, and understandability. These are code flaws that do not necessarily prevent the system from operating; rather, they increase the possibility of defects occurring in the future. Hence, to maintain code quality, code smells should be detected and corrected through refactoring. The objective of this paper is to investigate the associated risk of applying refactoring techniques and reveal the bad smells that may appear when fixing other bad smells. We conducted several controlled experiments to identify the smells that emerge after refactoring. The experiments resulted in a novel taxonomy revealing 9 bad smells that may appear as a result of fixing other bad smells. This represents the first study attempting to systematically identify and organize such refactoring-smell relationships into a taxonomy. The research results can assist developers in relating different bad smells to each other and helping them determine the refactoring technique that should be applied when certain smells are present. Moreover, the results can be beneficial in breaking the cycle of bad smells. Such knowledge tends to enhance code refactoring, which in turn will improve software quality and avoid technical debt.