Code Syntax Research Articles

A study on the computational effort of hyper-dual numbers to evaluate derivatives in geometrically nonlinear hyperelastic trusses

We report the use of hyper-dual numbers as a derivative tool for stress and tangent modulus calculation in hyperelastic models. By using the analytical expressions of Ogden’s model as a reference, we confirmed the accuracy of this tool for both first- and second-order derivatives. Moreover, the hyper-dual implementation considering the operator overloading technique corroborated the interesting generality properties of this method; by using virtually the same code syntax, the material behavior was entirely described by the hyper-dual representation of the strain energy function. Therefore, the use of the hyper-dual procedure brings an important advantage in this field since the development of the expressions concerning stress and tangent modulus becomes unnecessary; only the potential function of a given model is implemented. In this context, due to its specific set of arithmetic operations, a detailed study on the efficiency of the hyper-dual scheme in a finite element analysis is demanded. In this research, we proposed a comparative study regarding the effects of the hyper-dual procedure on the analysis processing time. Using a specific mesh generator, we evaluated a wide range of model sizes for a beam structure made of hyperelastic trusses. As a result, when compared to an ordinary finite element execution using analytical expressions for the constitutive model, we found corresponding hyper-dual performance in the larger models. Particularly, we identified the model size from which the hyper-dual approach becomes competitive; considering this element type, this model contains approximately 30,000 elements and 25,000 degrees of freedom. Furthermore, as for the computational time related to the material subroutine and the stiffness matrix, we found that the hyper-dual scheme increased the computational time by a factor of 4 and 2, respectively. We demonstrated that the hyper-dual procedure combines interesting characteristics in terms of accuracy, generality and computational costs. Hence, this numerical strategy for derivative calculation potentially represents an important tool for the development and application of new constitutive models in structural mechanics.

Early Detection of Flawed Structural Dependencies During Software Evolution

During software evolution, complex structural dependencies between source files pose a great challenge on maintenance activities. Some of these dependencies propagate defects among files, incurring frequent bugs or changes, and consuming significant maintenance costs. They can be referred to as flawed structural dependencies. In this paper, we proposed a method to identify these potential problematic dependencies at an early stage during software evolution, by combing structural and semantic dependencies, so that developers can save maintenance costs by fixing these issues in time. Our method works as follows: First, we extract structural dependencies from the source code syntax and semantic dependencies from the source code lexicon. Second, we collect suspect file pairs by calculating the difference between structural and semantic dependencies. Next, we exhaustively examine each source file in the system and locate the interaction of its impacted subordinated files and suspect file pairs (SFP) as suspect dependencies. Finally, we gather all the suspect dependencies as flawed structural dependencies candidates. We evaluate our method using 838 releases of 15 open source projects, including 33353 bug reports and 86690 revision commits. The detection result shows that our identified dependencies use 14% of all the files to capture almost 70% of top 10% bug-prone files or change-prone files with enough high precision: 92%. Moreover, our identified dependencies also incur 957% of bug frequencies and 1050% of change frequencies than average in future versions. In summary, our method can effectively and efficiently detect flawed structural dependencies in time during software evolution.

Computer Aided Drafting Application (CAD) as – A Design Tool

Computer Aided Drafting or (CAD) is a computer application known among the construction engineering field as a drafting tool, that offers computer aided drafting only, and does not combine the produced drawings with construction engineering information like engineering specifications, bill of quantities, material specifications, project scheduling, and other related data. On the other hand, the main purpose of the emergence of Computer Aided Drafting or (CAD) technology is to minimize effort and time consumed in the preparation of construction drawings. Such process is the most tedious and the core task of the design firms. Research work in this paper focus on introducing a base system concept that may lead to a computer program/script or a “Plug-in” that may give a (CAD) based software application commonly known as (AutoCAD Architecture Desktop) an (AI) capacity. The paper started with a short explanation of the major elements of the architectural design process from a cognitive approach, followed by a briefing about (CAD) technology as a drafting tool, then goes directly towards explaining the “CAD - Plug-in” suggested base system, and criteria with a simulation of the suggested concept over an architectural design example; a “Hospital 4 Surgery Rooms Zone”, as a case study. At the end, the paper concludes a Programing Scheme the (CAD - Plugin Syntax Code) written in “Prolog” computer programing language.

ABMMRS Eradicator: Improving Accuracy in Recommending Move Methods for Web-based MVC Projects and Libraries Using Method’s External Dependencies

Move Method Refactoring (MMR) is used to place highly coupled methods in appropriate classes for making source code more cohesive. Like other refactoring techniques, it is mandatory that applying MMR will preserve applications’ behaviors. However, traditional MMR techniques failed to meet this essential precondition for Action methods in web-based application and API methods in libraries projects. The reason is that applying MMR on these methods changes the behaviors of the projects by raising Application-breaking issues, for instance, failure of browser requests and compilation errors in client projects. To resolve this problem, developers are suggested to manually check Action and API methods while applying MMR. However, manually inspecting thousands of lines of code for these issues is a time-consuming and hectic task. In this paper, an advanced MMR technique is proposed which automatically identifies Application-breaking MMR suggestions. This technique first takes the initial move method suggestions from the existing prominent MMR techniques e.g. JDeodorant. For each of the suggestions, it parses the source code and construct Abstract Syntax Tree to examine two types of usage. One is whether a suggestion has not been used in any unit test and Regular Class, and another is whether the suggestion has been used in unit test classes only. If any MMR suggestion is found having one of these two types of usage or both, the respective suggestion is marked as Application-breaking. In order to evaluate the proposed technique, several experiments have been conducted on open source projects. The experimental results show that the proposed technique achieved 96.4% Precision, 90% Recall and 93.1% F-score in detecting Application-breaking MMR suggestions, because of considering external dependencies of the MMR suggestions.

CommtPst: Deep learning source code for commenting positions prediction

Existing techniques for automatic code commenting assume that the code snippet to be commented has been identified, thus requiring users to provide the code snippet in advance. A smarter commenting approach is desired to first self-determine where to comment in a given source code and then generate comments for the code snippets that need comments. To achieve the first step of this goal, we propose a novel method, CommtPst, to automatically find the appropriate commenting positions in the source code. Since commenting is closely related to the code syntax and semantics, we adopt neural language model (word embeddings) to capture the code semantic information, and analyze the abstract syntax trees to capture code syntactic information. Then, we employ LSTM (long short term memory) to model the long-term logical dependency of code statements over the fused semantic and syntactic information and learn the commenting patterns on the code sequence. We evaluated CommtPst using large data sets from dozens of open-source software systems in GitHub. The experimental results show that the precision, recall and F-Measure values achieved by CommtPst are 0.792, 0.602 and 0.684, respectively, which outperforms the traditional machine learning method with 11.4% improvement on F-measure.

Data and supplemental material of the paper "Effectiveness of digital-based interventions for children with mathematical learning difficulties: A meta-analysis".

Data and supplement material of the article “Effectiveness of digital-based interventions for children with mathematical learning difficulties: A meta-analysis” (Benavides-Varela et al.) [1] are presented. Data were collected from studies included in the meta-analysis to evaluate the effects of digital-based interventions for children with mathematical learning difficulties compared to control conditions in group-designed randomized controlled trials. Literature search, inclusion criteria and coding procedure are described. PRISMA flow-chart is reported to summarize the literature search and coding of all the relevant characteristics of the primary studies is made available. This allows other researchers to easily access to the information needed to evaluate the studies and to use these data in future meta-analyses. However, researchers are highly recommended to refer to the original papers in order to check studies suitability to their own criteria. Moreover, in the supplemental material all the information needed to reproduce the meta-analysis results is reported together with the R code syntax. Data and supplemental material are available online (https://osf.io/ajdnv/).

Tool for Generating Behavior-Driven Development Test-Cases

Background: Testing using Behavior-Driven Development (BDD) techniques is one of the practices of Agile software development. This technique composes a test-case based on a use case scenario, for web application acceptance tests.Objective: In this study, we developed a tool to generate test case codes from BDD scenario definitions to help and facilitate practitioners to conduct testing.Methods: The generated test case code is made according to the codeception framework format so that it can be directly executed by the tester. The procedure is performed as follows: map the correlation of the language used in BDD (gherkin language) and the code syntax of the test code in the codeception framework, designed the GUIs in such a way that users can easily transform the Use Case Scenario, built the tool so that it can generate test cases codes. Evaluation is done by gathering respondents; ask to run the application and gathering feedback from respondents.Results: This tool can generate a codeception test-case file based on the BDD scenario. Generated test cases can be directly used on codeception tools. The results of the evaluation show that the tools can help entry-level programmers in developing automated tests.Conclusion: The tool can help user especially entry-level programmers to generate BDD test-case and make easy for the users for testing the web applications.

CodeGRU: Context-aware deep learning with gated recurrent unit for source code modeling

Recently deep learning based Natural Language Processing (NLP) models have shown great potential in the modeling of source code. However, a major limitation of these approaches is that they take source code as simple tokens of text and ignore its contextual, syntactical and structural dependencies. In this work, we present CodeGRU, a gated recurrent unit based source code language model that is capable of capturing source code's contextual, syntactical and structural dependencies. We introduce a novel approach which can capture the source code context by leveraging the source code token types. Further, we adopt a novel approach which can learn variable size context by taking into account source code's syntax, and structural information. We evaluate CodeGRU with real-world data set and it shows that CodeGRU outperforms the state-of-the-art language models and help reduce the vocabulary size up to 24.93\%. Unlike previous works, we tested CodeGRU with an independent test set which suggests that our methodology does not requisite the source code comes from the same domain as training data while providing suggestions. We further evaluate CodeGRU with two software engineering applications: source code suggestion, and source code completion. Our experiment confirms that the source code's contextual information can be vital and can help improve the software language models. The extensive evaluation of CodeGRU shows that it outperforms the state-of-the-art models. The results further suggest that the proposed approach can help reduce the vocabulary size and is of practical use for software developers.

Hazards That Can Affect CNC Machine Tools during Operation—An AHP Approach

CNC (computer numerically controlled) machine tools are highly advanced technological systems, used to machine parts by means of metal cutting processes. Their structure and kinematics are very complex, involving accurate coordinated motions on three to five axes. Operating CNC machine tools is a complicated process, which can easily be affected by errors. Nowadays, safety systems and devices are developed in order to make this process safer and more user friendly. Modern CNC controllers are designed to deal with obvious sources of hazards, such as overloads (by means of various sensor systems) and collisions (by checking the NC code syntax and simulating it on the machine). However, despite of these safety systems, various unwanted events still occur during machining operations on CNC machine tools. These means that there are still certain hazards, not so obvious, which can severely affect the operation of CNC machine tools. This work tries to identify and hierarchize the above-mentioned hazards by using an AHP (analytic hierarchy process) approach. The results of the AHP emphasize which hazard has the biggest influence upon the CNC machine tools operation and consequently should be avoided. The results of this work could be used by the machine tools designers to develop new safety features for the existing CNC controllers. Also, the users of the machine tools could focus some of the safety measures during the machining process upon the most significant hazards pointed by the results of the research.

Monitoring Interfaces Fastethernet on Cisco Catalyst 3750 to Ensure Use of The Security Computer Network In STTA Computing Laboratories

Cisco is a company that concentrates on hardware and software related to computer networks. One of the hardware produced by Cisco is a switch device that can be used for management of a computer network. Many types of switches that have been produced by Cisco, one of which is the Cisco Catalyst 3750. In the configuration and monitoring of the Cisco Catalyst 3750 user / administrator must do management with command line based configuration. This is because Cisco has not facilitated its users with user interface based configurations. So the user is required to know the code syntax to execute a command on the switch. In this study, researchers will discuss about how to create a user interface for monitoring web-based Fastethernet Interfaces on the Cisco Catalist 3750 to ensure the security of using computer networks in STTA computing laboratories that have many interconnected computer devices using e-mail notifications using APIs. The results of the test show that the application can be monitored by the administrator remotely in real time, the user interface can run properly on the personal computer browser and smartphone responsively.

Toward the Unification of Physics and Number Theory

This paper introduces the notion of simplex-integers and shows how, in contrast to digital numbers, they are the most powerful numerical symbols that implicitly express the information of an integer and its set theoretic substructure. A geometric analogue to the primality test is introduced: when [Formula: see text] is prime, it divides [Formula: see text] for all [Formula: see text]. The geometric form provokes a novel hypothesis about the distribution of prime-simplexes that, if solved, may lead to a proof of the Riemann hypothesis. Specifically, if a geometric algorithm predicting the number of prime simplexes within any bound [Formula: see text]-simplex or associated [Formula: see text] lattice is discovered, a deep understanding of the error factor of the prime number theorem would be realized — the error factor corresponding to the distribution of the non-trivial zeta zeros, which might be the mysterious link between physics and the Riemann hypothesis [D. Schumayer and D. A. W. Hutchinson, Colloquium: Physics of the Riemann hypothesis, Rev. Mod. Phys. 83 (2011) 307]. It suggests how quantum gravity and particle physicists might benefit from a simplex-integer-based quasicrystal code formalism. An argument is put forth that the unifying idea between number theory and physics is code theory, where reality is information theoretic and 3-simplex integers form physically realistic aperiodic dynamic patterns from which space, time and particles emerge from the evolution of the code syntax.

Systematic adaptation of dynamically generated source code via domain‐specific examples

In modern web-based applications, an increasing amount of source code is generated dynamically at runtime. Web applications commonly execute dynamically generated code (DGC) emitted by third-party, black-box generators, run at remote sites. Web developers often need to adapt DGC before it can be executed: embedded HTML can be vulnerable to cross-site scripting attacks; an API may be incompatible with some browsers; and the program's state created by DGC may not be persisting. Lacking any systematic approaches for adapting DGC, web developers resort to ad-hoc techniques that are unsafe and error-prone. This study presents an approach for adapting DGC systematically that follows the program-transformation-by-example paradigm. The proposed approach provides predefined, domain-specific before/after examples that capture the variability of commonly used adaptations. By approving or rejecting these examples, web developers determine the required adaptation transformations, which are encoded in an adaptation script operating on the generated code's abstract syntax tree. The proposed approach is a suite of practical JavaScript program adaptations and their corresponding before/after examples. The authors have successfully applied the approach to real web applications to adapt third-party generated JavaScript code for security, browser compatibility, and persistence.

Modular programming for tuberculosis control, the \u201cAuTuMN\u201d platform

BackgroundTuberculosis (TB) is now the world’s leading infectious killer and major programmatic advances will be needed if we are to meet the ambitious new End TB Targets. Although mathematical models are powerful tools for TB control, such models must be flexible enough to capture the complexity and heterogeneity of the global TB epidemic. This includes simulating a disease that affects age groups and other risk groups differently, has varying levels of infectiousness depending upon the organ involved and varying outcomes from treatment depending on the drug resistance pattern of the infecting strain.ResultsWe adopted sound basic principles of software engineering to develop a modular software platform for simulation of TB control interventions (“AuTuMN”). These included object-oriented programming, logical linkage between modules and consistency of code syntax and variable naming. The underlying transmission dynamic model incorporates optional stratification by age, risk group, strain and organ involvement, while our approach to simulating time-variant programmatic parameters better captures the historical progression of the epidemic. An economic model is overlaid upon this epidemiological model which facilitates comparison between new and existing technologies. A “Model runner” module allows for predictions of future disease burden trajectories under alternative scenario situations, as well as uncertainty, automatic calibration, cost-effectiveness and optimisation. The model has now been used to guide TB control strategies across a range of settings and countries, with our modular approach enabling repeated application of the tool without the need for extensive modification for each application.ConclusionsThe modular construction of the platform minimises errors, enhances readability and collaboration between multiple programmers and enables rapid adaptation to answer questions in a broad range of contexts without the need for extensive re-programming. Such features are particularly important in simulating an epidemic as complex and diverse as TB.

Examining Differential Item Functioning: IRT-Based Detection in the Framework of Confirmatory Factor Analysis

ABSTRACTThis article offers an approach to examining differential item functioning (DIF) under its item response theory (IRT) treatment in the framework of confirmatory factor analysis (CFA). The approach is based on integrating IRT- and CFA-based testing of DIF and using bias-corrected bootstrap confidence intervals with a syntax code in Mplus.

Code sniffer: a risk based smell detection framework to enhance code quality using static code analysis

To maintain software and enhance its code quality, code smell, i.e., undesired design flaws need to be detected. However, as the system size increases, manual smell detection becomes difficult. In this paper, a static code analysis framework, named code sniffer, is proposed to detect code smells with predicting their risk severity. This has been calculated using code metrics, and defined as low, moderate and high. The system consists of three main components: parser extracts a syntax tree from the given source code to identify the code structure. The syntax tree is searched against the syntax of class and method. Analyser searches found classes and methods against various code syntax to identify key features like line of code (LOC), number of properties (NOP), etc. In smell and risk detector, code smells, risky code segments and their severity are detected as a set of quantitative values (using LOC, NOP, etc.) using which classes and methods are judged. A comparative case study of this risk based static analyser is performed with a dynamic analyser, FxCop, and the comparison results support each other.

DNSLab: A gateway to turbulent flow simulation in Matlab

Computational fluid dynamics (CFD) research is increasingly much focused towards computationally intensive, eddy resolving simulation techniques of turbulent flows such as large-eddy simulation (LES) and direct numerical simulation (DNS). Here, we present a compact educational software package called DNSLab, tailored for learning partial differential equations of turbulence from the perspective of DNS in Matlab environment. Based on educational experiences and course feedback from tens of engineering post-graduate students and industrial engineers, DNSLab can offer a major gateway to turbulence simulation with minimal prerequisites. Matlab implementation of two common fractional step projection methods is considered: the 2d Fourier pseudo-spectral method, and the 3d finite difference method with 2nd order spatial accuracy. Both methods are based on vectorization in Matlab and the slow for-loops are thus avoided. DNSLab is tested on two basic problems which we have noted to be of high educational value: 2d periodic array of decaying vortices, and 3d turbulent channel flow at Reτ=180. To the best of our knowledge, the present study is possibly the first to investigate efficiency of a 3d turbulent, wall bounded flow in Matlab. The accuracy and efficiency of DNSLab is compared with a customized OpenFOAM solver called rk4projectionFoam. Based on our experiences and course feedback, the main contribution of DNSLab consists of the following features. (i) The very compact Matlab implementation of present Navier–Stokes solvers provides a gateway to efficient learning of both, physics of turbulent flows, and simulation of turbulence. (ii) Only relatively minor prerequisites on fluid dynamics and numerical methods are required for using DNSLab. (iii) In 2d, interactive results for turbulent flow cases can be obtained. Even for a 3d channel flow, the solver is fast enough for nearly interactive educational use. (iv) DNSLab is made openly available and thus contributing to the general availability and accessibility of educational DNS codes in Matlab environment. Program summaryProgram title: DNSLabCatalogue identifier: AEZX_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEZX_v1_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 227177No. of bytes in distributed program, including test data, etc.: 40553359Distribution format: tar.gzProgramming language: Matlab (2014&2015) Compatible with Octave (tested on v-3.x.x and v-4.0.0).Computer: Any work-station or laptop computer where Matlab is running.Operating system: Linux and Windows, and Mac OS X.Has the code been vectorized or parallelized?: Vectorization in Matlab is utilized.RAM: The peak memory consumption for the distributed default test cases is about 600 Mb for Channel3dLab (723 grid) and about 150 Mb for NS2dLab (2562 grid). Matlab as such requires about 350 Mb of memory without GUI.Classification: 12, 4.3, 4.6.Nature of problem: Numerical solution of the Navier–Stokes equations in turbulent state is demonstrated in Matlab environment for two test problems: turbulent 3d channel flow and 2d periodic array of vortices. The high-level, interpreted language Matlab enables the solution of turbulent flows using compact and short code syntax. Both of the problems are of high relevance in numerical test phases of research, and in education and numerical simulation of turbulence.Solution method: The two solvers of DNSLab are based on the fractional step projection methods utilizing finite differences in 3d, and Fourier pseudo-spectral method in 2d. The time integrator in both solvers is the classical fourth order Runge–Kutta scheme.Restrictions: As such, the implemented codes are limited to either periodic or simple channel flow configurations. In general, stability of fluid flow solvers is dependent on the Reynolds number, Courant number, Courant–Friedrichs–Lewy number, the initial data, as well as linear solver settings.Additional comments: !!!!! The distribution file for this program is over 40 Mbytes and therefore is not delivered directly when download or Email is requested. Instead a html file giving details of how the program can be obtained is sent. !!!!!Running time: Results for test cases can be produced in tens of seconds in 2d and in a few minutes in 3d. Runtime grid size dependence is investigated in the manuscript.

3D Simulation of the Ultra-Precision V-Groove Machine Tool

This paper develops a three dimensional (3D) simulation system with QT platform and OpenGL 3D library by adopting the driver and Aerotech’s linear motor as hardware platform and INtime and A3200 controller as the software platform. The system uses numerical control (NC) code syntax checking module to test the NC code syntax and applies 3D simulation module to display the actual machining process. The interference and collision detection module is built in this system to detect the problem during the actual processing. The system therefore contributes to avoiding the trial and tests for the ultra-precision machining process and improving the machining efficiency as well as reducing the loss of ultra-precision components of machine tool due to the collision.

A framework for programmatically designing user interfaces in JavaScript

Purpose – The purpose of this paper is to investigate the feasibility of creating a declarative user interface language suitable for rapid prototyping of mobile and Web apps. Moreover, this paper presents a new framework for creating responsive user interfaces using JavaScript. Design/methodology/approach – Very little existing research has been done in JavaScript-specific declarative user interface (UI) languages for mobile Web apps. This paper introduces a new framework, along with several case studies that create modern responsive designs programmatically. Findings – The fully implemented prototype verifies the feasibility of a JavaScript-based declarative user interface library. This paper demonstrates that existing solutions are unwieldy and cumbersome to dynamically create and adjust nodes within a visual syntax of program code. Originality/value – This paper presents the Guix.js platform, a declarative UI library for rapid development of Web-based mobile interfaces in JavaScript.

Initial results on computational performance of Intel many integrated core, sandy bridge, and graphical processing unit architectures: implementation of a 1D c++/OpenMP electrostatic particle‐in‐cell code

SummaryWe present initial comparison performance results for Intel many integrated core (MIC), Sandy Bridge (SB), and graphical processing unit (GPU). A 1D explicit electrostatic particle‐in‐cell code is used to simulate a two‐stream instability in plasma. We compare the computation times for various number of cores/threads and compiler options. The parallelization is implemented via OpenMP with a maximum thread number of 128. Parallelization and vectorization on the GPU is achieved with modifying the code syntax for compatibility with CUDA. We assess the speedup due to various auto‐vectorization and optimization level compiler options. Our results show that the MIC is several times slower than SB for a single thread, and it becomes faster than SB when the number of cores increases with vectorization switched on. The compute times for the GPU are consistently about six to seven times faster than the ones for MIC. Compared with SB, the GPU is about two times faster for a single thread and about an order of magnitude faster for 128 threads. The net speedup, however, for MIC and GPU are almost the same. An initial attempt to offload parts of the code to the MIC coprocessor shows that there is an optimal number of threads where the speedup reaches a maximum. Copyright © 2014 John Wiley & Sons, Ltd.

Peephole Optimization Technique for analysis and review of Compiler Design and Construction

In term of Compiler optimization, classical compilers implemented with an effective optimization technique called Peephole optimization. In the early stage of the implementation of this technique basically applied using string pattern matching performed on the regular expression and which are known as classical peephole optimizers. In the classical optimizers, the string pattern matching approach is considered as a processing of the input of the syntax of assembly code but its meaning gets lost. This paper explores prior research and current research issues in term of 'Optimizing' compilers with the implementation of Peephole optimization using different pattern matching approach that focuses on regular expression. In several research discussed below targets the implementation of pattern matching approach based on rule application strategy to achieve optimization of assembly code syntax for specific machine or retargetable (machine independent) in context of structured programming, procedure oriented programming and Object Oriented Programming.