Automatic Grading of Programming Exercises using Property-Based Testing

Many methods in data structures contain a loop structure on a collection type. These loops result in a large number of test cases and are one of the main obstacles to systematically test these methods. To deal with the loops in methods, in this paper, we propose a novel loop-extended model checking approach, abbreviated as LEMC, to efficiently test whether methods satisfy their own invariant. Our main idea is to combine dynamic symbolic execution with static analysis techniques. Specifically, a concrete execution of the method under test is initially done to collect dynamic execution information, which is used to statically identify the loop-extended similar paths of the concrete execution path. LEMC statically checks and prunes all the states which follow these loop-extended similar paths. The experiments on several case studies show that LEMC can dramatically reduce as many as 90% of the search space and achieve much better performance, compared with the existing approaches such as the Glass Box model checker and Korat.

Major Depressive Disorder is a leading cause of disability worldwide. An accurate assessment of depression severity is critical for diagnosis, treatment planning, and monitoring, yet current clinical tools are largely subjective, relying on self-report and clinician judgment via traditional assessment scales. EEG has emerged as a promising, non-invasive modality for capturing neural correlates of depression. However, most EEG-based machine learning diagnostic studies focus on boosting classification accuracy through complex algorithms and small, homogenous datasets. These black-box approaches often yield results that are difficult to interpret and poorly generalizable, making clinical translation impractical. Therefore there remains a critical need for models that are not only accurate but also transparent, robust, and grounded in the physiological properties of the data itself. We proposed a data-centric, interpretable framework for EEG-based depression severity grading. A hybrid feature selection method was used, combining p-value and SHapley Additive exPlanations (SHAP) methods to select features that are both independently significant and jointly informative. The system was trained and evaluated on a large-scale, multi-site resting-state EEG dataset, using random forest for both classification and regression tasks. The SHAP method, an explainable artificial intelligence technique, is also used post-hoc to infer the key electrophysiological features and key brain regions associated with MDD mechanism to further increase interpretability. The proposed system achieved 74.5% (95% CI [70.97%, 78.80%], p < 0.001) ten-fold classification accuracy and a correlation coefficient of 0.56 (95% CI [0.407, 0.683], p < 0.001) for severity estimation. SHAP analysis identified consistent, clinically meaningful EEG features, particularly in the left parietal-occipital lobe. Through in-depth SHAP value analysis, we identified critical disease-related brain areas in the left occipital and parietal lobes, along with key features including relative beta power in the left parietal lobe, time-domain features at the parietal midline, 1/f intercept, left occipital relative beta power, and global brain alpha energy. This study proposes a data-centric, interpretable depression grading system built on large-scale, multi-center EEG data, using simple models and hybrid feature selection to emphasize explainability, generalizability and data fidelity. By shifting the focus from algorithmic complexity to data transparency and feature-level insight, the model offers a practical and trustworthy path toward real-world mental health assessment.

This paper introduces the prediction model of workforce competency & defect density for Vehicle navigation system, and shows the methods to improve the software project quality. The study shows that the average programming competency level of the developers and cyclomatic complexity are related to the coding stage defect density. Further, a prediction model of competency, cyclomatic complexity and coding stage defect density is drawn on the basis of statistics; meanwhile, according to the research result some methods to improve the navigation software project quality are concluded.

Most functional language runtime systems context switch between executing user code and a non-concurrent garbage collector (GC), exposing GC latency to overall wall-clock time. Recent concurrent software-based GCs reduce these latencies, but wall-clock times are instead increased due to their synchronisation and write barrier overheads, by as much as 21%. This GC overhead is exacerbated further for pure non-strict languages like Haskell, due to the abundance of allocations for storing immutable data structures and closures. This paper presents Cloaca, an FPGA-based hardware implementation of a concurrent, hybrid GC for a pure non-strict functional language. It combines mark-and-sweep tracing and one-bit reference counting. It traces live heap data using hardware-level synchronisation and write barriers, without damaging graph reduction performance. To ensure the correctness of Cloaca, three invariants of its Haskell-based implementation are verified with property-based testing. Despite GHC running on an Intel i7 CPU operating at a x25 higher clock frequency than Cloaca; Cloaca takes, on average, 4.1% of GHC's GC wall-clock time across 14 of 15 benchmarks.

BackgroundThe growth in multi-center neuroimaging studies generated a need for methods that mitigate the differences in hardware and acquisition protocols across sites i.e., scanner effects. ComBat harmonization methods have shown promise but have not yet been tested on all the data types commonly studied with magnetic resonance imaging (MRI). This study aimed to validate neuroCombat, longCombat and gamCombat on both structural and diffusion metrics in both cross-sectional and longitudinal data. MethodsWe used a travelling subject design whereby 73 healthy volunteers contributed 161 scans across two sites and four machines using one T1 and five diffusion MRI protocols. Scanner was defined as a composite of site, machine and protocol. A common pipeline extracted two structural metrics (volumes and cortical thickness) and two diffusion tensor imaging metrics (mean diffusivity and fractional anisotropy) for seven regions of interest including gray and (except for cortical thickness) white matter regions. ResultsStructural data exhibited no significant scanner effect and therefore did not benefit from harmonization in our particular cohort. Indeed, attempting harmonization obscured the true biological effect for some regions of interest. Diffusion data contained marked scanner effects and was successfully harmonized by all methods, resulting in smaller scanner effects and better detection of true biological effects. LongCombat less effectively reduced the scanner effect for cross-sectional white matter data but had a slightly lower probability of incorrectly finding group differences in simulations, compared to neuroCombat and gamCombat. False positive rates for all methods and all metrics did not significantly exceed 5%. ConclusionsStatistical harmonization of structural data is not always necessary and harmonization in the absence of a scanner effect may be harmful. Harmonization of diffusion MRI data is highly recommended with neuroCombat, longCombat and gamCombat performing well in cross-sectional and longitudinal settings.

It is a well known fact that software effort estimation is exceptionally critical in every software industry, particular during the development of projects. It is hard to estimate the parameters involved due to ambiguity and uncertainty associated with the parameters. It is exactly here the hard limiting techniques, soft computing techniques comes to play. In this unique circumstance, this paper, presents an attempt to that compare the two paradigms for effort estimation. For this, we have considered fifty real time small visualization projects thrive by post graduate students. The prototype development involves following stages: i) Elicitation of seven novel parameters namely Lines of Code, Cumulative Grade Point Average, New and changed code, Reused code, Cyclomatic Complexity, Algorithmic Complexity and Functional Points. ii) Developing of hard limiting methods and soft computing methods for prediction of software effort involved in terms of duration in minutes.For the validation of the models error metrics namely: Mean Absolute Error (MAE), Mean Magnitude of Relative Error (MMRE), Mean of Magnitude of error Relative to the Estimate (MMER) and Root Mean Square Error (RMSE) have been used. The result showed that the models compared very well with marginal difference in terms of predict values of error matrix.

Program performance optimization is usually based solely on measurements of execution behavior of code segments using hardware performance counters. However, memory access patterns are critical performance limiting factors for today's multicore chips where performance is highly memory bound. Therefore diagnoses and selection of optimizations based only on measurements of the execution behavior of code segments are incomplete because they do not incorporate knowledge of memory access patterns and behaviors. This article presents a low-overhead tool (MACPO) that captures memory traces and computes metrics for the memory access behavior of source-level (C, C++, Fortran) data structures. MACPO explicitly targets the measurement and metrics important to performance optimization for multicore chips. The article also presents a complete process for integrating measurement and analyses of code execution with measurements and analyses of memory access patterns and behaviors for performance optimization, specifically targeting multicore chips and multichip nodes of clusters. MACPO uses more realistic cache models for computation of latency metrics than those used by previous tools. Evaluation of the effectiveness of adding memory access behavior characteristics of data structures to performance optimization was done on subsets of the ASCI, NAS and Rodinia parallel benchmarks and two versions of one application program from a domain not represented in these benchmarks. Adding characteristics of the behavior of data structures enabled easier diagnoses of bottlenecks and more accurate selection of appropriate optimizations than with only code centric behavior measurements. The performance gains ranged from a few percent to 38 percent.

Recently studies [1, 2] have shown that about 75 to 89 percent of students in courses on data structures prefer to learn short, complex algorithms using a graphic method (structured flowcharts), while the remaining students prefer a verbal method (pseudocode). These studies have been comprehensive and properly controlled. Sixteen replications have been done at three universities and one college. A total of 571 students from 42 data-structures classes have participated. These studies only investigated the percentages of students preferring structured flowcharts over pseudocode. Knowing just these percentages is not enough. We need to know how strongly the students feel about their preferences. Thus, the primary reason for this new research is to measure the strength of that preference.

The considerable "algorithmic complexity" of biological systems requires a huge amount of detailed information for their complete description. Current high-throughput technology such as microarrays is generating an overwhelming amount of data of biological systems at the molecular and cellular level. To adequately organize, maintain, analyze and interpret this deluge of information the adaptation of existing and the development of new computational methodologies and tools is required. The principal approach to analyzing and interpreting biological data is to abstract them into logical structures that support and incrementally promote the development of a more general conceptual framework for characterizing, explaining, and predicting processes in living systems. Cluster analysis refers to a computing methodology that discovers and describes meaningful patterns or structures in data. Generally, cluster algorithms are governed by a learning-by-observation process. A plethora of specific algorithms has been suggested in the literature. In the context of microarray gene expression profiling of tumors, this work describes a comparative study of five clustering methods.

With the widespread use of mobile devices relying on limited battery power, the burden of optimizing applications for energy has shifted towards the application developers. In their quest to develop energy efficient applications, developers face the hurdle of measuring the effect of software change on energy consumption. A naive solution to this problem would be to have an exhaustive suite of test cases that are executed upon every change to measure their effect on energy consumption. This method is inefficient and also suffers from environment dependent inconsistencies. A more generalized method would be to relate software structural metrics with its energy consumption behavior. Previous attempts to relate change in objectoriented metrics to their effects on energy consumption have been inconclusive. We observe that structural information is global and executed tests are rarely comprehensive in their coverage, this approach is prone to errors. In this paper, we present a methodology to relate software energy consumption with software structural metrics considering the test case execution traces. Furthermore, we demonstrate that software structural metrics can be reliably related to energy consumption behavior of programs using several versions of three open-source iteratively developed android applications. We discover that by using our approach we are able to identify strong correlations between several software metrics and energy consumption behavior.

Critical chains composed of critical flows and functions have been demonstrated as an effective qualitative analogy retrieval approach based on performance metrics. In prior work, engineers used expert knowledge to transform functional models into critical chain models, which are abstractions of the functional model. Automating this transformation process is highly desirable so as to provide for a robust transformation method. Within this paper, two paradigms for functional modeling abstraction are compared. A series of pruning rules provide an automated transformation approach, and this is compared to the results generated previously through an expert knowledge approach. These two approaches are evaluated against a set of published functional models. The similarity of the resulting transformation of the functional models into critical chain models is evaluated using a functional chain similarity metric, developed in previous work. Once critical chain models are identified, additional model evaluation criteria are used to evaluate the utility of the critical chain models for design analogy identification. Since the functional vocabulary acts as a common language among designers and engineers to abstract and represent critical design artifact information, analogous matching can be made about the functional vocabulary. Thus, the transformation of functional models into critical chain models enables engineers to use functional abstraction as a mechanism to identify design analogies. The critical flow rule is the most effective first step when automatically transforming a functional model to a critical chain model. Further research into more complex critical chain model architectures and the interactions between criteria is merited.

We present an algorithm for computing the closest point, transform to an explicitly described manifold on a rectilinear grid in low dimensional spaces. The closest point transform finds the closest point on a manifold and the Euclidean distance to a manifold for the points in a grid. We consider manifolds composed of simple geometric shapes, such as, a set of points, piecewise linear curves or triangle meshes. The algorithm solves the eikonal equation |∇u| = 1 with the method of characteristics. For many problems, the computational complexity of the algorithm is linear in both the number of grid points and the complexity of the manifold. Many query problems can be aided by using orthogonal range queries (ORQ). There are several standard data structures for performing ORQ's in 3-D, including kd-trees, octrees, and cell arrays. We develop additional data structures based on cell arrays. We study the characteristics of each data structure and compare their performance. We present a new algorithm for solving the single-source, non-negative weight, shortest-paths problem. Dijkstra's algorithm solves this problem with computational complexity O ((E + V)log V) where E is the number of edges and V is the number of vertices. The new algorithm, called Marching with a Correctness Criterion (MCC), has computational complexity O (E + RV), where R is the ratio of the largest to smallest edge weight. Sethian's Fast Marching Method (FMM) may be used to solve static Hamilton-Jacobi equations. It has computational complexity O (N log N), where N is the number of grid points. The FMM has been regarded as an optimal algorithm because it is closely related to Dijkstra's algorithm. The new shortest-paths algorithm discussed above can be used to develop an ordered, upwind, finite difference algorithm for solving static Hamilton-Jacobi equations. This algorithm requires difference schemes that difference not only in coordinate directions, but in diagonal directions as well. It has computational complexity O(RN), where R is the ratio of the largest to smallest propagation speed and N is the number of grid points.

the University of Amsterdam, May 20-31, 1974.This Tract collects the lecture notes of five of the courses given.The sixth course, given by Dr. R. Kowalski on Predicate Logic as a Programming Language in Artificial Intelligence, is scheduled to appear elsewhere.We are very grateful to the Netherlands Organization for the Advancement of Pure Research (Z.W.O.)

Automatically generated unit tests-from searchbased tools like EvoSuite or LLMs-vary significantly in structure and readability. Yet most evaluations rely on metrics like Cyclomatic Complexity and Cognitive Complexity, designed for functional code rather than test code. Recent studies have shown that SonarSource's Cognitive Complexity metric assigns nearzero scores to LLM-generated tests, yet its behavior on EvoSuitegenerated tests and its applicability to test-specific code structures remain unexplored. We introduce CCTR, a Test-Aware Cognitive Complexity metric tailored for unit tests. CCTR integrates structural and semantic features like assertion density, annotation roles, and test composition patterns-dimensions ignored by traditional complexity models but critical for understanding test code. We evaluate <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$\mathbf{1 5, 7 5 0}$</tex> test suites generated by EvoSuite, GPT4o, and Mistral Large-1024 across 350 classes from Defects4J and SF110. Results show CCTR effectively discriminates between structured and fragmented test suites, producing interpretable scores that better reflect developer-perceived effort. By bridging structural analysis and test readability, CCTR provides a foundation for more reliable evaluation and improvement of generated tests. We publicly release all data, prompts, and evaluation scripts to support replication.

Energy is a fundamental resource limitation in mobile and wireless devices. Much research in mobile and wireless networking over the past decade has examined ways of reducing energy usage, including specific techniques such as energy-aware protocols for routing and communication. However, to our knowledge, no systematic way has been developed for reasoning generally about the energy consumption of algorithms. A method for analyzing energy complexity at an abstract algorithmic level would be invaluable. However, it is not clear if we can develop a uniform abstract model of energy complexity that has both theoretical and practical value. This paper surveys techniques for modeling and minimizing energy consumption at various system levels, so as to place algorithmic energy complexity in perspective. We then discuss the attributes an energy complexity model should have, and describe our initial approach towards developing such a model. We end by discussing future technical directions.