High-level Language Research Articles

Validity Profile and Practically Biological Teaching Structures Based on Local Potenties BIOLA PJBL High Level and Enrichment Program

Biology based on local potential Bioecology (BIOLA) PjBL High Level, is a promoter of a valid and practical enrichment program for SMAN pupils in Saparua Island. Products were developed in the form of RPPs, teaching materials, and Students Project Activity Sheets (LAPPD). This research includes a type of research and development that refers to a modified 4D development model that has three phases: (1) define, (2) design, and (3) develop. Research instruments use validation lifts and practicality lifts. Validation of learning instruments using a validation lift evaluated by four instruments expert validators consisting of two lecturers and two practitioners namely Biology subjects teachers. The practicality test of the learning instruments was evaluated using the response lift by the teacher and the pupil and the implementation of learning process by the teacher as an observer. The method used is descriptive statistics to obtain averages and percentages. The results of the validity analysis of the learning instruments using the Ideal Baku deviation (SBI), showing a rating of 3.93 with a very good category. Results of the analysis of implementation of the PJBL high level Biola instruments in the learning process by the observer and student responses in sequence showed 91% and 89.20% with the very practical category. So, it can be concluded that the BIOLA-PjBL High Level based biology learning instruments that has been developed is valid and practical for use as well as useful for teachers and pupils. Keywords: Innovative teaching instruments, local potential, bioecology, PJBL High Level, enrichment program

Computer-Modeling System of Agronomist’s Labor Functions

The goal of the paper is to develop the computer-modeling system of an agronomist’s labor functions as the most optimal solution for teaching preschoolers and primary schoolchildren about trends and technologies in farming, aimed at increasing the attractiveness of professions in the field of agriculture. Among the main objectives of the research is the study of the essence of computer modeling as a teaching method in the works of domestic scientists, as well as the construction of models and their implementation using high-level programming languages in order to obtain an information system for the labor functions of an agronomist.Materials and methods. In the course of the analysis, a study was carried out of scientific and technical literature on the use of computer-modeling systems in the educational field. The analysis of the market for computer-modeling systems in the agricultural sector of crop production was carried out. When visualizing and describing system models, UML modeling notation was used. A diagram of use cases for this notation made it possible to describe the functional requirements and interactions between the system and its user. A UML notation sequence diagram was used to model the interaction of the main menu, game scene, and game character over time. The class diagram made it possible to define the structure of the system and the relationships between its objects, as well as an overview of the attributes and operations of the identified classes. The designed system models were implemented in the C# programming language in the Visual Studio development environment.Results. The study revealed the need to introduce new forms, methods and means of teaching into the content of the modern educational process, the implementation of which, largely, is carried out using information technology. The most optimal solution to the issue of teaching children about trends and technologies in agriculture, which has become relevant in the light of the rapid development of agriculture and its digital transformation, was the introduction of computer- modeling systems. The analysis of literature on the research problem has shown that in the works of L. Zhuk, M. Larionova, N. Rozova, etc. great attention is paid to the use of computer modeling as a teaching tool. According to the author, the use of this technology in the educational process makes it possible to implement such teaching principles as the principle of integrative learning, the principle of a practice-oriented approach, the principle of differentiation of learning and the principle of dialogical learning. There are no domestic developments in the subject area under consideration on the information systems market. The author of the study designed and implemented, using the object-oriented programming language C#, the computer-modeling system of agronomist’s labor functions as a technology for teaching professional tasks of an agronomist at various stages of agrarian evolution. The proposed solution allows you to be acquainted with four significant agrarian revolutions that played a decisive role in the transformation of agriculture: the Neolithic revolution, the Renaissance agricultural revolution, the green revolution and the digital revolution in agriculture. Conclusion. It is important to note that the computer-modeling system of the labor functions of agronomist is of interest for preschool and primary education institutions. This development can also be used in the system of additional education for children. Using a computer game in the educational process will expand children’s knowledge about agriculture: it will familiarize them with different agricultural processes, such as planting, growing and harvesting crops, as well as with various types of crop cultivation technologies. This will contribute to the development of interest in the study of agriculture and, as a result, the growth of students’ motivation to connect their professional activities with agriculture.

Physiological signal analysis and open science using the Julia language and associated software

In this mini review, we propose the use of the Julia programming language and its software as a strong candidate for reproducible, efficient, and sustainable physiological signal analysis. First, we highlight available software and Julia communities that provide top-of-the-class algorithms for all aspects of physiological signal processing despite the language’s relatively young age. Julia can significantly accelerate both research and software development due to its high-level interactive language and high-performance code generation. It is also particularly suited for open and reproducible science. Openness is supported and welcomed because the overwhelming majority of Julia software programs are open source and developed openly on public platforms, primarily through individual contributions. Such an environment increases the likelihood that an individual not (originally) associated with a software program would still be willing to contribute their code, further promoting code sharing and reuse. On the other hand, Julia’s exceptionally strong package manager and surrounding ecosystem make it easy to create self-contained, reproducible projects that can be instantly installed and run, irrespective of processor architecture or operating system.

A Novel Method for Designing Electronic Logic Circuits

This scientific paper presents a novel method for designing single and multi-output electronic logic circuits. The produced circuit consists of two parts. The first part consists of (n-1) XOR gates, where "n" is the number of input signals to the logic circuits. This part is called the linear part of the circuit. The second part is designed by any method used in designing logic circuits. This part called the non-linear part of the circuit. The suggested method can be programmed by any high level programming language to be used on any digital computer especially with the circuits which have a large number of input signals.

Design and Implementation of a 7-Person Voting Device based on Quartus

As the complexity of digital system design continues to increase, efficient and precise decision support systems have become increasingly important. This paper presents the design and implementation of a 7-voter decision system based on Altera’s Quartus software. The voter is applied in the core decision-making process to ensure the accuracy and efficiency of decisions. The study begins by outlining the design principles of the 7-voter decision system, using a design philosophy that minimizes timing delays and optimizes hardware resource utilization. A complex majority voting logic circuit is implemented using high-level hardware description languages (VHDL/Verilog), ensuring the advanced nature and applicability of the voting circuit. In terms of the logical implementation of the voting circuit, the paper conducts an in-depth analysis of the optimization of combinational and sequential logic and standardizes the input and output to enhance the signal stability and the system’s resistance to interference. On the Quartus platform, the design process of the voting system is elaborated in detail, with careful consideration given to boundary conditions and hardware compatibility. The implementation of the voter has undergone rigorous simulation and testing. Strict parameter setting for simulations and waveform analysis confirm the correctness of the circuit, and fault simulation tests further confirm its reliability. Performance indicators such as response time and percentage of resource utilization have been quantitatively analyzed and meet the design objectives set beforehand. Overall, this research not only realizes a highperformance 7-voter decision system but also provides an effective case study for applications on the high-performance Quartus design platform. Future research can build on the current work to further optimize algorithms and hardware, explore the potential for the application of the voter in a broader range of fields, and adapt to the new features of the Quartus platform to achieve more powerful decision support functions.

CollectiveHLS: A Collaborative Approach to High-Level Synthesis Design Optimization

High-Level Synthesis (HLS) has played a pivotal role in making FPGAs accessible to a broader audience by facilitating high-level device programming and rapid microarchitecture customization through the use of directives. However, manually selecting the right directives can be a formidable challenge for programmers lacking a hardware background. This paper presents CollectiveHLS, an ultra-fast, knowledge-driven approach to optimizing HLS designs. It automates the identification and application of optimal directive configurations from the original source code, focusing on minimizing design latency and ensuring synthesizability. This optimization approach is entirely data-driven, offering a generalized HLS tuning solution without reliance on Quality of Result (QoR) models or meta-heuristics. CollectiveHLS is designed, implemented, and evaluated using around 60 applications sourced from well-established benchmark suites and GitHub repositories, all running on a Xilinx UltraScale + MPSoC ZCU104. It achieves an average geometric mean speedup of up to \(23.1\times\) compared to the official source code without directives, while maintaining synthesizability and feasibility rates of 100% and 96.6%, respectively, matching those of Vitis, the industry-standard framework for FPGA acceleration. Comparisons with resource over-provisioning, traditional genetic algorithm-based Design Space Exploration (DSE), and State-of-the-Art (SotA) approaches demonstrate that CollectiveHLS produces designs of comparable quality \(14.6\times\) faster on average. These results underscore the potential of our approach as an ultra-fast and automated solution for HLS optimization.

GraphPPL.jl: A Probabilistic Programming Language for Graphical Models

This paper presents GraphPPL.jl, a novel probabilistic programming language designed for graphical models. GraphPPL.jl uniquely represents probabilistic models as factor graphs. A notable feature of GraphPPL.jl is its model nesting capability, which facilitates the creation of modular graphical models and significantly simplifies the development of large (hierarchical) graphical models. Furthermore, GraphPPL.jl offers a plugin system to incorporate inference-specific information into the graph, allowing integration with various well-known inference engines. To demonstrate this, GraphPPL.jl includes a flexible plugin to define a Constrained Bethe Free Energy minimization process, also known as variational inference. In particular, the Constrained Bethe Free Energy defined by GraphPPL.jl serves as a potential inference framework for numerous well-known inference backends, making it a versatile tool for diverse applications. This paper details the design and implementation of GraphPPL.jl, highlighting its power, expressiveness, and user-friendliness. It also emphasizes the clear separation between model definition and inference while providing developers with extensibility and customization options. This establishes GraphPPL.jl as a high-level user interface language that allows users to create complex graphical models without being burdened with the complexity of inference while allowing backend developers to easily adopt GraphPPL.jl as their frontend language.

Viability Study of SYCL as a Unified Programming Model for Heterogeneous Systems Based on GPUs in Bioinformatics

Bioinformatics and Computational Biology are disciplines that have used GPUs for over two decades to accelerate data processing in computational applications, where CUDA has been the most utilized programming language. However, the exclusive use of CUDA presents a portability issue, as it is only compatible with NVIDIA GPUs and not with other heterogeneous architectures, such as AMD or Intel GPUs, or any other type of accelerator. To address this portability challenge, the Khronos Group recently introduced the SYCL standard, a multi-platform programming model that offers a high-level programming interface. This standard facilitates the development of portable applications that can efficiently leverage the capabilities of different hardware devices, such as NVIDIA, Intel, and AMD GPUs, without needing significant modifications to the source code. Therefore, this thesis set out as its general objective to evaluate the feasibility of SYCL as a unified, portable, and efficient heterogeneous programming model for the design and development of computationally demanding applications on heterogeneous GPU-based systems, specifically in the field of bioinformatics. Initially, a detailed investigation was conducted about heterogeneous programming models, performance metrics, and bioinformatics concepts, in order to establish the theoretical foundations of this thesis. Then, the SW# suite was chosen as the case study, as it represents a clear example of a CUDA-based bioinformatics application for biological sequence alignment. Using the SYCLomatic tool, a complete migration of the CUDA code to SYCL was carried out, which involved modifying the generated code and solving runtime errors. Additionally, the functionality was verified, optimizations were applied, and the resulting SYCL code was standardized to be compatible with other SYCL implementations. Subsequently, multiple experiments were conducted to evaluate the functionality and performance portability of the software migrated to SYCL. These experiments involved running the application on a wide variety of HPC platforms, including different CPUs and GPUs from various manufacturers. The results obtained demonstrated performance comparable to CUDA in most configurations, confirming the effectiveness of SYCL. Moreover, good performance portability across platforms was observed due to SYCL's ability to run on various hardware combinations. Furthermore, performance remained consistent when switching SYCL implementations. In conclusion, this study demonstrates that SYCL is a viable alternative as a unified, portable, and efficient programming model in the context of heterogeneous computing with GPUs for bioinformatics applications. The findings of this study lay the groundwork for the transition of legacy applications and the development of new solutions leveraging the capabilities of SYCL.

Isabelle/Solidity: A deep embedding of Solidity in Isabelle/HOL

Smart contracts are computer programs designed to automate legal agreements. They are usually developed in a high-level programming language, the most popular of which is Solidity. Every day, hundreds of thousands of new contracts are deployed managing millions of dollars’ worth of transactions. As for every computer program, smart contracts may contain bugs which can be exploited. However, since smart contracts are often used to automate financial transactions, such exploits may result in huge economic losses. In general, it is estimated that since 2019, more than $5B was stolen due to vulnerabilities in smart contracts. This paper addresses the issue of smart contract vulnerabilities by introducing an executable denotational semantics for Solidity within the Isabelle/HOL interactive theorem prover. This formal semantics serves as the basis for an interactive program verification environment for Solidity smart contracts. To evaluate our semantics, we integrate grammar-based fuzzing with symbolic execution to automatically test it against the Solidity reference implementation. The paper concludes by showcasing the formal verification of Solidity programs, exemplified through the verification of a basic Solidity token.

Development of integrated FEPs for safety case scenario development

ABSTRACT To establish a deep disposal repository for high-level radioactive waste, it is crucial to develop a safety case, which is comprehensive evidence and arguments supporting the safety of a nuclear facility or activity. The development of safety cases is achieved by creating scenarios based on a comprehensive understanding of the disposal system. Scenarios are developed using Features, Events, and Processes (FEP) and must follow the rules of comprehensiveness, systematic approach, transparency, and traceability (rules for the scenario). Also, scenarios have to be developed in a way that the stakeholders understand the whole development process clearly. In this study, an intermediate step was introduced for the high-level radioactive waste management program to strengthen the rules for the scenario. An intermediate step was established through the integration of FEP. For integrating FEPs, we classified 268 NEA International FEPs into six classifications concerning the relationships between each FEP to scenario and safety objectives. Finally, we selected Repository system evolution FEPs as the target for integration because they can result in significant changes in system performance.

Modular Synthesis of Efficient Quantum Uncomputation

A key challenge of quantum programming is uncomputation: the reversible deallocation of qubits. And while there has been much recent progress on automating uncomputation, state-of-the-art methods are insufficient for handling today’s expressive quantum programming languages. A core reason is that they operate on primitive quantum circuits, while quantum programs express computations beyond circuits, for instance, they can capture families of circuits defined recursively in terms of uncomputation and adjoints. In this paper, we introduce the first modular automatic approach to synthesize correct and efficient uncomputation for expressive quantum programs. Our method is based on two core technical contributions: (i) an intermediate representation (IR) that can capture expressive quantum programs and comes with support for uncomputation, and (ii) modular algorithms over that IR for synthesizing uncomputation and adjoints. We have built a complete end-to-end implementation of our method, including an implementation of the IR and the synthesis algorithms, as well as a translation from an expressive fragment of the Silq programming language to our IR and circuit generation from the IR. Our experimental evaluation demonstrates that we can handle programs beyond the capabilities of existing uncomputation approaches, while being competitive on the benchmarks they can handle. More broadly, we show that it is possible to benefit from the greater expressivity and safety offered by high-level quantum languages without sacrificing efficiency.

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

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

Unifying Static and Dynamic Intermediate Languages for Accelerator Generators

Compilers for accelerator design languages (ADLs) translate high-level languages into application-specific hardware. ADL compilers rely on a hardware control interface to compose hardware units. There are two choices: static control, which relies on cycle-level timing; or dynamic control, which uses explicit signalling to avoid depending on timing details. Static control is efficient but brittle; dynamic control incurs hardware costs to support compositional reasoning. Piezo is an ADL compiler that unifies static and dynamic control in a single intermediate language (IL). Its key insight is that the IL’s static fragment is a refinement of its dynamic fragment: static code admits a subset of the run-time behaviors of the dynamic equivalent. Piezo can optimize code by combining facts from static and dynamic submodules, and it opportunistically converts code from dynamic to static control styles. We implement Piezo as an extension to an existing dynamic ADL compiler, Calyx. We use Piezo to implement a frontend for an existing ADL, a systolic array generator, and a packet-scheduling hardware generator to demonstrate its optimizations and the static–dynamic interactions it enables.

When Your Infrastructure Is a Buggy Program: Understanding Faults in Infrastructure as Code Ecosystems

Modern applications have become increasingly complex and their manual installation and configuration is no longer practical. Instead, IT organizations heavily rely on Infrastructure as Code (IaC) technologies, to automate the provisioning, configuration, and maintenance of computing infrastructures and systems. IaC systems typically offer declarative, domain-specific languages (DSLs) that allow system administrators and developers to write high-level programs that specify the desired state of their infrastructure in a reliable, predictable, and documented fashion. Just like traditional programs, IaC software is not immune to faults, with issues ranging from deployment failures to critical misconfigurations that often impact production systems used by millions of end users. Surprisingly, despite its crucial role in global infrastructure management, the tooling and techniques for ensuring IaC reliability still have room for improvement. In this work, we conduct a comprehensive analysis of 360 bugs identified in IaC software within prominent IaC ecosystems including Ansible, Puppet, and Chef. Our work is the first in-depth exploration of bug characteristics in these widely-used IaC environments. Through our analysis we aim to understand: (1) how these bugs manifest, (2) their underlying root causes, (3) their reproduction requirements in terms of system state (e.g., operating system versions) or input characteristics, and (4) how these bugs are fixed. Based on our findings, we evaluate the state-of-the-art techniques for IaC reliability, identify their limitations, and provide a set of recommendations for future research. We believe that our study helps researchers to (1) better understand the complexity and peculiarities of IaC software, and (2) develop advanced tooling for more reliable and robust system configurations.

CONTENTS OF TRAINING IN CONSTRUCTING CONTROLLED QUANTUM GATES

The article makes a selection and subsequent structuring of the content of training in the construction of controlled quantum gates using twelve decompositions of single-qubit quantum gates (Z-Y, Z-X, X-Y, Y-Z, X-Z, Y-X; Z-Y-X, Z-X-Y, X-Y-Z, X-Z-Y, Y-X-Z, Y-Z-X) used in the process of teaching the section “Quantum Computing and Programming in the QCL Language” of the training course “Applied Programming in High-Level Languages” to students of the Institute of Information Technology and Technological Education (3rd year, Herzen State Pedagogical University of Russia).

Specifying and Verifying Information Flow Control in SELinux Configurations

Security Enhanced Linux (SELinux) is a security architecture for Linux implementing Mandatory Access Control. It has been used in numerous security-critical contexts ranging from servers to mobile devices. However, its application is challenging as SELinux security policies are difficult to write, understand, and maintain. Recently, the intermediate language CIL was introduced to foster the development of high-level policy languages and to write structured configurations. Despite CIL’s high level features, CIL configurations are hard to understand as different constructs interact in non-trivial ways. Moreover, there is no mechanism to ensure that a given configuration obeys desired information flow policies. To remedy this, we enrich CIL with a formal semantics, and we propose IFCIL, a backward compatible extension of CIL for specifying fine-grained information flow requirements. Using IFCIL, administrators can express confidentiality, integrity, and non-interference properties. We also provide a tool to statically verify these requirements and we experimentally assess it on ten real-world policies.

Exploring Python: A Comprehensive Guide for Data Science, Machine Learning, and IoT

Python is a versatile, high-level programming language that has gained immense popularity in various domains, especially in data science, machine learning, and the Internet of Things (IoT). Originally created by Guido van Rossum, Python's simplicity and extensive libraries make it an ideal choice for both beginners and experienced programmers. This paper aims to provide an overview of Python's application in these fields, highlighting essential tools and libraries while showcasing practical examples. By delving into Python's features and capabilities, we aim to demonstrate its pivotal role in advancing technology and research.

An exploratory study on the usage of quantum programming languages

As in the classical computing realm, quantum programming languages in quantum computing allow one to instruct a quantum computer to perform certain tasks. In the last 25 years, many imperative, functional, and multi-paradigm quantum programming languages with different features and goals have been developed. However, to the best of our knowledge, no study has investigated who uses quantum languages, how practitioners learn a quantum language, how experience are practitioners with quantum languages, what is the most used quantum languages, in which context practitioners use quantum languages, what are the challenges faced by quantum practitioners while using quantum languages, are program written with quantum languages tested, and what are quantum practitioners' perspectives on the variety of quantum languages and the potential need for new languages. In this paper, we first conduct a systematic survey to find and collect all quantum languages proposed in the literature and/or by organizations. Secondly, we identify and describe 37 quantum languages. Thirdly, we survey 251 quantum practitioners to answer several research questions about their quantum language usage. Fourthly, we conclude that (i) 58.2% of all practitioners are 25–44 years old, 63.0% have a master's or doctoral degree, and 86.2% have more than five years of experience using classical languages. (ii) 60.6% of practitioners learn quantum languages from the official documentation. (iii) Only 16.3% of practitioners have more than five years of experience with quantum languages. (iv) Qiskit (Python) is the most used quantum language, followed by Cirq (Python) and QDK (Q#). (v) 42.8% use quantum languages for research. (vi) Lack of documentation and usage examples are practitioners' most challenging issues. Practitioners prefer open-source quantum languages with an easy-to-learn syntax (e.g., based on an existing classical language), available documentation and examples, and an active community. (vii) 76.4% of all participants test their quantum programs, and 42.6% test them automatically. (viii) A standard quantum language, perhaps high-level language, for quantum computation could accelerate the development of quantum programs. Finally, we present a set of suggestions for developers and researchers on the development of new quantum languages or enhancement of existing ones.

Domain Specific Abstractions for the Development of Fast-by-Construction Dataflow Codes on FPGAs

FPGAs are popular in many fields but have yet to gain wide acceptance for accelerating HPC codes. A major cause is that whilst the growth of High-Level Synthesis (HLS), enabling the use of C or C++, has increased accessibility, without widespread algorithmic changes these tools only provide correct-by-construction rather than fast-by-construction programming. The fundamental issue is that HLS presents a Von Neumann-based execution model that is poorly suited to FPGAs, resulting in a significant disconnect between HLS’s language semantics and how experienced FPGA programmers structure dataflow algorithms to exploit hardware. We have developed the high-level language Lucent which builds on principles previously developed for programming general-purpose dataflow architectures. Using Lucent as a vehicle, in this paper we explore appropriate abstractions for developing application-specific dataflow machines on reconfigurable architectures. The result is an approach enabling fast-by-construction programming for FPGAs, delivering competitive performance against hand-optimised HLS codes whilst significantly enhancing programmer productivity.

The implementation of STE(A)M education through Scratch projects

Abstract The present research is motivated by the necessity of introducing modern methodologies corresponding to the study’s content into the educational process. The work aims to use Scratch projects for the organization of students’ educational activities, as well as for their creative self-realization. Authors realize STE(A)M-approach in the educational activity by facilities of Scratch-projects. The high-level block-based visual programming language could be an auxiliary technology for a teacher and an independent developing tool for students. The research revealed the main themes that became the basis for the development of the author’s course “Creative Self-Fulfilment in Scratch”. This contributes to the development of students’ creativity. The content of the course is extended with projects in algebra, geometry, physics and musical culture. Each of these projects demonstrates the unity of technology and creativity.