Programming Paradigm Research Articles

To Abstract or Not to Abstract? A Comparative Study Evaluating the User Experience of Spreadsheet Programming with Sheet-Defined Functional Abstractions

Spreadsheets are a widespread functional programming paradigm that offer liveness and directness of interaction. However, spreadsheets are notoriously error-prone and difficult to debug. To overcome this limitation and improve the expressive power of spreadsheets, we propose an extension to the spreadsheet paradigm in the form of sheet-defined lambdas – user-defined functions that abstract computations on the sheet. This concept was developed and deployed in our web-based spreadsheet application named Lattice. We evaluate this approach through a user study which compared the user experience of programming in a spreadsheet with and without lambdas, as well as the difference in performance between learner (N = 12) and experienced (N = 12) programmers. The study measured participant task performance (task time, success rate and number of errors) and the quality of their user experience of using Lattice (video recordings of use, interviews and questionnaire responses). Our findings indicate that programming with lambdas is not only more efficient than writing formulas in a conventional way, but also provides a rewarding hedonic experience. However, we found that learners perceived the concept of functional abstractions with lambdas as difficult to comprehend; while experienced programmers noted potential utilitarian advantages that aid in managing the complexity of a spreadsheet program. The results obtained in this work contribute to a better understanding of human-spreadsheet interaction and can inform the future design of user-friendly computational systems.

Abstraction and Refinement: Towards Scalable and Exact Verification of Neural Networks

As a new programming paradigm, deep neural networks (DNNs) have been increasingly deployed in practice, but the lack of robustness hinders their applications in safety-critical domains. While there are techniques for verifying DNNs with formal guarantees, they are limited in scalability and accuracy. In this article, we present a novel counterexample-guided abstraction refinement (CEGAR) approach for scalable and exact verification of DNNs. Specifically, we propose a novel abstraction to break down the size of DNNs by over-approximation. The result of verifying the abstract DNN is conclusive if no spurious counterexample is reported. To eliminate each spurious counterexample introduced by abstraction, we propose a novel counterexample-guided refinement that refines the abstract DNN to exclude the spurious counterexample while still over-approximating the original one, leading to a sound, complete yet efficient CEGAR approach. Our approach is orthogonal to and can be integrated with many existing verification techniques. For demonstration, we implement our approach using two promising tools, Marabou and Planet , as the underlying verification engines, and evaluate on widely used benchmarks for three datasets ACAS , Xu , MNIST , and CIFAR-10 . The results show that our approach can boost their performance by solving more problems in the same time limit, reducing on average 13.4%–86.3% verification time of Marabou on almost all the verification tasks, and reducing on average 8.3%–78.0% verification time of Planet on all the verification tasks. Compared to the most relevant CEGAR-based approach, our approach is 11.6–26.6 times faster.

Exploratory data science on supercomputers for quantum mechanical calculations

Literate programming—the bringing together of program code and natural language narratives—has become a ubiquitous approach in the realm of data science. This methodology is appealing as well for the domain of Density Functional Theory (DFT) calculations, particularly for interactively developing new methodologies and workflows. However, effective use of literate programming is hampered by old programming paradigms and the difficulties associated with using high performance computing (HPC) resources. Here we present two Python libraries that aim to remove these hurdles. First, we describe the PyBigDFT library, which can be used to setup materials or molecular systems and provides high-level access to the wavelet based BigDFT code. We then present the related remotemanager library, which is able to serialize and execute arbitrary Python functions on remote supercomputers. We show how together these libraries enable transparent access to HPC based DFT calculations and can serve as building blocks for rapid prototyping and data exploration.

LLM4VV: Developing LLM-driven testsuite for compiler validation

Large language models (LLMs) are a new and powerful tool for a wide span of applications involving natural language and demonstrate impressive code generation abilities. The goal of this work is to automatically generate tests and use these tests to validate and verify compiler implementations of a directive-based parallel programming paradigm, OpenACC. To do so, in this paper, we explore the capabilities of state-of-the-art LLMs, including open-source LLMs - Meta’s Codellama, Phind’s fine-tuned version of Codellama, Deepseek’s Deepseek Coder and closed-source LLMs - OpenAI’s GPT-3.5-Turbo and GPT-4-Turbo. We further fine-tune the open-source LLMs and GPT-3.5-Turbo using our own testsuite dataset along with using the OpenACC specification. We also explored these LLMs using various prompt engineering techniques that include code template, template with retrieval-augmented generation (RAG), one-shot example, one-shot with RAG, expressive prompt with code template and RAG. This paper highlights our findings from over 5000 tests generated via all the above mentioned methods. Our contributions include: (a) exploring the capabilities of the latest and relevant LLMs for code generation, (b) investigating fine-tuning and prompt methods, and (c) analyzing the outcome of LLMs generated tests including manually analysis of representative set of tests. We found the LLM Deepseek-Coder-33b-Instruct produced the most passing tests followed by GPT-4-Turbo.

A differentiable programming framework for spin models

We introduce a novel framework for simulating spin models using differentiable programming, an approach that leverages the advancements in machine learning and computational efficiency. We focus on three distinct spin systems: the Ising model, the Potts model, and the Cellular Potts model, demonstrating the practicality and scalability of our framework in modeling these complex systems. Additionally, this framework allows for the optimization of spin models, which can adjust the parameters of a system by a defined objective function. In order to simulate these models, we adapt the Metropolis-Hastings algorithm to a differentiable programming paradigm, employing batched tensors for simulating spin lattices. This adaptation not only facilitates the integration with existing deep learning tools but also significantly enhances computational speed through parallel processing capabilities, as it can be implemented on different hardware architectures, including GPUs and TPUs.

Scalable Diversified Top-k Pattern Matching in Big Graphs

Typically, graph pattern matching is expressed in terms of subgraph isomorphism. Graph simulation and its variants were introduced to reduce the time complexity and obtain more meaningful results in big graphs. Among these models, the matching subgraphs obtained by tight simulation are more compact and topologically closer to the pattern graph than results produced by other approaches. However, the number of resulting subgraphs can be huge, overlapping each other and unequally relaxed from the pattern graph. Hence, we introduce a ranking and diversification method for tight simulation results, which allows the user to obtain the most diversified and relevant matching subgraphs. This approach exploits the weights on edges of the big graph to express the interest of the matching subgraph by tight simulation. Furthermore, we provide distributed scalable algorithms to evaluate the proposed methods based on distributed programming paradigms. The experiments on real data graphs succeed in demonstrating the effectiveness of the proposed models and the efficiency of the associated algorithms. The result diversification reached 123% within a time frame that does not exceed 40%, on average, of the duration required for tight simulation graph pattern matching.

Pelatihan dan Pendampingan Pemrograman Python Dalam Meningkatkan Kompetensi Siswa SMKN 5 Palu

Python programming is a multipurpose interpretive programming language with a design philosophy that focuses on code readability. Python is a language that combines capabilities with very clear code syntax and is equipped with the functionality of a large and comprehensive standard library. Python supports multiple programming paradigms. One of the features available in Python is that it is a dynamic programming language equipped with automatic memory management. This Community Service Activity is carried out by providing training material starting from a basic introduction to the Python programming language, basic rules for writing Python syntax, an introduction to variables and data types in Python, operators in Python, and learning structures and functions in Python. The mentoring process is also carried out to provide direct experience to students. This activity went well and received appreciation from the school, and the students hope that this activity can be continued so that students are able to apply Python programming well.

Design and Implementation of an Aspect-Oriented C Programming Language

Aspect-Oriented Programming (AOP) is a programming paradigm that implements crosscutting concerns in a modular way. People have witnessed the prosperity of AOP languages for Java and C++, such as AspectJ and AspectC++, which has propelled AOP to become an important programming paradigm with many interesting application scenarios, e.g., runtime verification. In contrast, the AOP languages for C are still poor and lack compiler support. In this paper, we design a new general-purpose and expressive aspect-oriented C programming language, namely Aclang, and implement a compiler for it, which brings fully-fledged AOP support into the C domain. We have evaluated the effectiveness and performance of our compiler against two state-of-the-art tools, ACC and AspectC++. In terms of effectiveness, Aclang outperforms ACC and AspectC++. In terms of performance, Aclang outperforms ACC in execution time and outperforms AspectC++ in both execution time and memory consumption.

Universal Synaptic Plasticity of Interface‐Based Second‐Order Memristors

AbstractSecond‐order memristors with their internal short‐term dynamics display behavioral similarities with biological neurons and constitute an ideal basis unit for hardware neuromorphic networks, aims at treating spatio‐temporal tasks. Here, La0.7Sr0.3MnO3/BaTiO3/La0.7Sr0.3MnO3 second‐order memristive devices are investigated whose resistances and temperature dependencies range, on the same chip, from semiconductor to metal, but exhibit a universal neuromorphic plasticity. All devices may be described using a compact phenomenological model of current conduction, showing that resistive switching originates from interfaces, through charge trapping. Remarkably, the processes of short‐term memory gain/loss and long‐term consolidation/forgetting are the same whatever the device type. Only the synaptic transmission weights and the excitation/relaxation times with respect to stimuli differ, as it occurs for synapses/neurons in the brain. The weights may be tuned by the sole use of the frequency of stimuli (the activity rate), their evolution being dependent on previous activities (the history). Metal and semiconductor devices display the same in‐operando dynamics of potentiation or of depression, the transition from one regime to another being history‐dependent. The threshold frequencies are slightly lower in semiconducting devices. This work contributes to better understanding of memristive switching and plasticity and is relevant for the development of brain‐mimetic neural networks with new programming paradigms.

ExaFlexHH: an exascale-ready, flexible multi-FPGA library for biologically plausible brain simulations.

In-silico simulations are a powerful tool in modern neuroscience for enhancing our understanding of complex brain systems at various physiological levels. To model biologically realistic and detailed systems, an ideal simulation platform must possess: (1) high performance and performance scalability, (2) flexibility, and (3) ease of use for non-technical users. However, most existing platforms and libraries do not meet all three criteria, particularly for complex models such as the Hodgkin-Huxley (HH) model or for complex neuron-connectivity modeling such as gap junctions. This work introduces ExaFlexHH, an exascale-ready, flexible library for simulating HH models on multi-FPGA platforms. Utilizing FPGA-based Data-Flow Engines (DFEs) and the dataflow programming paradigm, ExaFlexHH addresses all three requirements. The library is also parameterizable and compliant with NeuroML, a prominent brain-description language in computational neuroscience. We demonstrate the performance scalability of the platform by implementing a highly demanding extended-Hodgkin-Huxley (eHH) model of the Inferior Olive using ExaFlexHH. Model simulation results show linear scalability for unconnected networks and near-linear scalability for networks with complex synaptic plasticity, with a 1.99 × performance increase using two FPGAs compared to a single FPGA simulation, and 7.96 × when using eight FPGAs in a scalable ring topology. Notably, our results also reveal consistent performance efficiency in GFLOPS per watt, further facilitating exascale-ready computing speeds and pushing the boundaries of future brain-simulation platforms. The ExaFlexHH library shows superior resource efficiency, quantified in FLOPS per hardware resources, benchmarked against other competitive FPGA-based brain simulation implementations.

Domain‐specific translation tool from structured text to C source code with code readability enhancement in programmable logic controllers

AbstractThe Industrial Internet has emerged as a key technology in the field of industrial automation, revolutionizing traditional manufacturing processes and enabling advanced control systems by integrating machines, sensors, and software systems through network connectivity, allowing for real‐time data exchange, analysis, and decision‐making in industrial environments. Programmable Logic Controllers (PLCs) play a critical role in industrial automation systems, which are specialized digital computers designed to control various manufacturing processes and machinery. As a promising language, Structured Text (ST) is of paramount importance for industrial Internet, and it is essential to translate ST into C, which is widely used in various industries for implementing control systems. However, due to differences in syntax, data types, and programming paradigms between the two languages, the translation process is facing several challenges. In this paper, we present a domain‐specific translation tool that automates the process of converting ST code to C code. This tool incorporates advanced AI techniques, particularly leveraging the capabilities of NL‐PL LLMs, to facilitate accurate and efficient translation while generating comprehensive documentation to assist developers. Finally, the evaluation and case studies conducted validate the effectiveness of the tool, demonstrating its practical applicability and benefits in real‐world industrial settings.

Incorporation of poverty principles into goal programming

This paper presents a methodology for the incorporation of poverty related concepts into the goal programming paradigm. The concepts of poverty line, absolute poverty and relative poverty are discussed in the context of their potential usage in the field of Operations Research. The synergy between goal programming and poverty lines is examined. Two additional meta-goals are proposed for inclusion in a meta-goal programming framework based around absolute and relative poverty respectively. The resulting poverty incorporating meta-goal programming model is compared against other goal programming variants over a test set of school budget allocation models. The results demonstrate how the incorporation of poverty principles allows for greater modelling flexibility in the goal programming framework. This in turn allows decision makers to avoid solutions that are below threshold levels for a subset of stakeholders in either a relative or absolute sense. Appropriate conclusions and suggestions for future research are given.

Behavioral equivalences for AbU: Verifying security and safety in distributed IoT systems

Attribute-based memory Updates (▪in short) is an interaction mechanism recently introduced for adapting the Event-Condition-Action (ECA) programming paradigm to distributed reactive systems, such as autonomic and smart IoT device ensembles. In this model, an event (e.g., an input from a sensor, or a device state update) can trigger an ECA rule, whose execution can cause the state update of (possibly) many remote devices at once; the latter are selected “on the fly” by means of predicates over their state, without the need of a central coordinating entity.However, the combination of different ▪systems may yield unexpected interactions, e.g., when a new device is added to an existing secure system, potentially hindering the security of the whole ensemble of devices. This can be critical in the IoT, where smart devices are more and more pervasive in our daily life.In this paper, we consider the problem of ensuring security and safety requirements for ▪systems (and, in turn, for IoT devices). The first are a form of noninterference, as they correspond to avoid forbidden information flows (e.g., information flows violating confidentiality); while the second are a form of non-interaction, as they correspond to avoid unintended executions (e.g., leading to erroneous/unsafe states).In order to formally model these requirements, we introduce suitable behavioral equivalences for ▪. These equivalences are generalizations of hiding bisimilarity, i.e., a kind of weak bisimilarity where we can compare systems up to actions at different levels of security. Leveraging these behavioral equivalences, we propose (syntactic) sufficient conditions guaranteeing the requirements and, then, effective algorithms for statically verifying such conditions.

Attack as Detection: Using Adversarial Attack Methods to Detect Abnormal Examples

As a new programming paradigm, deep learning (DL) has achieved impressive performance in areas such as image processing and speech recognition, and has expanded its application to solve many real-world problems. However, neural networks and DL are normally black-box systems; even worse, DL-based software are vulnerable to threats from abnormal examples, such as adversarial and backdoored examples constructed by attackers with malicious intentions as well as unintentionally mislabeled samples. Therefore, it is important and urgent to detect such abnormal examples. Although various detection approaches have been proposed respectively addressing some specific types of abnormal examples, they suffer from some limitations; until today, this problem is still of considerable interest. In this work, we first propose a novel characterization to distinguish abnormal examples from normal ones based on the observation that abnormal examples have significantly different (adversarial) robustness from normal ones. We systemically analyze those three different types of abnormal samples in terms of robustness and find that they have different characteristics from normal ones. As robustness measurement is computationally expensive and hence can be challenging to scale to large networks, we then propose to effectively and efficiently measure robustness of an input sample using the cost of adversarially attacking the input, which was originally proposed to test robustness of neural networks against adversarial examples. Next, we propose a novel detection method, named attack as detection (A 2 D for short), which uses the cost of adversarially attacking an input instead of robustness to check if it is abnormal. Our detection method is generic, and various adversarial attack methods could be leveraged. Extensive experiments show that A 2 D is more effective than recent promising approaches that were proposed to detect only one specific type of abnormal examples. We also thoroughly discuss possible adaptive attack methods to our adversarial example detection method and show that A 2 D is still effective in defending carefully designed adaptive adversarial attack methods—for example, the attack success rate drops to 0% on CIFAR10.

Task-Level Checkpointing and Localized Recovery to Tolerate Permanent Node Failures for Nested Fork–Join Programs in Clusters

Exascale supercomputers consist of millions of processing units, and this number is still growing. Therefore, hardware failures, such as permanent node failures, become increasingly frequent. They can be tolerated with system-level Checkpoint/Restart, which saves the whole application state transparently and, if needed, restarts the application from the saved state; or with application-level checkpointing, which saves only relevant data via explicit calls in the program. The former approach requires no additional programming expense, whereas the latter is more efficient and allows to continue program execution after failures on the intact resources (localized shrinking recovery). An increasingly popular programming paradigm is asynchronous many-task (AMT) programming. Here, programmers identify parallel tasks, and a runtime system assigns the tasks to worker threads. Since tasks have clearly defined interfaces, the runtime system can automatically extract and save their interface data. This approach, called task-level checkpointing (TC), combines the respective strengths of system-level and application-level checkpointing. AMTs come in many variants, and so far, TC has only been applied to a few, rather simple variants. This paper considers TC for a different AMT variant: nested fork–join (NFJ) programs that run on clusters of multicore nodes under work stealing. We present the first TC scheme for this setting. It performs a localized shrinking recovery and can handle multiple node failures. In experiments with four benchmarks, we observed execution time overheads of around 44 % at 1536 workers, and negligible recovery costs. Additionally, we developed and experimentally validated a prediction model for the running times of the scheme.

PRogramAR: Augmented Reality End-User Robot Programming

The field of end-user robot programming seeks to develop methods that empower non-expert programmers to task and modify robot operations. In doing so, researchers may enhance robot flexibility and broaden the scope of robot deployments into the real world. We introduce PRogramAR (Programming Robots using Augmented Reality), a novel end-user robot programming system that combines the intuitive visual feedback of augmented reality (AR) with the simplistic and responsive paradigm of trigger-action programming (TAP) to facilitate human-robot collaboration. Through PRogramAR, users are able to rapidly author task rules and desired reactive robot behaviors, while specifying task constraints and observing program feedback contextualized directly in the real world. PRogramAR provides feedback by simulating the robot’s intended behavior and providing instant evaluation of TAP rule executability to help end users better understand and debug their programs during development. In a system validation, 17 end users ranging from ages 18 to 83 used PRogramAR to program a robot to assist them in completing three collaborative tasks. Our results demonstrate how merging the benefits of AR and TAP using elements from prior robot programming research into a single novel system can successfully enhance the robot programming process for non-expert users.

Effects of subthalamic nucleus deep brain stimulation using different frequency programming paradigms on axial symptoms in advanced Parkinson's disease.

In advanced Parkinson's disease (PD), axial symptoms are common and can be debilitating. Although deep brain stimulation (DBS) significantly improves motor symptoms, conventional high-frequency stimulation (HFS) has limited effectiveness in improving axial symptoms. In this study, we investigated the effects on multiple axial symptoms after DBS surgery with three different frequency programming paradigms comprising HFS, low-frequency stimulation (LFS), and variable-frequency stimulation (VFS). This study involved PD patients who had significant preoperative axial symptoms and underwent bilateral subthalamic nucleus (STN) DBS. Axial symptoms, motor symptoms, medications, and quality of life were evaluated preoperatively (baseline). One month after surgery, HFS was applied. At 6months post-surgery, HFS assessments were performed, and HFS was switched to LFS. A further month later, we conducted LFS assessments and switched LFS to VFS. At 8months after surgery, VFS assessments were performed. Of the 21 PD patients initially enrolled, 16 patients were ultimately included in this study. Regarding HFS, all axial symptoms except for the Berg Balance Scale (p < 0.0001) did not improve compared with the baseline (all p > 0.05). As for LFS and VFS, all axial symptoms improved significantly compared with both the baseline and HFS (all p < 0.05). Moreover, motor symptoms and medications were significantly better than the baseline (all p < 0.05) after using LFS and VFS. Additionally, the quality of life of the PD patients after receiving LFS and VFS was significantly better than at the baseline and with HFS (all p < 0.0001). Our findings indicate that HFS is ineffective at improving the majority of axial symptoms in advanced PD. However, both the LFS and VFS programming paradigms exhibit significant improvements in various axial symptoms.

Evaluating Datalog Tools for Meta-reasoning over OWL 2 QL

Abstract Metamodeling is a general approach to expressing knowledge about classes and properties in an ontology. It is a desirable modeling feature in multiple applications that simplifies the extension and reuse of ontologies. Nevertheless, allowing metamodeling without restrictions is problematic for several reasons, mainly due to undecidability issues. Practical languages, therefore, forbid classes to occur as instances of other classes or treat such occurrences as semantically different objects. Specifically, meta-querying in SPARQL under the Direct Semantic Entailment Regime uses the latter approach, thereby effectively not supporting meta-queries. However, several extensions enabling different metamodeling features have been proposed over the last decade. This paper deals with the Metamodeling Semantics (MS) over OWL 2 QL and the Metamodeling Semantic Entailment Regime (MSER), as proposed in Lenzerini et al. (2015, Description Logics) and Lenzerini et al. (2020, Information Systems 88, 101294), Cima et al. (2017, Proceedings of the 7th International Conference on Web Intelligence, Mining and Semantics, 1–6). A reduction from OWL 2 QL to Datalog for meta-querying was proposed in Cima et al. (2017, Proceedings of the 7th International Conference on Web Intelligence, Mining and Semantics, 1–6). In this paper, we experiment with various logic programming tools that support Datalog querying to determine their suitability as back-ends to MSER query answering. These tools stem from different logic programming paradigms (Prolog, pure Datalog, Answer Set Programming, Hybrid Knowledge Bases). Our work shows that the Datalog approach to MSER querying is practical also for sizeable ontologies with limited resources (time and memory). This paper significantly extends Qureshi and Faber (2021, International Joint Conference on Rules and Reasoning, Springer, 218–233.) by a more detailed experimental analysis and more background.

An Adaptive Parallel Pattern Based Design for Molecular Dynamic Simulation

In Parallel programming, a programmer needs to understand hardware environment, programming paradigm and primitives available in the programming language. Most of the time, parallel programmes are written for a specific architecture and cannot typically adapt to other architectures Particularly, programs written for shared memory architectures are unsuitable for distributed or hybrid architectures. This paper proposes Adaptive Design Pattern for Parallel Programming to improve adaptability, flexibility with achieving performance on different architectures. Molecular Dynamics (MD) simulation is required to scale to various architectures from simple machine to cluster of workstations. In this study, MD Simulation experimented using both pure benchmark code and code based on adaptive design patterns. Redesigned MD Simulation with Adaptive Design Pattern claims parallel efficiency from 56% to 90% for different number of processing elements used. The solution demonstrates adaptability to different architectures and scalability to use with large number of atoms and long duration simulation.

A Proposal of Naturalistic Software Development Method

Naturalistic programming purports to include natural language elements in programming languages to increase software expressiveness. Even though natural language is inherently ambiguous, it is richer and thus more expressive than any artificial language. Currently, the Naturalistic Programming Paradigm (NPP) is supported by its conceptual model and three general-purpose naturalistic programming languages that can generate executable binary code. Nevertheless, to date, no research efforts have been concentrated on applying the NPP within a software development process. To address this gap, in this article, we propose a naturalistic software development method to test the advantages of the NPP. The method focuses on the analysis and design stages of the software development process and seeks to contribute to closing the gap between the problem and the solution domains. We also present an example of an implementation using Cal-4700, a naturalistic programming language, showing the differences in expressiveness of programming with a traditional programming language, like Python.&amp;nbsp;