High-level Language Research Articles

CRUD Operation On WordPress Custom Post Type (CPT) From C# Over REST API

Purpose: WordPress is a popular content management system. Around 45% of the internet's websites are powered by WordPress. Its main feature is posts. The contents are stored as posts. WordPress uses a database to store posts and configurations. Its REST API interface is robust and feature-rich. We can efficiently save the data from external environments into the database over the REST API as a post. However, standard post types provide enormous amounts of data. Low-speed systems and real-time processing can create a bottleneck. The data flow can be optimized using custom post type (CPT). Here, we describe how to create a custom field using available plugins. We make a REST API client using C# language. From the client application, we execute CRUD operation. The complete project code is freely available on GitHub. Design/Methodology/Approach: There are several ways to test WordPress code. Instead of testing in live WordPress website, the best way is to work in local website. It is not harmful anymore because code is deploying in local only. to install WordPress locally, we use the “LOCAL” application. Using this approach, we can eliminate the server hiring cost for the experiment. after that inside the local application, we install WordPress Website. Then create Custom route to navigate our code. For client side, we make a client application in C# with GUI for better operation. Findings/Result: We ran the project for a long time with practical examples without any issues. This architecture can be used to store IoT data inside the cloud. For the POST data is stored in the “wp_Posts” table where the additional CPT field is kept inside the “wp_postmeta” table, a couple of extra transactions that might cause data flow delays. Originality/Value: WordPress database generally stores external data using post type. Here, we are using an approach beyond general usage. Even C# is not used for this purpose. The other more high-level languages are available to do our task effectively. However, the researchers from the dot net framework domain who want to keep data in the WordPress database as a custom post type can get this as a practical reference. Paper Type: Experimental-based Research.

CNL2ASP: Converting Controlled Natural Language Sentences into ASP

Abstract Answer set programming (ASP) is a popular declarative programming language for solving hard combinatorial problems. Although ASP has gained widespread acceptance in academic and industrial contexts, there are certain user groups who may find it more advantageous to employ a higher-level language that closely resembles natural language when specifying ASP programs. In this paper, we propose a novel tool, called CNL2ASP, for translating English sentences expressed in a controlled natural language (CNL) form into ASP. In particular, we first provide a definition of the type of sentences allowed by our CNL and their translation as ASP rules and then exemplify the usage of the CNL for the specification of both synthetic and real-world combinatorial problems. Finally, we report the results of an experimental analysis conducted on the real-world problems to compare the performance of automatically generated encodings with the ones written by ASP practitioners, showing that our tool can obtain satisfactory performance on these benchmarks.

GAHLS: an optimized graph analytics based high level synthesis framework

The urgent need for low latency, high-compute and low power on-board intelligence in autonomous systems, cyber-physical systems, robotics, edge computing, evolvable computing, and complex data science calls for determining the optimal amount and type of specialized hardware together with reconfigurability capabilities. With these goals in mind, we propose a novel comprehensive graph analytics based high level synthesis (GAHLS) framework that efficiently analyzes complex high level programs through a combined compiler-based approach and graph theoretic optimization and synthesizes them into message passing domain-specific accelerators. This GAHLS framework first constructs a compiler-assisted dependency graph (CaDG) from low level virtual machine (LLVM) intermediate representation (IR) of high level programs and converts it into a hardware friendly description representation. Next, the GAHLS framework performs a memory design space exploration while account for the identified computational properties from the CaDG and optimizing the system performance for higher bandwidth. The GAHLS framework also performs a robust optimization to identify the CaDG subgraphs with similar computational structures and aggregate them into intelligent processing clusters in order to optimize the usage of underlying hardware resources. Finally, the GAHLS framework synthesizes this compressed specialized CaDG into processing elements while optimizing the system performance and area metrics. Evaluations of the GAHLS framework on several real-life applications (e.g., deep learning, brain machine interfaces) demonstrate that it provides 14.27× performance improvements compared to state-of-the-art approaches such as LegUp 6.2.

COMPARAÇÃO DE DESEMPENHO DO ALGORITMO DE DEUTSCH-JOZSA NAS LINGUAGENS QUÂNTICAS SILQ E QASM

Due to the importance given to information in the last few decades, a performance and processing advantage of information becomes relevant, something that can be found through quantum computing. The Deutsch-Jozsa Algorithm is the first example of a quantum algorithm that offers an exponential advantage against classical algorithms, whether in a local environment or through cloud simulators. Seeking to explore the advantages of quantum computation, the Deutsch-Jozsa Algorithm was implemented in two quantum programming languages, namely the high level language Silq, focused on the execution of the algorithm on a local environment through VSCode, which offers a cleaner and friendly sintaxe as well as quantum uncomputation, and also in OpenQASM, a low level language meant to interact with quantum circuits, used to better visualizethe Deutsch-Jozsa Algorithm. This paper aims to make the differences between high and low-level quantum languages clear, as well as incentivize the change to a new paradigm

Cash Rules Everything Around Me: The Expansion of NCAA Name, Image, and Likeness Policy Among the States

Name, image, and likeness (NIL) policies have expanded rapidly in the United States in the past three years. Since the state of California passed a law allowing college student athletes to profit off their NIL, 41 states have either adopted or proposed similar legislation. Politics, the presence of high-level football programs, revenue, and geography have shaped this rapid expansion that has significant effects on higher education administration. Using survival analysis, this article explains the expansion of NIL policy and finds the key factors leading to its rapid diffusion. We find that the significant drivers of NIL adoption include high level NCAA football and the political motives of the state adopting that contributes to civic pride. The major findings suggest that this focus on football and its connection to civic pride and resulting political decisions creates opportunities and challenges for higher education.

Mathematical model for investigation of alkylbenzenes sulfonation

The relevance. Lack of experimental data that allow developing a scientifically based method for calculating and designing film-type reactors, which are also used to produce alkylbenzenesulfonic acids. These acids, in their turn, are currently the main components of synthetic detergents. The issue of increasing reactor equipment efficiency can be most effectively solved using mathematical models built on a physical and chemical basis. The aim. Development of a mathematical model of alkylbenzenes sulfonation, taking into account a substance mass transfer from a gas phase to a liquid phase. Software implementation of the developed model, as well as the use of the developed mathematical model for studying the influence of the process parameters on its efficiency. Object. Alkylbenzenes sulfonation with sulfuric anhydride in a multitube film reactor. Methods. Mathematical modeling is used to perform all computational operations, a modern high-level general-purpose programming language with automatic memory management is used. The quantum-chemical methods for determining thermodynamic parameters of chemical reactions were used. Results. The paper considers the principles of constructing a mathematical model of sulfonation. The authors have developed the calculation program in the Python programming language and assessed the accuracy of description of a real process and the influence of the system technological parameters on a product yield and quality, taking into account a substance interfacial transfer. The system of practical recommendations for improving the alkylbenzenes sulfonation resource efficiency was developed. The mathematical model adequately describes the process. The calculated data are compared with the real data from the operating unit for alkylbenzenes sulfonation with sulfuric anhydride.

CHESSIoT: A model-driven approach for engineering multi-layered IoT systems

Context:The current technology revolution, which places the highest value on people’s welfare, is frequently seen as being mainly supported by Internet of Things (IoT) technologies. IoT is regarded as a powerful multi-layered network of systems that integrates several heterogeneous, independently networked (sub-)systems working together to achieve a shared purpose. Objective:In this article, we present CHESSIoT, a model-driven engineering environment that integrates high-level visual design languages, software development, safety analysis, and deployment approaches for engineering multi-layered IoT systems. With CHESSIoT, users may conduct different engineering tasks on system and software models under development to enable earlier decision-making and take prospective measures, all supported by a unique environment. Methodology:This is achieved through multi-staged designs, most notably the physical, functional, and deployment architectures. The physical model specification is used to perform both qualitative and quantitative safety analysis by employing logical Fault-Trees models (FTs). The functional model specifies the system’s functional behavior and is later used to generate platform-specific code that can be deployed on low-level IoT device nodes. Additionally, the framework supports modeling the system’s deployment plan and run-time service provisioning, which would ultimately be transformed into deployment configuration artifacts ready for execution on remote servers. Results:To showcase the effectiveness of our proposed approach, as well as the capability of the supporting tool, a multi-layered Home Automation system (HAS) scenario has been developed covering all its design, development, analysis, and deployment aspects. Furthermore, we present the results from different evaluation mechanisms which include a comparative analysis and a qualitative assessment. The evaluation mechanisms target mainly completeness of CHESSIoT by addressing specific research questions.

The Study on the Spectral Analysis of Fiber Bragg Grating (FBG) as a Strain Sensor

Abstract: By adjusting the grating length and refractive index change, parameters of the Fibre Bragg grating which are the effective refractive index, Bragg wavelength, grating period, and strain-optic constant are provided and discussed, along with the characterization of the grating, including strain, Bragg wavelength shift, spectral response, and bandwidth. The coupled mode equations form the basis for data analysis and acquisition. This research uses a high-level computer language, such as GNU Octave software, to simulate FBG spectral responses.

Equation-based and data-driven modeling: Open-source software current state and future directions

A review of current trends in scientific computing reveals a broad shift to open-source and higher-level programming languages such as Python and growing career opportunities over the next decade. Open-source modeling tools accelerate innovation in equation-based and data-driven applications. Significant resources have been deployed to develop data-driven tools (PyTorch, TensorFlow, Scikit-learn) from tech companies that rely on machine learning services to meet business needs while keeping the foundational tools open. Open-source equation-based tools such as Pyomo, CasADi, Gekko, and JuMP are also gaining momentum according to user community and development pace metrics. Integration of data-driven and principles-based tools is emerging. New compute hardware, productivity software, and training resources have the potential to radically accelerate progress. However, long-term support mechanisms are still necessary to sustain the momentum and maintenance of critical foundational packages.

Development of a Hardware-in-the-Loop Platform for the Validation of a Small-Scale Wind System Control Strategy

The use of renewable energies contributes to the goal of mitigating climate change by 2030. One of the fastest-growing renewable energy sources in recent years is wind power. Large wind generation systems have drawbacks that can be minimized using small wind systems and DC microgrids (DC-µGs). A wind system requires a control system to function correctly in different regions of its operating range. However, real-time analysis of a physical wind system may not be feasible. An alternative to counteract this disadvantage is using real-time hardware in the loop (HIL) simulation. This article describes the implementation of an HIL platform in an NI myRIO 1900 to evaluate the performance of control algorithms in a small wind system (SWS) that serves as a distributed generator for a DC-µG. In the case of an SWS, its implementation implies nonlinear behaviors and, therefore, nonlinear equations, and this paper shows a way to do it by distributing the computational work, using a high-level description language, and achieving good accuracy and latency with a student-oriented development kit. The platform reproduces, with an integration time of 10 µs, the response of the SWS composed of a 3.5 kW turbine with a fixed blade pitch angle and no gear transmission, a permanent magnet synchronous generator (PMSG), and a three-phase full-bridge AC/DC electronic power converter. The platform accuracy was validated by comparing its results against a software simulation. The compared variables were the PMSG currents in dq directions, the turbine’s angular speed, and the DC bus’s voltage. These comparisons showed mean absolute errors of 0.04 A, 1.9 A, 0.7 rad/s, and 9.5 V, respectively. The platform proved useful for validating the control algorithm, exhibiting the expected results in comparison with a lab-scale prototype using the same well-known control strategy. Using a well-known control strategy provides a solid reference to validate the platform.

Performance of Lambda Expressions in High Level Programming Languages

Functional programming is a programming paradigm that is becoming increasingly popular among software developers. This is due in part to the rise of distributed systems and the need for more robust and scalable code. In the paper is presented an overview of the syntax and capabilities of Lambda expressions in three programming languages – C#, Java and Python. Performance of programming language constructions is an important research task. Some popular topics for investigation are comparison of programming languages efficiency in fields like bioinformatics or classification of Lambda expression usage and their productiveness. In the current study the performance of Lambda expressions is tested with three specific test cases and the results are compared to alternative technologies that could be used to solve similar problems. The results shows that speed performance of C# is the best from the compared languages and that List Comprehensions is the optimal method for collection filtering in Python.

End-to-end programmable computing systems

Recent technological advances have contributed to the rapid increase in algorithmic complexity of applications, ranging from signal processing to autonomous systems. To control this complexity and endow heterogeneous computing systems with autonomous programming and optimization capabilities, we propose a unified, end-to-end, programmable graph representation learning (PGL) framework that mines the complexity of high-level programs down to low-level virtual machine intermediate representation, extracts specific computational patterns, and predicts which code segments run best on a core in heterogeneous hardware. PGL extracts multifractal features from code graphs and exploits graph representation learning strategies for automatic parallelization and correct assignment to heterogeneous processors. The comprehensive evaluation of PGL on existing and emerging complex software demonstrates a 6.42x and 2.02x speedup compared to thread-based execution and state-of-the-art techniques, respectively. Our PGL framework leads to higher processing efficiency, which is crucial for future AI and high-performance computing applications such as autonomous vehicles and machine vision.

Automated translation and accelerated solving of differential equations on multiple GPU platforms

We demonstrate a high-performance vendor-agnostic method for massively parallel solving of ensembles of ordinary differential equations (ODEs) and stochastic differential equations (SDEs) on GPUs. The method is integrated with a widely used differential equation solver library in a high-level language (Julia’s DifferentialEquations.jl) and enables GPU acceleration without requiring code changes by the user. Our approach achieves state-of-the-art performance compared to hand-optimized CUDA-C++ kernels while performing 20–100× faster than the vectorizing map (vmap) approach implemented in JAX and PyTorch. Performance evaluation on NVIDIA, AMD, Intel, and Apple GPUs demonstrates performance portability and vendor-agnosticism. We show composability with MPI to enable distributed multi-GPU workflows. The implemented solvers are fully featured – supporting event handling, automatic differentiation, and incorporation of datasets via the GPU’s texture memory – allowing scientists to take advantage of GPU acceleration on all major current architectures without changing their model code and without loss of performance. We distribute the software as an open-source library, DiffEqGPU.jl.

High-Performance Lightweight HLS Generator Module of Normally Distributed Random Numbers in FPGAs

This paper focuses on the problem of high-performance streaming random number generation in the range of uniform and normal distributions in FPGAs. Our work is focused on lightweight implementation, suitable for a wide range of FPGAs. First, we review the existing types of random generation modules. Next, in this paper we present the construction of the designed generator. We divide it into two sections: Stream Uniform Numbers Generator Implementation and Cumulative Distribution-Based Stream Gaussian Generator. Each design step was verified in the scope of the quality of the output data, especially regarding the produced distributions. The results obtained are compared with existing solutions. We mainly consider resource utilization and throughput. We also add our quality factor, which is an effective utilization of FPGAs. Despite quality results, our modules were implemented using a high-level synthesis language (C/C++), contrary to typical hardware description level (HDL) approaches. It provides the opportunity to implement the proposed algorithms on CPUs. It was tested with positive results, thus highlighting the versatility of the solution that is unavailable in terms of HDL implementations. Our designed generators were confirmed to stand out for their satisfactory performance while occupying low logical resources.

Translation certification for smart contracts

Compiler correctness is an old problem, but with the emergence of smart contracts on blockchains that problem presents itself in a new light. Smart contracts are self-contained pieces of software that control (valuable) assets in an adversarial environment; once committed to the blockchain, these smart contracts cannot be modified. Smart contracts are typically developed in a high-level contract language and compiled to low-level virtual machine code before being committed to the blockchain. For a smart contract user to trust a given piece of low-level code on the blockchain, they must convince themselves that (a) they are in possession of the matching source code and (b) that the compiler has correctly translated the source code to the given low-level code.Classic approaches to compiler correctness tackle the second point. We argue that translation certification also squarely addresses the first. We describe the proof architecture of a translation certification framework and demonstrate how we can model the compilation pipeline as a sequence of translation relations. We give a detailed account of such relations for most passes of the Plutus Tx compiler, which we formalised in Coq. This approach facilitates a modular verification methodology and is robust in the face of an evolving compiler implementation.

MR-AT: Map Reduce based Apriori Technique for Sequential Pattern Mining using Big Data in Hadoop

One of the most well-known and widely implemented data mining methods is Apriori algorithm which is responsible for mining frequent item sets. The effectiveness of the Apriori algorithm has been improved by a number of algorithms that have been introduced on both parallel and distributed platforms in recent years. They are distinct from one another on account of the method of load balancing, memory system, method of data degradation, and data layout that was utilised in their implementation. The majority of the issues that arise with distributed frameworks are associated with the operating costs of handling distributed systems and the absence of high-level parallel programming languages. In addition, when using grid computing, there is constantly a possibility that a node will fail, which will result in the task being re-executed multiple times. The MapReduce approach that was developed by Google can be used to solve these kinds of issues. MapReduce is a programming model that is applied to large-scale distributed processing of data on large clusters of commodity computers. It is effective, scalable, and easy to use. MapReduce is also utilised in cloud computing. This research paper presents an enhanced version of the Apriori algorithm, which is referred to as Improved Parallel and Distributed Apriori (IPDA). It is based on the scalable environment referred as Hadoop MapReduce, which was used to analyse Big Data. Through the generation of split-frequent data regionally and the early elimination of unusual data, the proposed work has its primary objective to reduce the enormous demands placed on available resources as well as the reduction of the overhead communication that occurs whenever frequent data are retrieved. The paper presents the results of tests, which demonstrate that the IPDA performs better than traditional apriori and parallel and distributed apriori in terms of the amount of time required, the number of rules created, and the various minimum support values.

Language support for verifying reconfigurable interacting systems

Reconfigurable interacting systems consist of a set of autonomous agents, with integrated interaction capabilities that feature opportunistic interaction. Agents seemingly reconfigure their interaction interfaces by forming collectives and interact based on mutual interests. Finding ways to design and analyse the behaviour of these systems is a vigorously pursued research goal. In this article, we provide a modelling and analysis environment for the design of such system. Our tool offers simulation and verification to facilitate native reasoning about the domain concepts of such systems. We present our tool named R-CHECK (please find the associated toolkit repository here: https://github.com/dsynma/recipe). R-CHECK supports a high-level input language with matching enumerative and symbolic semantics and provides modelling convenience for features such as reconfiguration, coalition formation, and self-organisation. For analysis, users can simulate the designed system and explore arising traces. Our included model checker permits reasoning about interaction protocols and joint missions.

An Architecture for a Tri-Programming Model-Based Parallel Hybrid Testing Tool

As the development of high-performance computing (HPC) is growing, exascale computing is on the horizon. Therefore, it is imperative to develop parallel systems, such as graphics processing units (GPUs) and programming models, that can effectively utilise the powerful processing resources of exascale computing. A tri-level programming model comprising message passing interface (MPI), compute unified device architecture (CUDA), and open multi-processing (OpenMP) models may significantly enhance the parallelism, performance, productivity, and programmability of the heterogeneous architecture. However, the use of multiple programming models often leads to unexpected errors and behaviours during run-time. It is also difficult to detect such errors in high-level parallel programming languages. Therefore, this present study proposes a parallel hybrid testing tool that employs both static and dynamic testing techniques to address this issue. The proposed tool was designed to identify the run-time errors of C++ and MPI + OpenMP + CUDA systems by analysing the source code during run-time, thereby optimising the testing process and ensuring comprehensive error detection. The proposed tool was able to identify and categorise the run-time errors of tri-level programming models. This highlights the need for a parallel testing tool that is specifically designed for tri-level MPI + OpenMP + CUDA programming models. As contemporary parallel testing tools cannot, at present, be used to test software applications produced using tri-level MPI + OpenMP + CUDA programming models, this present study proposes the architecture of a parallel testing tool to detect run-time errors in tri-level MPI + OpenMP + CUDA programming models.

OSWireless: Hiding specification complexity for zero-touch software-defined wireless networks

In the current practice of wireless engineering, to optimize wireless networks engineers usually need to grapple simultaneously with network modeling, algorithm and protocol design as well as their implementation on distributed edge nodes. This process is tedious and error prone. In this article we attempt to address this challenge by designing OSWireless, a new control plane for optimizing software-defined wireless networks. At the core of OSWireless is the virtualization of four control plane functionalities, including intent, mathematical, algorithmic and forwarding specifications, and then provide them as a service to network engineers. To this end, we design two new subplanes for the control plane: Wireless Network Abstraction Specification (WiNAS) Subplane and Optimization-as-a-Service (OaaS) Subplane. The former converts intent specifications defined using high-level Application Programming Interfaces (APIs) to the corresponding mathematical specifications, and the latter generates automatically operational (possibly distributed) algorithmic specifications. We prototype OSWireless and deploy it over NeXT, a newly developed software-defined experimentation testbed, and showcase the automated control program generation capability of OSWireless and the optimality of the resulting programs considering a variety of network control problems. We further test the applicability of OSWireless on UBSim, a newly-developed Python based simulator for integrated aerial-ground networks, considering location optimization of mobile nodes as an example. Through developing OSWireless, we hope to accelerate research towards future zero-touch software-defined wireless networks with reduced management complexity.

Оценка точности цифровой обработки сильно зашумленных сигналов с помощью эвристических алгоритмов

Heuristic algorithms are often used as an alternative when solving problems of high computational complexity or lacking an exact solution, allowing to quickly obtain the desired result. Usually, they do not have a strict mathematical justification, but their application is justified in terms of practicality. Formally, algorithms that use approximate methods can be classified as heuristic. However, when applying them, the problem of determinism lack is often arises, which does not always allow one to evaluate the solution obtained accuracy. The paper considers a methodical approach to assessing the accuracy of heuristic algorithms designed to determine the useful signal shape and parameters on the strong noise component background. It is based on the method of analogy and consists in modeling an artificial signal with given parameters and a background noise interference similar in its characteristics to additive white Gaussian noise. In this case, the noise component is formed by software using a pseudo-random number sequence generator. Such generators are included in the packages of almost all high-level programming languages built-in functions. A comparative analysis of the real and artificial noise characteristics is presented, that shown the problem solving by numerical modeling possibility. The results of accuracy estimation in determining the artificial signal parameters, that is separated from the noise component using piecewise linear approximation and averaging heuristic algorithms, are obtained. The problem of empirical data smoothing with the discrete signal equivalent replacement by a quadratic functions whose parameters provide a piecewise parabolic approximation its shape is also considered. This procedure eliminates the residual signal bounce that inevitably occurs as a result of linearization and allows further recording at any sampling rate. Thus, the proposed approach allows us to quantify the accuracy of heuristic algorithms used in determining the expected signal parameters.