Program Graph Research Articles

APPLICATION OF DYNAMIC PROGRAMMING IN DETERMINING THE SHORTEST ROUTE PT JNE USING BACKWARD RECURSIVE EQUATION

Technological progress speeds up human movement, the distribution of goods, and service provision. PT JNE, a prominent firm in Indonesia, concentrates on delivering goods swiftly and with comprehensive services.. On the other hand, problems include daily changes in delivery, delays, less than optimal routes, and expensive gasoline. The shortest ideal route for the transportation of products is found using dynamic programming and a backward recursive equation technique in this study. The Medan Belawan District as well as the JNE Medan Representative Office provided the data that was used. The findings show that a route of a → f → d → c → g → b → e → h → a is the ideal total distance for goods delivery using a dynamic programming graph is 12,2 km, with an average courier covering 16,5 km. Based on data analysis, this shows a 26% increase in efficiency over the current routes. The layout of the routes makes it easier for couriers to choose the fastest route.

MODERN METHODS OF ANALYSIS AND IMPROVEMENT OF PROGRAMS BASED ON GRAPH MODELS

The approach of automated computer program code plagiarism detection and enhancement based on reconstruct able CDFG graph models was proposed. It is suggested to use CDFG graph mode for analyze the computer program texts. The program plagiarism detection and enhancement can be done based on the similar program graph model analyses and different graph operation from the graph theory. The usage of CDFG-graph model allows to take in account both program data and control paths. This can help improve programming ethics and ensure integrity in the software development process.

Intelligent code search aids edge software development

The growth of multimedia applications poses new challenges to software facilities in edge computing. Developers must effectively develop edge computing software to accommodate the rapid expansion of multimedia applications. Code search has become a prevalent practice to enhance the efficiency of the construction of edge software infrastructure. Researchers have proposed lots of approaches for code search, and employed deep learning technology to extract features from program representations, such as token, AST, graphs, method name, and API. Nevertheless, two prominent issues remain: 1) there are only a few studies on the effective use of graph representation for code search (especially in Java language), and 2) there is a lack of empirical study on the contributions of different program representations. To address these issues, we conduct an empirical study to explore program representations, especially program graphs. To the best of our knowledge, this is the first attempt to conduct code search with mixed graphs representation for Java language, containing the control flow graph and the program dependence graph. We also present a hybrid approach to capture and fuse the features of a program with representations of Token, AST, and Mixed Graphs (TAMG). The results of our experiment show that our approach possesses the best ability (R@1 with 37% and R@10 with 67.1%). Our graph representation exhibits a positive effect, and the token and AST also have a significant contribution to the code search. Our findings can aid developers in efficiently searching for the desired code while constructing the software infrastructure for edge computing, which is crucial for the rapid expansion of multimedia applications.

Interpreting Tangled Program Graphs Under Partially Observable Dota 2 Invoker Tasks

Interpretable learning agents directly construct models that provide insight into the relationships learnt. Moreover, to date, there has been a lot of emphasis on interpreting reactive models developed for supervised learning tasks. In this work, we consider the case of models developed to address a suite of 6 partially observable tasks defined in the Dota 2 Online Battle Arena game engine. This means that learning agents need to make decisions based on the previous state as developed by the learning agent's memory; in addition to a 310-dimensional state vector provided by the game engine. Interpretability is addressed by adopting the tangled program graph approach to developing learning agents. Thus, decision-making is explicitly divide-and-conquer, with different parts of the resulting graph visited depending on the task context. We demonstrate that programs comprising the tangled program graph approach self-organize such that: (1) small subsets of task features are identified to define conditions under which index memory is written, and; (2) the subset of programs responsible for defining actions typically query indexed memory rather than task features. Particular preferences emerge for different tasks; thus, the blocking (or evasion) tasks result in a preference for specific actions whereas more open-ended tasks assume policies based on combinations of behaviours. In short, the ability to evolve the topology of the learning agent provides insights into how the policies are being constructed for addressing partially observable tasks.

Grapho-plastic program to improve fine motor skills

The development of fine motor skills commences in infancy and progresses as the child gains muscle control and coordination throughout their growth. These skills are essential for a wide range of tasks required throughout life. This study focuses on enhancing fine motor skills in 4-year-old children through a specialized plastic graph program. Thirty children participated, and their progress was assessed using an observation sheet. Adequate fine motor development is crucial not only for academic success and daily activities but also for cognitive and social growth. The results indicate significant progress in fine motor skills development, along with enthusiastic participation in group activities and subsequent improvement in manual dexterity.

DAG-Based Formal Modeling of Spark Applications with MSVL

Apache Spark is a high-speed computing engine for processing massive data. With its widespread adoption, there is a growing need to analyze its correctness and temporal properties. However, there is scarce research focused on the verification of temporal properties in Spark programs. To address this gap, we employ the code-level runtime verification tool UMC4M based on the Modeling, Simulation, and Verification Language (MSVL). To this end, a Spark program S has to be translated into an MSVL program M, and the negation of the property P specified by a Propositional Projection Temporal Logic (PPTL) formula that needs to be verified is also translated to an MSVL program M1; then, a new MSVL program “M and M1” can be compiled and executed. Whether program S violates the property P is determined by the existence of an acceptable execution of “M and M1”. Thus, the key issue lies in how to formalize model Spark programs using MSVL programs. We previously proposed a solution to this problem—using the MSVL functions to perform Resilient Distributed Datasets (RDD) operations and converting the Spark program into an MSVL program based on the Directed Acyclic Graph (DAG) of the Spark program. However, we only proposed this idea. Building upon this foundation, we implement the conversion from RDD operations to MSVL functions and propose, as well as implement, the rules for translating Spark programs to MSVL programs based on DAG. We confirm the feasibility of this approach and provide a viable method for verifying the temporal properties of Spark programs. Additionally, an automatic translation tool, S2M, is developed. Finally, a case study is presented to demonstrate this conversion process.

Exploiting the Sparseness of Control-Flow and Call Graphs for Efficient and On-Demand Algebraic Program Analysis

Algebraic Program Analysis (APA) is a ubiquitous framework that has been employed as a unifying model for various problems in data-flow analysis, termination analysis, invariant generation, predicate abstraction and a wide variety of other standard static analysis tasks. APA models program summaries as elements of a regular algebra . Suppose that a summary in A is assigned to every transition of the program and that we aim to compute the effect of running the program starting at line s and ending at line t . APA first computes a regular expression capturing all program paths of interest. In case of intraprocedural analysis, models all paths from s to t , whereas in the interprocedural case it models all interprocedurally-valid paths, i.e. ‍paths that go back to the right caller function when a callee returns. This regular expression is then interpreted over the algebra to obtain the desired result. Suppose the program has n lines of code and each evaluation of an operation in the regular algebra takes O ( k ) time. It is well-known that a single APA query, or a set of queries with the same starting point s , can be answered in O ( n · α( n ) · k ), where α is the inverse Ackermann function. In this work, we consider an on-demand setting for APA: the program is given in the input and can be preprocessed. The analysis has to then answer a large number of on-line queries, each providing a pair ( s , t ) of program lines which are the start and end point of the query, respectively. The goal is to avoid the significant cost of running a fresh APA instance for each query. Our main contribution is a series of algorithms that, after a lightweight preprocessing of O ( n · lg n · k ), answer each query in O ( k ) time. In other words, our preprocessing has almost the same asymptotic complexity as a single APA query, except for a sub-logarithmic factor, and then every future query is answered instantly, i.e. ‍by a constant number of operations in the algebra. We achieve this remarkable speedup by relying on certain structural sparsity properties of control-flow and call graphs (CFGs and CGs). Specifically, we exploit the fact that control-flow graphs of real-world programs have a tree-like structure and bounded treewidth and nesting depth and that their call graphs have small treedepth in comparison to the size of the program. Finally, we provide experimental results demonstrating the effectiveness and efficiency of our approach and showing that it beats the runtime of classical APA by several orders of magnitude.

MiniGraph: Querying Big Graphs with a Single Machine

This paper presents MiniGraph, an out-of-core system for querying big graphs with a single machine. As opposed to previous single-machine graph systems, MiniGraph proposes a pipelined architecture to overlap I/O and CPU operations, and improves multi-core parallelism. It also introduces a hybrid model to support both vertex-centric and graph-centric parallel computations, to simplify parallel graph programming, speed up beyond-neighborhood computations, and parallelize computations within each subgraph. The model induces a two-level parallel execution model to explore both inter-subgraph and intra-subgraph parallelism. Moreover, MiniGraph develops new optimization techniques under its architecture. Using real-life graphs of different types, we show that MiniGraph is up to 76.1x faster than prior out-of-core systems, and performs better than some multi-machine systems that use up to 12 machines.

Flowboard: How Seamless, Live, Flow-Based Programming Impacts Learning to Code for Embedded Electronics

Toolkits like the Arduino system have brought embedded programming to STEM education. However, learning embedded programming is still hard, requiring an understanding of coding, electronics, and how both sides interact. To investigate the opportunities of using a different programming paradigm than the imperative approach to learning embedded coding, we developed Flowboard . Students code in a visual iPad editor using flow-based programming , which is conceptually closer to circuit diagrams than imperative code. Two breadboards with I/O pins mirrored on the iPad connect electronics and program graph more seamlessly than existing IDEs. Program changes take effect immediately. This liveness reflects circuit behavior better than edit-compile-run loops. A first study confirmed that students can solve basic embedded programming tasks with Flowboard while highlighting important differences to a typical imperative IDE, Ardublock. A second, in-depth study provided qualitative insights into Flowboard’s impact on students’ conceptual models of electronics and embedded programming and exploring.

In Search of the Hyperglycemic Threshold Required to Induce Growth Hormone (GH) Suppression.

Introduction According to the 2014 Endocrine Society Clinical Practice Guideline on acromegaly, the confirmation of acromegaly diagnosis is established by finding a lack of suppression of growth hormone (GH) to < 1 ug/L following documented hyperglycemia during an oral glucose tolerance test. However, in this setting, the concept of hyperglycemia has never been clearly defined. Objective This study aimed to define the hyperglycemic threshold required to induce GH suppression. Methods We retrieved the glycemia profile of 44 individuals after a standard 2-h 75g oral glucose tolerance test prescribed to assess GH suppression and performed a comprehensive analysis of two subgroups of individuals (28 reaching GH suppression and 16 in whom GH suppression was not observed). All of the data were analyzed with the program Graph Pad Prism. Differences between means were assessed by Student's unpaired t-test or Mann-Whitney U test as deemed appropriate. Fisher's exact test was used for categorical variables. Results Individuals in G1 and G2 were different only for the median basal GH and median IGF-1. No significant differences in terms of the prevalence of diabetes and prediabetes were found. The glucose peak was achieved earlier in the group that reached GH suppression. The median of the highest glucose values of both subgroups was not different. A correlation between peak and baseline glucose value was found only among those in whom GH suppression was reached. Among these, the median glucose peak (P50) was 177 mg/dl, whereas the 75th percentile (P75) and 25th percentile (P25) were 199 mg/dl and 120 mg/dl, respectively. Conclusion Considering that 75% of those in whom GH suppression was observed after an oral glucose overload test reached blood glucose values above 120 mg/dl, we propose to use this value as the blood glucose threshold for inducing GH suppression. In light of our results, whenever GH suppression is not observed; and the highest glycemic value is below 120 mg/dl, it might be useful to repeat the test prior to any conclusion.

Time and Space Measures for a Complete Graph Computation Model

We present a computation model based on a subclass of GP 2 graph programs which can simulate any off-line Turing machine of space complexity O(s(n) log s(n)) in space O(s(n)). The simulation only requires a quadratic time overhead. Our model shares this property with Sch\"onhage's storage modification machines and Kolmogorov-Uspenskii machines. These machines use low-level pointer instructions whereas our GP 2-based model uses pattern-based transformation rules and high-level control constructs.

Towards Mechanised Proofs in Double-Pushout Graph Transformation

We formalise the basics of the double-pushout approach to graph transformation in the proof assistant Isabelle/HOL and provide associated machine-checked proofs. Specifically, we formalise graphs, graph morphisms and rules, and a definition of direct derivations based on deletion and gluing. We then formalise graph pushouts and prove with Isabelle's help that both deletions and gluings are pushouts. We also prove that pushouts are unique up to isomorphism. The formalisation comprises around 2000 lines of source text. Our motivation is to pave the way for rigorous, machine-checked proofs in the theory of the double-pushout approach, and to lay the foundations for verifying graph transformation systems and rule-based graph programs by interactive theorem proving.

A Foundation for Functional Graph Programs: The Graph Transformation Control Algebra (GTA)

Applications of graph transformation (GT) systems often require control structures that can be used to direct GT processes. Most existing GT tools follow a stateful computational model, where a single graph is repeatedly modified "in-place" when GT rules are applied. The implementation of control structures in such tools is not trivial. Common challenges include dealing with the non-determinism inherent to rule application and transactional constraints when executing compositions of GTs, in particular atomicity and isolation. The complexity of associated transaction mechanisms and rule application search algorithms (e.g., backtracking) complicates the definition of a formal foundation for these control structures. Compared to these stateful approaches, functional graph rewriting presents a simpler (stateless) computational model, which simplifies the definition of a formal basis for (functional) GT control structures. In this paper, we propose the "Graph Transformation control Algebra" (GTA) as such a foundation. The GTA has been used as the formal basis for implementing the control structures in the (functional) GT tool "GrapeVine".

CFL/Dyck Reachability

CFL/Dyck reachability is a simple graph-theoretic problem: given a CFL/Dyck language L over an alphabet Σ, a graph G = ( V , E ) of Σ-labeled edges, and two distinguished nodes s , t ∈ V , does there exist a path from s to t that spells out a word in L ? This simple notion of language-based graph reachability serves as the algorithmic formulation of a large number of problems in diverse domains, such as graph databases and program static analysis. This paper takes an algorithmic perspective on CFL/Dyck reachability, and overviews several recent advances concerning the decidability and complexity of the problem and some its close variants, as realized in the areas of automata theory and program verification.

Positive Dependency Graphs Revisited

AbstractTheory of stable models is the mathematical basis of answer set programming. Several results in that theory refer to the concept of the positive dependency graph of a logic program. We describe a modification of that concept and show that the new understanding of positive dependency makes it possible to strengthen some of these results.

Monitoring Systems Mediate Human Capital to Performance of Government Aided Primary Schools in Isingiro District, Uganda. “Using Med Graph program Approach”

Purpose: The purpose of this research was to establish whether the Monitoring systems mediate the relationship between human capital and performance of government aided primary schools in Isingiro District, Uganda.&#x0D; Methodology: A cross sectional research design and post-positivist paradigm were used to collect data from 118 government aided primary schools in Isingiro district, Uganda where 475 respondents participated in the study. The study used closed-ended questionnaires, interview guide and checklists. The schools to be included were selected using simple random sampling and were considered as unit of analysis while the respondents who included District officials, head teachers, teachers and school management committee (SMC) members formed the unit of enquiry, these were selected purposively based on the knowledge they had on the subject matter. Each school selected, provided the information from the respondents who in this case were the head teacher, two (2) teachers and a chairperson of school management committee member. The research was guided by the null hypothesis, Ho1: Monitoring systems do not mediate the relationship between human capital and performance of government aided primary schools in Isingiro District, Uganda.&#x0D; Findings: The findings of the study revealed that the relationship between human capital and performance of government aided primary schools is partially mediated by monitoring systems, hence rejecting the null hypothesis (Ho1) that there is no mediation. The results signified that monitoring systems partially mediates human capital and performance of government aided primary schools in Isingiro District, Uganda.&#x0D; The Unique Contribution to Theory and Practice: This study suggest to planners and managers of government aided primary schools that, since human capital is important for the improvement of primary school performance, it is advisable that the government should impose monitoring systems to oversee the programmes and activities taking place in government aided primary school which possibly caters for teachers’ productivity, school developments and hence improving its performance.

Multi-View Graph Representation for Programming Language Processing: An Investigation into Algorithm Detection

Program representation, which aims at converting program source code into vectors with automatically extracted features, is a fundamental problem in programming language processing (PLP). Recent work tries to represent programs with neural networks based on source code structures. However, such methods often focus on the syntax and consider only one single perspective of programs, limiting the representation power of models. This paper proposes a multi-view graph (MVG) program representation method. MVG pays more attention to code semantics and simultaneously includes both data flow and control flow as multiple views. These views are then combined and processed by a graph neural network (GNN) to obtain a comprehensive program representation that covers various aspects. We thoroughly evaluate our proposed MVG approach in the context of algorithm detection, an important and challenging subfield of PLP. Specifically, we use a public dataset POJ-104 and also construct a new challenging dataset ALG-109 to test our method. In experiments, MVG outperforms previous methods significantly, demonstrating our model's strong capability of representing source code.

Julian Francis Miller, 1955-2022.

Julian Francis Miller1It is with great sadness that we report the death of our colleague and friend, Julian Miller.Julian’s work is well known throughout the Artificial Life community: His Cartesian genetic programming (CGP) and in materio computing are foundational concepts. He also made contributions in morphological computing and neurocomputing, all based on his fascination with evolution as a means of attacking and solving problems. Like many in the ALife community, he had an interdisciplinary career, commencing with a first degree in Physics and a PhD in Mathematics, followed by research in Natural Computing and material computing at the universities of Napier, Birmingham, and York in the UK.Julian invented CGP (Miller, 1999), a way of encoding graph programs (functional nodes connected by edges) in a string of integers, allowing the string to be evolved in the standard way, with the graph (located on a Cartesian grid, hence its name) produced as the result of a genotype to phenotype mapping. From this simple beginning, Julian and his students continued to develop the approach, and other researchers joined in. Ten years later, the field had grown significantly, with many researchers both using CGP in their own work and extending the original concept. Indeed, the field had grown enough that Julian could edit an entire book on the topic (Miller, 2011). Ten years later still, the field shows no signs of abating, and Julian wrote a 40-page review for Genetic Programming and Evolvable Machines on CGP’s status, its many variants, and its future prospects (Miller, 2020).Julian was also a pioneer in the field of in materio computing (Miller &amp; Downing, 2002), which exploits the physical properties of unconventional materials, such as liquid crystals (Harding &amp; Miller, 2004) and carbon nanotubes (Miller et al., 2014), to perform computation intrinsically, in what he dubbed a “Field Programmable Matter Array.” His original work used evolutionary algorithms directly to configure the materials. Later, he also used Reservoir Computing as a more abstract model for getting these materials to compute (Dale et al., 2017). This is another field with explosive growth, so much so that some authors have even published on the name of the domain itself (Ricciardi &amp; Milano, 2022). Julian was there from the start, contributing his insights and ideas throughout.CGP and in materio computing may be what Julian is best known for, but these contributions were embedded in a deeper research program of understanding development as a fundamental component of evolving embodied computation. From growing a self-repairing “French-flag” organism (Miller, 2004), to assembling complex structures through Artificial Chemistries (Faulconbridge et al., 2011), to the idea of the “software garden” (Miller, 2018), Julian felt that both growth and evolution are essential concepts in complex systems.His Festschrift Inspired by Nature (Stepney &amp; Adamatzky, 2018) was a (slightly late) 60th birthday present from his many academic colleagues. It includes chapters contributed by a wide range of authors who have built on and been inspired by his many research interests. The text covers evolution and hardware, CGP applications, chemistry, and development. Julian retired in 2016, but he did not stop his research. He used the freedom from the quotidian constraints of an academic job to pursue a new interest. He was bringing together his discoveries in evolution, development, networks, and computation to develop a new neural model to evolve programs that build, or grow, neural networks. His most recent publication on that topic has only just appeared (Miller, 2022).Julian’s retirement also allowed him to spend time with his recently acquired beloved new family. His wife Gabi remembers him thus: “He was a loving and generous-hearted husband, a wise step-father to my three grown adults and much loved Grandpa to our four grand-children. Jules will be sadly missed, but also lovingly remembered by all whose life he touched.” Many further tributes to Julian from his colleagues can be found in the latest SIGEVO newsletter (Ochoa, 2022).

Taskflow: A Lightweight Parallel and Heterogeneous Task Graph Computing System

Taskflow aims to streamline the building of parallel and heterogeneous applications using a lightweight task graph-based approach. Taskflow introduces an expressive task graph programming model to assist developers in the implementation of parallel and heterogeneous decomposition strategies on a heterogeneous computing platform. Our programming model distinguishes itself as a very general class of task graph parallelism with in-graph control flow to enable end-to-end parallel optimization. To support our model with high performance, we design an efficient system runtime that solves many of the new scheduling challenges arising out of our models and optimizes the performance across latency, energy efficiency, and throughput. We have demonstrated the promising performance of Taskflow in real-world applications. As an example, Taskflow solves a large-scale machine learning workload up to 29% faster, 1.5x less memory, and 1.9x higher throughput than the industrial system, oneTBB, on a machine of 40 CPUs and 4 GPUs. We have opened the source of Taskflow and deployed it to large numbers of users in the open-source community.

BRGraph: An efficient graph neural network training system by reusing batch data on GPU

SummaryWith the increasing adoption of graph neural networks (GNNs) in the community, various GPU‐based graph programming systems have been developed to improve the productivity of GNNs. However, sampling‐based GNN training is still inefficient, and we observe that the main bottleneck comes from the data transferring, where vertex features are transferred from host memory to GPU through limited bandwidth. In this article, we propose BRGraph, a sampling‐based GNN training system that supports efficient data transferring. BRGraph leverages the duplicate vertices between mini‐batches by batch reusing (BR) strategy to avoid duplicate data transmission. Furthermore, to reduce the overhead of detecting duplicate vertices, we design an efficient parallel batch reusing algorithm based on GPU. BRGraph also exploits the data reusing potential of the non‐duplicate vertex features by the two‐level batch reusing (two‐level BR) strategy. Comprehensive evaluations on three representative GNN models show that BRGraph reduces data transferring time by up to 60% and delivers up to 1.79 GNN training speedup over the state‐of‐the‐art baselines. Besides, it can save GPU memory by up to 40% while reaching the same training time compared with the static cache strategy. When applying the two‐level BR, BRGraph further reduces 20% of the data transferring time compared with the BR.