Java Methods Research Articles

An intelligent java method name recommendation framework via two-phase neural networks

An intelligent java method name recommendation framework via two-phase neural networks

The Correlation between Java Programming and BSICT Graduate Attributes of Information Technology Students at Surigao del Norte State University

This study examines the relationship between graduate attributes of 150 Bachelor of Science in Information Technology (BSIT) students and Java programming. The study focuses on graduate-level skills like problem-solving abilities, communication, and problem analysis in relation to Java programming elements like classes, file handling, and methods. A 5-point Likert scale rating is incorporated into the survey questionnaire design in order to quantitatively evaluate the responses. The study makes use of the Jamovi application as a statistical spreadsheet. The outcome shows a good relationship between the characteristics of BSIT graduates, such as communication, problem-solving skills, and problem analysis, and Java programming elements like classes, file handling, and methods. Additionally, some BSIT students find it difficult to use complicated methods, indicating the necessity for instructional strategies, practical projects, assessments, and peer programming exercises.

Estudio comparativo de los paradigmas de programación orientada a objetos y programación reactiva en la resolución de Integrales Algebraicas

The article evaluates the performance in terms of execution times in solving algebraic integrals using both the object-oriented programming (OOP) and reactive programming (RP) paradigms. The problem addressed is the lack of scientific evidence that allows us to determine which paradigm offers the best results in terms of execution times in solving these integrals. The approach of the study involves the implementation of two versions in Java, each built following the principles of the aforementioned paradigms. Subsequently, through controlled experimental scenarios and integrated Java methods, the execution time of each application is measured. The results reveal that reactive programming demonstrates greater efficiency in terms of performance. This research focuses on the resolution of linear and polynomial algebraic integrals and points out the need for more extensive research in this field. In conclusion, the study shows that reactive programming significantly outperforms object-oriented programming, demonstrating notably lower execution times.

BioCoder: a benchmark for bioinformatics code generation with large language models.

Pretrained large language models (LLMs) have significantly improved code generation. As these models scale up, there is an increasing need for the output to handle more intricate tasks and to be appropriately specialized to particular domains. Here, we target bioinformatics due to the amount of domain knowledge, algorithms, and data operations this discipline requires. We present BioCoder, a benchmark developed to evaluate LLMs in generating bioinformatics-specific code. BioCoder spans much of the field, covering cross-file dependencies, class declarations, and global variables. It incorporates 1026 Python functions and 1243 Java methods extracted from GitHub, along with 253 examples from the Rosalind Project, all pertaining to bioinformatics. Using topic modeling, we show that the overall coverage of the included code is representative of the full spectrum of bioinformatics calculations. BioCoder incorporates a fuzz-testing framework for evaluation. We have applied it to evaluate various models including InCoder, CodeGen, CodeGen2, SantaCoder, StarCoder, StarCoder+, InstructCodeT5+, GPT-3.5, and GPT-4. Furthermore, we fine-tuned one model (StarCoder), demonstrating that our training dataset can enhance the performance on our testing benchmark (by >15% in terms of Pass@K under certain prompt configurations and always >3%). The results highlight two key aspects of successful models: (i) Successful models accommodate a long prompt (>2600 tokens) with full context, including functional dependencies. (ii) They contain domain-specific knowledge of bioinformatics, beyond just general coding capability. This is evident from the performance gain of GPT-3.5/4 compared to the smaller models on our benchmark (50% versus up to 25%). All datasets, benchmark, Docker images, and scripts required for testing are available at: https://github.com/gersteinlab/biocoder and https://biocoder-benchmark.github.io/.

Dataset of Functionally Equivalent Java Methods and Its Application to Evaluating Clone Detection Tools

Dataset of Functionally Equivalent Java Methods and Its Application to Evaluating Clone Detection Tools

Method-level Bug Prediction: Problems and Promises

Fixing software bugs can be colossally expensive, especially if they are discovered in the later phases of the software development life cycle. As such, bug prediction has been a classic problem for the research community. As of now, the Google Scholar site generates ∼113,000 hits if searched with the “bug prediction” phrase. Despite this staggering effort by the research community, bug prediction research is criticized for not being decisively adopted in practice. A significant problem of the existing research is the granularity level (i.e., class/file level) at which bug prediction is historically studied. Practitioners find it difficult and time-consuming to locate bugs at the class/file level granularity. Consequently, method-level bug prediction has become popular in the past decade. We ask, are these method-level bug prediction models ready for industry use? Unfortunately, the answer is no . The reported high accuracies of these models dwindle significantly if we evaluate them in different realistic time-sensitive contexts. It may seem hopeless at first, but, encouragingly, we show that future method-level bug prediction can be improved significantly. In general, we show how to reliably evaluate future method-level bug prediction models and how to improve them by focusing on four different improvement avenues: building noise-free bug data, addressing concept drift, selecting similar training projects, and developing a mixture of models. Our findings are based on three publicly available method-level bug datasets and a newly built bug dataset of 774,051 Java methods originating from 49 open-source software projects.

Высокопроизводительный алгоритм решения проблем связного списка с использованием техники быстрого и медленного указателей

This article discusses a combination of the fast and slow pointer method and other techniques in the high-level programming language Java to effectively solve popular algorithmic linked list problems. The result includes a description of the problem, implementation of a high-performance algorithm and solution to the computational problem.

Log statements generation via deep learning: Widening the support provided to developers

Logging assists in monitoring events that transpire during the execution of software. Previous research has highlighted the challenges confronted by developers when it comes to logging, including dilemmas such as where to log, what data to record, and which log level to employ (e.g., info, fatal). In this context, we introduced LANCE, an approach rooted in deep learning (DL) that has demonstrated the ability to correctly inject a log statement into Java methods in ∼15% of cases. Nevertheless, LANCE grapples with two primary constraints: (i) it presumes that a method necessitates the inclusion of logging statements and; (ii) it allows the injection of only a single (new) log statement, even in situations where the injection of multiple log statements might be essential. To address these limitations, we present LEONID, a DL-based technique that can distinguish between methods that do and do not require the inclusion of log statements. Furthermore, LEONID supports the injection of multiple log statements within a given method when necessary, and it also enhances LANCE’s proficiency in generating meaningful log messages through the combination of DL and Information Retrieval (IR).

Lightweight precise automatic extraction of exception preconditions in java methods

When a method throws an exception— its exception precondition—is a crucial element of the method’s documentation that clients should know to properly use it. Unfortunately, exceptional behavior is often poorly documented, and sensitive to changes in a project’s implementation details that can be onerous to keep synchronized with the documentation. We present wit, an automated technique that extracts the exception preconditions of Java methods and constructors. wit uses static analysis to analyze the paths in a method’s implementation that lead to throwing an exception. wit’s analysis is precise, in that it only reports exception preconditions that are correct and correspond to feasible exceptional behavior. It is also lightweight: it only needs the source code of the class (or classes) to be analyzed— without building or running the whole project. To this end, its design uses heuristics that give up some completeness (wit cannot infer all exception preconditions) in exchange for precision and ease of applicability. We ran wit on the JDK and 46 Java projects, where it discovered 30 487 exception preconditions in 24 461 methods, taking less than two seconds per analyzed public method on average. A manual analysis of a significant sample of these exception preconditions confirmed that wit is 100% precise, and demonstrated that it can document the exceptional behavior of Java methods.

APPLICATION OF DEEP BREATHING TECHNIQUES IN REDUCING POST SECTIO CAESAREA PAIN

Introduction: This case study is motivated by the increasing number of sectio caesarean deliveries. The number of deliveries using the Sectio Caesarea (SC) method in West Java reached 15.48% of 5,850 people. Problems that arise after sectio caesarea is pain in the incision wound caused by tearing of the tissue. tissue.
 Objective : This case study aims to determine the description of nursing care for Mrs. E P3A2 with acute pain problems in the Postpartum Room of AlIhsan Hospital, West Java Province.
 Method: The case study method in this scientific paper uses the case study method.
 Result: Results after five days of nursing action on Mrs. E with the problem of acute pain can be resolved assisted by non-pharmacological measures. pharmacological deep breath relaxation techniques and the pain scale decreases every day.
 Conclusion: The management of deep breath relaxation techniques was able to reduce the pain scale in Mrs. E P3A2 with acute pain problems. It is recommended to the nursing profession to be directly involved in handling care in post SC patients with acute pain problems.

Intelligent Visual Representation for Java Code Data in the Field of Software Engineering Based on Remote Sensing Techniques

In the field of software engineering, large and complex code bases may lead to some burden of understanding their structure and meaning for developers. To reduce the burden on developers, we consider a code base visualization method to visually express the meaning of code bases. Inspired by remote sensing imagery, we employ graphical representations to illustrate the semantic connections within Java code bases, aiming to help developers understand its meaning and logic. This approach is segmented into three distinct levels of analysis. First, at the project-level, we visualize Java projects by portraying each file as an element within a code forest, offering a broad overview of the project’s structure. This macro-view perspective aids in swiftly grasping the project’s layout and hierarchy. Second, at the file-level, we concentrate on individual files, using visualization techniques to highlight their unique attributes and complexities. This perspective enables a deeper understanding of each file’s structure and its role within the larger project. Finally, at the component-level, our focus shifts to the detailed analysis of Java methods and classes. We examine these components for complexity and other specific characteristics, providing insights that are crucial for the optimization of code and the enhancement of software quality. By integrating remote sensing technology, our method offers software engineers deeper insights into code quality, significantly enhancing the software development lifecycle and its outcomes.

PassSum: Leveraging paths of abstract syntax trees and self‐supervision for code summarization

AbstractCode summarization is to provide a high‐level comment for a code snippet that typically describes the function and intent of the given code. Recent years have seen the successful application of data‐driven code summarization. To improve the performance of the model, numerous approaches use abstract syntax trees (ASTs) to represent the structural information of the code, which is considered by most researchers to be the main factor that distinguishes code from natural language. Then, such data‐driven methods are trained on large‐scale labeled datasets to obtain a model with strong generalization capabilities that can be applied to new examples. Nevertheless, we argue that state‐of‐the‐art approaches suffer from two key weaknesses: (1) inefficient encoding of ASTs; (2) reliance on a large labeled corpus for model training. As a result, such drawbacks lead to (1) oversized model, slow training, information loss and instability; (2) inability to be applied to programming languages with only a small amount of labeled data. In light of these weaknesses, we propose PassSum, a code summarization approach that addresses the aforementioned weaknesses via (1) a novel input representation which contains an efficient AST encoding method; (2) introducing three pretraining objectives and pretraining our model with a large amount of (easy‐to‐obtain) unlabeled data under the guidance of self‐supervised learning. Experimental results on code summarization for Java, Python, and Ruby methods demonstrate the superiority of PassSum to state‐of‐the‐art methods. Further experiments demonstrate that the input representation we use has both temporal and spatial advantages in addition to performance leadership. In addition, pretraining is also shown to make the model more generalizable with less labeled data, and also to speed up the convergence of the model during training.

G-DCS: GCN-Based Deep Code Summary Generation Model

<p>In software engineering, software personnel faced many large-scale software and complex systems, these need programmers to quickly and accurately read and understand the code, and efficiently complete the tasks of software change or maintenance tasks. Code-NN is the first model to use deep learning to accomplish the task of code summary generation, but it is not used the structural information in the code itself. In the past five years, researchers have designed different code summarization systems based on neural networks. They generally use the end-to-end neural machine translation framework, but many current research methods do not make full use of the structural information of the code. This paper raises a new model called G-DCS to automatically generate a summary of java code; the generated summary is designed to help programmers quickly comprehend the effect of java methods. G-DCS uses natural language processing technology, and training the model uses a code corpus. This model could generate code summaries directly from the code files in the coded corpus. Compared with the traditional method, it uses the information of structural on the code. Through Graph Convolutional Neural Network (GCN) extracts the structural information on the code to generate the code sequence, which makes the generated code summary more accurate. The corpus used for training was obtained from GitHub. Evaluation criteria using BLEU-n. Experimental results show that our approach outperforms models that do not utilize code structure information.</p> <p> </p>

RECOMMENDING JAVA API METHODS BASED ON PROGRAMMING TASK DESCRIPTIONS BY NOVICE PROGRAMMERS

The overwhelming number of Application Programming Interfaces (APIs) and the lexical gap between novices’ programming task descriptions in their search queries and API documentations deter novice programmers from finding suitable API methods to be used in their code. To address the lexical gap, this study investigated novice programmers’ descriptions of their programming tasks and used the found insights in a novel approach (APIFind) for recommending relevant API methods for the programming tasks. Queries written by novice programmers were collected and analysed using term frequency and constituency parsing. Four common patterns related to the return type of an API method and/or API class that provides an implementation for the API method were found and captured in the Novice Programming Task Description Model (NPTDM). APIFind uses NPTDM that was operationalised in a rule-based module, a WordNet map of API word-synonyms, a programming task dataset comprising the collected queries, a Java API class and method repository, a Stack Overflow Q&A thread repository, and the BM25 model in Apache Lucene, to produce the top-5 API methods relevant to a search query. Benchmarking results using mean average precision @ 5 and mean reciprocal rank @ 5 as the evaluation metrics show that APIFind outperformed BIKER and CROKAGE when the novice queries test dataset was used. It performed slightly better than BIKER but slightly worse than CROKAGE when the reduced BIKER test dataset was used. In conclusion, common patterns exist in novice programmers’ search queries and can be used in API recommendations for novice programmers.

NURSE AND PATIENT PERCEPTION IN SELF-MONITORING OF DAWN EFFECT TO ENHANCE SELF-MANAGEMENT IN DIABETES MELLITUS PATIENT’S: A QUALITATIVE CASE STUDY

Background: A phenomenon in diabetes mellitus patients is called dawn effect, the condition of hyperglycemia suddenly increasing insulin requirement in the morning caused by nonattendance of nighttime hypoglycemia. Self-monitoring can be minimizing the impacts of dawn effect. Self-management can be actualized to oversee the blood glucose levels fluctuation in diabetes mellitus patients. Objective: to gain self-monitoring influencing factors of dawn effect phenomenon, and increase self-management in diabetic patient and nurse knowledge in Temanggung, Central Java Methods: A qualitative study design was used in this research with semi-structured interviews and open-ended questions. Participants were selected using purposive sampling technique from primary healthcare and secondary healthcare of both nurse and patient. Twelve participants consisted of senior nurse (n=5), patients with type 2 diabetes mellitus (n=7). Information of psychometric diabetes self-management scale and blood glucose monitoring were day by day collected within the morning. Result: Nurses' perception of the dawn effect is still relatively low due to a lack of knowledge and competence in self-management of diabetes patients. They followed the doctor's advice. In addition, the patient's perspective of blood glucose monitoring was taken into account, despite the fact that they did not have a glucometer from a mobile device (lack of self-management and dawn effect). Furthermore, all participants (n=7) increase in blood glucose level in the morning. Invasive glucometer has a high accuracy, but inducing finger discomfort, uncomfortable, and increase risk of infection when it checked daily. Conclusion: Perceptions of nurse and patient about self-monitoring can improve patient self-management and prevent the occurrence of dawn effects.

μDep: Mutation-Based Dependency Generation for Precise Taint Analysis on Android Native Code

The existence of native code in Android apps plays an important role in triggering inconspicuous propagation of secrets and circumventing malware detection. However, the state-of-the-art information-flow analysis tools for Android apps all have limited capabilities of analyzing native code. Due to the complexity of binary-level static analysis, most static analyzers choose to build conservative models for a selected portion of native code. Though the recent inter-language analysis improves the capability of tracking information flow in native code, it is still far from attaining similar effectiveness of the state-of-the-art information-flow analyzers that focus on non-native Java methods. To overcome the above constraints, we propose a new analysis framework, <inline-formula><tex-math notation="LaTeX">$\mu$</tex-math></inline-formula> Dep, to detect sensitive information flows of the Android apps containing native code. In this framework, we combine a control-flow based static binary analysis with a mutation-based dynamic analysis to model the tainting behaviors of native code in the apps. Based on the result of the analyses, <inline-formula><tex-math notation="LaTeX">$\mu$</tex-math></inline-formula> Dep conducts a stub generation for the related native functions to facilitate the state-of-the-art analyzer DroidSafe with fine-grained tainting behavior summaries of native code. The experimental results show that our framework is competitive on the accuracy, and effective in analyzing the information flows in real-world apps and malware compared with the state-of-the-art inter-language static analysis.

Method name recommendation based on source code metrics

Method naming is a critical factor in program comprehension, affecting software quality. State-of-the-art naming techniques use deep learning to compute the methods’ similarity considering their textual contents. They highly depend on identifiers’ names and do not compute semantical interrelations among methods’ instructions. Source code metrics compute such semantical interrelations. This article proposes using source code metrics to measure semantical and structural cross-project similarities. The metrics constitute features of a KNN model, determining k-most similar methods to a given method. Experiments with 4000000 Java methods on the proposed model demonstrate improvements in precision and recall of state-of-the-arts with 4.25 and 12.08%.

Bi-LSTM-Based Neural Source Code Summarization

Code summarization is a task that is often employed by software developers for fixing code or reusing code. Software documentation is essential when it comes to software maintenance. The highest cost in software development goes to maintenance because of the difficulty of code modification. To help in reducing the cost and time spent on software development and maintenance, we introduce an automated comment summarization and commenting technique using state-of-the-art techniques in summarization. We use deep neural networks, specifically bidirectional long short-term memory (Bi-LSTM), combined with an attention model to enhance performance. In this study, we propose two different scenarios: one that uses the code text and the structure of the code represented in an abstract syntax tree (AST) and another that uses only code text. We propose two encoder-based models for the first scenario that encodes the code text and the AST independently. Previous works have used different techniques in deep neural networks to generate comments. This study’s proposed methodologies scored higher than previous works based on the gated recurrent unit encoder. We conducted our experiment on a dataset of 2.1 million pairs of Java methods and comments. Additionally, we showed that the code structure is beneficial for methods’ signatures featuring unclear words.

VID2META: Complementing Android Programming Screencasts with Code Elements and GUIs

The complexity of software projects and the rapid technological evolution make it such that developers often need additional help and knowledge to tackle their daily tasks. For this purpose, they often refer to online resources, which are easy to access and contain a wealth of information in various formats. Programming screencasts hosted on platforms such as YouTube are one such online resource that has seen a growth in popularity and adoption over the past decade. These screencasts usually have some metadata such as a title, a short description, and a set of tags that should describe what the main concepts captured in the video are. Unfortunately, metadata are often generic and do not contain detailed information about the code showcased in the tutorial, such as the API calls or graphical user interface (GUI) elements employed, which could lead to developers missing useful tutorials. Having a quick overview of the main code elements and GUIs used in a video tutorial can be very helpful for developers looking for code examples involving specific API calls, or looking to design applications with a specific GUI in mind. The aim is to make this information easily available to developers, and propose VID2META, a technique that automatically extracts Java import statements, class names, method information, GUI elements, and GUI screens from videos and makes them available to developers as metadata. VID2META is currently designed to work with Android screencasts. It analyzes video frames using a combination of computer vision, deep learning, optical character recognition, and heuristic-based approaches to identify the needed information in a frame, extract it, and present it to the developer. VID2META has been evaluated in an empirical study on 70 Android programming videos collected from YouTube. The results revealed that VID2META can accurately detect and extract Java and GUI elements from Android programming videos with an average accuracy of 90%.

Revisiting the debate: Are code metrics useful for measuring maintenance effort?

Evaluating and predicting software maintenance effort using source code metrics is one of the holy grails of software engineering. Unfortunately, previous research has provided contradictory evidence in this regard. The debate is still open: as a community we are not certain about the relationship between code metrics and maintenance impact. In this study we investigate whether source code metrics can indeed establish maintenance effort at the previously unexplored method level granularity. We consider $\sim $ 730K Java methods originating from 47 popular open source projects. After considering seven popular method level code metrics and using change proneness as a maintenance effort indicator, we demonstrate why past studies contradict one another while examining the same data. We also show that evaluation context is king. Therefore, future research should step away from trying to devise generic maintenance models and should develop models that account for the maintenance indicator being used and the size of the methods being analyzed. Ultimately, we show that future source code metrics can be applied reliably and that these metrics can provide insight into maintenance effort when they are applied in a judiciously context-sensitive manner.