Lines Of Code Research Articles

CodeCity: A comparison of on-screen and virtual reality

Over the past decades, researchers proposed numerous approaches to visualize source code. A popular one is CodeCity , an interactive 3D software visualization representing software system as cities: buildings represent classes (or files) and districts represent packages (or folders). Building dimensions represent values of software metrics, such as number of methods or lines of code. There are many implementations of CodeCity , the vast majority of them running on-screen. Recently, some implementations using virtual reality (VR) have appeared, but the usefulness of CodeCity in VR is still to be proven. Our comparative study aims to answer the question “Is VR well suited for CodeCity , compared to the traditional on-screen implementation?” We performed two experiments with our web-based implementation of CodeCity , which can be used on-screen or in immersive VR. First, we conducted a controlled experiment involving 24 participants from academia and industry. Taking advantage of the obtained feedback, we improved our approach and conducted a second controlled experiment with 26 new participants. Our results show that people using the VR version performed the assigned tasks in much less time, while maintaining a comparable level of correctness. VR is at least equally well-suited as on-screen for visualizing CodeCity , and likely better. • CodeCity in VR is comparable to CodeCity on-screen, with respect to the accuracy of results, and much better with respect to efficiency. • Virtual Reality users are considerably faster than on-screen users across program comprehension tasks using CodeCity. • Virtual Reality immersion could play a pivotal role when carrying out program comprehension tasks in a 3D environment. • BabiaXR offers a web-based version of CodeCity that is able to use in any modern browser, including the browser for the VR glasses with the VR interaction by default.

Software Fault Prediction for Imbalanced Data: A Survey on Recent Developments

The method of recognizing faults in a software system is acknowledged as software fault prediction. Software faults predicted in prior stages help in the management of resources and time required during software testing and maintenance. The identified software module can be fixed ahead of time, saving time and money near the end of the software development process. Over the years, various supervised machine learning-based techniques for fault prediction have been suggested. These models’ accuracy is based on the training datasets. The models are created and trained using a labeled dataset consisting of multiple independent variables like lines of codes, the complexity of the software, the size of the software, etc., and a dependent binary variable, either true or false. But the fault dataset may have some concerns like a class overlapping problem, class imbalance problem, null values, etc. Recent research in software fault prediction focuses on data quality. An imbalanced dataset is one in which one of the class data is present in the majority and another class data is present in the minority. Models built using imbalanced datasets are biased which results in inaccurate predictions. Therefore, balancing the dataset is important. In this paper, the most recent software fault prediction algorithms, which focus on class imbalance issues are discussed. A comparative presentation is presented in this paper, which would benefit the scholar in selecting the best techniques of fault prediction based on different datasets and algorithms. According to the survey, SMOTE is the most commonly used data sampling technique for dealing with data quality issues.

Online and Real-Time Trajectory Generation Method for Unforeseen Events Using a Modified Spline Approach

This letter focuses on the problem of online and instantaneous generation of smooth trajectories and their analytical time derivatives, where future reference signals provided by a trajectory planner or a user are a-priori unknown. For this purpose, we propose a modified cubic spline polynomial which transforms the instantaneous piecewise references into smooth and continuous functions for digital control systems. The resulting reference signals are not only smooth and continuous in time but also analytically differentiable. The inferred derivative values could then be used in a variety of linear and non-linear controllers such as, Proportional-Integral-Derivative (PID), sliding mode, and backstepping. We also provide optimum and boundary values for the parameters used in the proposed technique. In addition, we present a lightweight implementation (a few lines of code) of the algorithm by which real-time computations are rapidly performed using a microcontroller. Both simulation and real experiments demonstrate that for the plants having different degrees of complexities, the proposed approach with a PD / PID controller outperforms the conventional filtered derivative-based one in terms of overshoot in the step response, robustness against noise, and trajectory tracking error.

Trust Beyond Border: Lightweight, Verifiable User Isolation for Protecting In-Enclave Services.

Due to the absence of in-enclave isolation, today's trusted execution environment (TEE), specifically Intel's Software Guard Extensions (SGX), does not have the capability to securely run different users' tasks within a single enclave, which is required for supporting real-world services, such as an in-enclave machine learning model that classifies the data from various sources, or a microservice (e.g., data search) that performs a very small task (within sub-seconds) for a user and therefore cannot afford the resources and the delay for creating a separate enclave for each user. To address this challenge, we developed Liveries, a technique that enables lightweight, verifiable in-enclave user isolation for protecting time-sharing services. Our approach restricts an in-enclave thread's privilege when configuring an enclave, and further performs integrity check and sanitization on critical enclave data upon user switches. For this purpose, we developed a novel technique that ensures the protection of sensitive user data (e.g., session keys) even in the presence of the adversary who may have compromised the enclave. Our study shows that the new technique is lightweight (1% overhead) and verifiable (about 3200 lines of code), making a step towards assured protection of real-world in-enclave services.

Efficient querying of genomic reference databases with gget.

A recurring challenge in interpreting genomic data is the assessment of results in the context of existing reference databases. With the increasing number of command line and Python users, there is a need for tools implementing automated, easy programmatic access to curated reference information stored in a diverse collection of large, public genomic databases. gget is a free and open-source command line tool and Python package that enables efficient querying of genomic reference databases, such as Ensembl. gget consists of a collection of separate but interoperable modules, each designed to facilitate one type of database querying required for genomic data analysis in a single line of code. The manual and source code are available at https://github.com/pachterlab/gget. Supplementary data are available at Bioinformatics online.

Estimation of DC motor parameters using the least square estimator

The main objective of this work is to present in detail the least squares methodology to estimate the unknown parameters that are part of the mathematical model that represents the behavior of a direct current motor. For this purpose, experimental data of speed and angular position of a direct current (DC) motor with the following characteristics were obtained. DC motor with encoder CN5003-6006, 32 lines of code, 2 output channels: A and B, an approximate weight of 25 g, an operating voltage of 6V/12V (4000/8000 rpm), a current of 30 mA, a shaft diameter of 2mm. The real values of the parameters of the differential equation modeling this motor are R=0.07Ω J=2.05932971x10^(-6) kg*m^2 K_T=0.002559499 (N*m)/A K_b=0.002559499 V/(Rad/s) The estimators obtained show that as the size of the sample (experimental data) grows, the value of the estimator tends to be the real value of the unknown parameter, that is, the estimators found comply with the consistency property, which is a requirement. minimum desirable for an estimator. The determination coefficient was used to analyze the convergence of the estimators found to the real value of the unknown parameter.

Igv.js: an embeddable JavaScript implementation of the Integrative Genomics Viewer (IGV).

igv.js is an embeddable JavaScript implementation of the Integrative Genomics Viewer (IGV). It can be easily dropped into any web page with a single line of code and has no external dependencies. The viewer runs completely in the web browser, with no backend server and no data pre-processing required. The igv.js JavaScript component can be installed from NPM at https://www.npmjs.com/package/igv. The source code is available at https://github.com/igvteam/igv.js under the MIT open-source license. IGV-Web, the end-user application built around igv.js, is available at https://igv.org/app. The source code is available at https://github.com/igvteam/igv-webapp under the MIT open-source license. Supplementary information is available at Bioinformatics online.

Software Defect Prediction using Deep Learning by Correlation Clustering of Testing Metrics

The software industry has made significant efforts in recent years to enhance software quality in businesses. The use of proactively defect prediction in the software will assist programmers and white box testing in detecting issues early, saving time and money. Conventional software defect prediction methods focus on traditional source code metrics such as code complexities, lines of code, and so on. These capabilities, unfortunately, are unable to retrieve the semantics of source code. In this paper, we have presented a novel Correlation Clustering fine-tuned CNN (CCFT-CNN) model based on testing Metrics. CCFT-CNN can predict the regions of source code that contain faults, errors, and bugs. Abstract Syntax Tree (AST) tokens are extracted as testing Metrics vectors from the source code. The correlation among AST testing Metrics is performed and clustered as a more relevant feature vector and fed into Convolutional Neural Network (CNN). Then, to enhance the accuracy of defect prediction, fine-tuning of the CNN model is performed by applying hyperparameters. The result analysis is performed on the PROMISE dataset that contains samples of open-source Java applications such as Camel Dataset, Jedit dataset, Poi dataset, Synapse dataset, Xerces dataset, and Xalan dataset. The result findings show that the CCFT- CNN model increases the average F-measure by 2% when compared to the baseline model.

TBPLaS: A tight-binding package for large-scale simulation

TBPLaS is an open-source software package for the accurate simulation of physical systems with arbitrary geometry and dimensionality utilizing the tight-binding (TB) theory. It has an intuitive object-oriented Python application interface (API) and Cython/Fortran extensions for the performance-critical parts, ensuring both flexibility and efficiency. Under the hood, numerical calculations are mainly performed by both exact diagonalization and the tight-binding propagation method (TBPM) without diagonalization. Especially, the TBPM is based on the numerical solution of the time-dependent Schrödinger equation, achieving linear scaling with system size in both memory and CPU costs. Consequently, TBPLaS provides a numerically cheap approach to calculate the electronic, optical, plasmon and transport properties of large tight-binding models with billions of atomic orbitals. Current capabilities of TBPLaS include the calculations of band structure, density of states, local density of states, quasi-eigenstates, optical conductivity, electrical conductivity, Hall conductivity, polarization function, dielectric function, plasmon dispersion, carrier mobility and velocity, localization length and free path, Z2 topological invariant, wave-packet propagation, etc. All the properties can be obtained with only a few lines of code. Other algorithms involving tight-binding Hamiltonians can be implemented easily due to the extensible and modular nature of the code. In this paper, we discuss the theoretical framework, implementation details and common workflow of TBPLaS, and give a few demonstrations of its applications. Program summaryProgram Title:TBPLaSCPC Library link to program files:https://doi.org/10.17632/5cjmzj9jwm.1Code Ocean capsule:https://codeocean.com/capsule/8296734Licensing provisions: BSD 3-clauseProgramming language: Python, Cython, FortranNature of problem: The TB method is a powerful tool for investigating the electronic structures and many other properties in condensed matter physics. However, the costs of memory and CPU time using standard diagonalization-based TB techniques scale as O(N2) and O(N3) with the model size N, severely limiting their applications in large complex systems. The development of numerical methods to solve TB problems without any diagonalization, as well as the implementation of these techniques in software packages, are urgently needed to promote the capability of TB methods to large systems with billions of atoms.Solution method: We proposed the TBPM and implemented it in the TBPLaS package. In TBPM, the electronic properties of a TB model are calculated numerically by solving the time-dependent Schrödinger equation without any diagonalization, which ensures a linear scaling of both memory and CPU costs with the system size. Models with billions of atoms (orbitals) can be easily handled, with many properties available from the evolution of time-dependent correlation functions. The TBPLaS package features an intuitive object-oriented Python API and Cython/Fortran extensions for performance-critical parts, ensuring both flexibility and efficiency. Moreover, TBPLaS implements hybrid MPI+OpenMP parallelism, which can exploit the modern hardware of high-performance computers.

A Semester-Long Learning Path Teaching Computational Skills via Molecular Graphics in PyMOL

ABSTRACT Structural biology describes biological processes at the molecular level and is an integral part of undergraduate study programs in molecular biosciences. Students are often fascinated by the visualizations created by molecular graphics software, which allow them to see the molecular world for the first time. Today, molecular visualization and structural analysis do not require expensive high-end computers but can be performed on the students' own laptops and are therefore highly suited for active learning approaches. We have designed a semester-long learning path that integrates molecular graphics and structural analysis using PyMOL into an undergraduate course in biomolecular structure and function. Compared to stand-alone PyMOL introductions, the semester-long learning path allows for an improved pedagogical design. The path progressively introduces more advanced functions in relevant scientific contexts and allows for spaced repetition. Advanced analysis functions in PyMOL are available only via the command line, so the learning path also teaches basic scripting and serves as an accessible introduction to computational thinking because a few lines of code can produce stunning results. Student surveys carried out at the end of the course suggest that the learning path supported the ability to perform structural analysis to a high degree. Moreover, a simulated exam showed that almost all students were able to carry out basic visualization tasks using PyMOL scripts, while three-quarters could undertake advanced structural analysis after following the course. In summary, integration of molecular graphics software with teaching of structural biochemistry allows a hands-on approach to analyzing molecular mechanisms and introduces biologically oriented students to computational thinking.

Pharokka: a fast scalable bacteriophage annotation tool.

In recent years, there has been an increasing interest in bacteriophages, which has led to growing numbers of bacteriophage genomic sequences becoming available. Consequently, there is a need for a rapid and consistent genomic annotation tool dedicated for bacteriophages. Existing tools either are not designed specifically for bacteriophages or are web- and email-based and require significant manual curation, which makes their integration into bioinformatic pipelines challenging. Pharokka was created to provide a tool that annotates bacteriophage genomes easily, rapidly and consistently with standards compliant outputs. Moreover, Pharokka requires only two lines of code to install and use and takes under 5 min to run for an average 50-kb bacteriophage genome. Pharokka is implemented in Python and is available as a bioconda package using 'conda install -c bioconda pharokka'. The source code is available on GitHub (https://github.com/gbouras13/pharokka). Pharokka has been tested on Linux-64 and MacOSX machines and on Windows using a Linux Virtual Machine.

Генерація багатоцільових формальних моделей із успадкованого коду

In this paper a method for generation of formal models from legacy systems code is proposed. The purpose of these models is to have a possibility of their application in different tasks such as automatic generation of executable tests, translation to modern programming languages, reverse engineering. The method pursues goals to decrease complexity of state space search and checking formulas satisfiability in relation to the direct code modeling, and to help legacy systems understanding and implementing in modern technologies. We focused on formalization of Cobol memory model as it is the most common language in legacy systems. Formal model is an attribute transition system with control flow. We proposed an algorithm for building enumerated types for any variables whose usage fulfills certain conditions, including translation procedure of numeric variables to enumerated ones. We considered a problem of translating non-comparable structures which overlap in memory (operator redefines in Cobol), are copied or compared with each other. In opposite to common approach of using union semantics (like union construction in C++), we described a method of structure fields decomposition which has no drawbacks of unions and makes for minimization of bytewise approach. We considered the developed method on the examples of structures as with simple fields as with arrays. We also gave examples of realization of bytewise approach in Java and C++ languages for those variables that cannot be represented as enumerated or numeric attributes. We tried this work for tests generation for middle-sized projects (up to 100 000 lines of code) where it showed efficiency of developed method, also generated formal models were used for debugging of Cobol to Java translator and business rules extraction.

슬로시티 상주의 지역정체성 형성에 관한 연구 : 근거이론을 중심으로

Based on the Grounded Theory, this study aims to establish new paradigm of Slowcity ‘Sangju Style’ by analyzing the process on the change of Sangju Local Residents’ recognition. For This, it interviewed the total of 20 Sangju Local Residents. Interview data was analyzed through Open coding, Axial coding and Selective coding of the Grounded Theory. Especially, Axial coding was conducted through the paradigm model of the Grounded Theory. And then core category and story line of Selective coding were derived. Interview data was finally drawn out into 76 concepts, 21 sub-categories and 7 upper-categories through Open coding process. The above mentioned concepts and categories through Open coding were reorganized into 6 axes through Axial coding. And finally Consequence with identity formation for region, Axial coding task was progressed on classification of initial Open coding data. And then a Paradigm Model with Central phenomenon connecting sub-categories and upper-categories was derived. Previous study on the Indentity of Slowcity was limited to hypothesis testing(Deductive research), this study on the Change of Identity and Formation process of Local Residents is significant that the first study using Qualitative research method(Inductive research) was conducted. It is thought that the results of the Change of Local Identity within Sangju Local Residents formed by Slowcity can be usefully used for policy-making with Establishment of Slowcity Policy in Sangju City. Ultimately, the following important implications have been drawn from this study. The Local Residents’ well-established Formation of Local Identity in Slowcity Sangju which can turn into a global city to welcome outsiders has been confirmed.

AlphaPeptDeep: a modular deep learning framework to predict peptide properties for proteomics

Machine learning and in particular deep learning (DL) are increasingly important in mass spectrometry (MS)-based proteomics. Recent DL models can predict the retention time, ion mobility and fragment intensities of a peptide just from the amino acid sequence with good accuracy. However, DL is a very rapidly developing field with new neural network architectures frequently appearing, which are challenging to incorporate for proteomics researchers. Here we introduce AlphaPeptDeep, a modular Python framework built on the PyTorch DL library that learns and predicts the properties of peptides (https://github.com/MannLabs/alphapeptdeep). It features a model shop that enables non-specialists to create models in just a few lines of code. AlphaPeptDeep represents post-translational modifications in a generic manner, even if only the chemical composition is known. Extensive use of transfer learning obviates the need for large data sets to refine models for particular experimental conditions. The AlphaPeptDeep models for predicting retention time, collisional cross sections and fragment intensities are at least on par with existing tools. Additional sequence-based properties can also be predicted by AlphaPeptDeep, as demonstrated with a HLA peptide prediction model to improve HLA peptide identification for data-independent acquisition (https://github.com/MannLabs/PeptDeep-HLA).

An empirical evaluation of the “Cognitive Complexity” measure as a predictor of code understandability

Background:Code that is difficult to understand is also difficult to inspect and maintain and ultimately causes increased costs. Therefore, it would be greatly beneficial to have source code measures that are related to code understandability. Many “traditional” source code measures, including for instance Lines of Code and McCabe’s Cyclomatic Complexity, have been used to identify hard-to-understand code. In addition, the “Cognitive Complexity” measure was introduced in 2018 with the specific goal of improving the ability to evaluate code understandability. Aims:The goals of this paper are to assess whether (1) “Cognitive Complexity” is better correlated with code understandability than traditional measures, and (2) the availability of the “Cognitive Complexity” measure improves the performance (i.e., the accuracy) of code understandability prediction models. Method:We carried out an empirical study, in which we reused code understandability measures used in several previous studies. We first built Support Vector Regression models of understandability vs. code measures, and we then compared the performance of models that use “Cognitive Complexity” against the performance of models that do not. Results:“Cognitive Complexity” appears to be correlated to code understandability approximately as much as traditional measures, and the performance of models that use “Cognitive Complexity” is extremely close to the performance of models that use only traditional measures. Conclusions:The “Cognitive Complexity” measure does not appear to fulfill the promise of being a significant improvement over previously proposed measures, as far as code understandability prediction is concerned.

FasterAI: A Lightweight Library for Neural Networks Compression

FasterAI is a PyTorch-based library, aiming to facilitate the use of deep neural network compression techniques, such as sparsification, pruning, knowledge distillation, or regularization. The library is built with the purpose of enabling quick implementation and experimentation. More particularly, compression techniques are leveraging callback systems of libraries, such as fastai and Pytorch Lightning to propose a user-friendly and high-level API. The main asset of FasterAI is its lightweight, yet powerful, simplicity of use. Indeed, because it has been developed in a very granular way, users can create thousands of unique experiments by using different combinations of parameters, with only a single line of additional code. This allows FasterAI to be suited for practical usage, as it contains the most common compression techniques available out-of-the-box, but also for research, as implementing a new compression technique usually boils down to writing a single line of code. In this paper, we propose an in-depth presentation of the different compression techniques available in FasterAI. As a proof of concept and to better grasp how the library is used, we present results achieved by applying each technique on a ResNet-18 architecture, trained on CALTECH-101.

PiDRAM: A Holistic End-to-end FPGA-based Framework for Processing-in-DRAM

Commodity DRAM-based processing-using-memory (PuM) techniques that are supported by off-the-shelf DRAM chips present an opportunity for alleviating the data movement bottleneck at low cost. However, system integration of these techniques imposes non-trivial challenges that are yet to be solve d . Potential solutions to the integration challenges require appropriate tools to develop any necessary hardware and software components. Unfortunately, current proprietary computing systems, specialized DRAM-testing platforms, or system simulators do not provide the flexibility and/or the holistic system view that is necessary to properly evaluate and deal with the integration challenges of commodity DRAM-based PuM techniques. We design and develop Processing-in-DRAM (PiDRAM), the first flexible end-to-end framework that enables system integration studies and evaluation of real, commodity DRAM-based PuM techniques. PiDRAM provides software and hardware components to rapidly integrate PuM techniques across the whole system software and hardware stack. We implement PiDRAM on an FPGA-based RISC-V system. To demonstrate the flexibility and ease of use of PiDRAM, we implement and evaluate two state-of-the-art commodity DRAM-based PuM techniques: (i) in-DRAM copy and initialization (RowClone) and (ii) in-DRAM true random number generation (D-RaNGe) . We describe how we solve key integration challenges to make such techniques work and be effective on a real-system prototype, including memory allocation, alignment, and coherence. We observe that end-to-end RowClone speeds up bulk copy and initialization operations by 14.6× and 12.6×, respectively, over conventional CPU copy, even when coherence is supported with inefficient cache flush operations. Over PiDRAM’s extensible codebase, integrating both RowClone and D-RaNGe end-to-end on a real RISC-V system prototype takes only 388 lines of Verilog code and 643 lines of C++ code.

A Straightforward Approach to Drawing Temperature-Dependent I–V Curves of Solar Cell Models

Equivalent circuit models of solar cells are important for understanding the behavior of photovoltaic systems under different weather conditions. They provide an equation F(V,I)=0 that expresses the correspondence between voltage V and current I a cell can deliver. The performance of a cell, and, therefore, the parameters of equation F, depend on the cell’s temperature and on the incoming light’s energy and angle. One would like to simulate and visualize these dependencies in real time. Given a fixed set of parameters, no elementary solution s(V)=I of Equation F(V,I)=0 is known. Hence, circuit simulation systems employ numerical methods to solve this equation and to approximate the circuit’s I–V curve, CIV. In this note, we propose a simpler approach. Instead of expressing I as a function of V, we represent both as elementary functions V(u) and I(u) of a real parameter u. In this way, the I–V curve CIV is obtained as the image of the mapping m(u)=(V(u),I(u)) from a u-interval to the VI-plane. Our approach offers both a precise mathematical description of CIV and an easy way to draw it. This allows us to study the influence of environmental changes on CIV by smooth animations, and yet with rather simple means. In this paper, we consider temperature dependence as an example; changes in irradiance or angle could be incorporated as well. Using formulae suggested in the literature that describe how the parameters in equation F(V,I)=0 depend on temperature, it takes only a few lines of code to generate an interactive worksheet that shows how CIV, the location of the maximum power point MPP and the maximum power change as the circuit’s temperature, is altered on a slider. Such a worksheet and its location will be presented in this paper.

A collaborative method for code clone detection using a deep learning model

Code cloning (CC) is the process of copying and reconfiguring a code fragment and using it in another part of a software project. This clones increases the running overhead of the software. As a result, Code Clone Detection (CCD) has become an active research area in software development research. The detection of Large-Variance Code Clones (LV-CCs) is very difficult when the lines of codes (LOCs) in the source code are very large. The distance metrics have been used in LV-CC detection by calculating the distance between training feature sets of source codes and testing feature sets of source codes. However, threshold selection for detecting clones is a challenging issue in distance-based LV-CC detection. To solve this, a Collaborative CCD using Deep Learning (CCCD-DL) is developed in this paper by utilising lexical, syntactic, semantic and structural features for identifying all types of clones together. A lexical feature is extracted from Clone Pairs (CPs) identified by LV-Mapper. Syntactic and semantic features are identified by the Abstract Syntax Tree (AST) and Control Flow Graph (CFG). The structural features are extracted by code size metrics (CZMs) and object-oriented metrics (OOMs). All features are coordinated and fed into the input layer of DNN. The hidden layer then transforms the inputs into the neural vertices in the multi-classification stage using linear transformation preceded by suppressing non-linearity. This process can generate a complicated and non-hypothetical prototype with a weight matrix for fitting the training sequence. Thus, the feed-forward step has been successfully completed. This model then uses back-propagation in the following element to modify the weight matrix based on the training set. Finally, a softmax layer converts the clone detection task into a classification process. The results of the experiments show that the proposed method solves distance-based problems more quickly and effectively than the traditional methods for the CCD.

Testing Very Large Database Management Systems: The Case of SAP HANA

Software Testing is an established activity in the software development process to ensure and improve the quality of a software. Consequently, there exists a wide range of literature, popular information, and even multiple ISO standards covering this topic. However, we found that testing very large database management systems (DBMS) requires special adaptations of the generally available guidance for software testing and requires to solve specific challenges that may not be relevant for other areas or smaller software projects. We therefore discuss the testing of SAP HANA, a very large software project with millions of lines of code, to share insights about our approach, best practices, and unsolved challenges that are open for further research.