High-level Language Research Articles

Assessing Intel OneAPI capabilities and cloud-performance for heterogeneous computing

This work presents a performance-oriented study of a heterogeneous application developed with Intel OneAPI to solve two well-known diffusion problems: heat diffusion and image denoising. We have explored CPU+iGPU and CPU+FPGA schemes, applying dynamic load balancing and conducting experiments on Intel DevCloud. The results demonstrate that the CPU+iGPU scheme outperforms the execution times achieved by the fastest device when the problem is sufficiently computationally demanding. We also found that the performance of the CPU+FPGA scheme is heavily affected by bandwidth limitations and specific strategies to manage memory efficiently are required. Moreover, it was demonstrated that dynamic workload balancing is crucial due to possible performance fluctuations in any of the implicated devices. In conclusion, Intel OneAPI provides a helpful tool for multi-platform development using a unique high-level language, DPC++. However, developing specific code for each platform is necessary to achieve optimal performance.

High-level language brain regions process sublexical regularities.

A network of left frontal and temporal brain regions supports language processing. This "core" language network stores our knowledge of words and constructions as well as constraints on how those combine to form sentences. However, our linguistic knowledge additionally includes information about phonemes and how they combine to form phonemic clusters, syllables, and words. Are phoneme combinatorics also represented in these language regions? Across five functional magnetic resonance imaging experiments, we investigated the sensitivity of high-level language processing brain regions to sublexical linguistic regularities by examining responses to diverse nonwords-sequences of phonemes that do not constitute real words (e.g. punes, silory, flope). We establish robust responses in the language network to visually (experiment 1a, n = 605) and auditorily (experiments 1b, n = 12, and 1c, n = 13) presented nonwords. In experiment 2 (n = 16), we find stronger responses to nonwords that are more well-formed, i.e. obey the phoneme-combinatorial constraints of English. Finally, in experiment 3 (n = 14), we provide suggestive evidence that the responses in experiments 1 and 2 are not due to the activation of real words that share some phonology with the nonwords. The results suggest that sublexical regularities are stored and processed within the same fronto-temporal network that supports lexical and syntactic processes.

Technical Note: mzML and imzML Libraries for Processing Mass Spectrometry Data with the High-Performance Programming Language Julia.

Julia combines the virtues of high-level and low-level programming languages: The code is human-readable, and the performance of the created binaries competes with machine-orientated compilers. Thus, Julia is popular in "Big Data" sciences. Reading mass spectrometry (MS) data with Julia was impossible until now due to missing libraries. Here, we present a Julia library for importing mass spectrometry (MS) data in HUPO standard mzML and imzML formats and demonstrate its function with direct and ambient ionization MS, liquid chromatography-MS, and MS imaging data on standard platforms (Windows, Linux, and Mac OS). The processing speed of Julia for reading imzML MS imaging files was up to 214 times faster than the comparable code in R. Julia can remove bottlenecks for computationally demanding tasks in large-scale MS-Omics and MS imaging data processing workflows and supports their agile development. In addition, time-critical and complex data evaluation tasks become possible, such as following the real-time monitoring of biological processes and pattern recognition in large MS imaging projects. Our mzML/imzML libraries and code examples are available under the terms of the MIT license from https://github.com/CINVESTAV-LABI/julia_mzML_imzML.

DEVELOPMENT OF AN ONTOLOGICAL MODEL OF DEEP LEARNING NEURAL NETWORKS

This research paper examines the challenges and prospects associated with the integration of artificial neural networks and knowledge bases. The focus is on leveraging this integration to address practical problems. The paper explores the development, training, and integration of artificial neural net- works, emphasizing their adaptation to knowledge bases. This adaptation involves processes such as in- tegration, communication, representation of ontological structures, and interpretation by the knowledge base of the artificial neural network's representation through input and output. The paper also delves into the direction of establishing an intellectual environment conducive to the development, training, and integration of adapted artificial neural networks with knowledge bases. The knowledge base embedded in an artificial neural network is constructed using a homogeneous semantic network, and knowledge processing employs a multi-agent approach. The representation of artificial neural networks and their specifications within a unified semantic model of knowledge representation is detailed, encompassing text-based specifications in the language of knowledge representation with theoretical semantics. The models shared with the knowledge base include dynamic and other types that vary in their capabilities for knowledge representation. Furthermore, the paper conducts an analysis of approaches to creating artificial neural networks across various libraries of the high-level programming language Python. It explores techniques for developing arti- ficial neural networks within the Python development environment, investigating the key features and func- tions of these libraries. A comparative analysis of neural networks created in object-oriented programming languages is provided, along with the development of an ontological model for deep learning neural net- works.

Real-time word recognition in heritage speakers: Evidence from the visual world paradigm

Up to 20% of children in the US come from multilingual households (Census, 2019). However, current language development models are still mostly based on monolingual input. Heritage speaker (HS) children pose a challenge for current understandings of monolingual language development because their first language (the heritage language, HL) becomes their less dominant language as they age (often when schooling begins), and their second language (the majority language, ML) eventually becomes dominant, despite a delayed start. Here, lexical processing—a key hub in the language system—is targeted as a model system in which to ask how HSs become more automatic language processors in the ML. To do so, the proposed study focuses on spoken word recognition, which is a critical bottleneck in early language development, as the ability to efficiently recognize continuous speech paves the way for higher level language abilities. Successful recognition requires listeners to suppress competitors, such that only the target word remains. We present eye-tracking data from school-aged HSs who have become more dominant in English (n = 30). Our findings show that HSs, despite a delayed start in English, reach target words efficiently. We discuss the strategies employed by HS children to resolve competition in their ML.

The transition from vision to language: Distinct patterns of functional connectivity for subregions of the visual word form area.

Reading entails transforming visual symbols to sound and meaning. This process depends on specialized circuitry in the visual cortex, the visual word form area (VWFA). Recent findings suggest that this text-selective cortex comprises at least two distinct subregions: the more posterior VWFA-1 is sensitive to visual features, while the more anterior VWFA-2 processes higher level language information. Here, we explore whether these two subregions also exhibit different patterns of functional connectivity. To this end, we capitalize on two complementary datasets: Using the Natural Scenes Dataset (NSD), we identify text-selective responses in high-quality 7T adult data (N = 8), and investigate functional connectivity patterns of VWFA-1 and VWFA-2 at the individual level. We then turn to the Healthy Brain Network (HBN) database to assess whether these patterns replicate in a large developmental sample (N = 224; age 6-20 years), and whether they relate to reading development. In both datasets, we find that VWFA-1 is primarily correlated with bilateral visual regions. In contrast, VWFA-2 is more strongly correlated with language regions in the frontal and lateral parietal lobes, particularly the bilateral inferior frontal gyrus. Critically, these patterns do not generalize to adjacent face-selective regions, suggesting a specific relationship between VWFA-2 and the frontal language network. No correlations were observed between functional connectivity and reading ability. Together, our findings support the distinction between subregions of the VWFA, and suggest that functional connectivity patterns in the ventral temporal cortex are consistent over a wide range of reading skills.

Impact of a pharmacy technician on an interprofessional antithrombotic stewardship program at an academic medical center.

The need for monitoring and standardization of anticoagulation management has garnered the attention of national organizations, driving the implementation of antithrombotic stewardship programs (ASPs). Established ASPs have highlighted interdisciplinary collaboration between physicians, nurses, and pharmacists and demonstrated financial benefits and positive patient care outcomes. While pharmacy technicians are key members of the pharmacy profession, they are rarely utilized to expand clinical programs. The aim of this report is to describe the impact of adding a pharmacy technician to an ASP at an academic medical center. The departments of pharmacy and quality at West Virginia University Hospitals (WVUH) developed a business plan and financially justified an ASP. The ASP was implemented in January 2022 and consisted of 2 full-time clinical pharmacist specialists, 1 full-time clinical pharmacy technician, 2 full-time clinical nurse specialists, and 1 part-time physician medical director. The clinical pharmacy technician's primary role was to review patients' sequential compression device (SCD) compliance and newly started oral anticoagulants prior to discharge. The clinical nurse specialists educated patients newly started on oral anticoagulants within 24 hours of discharge and triaged any postdischarge medication access issues. The medical director provided high-level program oversight and acted as a clinical consultant on complex patient cases. In the first 6 months after the program's implementation, the clinical pharmacy technician made 174 recommendations to the clinical pharmacist specialists regarding discharge transitions of care and assessed SCD compliance in 246 patients. Of the 246 patients assessed, 217 patients (88%) were deemed to be noncompliant. The pharmacy department at WVUH successfully justified and implemented an interprofessional ASP at an academic medical center, which is the first ASP to date to incorporate a clinical pharmacy technician.

SoK: Analysis Techniques for WebAssembly

WebAssembly is a low-level bytecode language that enables high-level languages like C, C++, and Rust to be executed in the browser at near-native performance. In recent years, WebAssembly has gained widespread adoption and is now natively supported by all modern browsers. Despite its benefits, WebAssembly has introduced significant security challenges, primarily due to vulnerabilities inherited from memory-unsafe source languages. Moreover, the use of WebAssembly extends beyond traditional web applications to smart contracts on blockchain platforms, where vulnerabilities have led to significant financial losses. WebAssembly has also been used for malicious purposes, like cryptojacking, where website visitors’ hardware resources are used for crypto mining without their consent. To address these issues, several analysis techniques for WebAssembly binaries have been proposed. This paper presents a systematic review of these analysis techniques, focusing on vulnerability analysis, cryptojacking detection, and smart contract security. The analysis techniques are categorized into static, dynamic, and hybrid methods, evaluating their strengths and weaknesses based on quantitative data. Our findings reveal that static techniques are efficient but may struggle with complex binaries, while dynamic techniques offer better detection at the cost of increased overhead. Hybrid approaches, which merge the strengths of static and dynamic methods, are not extensively used in the literature and emerge as a promising direction for future research. Lastly, this paper identifies potential future research directions based on the state of the current literature.

Boosting general-purpose stream processing with reconfigurable hardware

Reconfigurable devices such as field-programmable gate arrays (FPGAs) offer flexible solutions to workload acceleration with high energy efficiency. Despite such a potential advantage, they often reveal hard to program by application programmers. High-level synthesis languages have been developed to provide higher-level abstractions, allowing the developers to define the FPGA behavior using an imperative programming approach based on C/C++ languages. However, such approaches still leave the developer with the responsibility to harness the low-level optimizations required to develop efficient FPGA programs. Along this line, this paper introduces FSPX, a framework helping programmers to develop FPGA-accelerated data stream processing (DSP) applications. The approach provides a high-level Python API to develop the data-flow graph of operators, which is automatically translated into an efficient Vitis source code targeting Xilinx devices. The execution of the bitstreams implementing two benchmark applications showcases the efficiency of using FPGAs for DSP workloads. In general, FSPX provides, with a reasonable time-to-solution, higher performance compared with state-of-the-art DSP frameworks.

A case study of medical image software evolution and its impact in the medical imaging community

Objective: We present the evolution of medical imaging software and its impact on the medical imaging community through the study of four open-source image analysis software platforms: 3D Slicer, FreeSurfer, FSL, and SPM. Materials and methods: We have studied the impact of these software tools over time, measured by the number of scientific citations. Additionally, we have also studied the source code evolution by measuring the lines of code and the tarball size of the stable releases and the changes in programming languages. Results and discussion: The rising number of related scientific publications confirms the popularity of these software tools in the research community, albeit some differences can be observed in the popularity of the tools. Moreover, we demonstrate that source code has evolved to modernize and optimize, at least partially thanks to the collaboration and code sharing with the user community. Furthermore, this evolution reveals an increased use of higher-level programming languages and meta-languages. Conclusions: The study of four open-source packages has revealed certain patterns in the evolution of medical imaging software and their impact on the medical image community. Further analyses and complementary metrics are suggested.

Compilation of algorithm-specific graph states for quantum circuits

We present a quantum circuit compiler that prepares an algorithm-specific graph state from quantum circuits described in high level languages, such as Cirq and Q#. The computation can then be implemented using a series of non-Pauli measurements on this graph state. By compiling the graph state directly instead of starting with a standard lattice cluster state and preparing it over the course of the computation, we are able to better understand the resource costs involved and eliminate wasteful Pauli measurements on the actual quantum device. Access to this algorithm-specific graph state also allows for optimisation over locally equivalent graph states to implement the same quantum circuit. The compiler presented here finds ready application in measurement based quantum computing, NISQ devices and logical level compilation for fault tolerant implementations.

Cerise: Program Verification on a Capability Machine in the Presence of Untrusted Code

A capability machine is a type of CPU allowing fine-grained privilege separation using capabilities , machine words that represent certain kinds of authority. We present a mathematical model and accompanying proof methods that can be used for formal verification of functional correctness of programs running on a capability machine, even when they invoke and are invoked by unknown (and possibly malicious) code. We use a program logic called Cerise for reasoning about known code, and an associated logical relation, for reasoning about unknown code. The logical relation formally captures the capability safety guarantees provided by the capability machine. The Cerise program logic, logical relation, and all the examples considered in the paper have been mechanized using the Iris program logic framework in the Coq proof assistant. The methodology we present underlies recent work of the authors on formal reasoning about capability machines [Georges et al. 2021 ; Skorstengaard et al. 2019a ; Van Strydonck et al. 2022 ], but was left somewhat implicit in those publications. In this paper we present a pedagogical introduction to the methodology, in a simpler setting (no exotic capabilities), and starting from minimal examples. We work our way up to new results about a heap-based calling convention and implementations of sophisticated object-capability patterns of the kind previously studied for high-level languages with object-capabilities, demonstrating that the methodology scales to such reasoning.

Irony Understanding in Children With Attention-Deficit/Hyperactivity Disorder: A Comparative Analysis.

Attention-deficit/hyperactivity disorder (ADHD) is a neurodevelopmental disorder characterized by persistent patterns of inattention, hyperactivity, and impulsivity that can significantly impact a child's daily life and academic performance. Some studies have noted challenges in social cognition among children with ADHD, specifically in aspects like emotion perception and processing, empathy, Theory of Mind, and pragmatics. One of the lesser-explored aspects of ADHD is its potential impact on higher-level language skills, such as irony understanding. Our goal in this study was to compare irony comprehension in two groups: schoolchildren with normal development and schoolchildren with ADHD. We performed a comparative cross-sectional study on a total of 35 children aged between 6 and 12 years: 17 with ADHD and 18 not neurodevelopmentally impaired. Irony comprehension was evaluated using an assessment method validated for the Portuguese population: Turtle on the Island - Battery of Assessment of Executive Functions in Children (TI-BAFEC). We also applied the EACE (Emotional Awareness and Coping in Children) scale. It is the Portuguese adaptation of the Assessment of Children's Emotion Skills and assesses children's emotional knowledge. We obtained two comparable groups concerning sociodemographic data. The analysis of the data, using the Mann-Whitney U Test, showed that in all parameters, the control group consistently exhibited superior performance compared to the ADHD group. However, only TI-BAFEC (p = 0.005) and emotional behavior (p = 0.007) showed a significant statistical variance between the two groups. This article shows that children with ADHD encounter challenges in grasping irony. However, the underlying cognitive processes contributing to these difficulties warrant further investigation.

Creating a common notation of the x86 processor software interface for automated disassembler construction

The subject of the study is the process of reverse engineering of programs in order to obtain their source code in low- or high-level languages for processors with x86 architecture, the software interface of which is developed by Intel and AMD. The object of the study is the technical specifications in the documentation produced by these companies. The intensity of updating documentation for processors is investigated and the need to develop technological approaches aimed at automated disassembler construction, taking into account regularly released and frequent updates of the processor software interface, is justified. The article presents a method for processing documentation in order to obtain a generalized, formalized and uniform specification of processor commands for further automated translation into the disassembler program code. The article presents two main results: the first is an analysis of the various options for describing commands presented in the Intel and AMD documentation, and a concise reduction of these descriptions to a monotonous form of representation; the second is a comprehensive syntactic analysis of machine code description notations and the form of representation of each command in assembly language. This, taking into account some additional details of the description of the commands, for example, the permissible operating mode of the processor when executing the command, made it possible to create a generalized description of the command for translating the description into the disassembler code. The results of the study include the identification of a number of errors in both the documentation texts and in the operation of existing industrial disassemblers, built, as shown by the analysis of their implementation, using manual coding. The identification of such errors in the existing reverse engineering tools is an indirect result of the author's research.

Высокопроизводительный алгоритм решения проблем связного списка с использованием техники быстрого и медленного указателей

This article discusses a combination of the fast and slow pointer method and other techniques in the high-level programming language Java to effectively solve popular algorithmic linked list problems. The result includes a description of the problem, implementation of a high-performance algorithm and solution to the computational problem.

Mitigating Debugger-based Attacks to Java Applications with Self-Debugging

Java bytecode is a quite high-level language and, as such, it is fairly easy to analyze and decompile with malicious intents, e.g., to tamper with code and skip license checks. Code obfuscation was a first attempt to mitigate malicious reverse engineering based on static analysis. However, obfuscated code can still be dynamically analyzed with standard debuggers to perform step-wise execution and to inspect (or change) memory content at important execution points, e.g., to alter the verdict of license validity checks. Although some approaches have been proposed to mitigate debugger-based attacks, they are only applicable to binary compiled code and none address the challenge of protecting Java bytecode. In this paper, we propose a novel approach to protect Java bytecode from malicious debugging. Our approach is based on automated program transformation to manipulate Java bytecode and split it into two binary processes that debug each other (i.e., a self-debugging solution). In fact, when the debugging interface is already engaged, an additional malicious debugger cannot attach. To be resilient against typical attacks, our approach adopts a series of technical solutions, e.g., an encoded channel is shared by the two processes to avoid leaking information, an authentication protocol is established to avoid Man-in-the-Middle attacks and the computation is spread between the two processes to prevent the attacker to replace or terminate either of them. We test our solution on 18 real-world Java applications, showing that our approach can effectively block the most common debugging tasks (either with the Java debugger or the GNU debugger) while preserving the functional correctness of the protected programs. While the final decision on when to activate this protection is still up to the developers, the observed performance overhead was acceptable for common desktop application domains.

EasyBC: A Cryptography-Specific Language for Security Analysis of Block Ciphers against Differential Cryptanalysis

Differential cryptanalysis is a powerful algorithmic-level attack, playing a central role in evaluating the security of symmetric cryptographic primitives. In general, the resistance against differential cryptanalysis can be characterized by the maximum expected differential characteristic probability. In this paper, we present generic and extensible approaches based on mixed integer linear programming (MILP) to bound such probability. We design a high-level cryptography-specific language EasyBC tailored for block ciphers and provide various rigorous procedures, as differential denotational semantics, to automate the generation of MILP from block ciphers written in EasyBC. We implement an open-sourced tool that provides support for fully automated resistance evaluation of block ciphers against differential cryptanalysis. The tool is extensively evaluated on 23 real-life cryptographic primitives including all the 10 finalists of the NIST lightweight cryptography standardization process. The experiments confirm the expressivity of EasyBC and show that the tool can effectively prove the resistance against differential cryptanalysis for all block ciphers under consideration. EasyBC makes resistance evaluation against differential cryptanalysis easily accessible to cryptographers.

Automatic Parallelism Management

On any modern computer architecture today, parallelism comes with a modest cost, born from the creation and management of threads or tasks. Today, programmers battle this cost by manually optimizing/tuning their codes to minimize the cost of parallelism without harming its benefit, performance. This is a difficult battle: programmers must reason about architectural constant factors hidden behind layers of software abstractions, including thread schedulers and memory managers, and their impact on performance, also at scale. In languages that support higher-order functions, the battle hardens: higher order functions can make it difficult, if not impossible, to reason about the cost and benefits of parallelism. Motivated by these challenges and the numerous advantages of high-level languages, we believe that it has become essential to manage parallelism automatically so as to minimize its cost and maximize its benefit. This is a challenging problem, even when considered on a case-by-case, application-specific basis. But if a solution were possible, then it could combine the many correctness benefits of high-level languages with performance by managing parallelism without the programmer effort needed to ensure performance. This paper proposes techniques for such automatic management of parallelism by combining static (compilation) and run-time techniques. Specifically, we consider the Parallel ML language with task parallelism, and describe a compiler pipeline that embeds "potential parallelism" directly into the call-stack and avoids the cost of task creation by default. We then pair this compilation pipeline with a run-time system that dynamically converts potential parallelism into actual parallel tasks. Together, the compiler and run-time system guarantee that the cost of parallelism remains low without losing its benefit. We prove that our techniques have no asymptotic impact on the work and span of parallel programs and thus preserve their asymptotic properties. We implement the proposed techniques by extending the MPL compiler for Parallel ML and show that it can eliminate the burden of manual optimization while delivering good practical performance.

Polymorphic Reachability Types: Tracking Freshness, Aliasing, and Separation in Higher-Order Generic Programs

Fueled by the success of Rust, many programming languages are adding substructural features to their type systems. The promise of tracking properties such as lifetimes and sharing is tremendous, not just for low-level memory management, but also for controlling higher-level resources and capabilities. But so are the difficulties in adapting successful techniques from Rust to higher-level languages, where they need to interact with other advanced features, especially various flavors of functional and type-level abstraction. What would it take to bring full-fidelity reasoning about lifetimes and sharing to mainstream languages? Reachability types are a recent proposal that has shown promise in scaling to higher-order but monomorphic settings, tracking aliasing and separation on top of a substrate inspired by separation logic. However, naive extensions on top of the prior reachability type system λ * with type polymorphism and/or precise reachability polymorphism are unsound, making λ * unsuitable for adoption in real languages. Combining reachability and type polymorphism that is precise, sound, and parametric remains an open challenge. This paper presents a rethinking of the design of reachability tracking and proposes new polymorphic reachability type systems. We introduce a new freshness qualifier to indicate variables whose reachability sets may grow during evaluation steps. The new system tracks variables reachable in a single step and computes transitive closures only when necessary, thus preserving chains of reachability over known variables that can be refined using substitution. These ideas yield the simply-typed λ ✦ -calculus with precise lightweight, i.e., quantifier-free, reachability polymorphism, and the F <: ✦ -calculus with bounded parametric polymorphism over types and reachability qualifiers, paving the way for making true tracking of lifetimes and sharing practical for mainstream languages. We prove type soundness and the preservation of separation property in Coq. We discuss various applications (e.g., safe capability programming), possible effect system extensions, and compare our system with Scala’s capture types.

Instance segmentation on distributed deep learning big data cluster

AbstractDistributed deep learning is a promising approach for training and deploying large and complex deep learning models. This paper presents a comprehensive workflow for deploying and optimizing the YOLACT instance segmentation model as on big data clusters. OpenVINO, a toolkit known for its high-speed data processing and ability to optimize deep learning models for deployment on a variety of devices, was used to optimize the YOLACT model. The model is then run on a big data cluster using BigDL, a distributed deep learning library for Apache Spark. BigDL provides a high-level programming interface for defining and training deep neural networks, making it suitable for large-scale deep learning applications. In distributed deep learning, input data is divided and distributed across multiple machines for parallel processing. This approach offers several advantages, including the ability to handle very large data that can be stored in a distributed manner, scalability to decrease processing time by increasing the number of workers, and fault tolerance. The proposed workflow was evaluated on virtual machines and Azure Databricks, a cloud-based platform for big data analytics. The results indicated that the workflow can scale to large datasets and deliver high performance on Azure Databricks. This study explores the benefits and challenges of using distributed deep learning on big data clusters for instance segmentation. Popular distributed deep learning frameworks are discussed, and BigDL is chosen. Overall, this study highlights the practicality of distributed deep learning for deploying and scaling sophisticated deep learning models on big data clusters.