Nija Shi, Ronald A. Olsson · 2006
Recovering design patterns can enhance existing source code analysis tools by bringing program understanding to the design level. This paper presents a new, fully automated pattern detection approach. The new approach is based on our reclassification of the GoF patterns by their pattern intent. We argue that the GoF pattern catalog classifies design patterns in the forward-engineering sense; our reclassification is better suited for reverse engineering. Our approach uses lightweight static program analysis techniques to capture program intent. This paper also describes our tool, PINOT, that implements this new approach. PINOT detects all the GoF patterns that have concrete definitions driven by code structure or system behavior. Our tool is faster, more accurate, and targets more patterns than existing pattern detection tools. PINOT has been used successfully in detecting patterns in Java AWT, JHotDraw, Swing, Apache Ant, and many other programs and packages
Cited by 186
Camilo Andres Orejuela Sandoval, Manuel Alfonso Mora Montagut · Universidad Industrial de Santander · 2016
Los patrones de diseño son un tema del que se empezó a hablar en el mundo del software en la década de los 80, y desde ese entonces hasta la actualidad son un tema que se mantiene vigente y del que se sigue hablando, ya que pertenece a un campo que no pierde importancia, independientemente de las tecnologías del momento o de nuevas metodologías de desarrollo, y es el diseño de software. La banda de los cuatro (GoF, por sus siglas en inglés) definió un conjunto de patrones, que son los más populares en la industria. Este proyecto está enfocado en apoyar el aprendizaje de un subconjunto de dichos patrones GoF; específicamente 13 de ellos: Builder, Factory Method, Singleton, Adapter, Composite, Decorator, Command, Iterator, Memento, Observer, State, Strategy y Template Method. Para el fin de servir al aprendizaje de estos patrones, se creó un sitio web el cual se compone de contenido teórico escrito por los autores a cerca de estos patrones y una introducción a los mismos, así como ejemplos de aplicación de éstos usando el lenguaje de programación Java, los cuales el usuario puede descargar; además incluye una aplicación que permite al usuario generar código en Java luego de interactuar con el diagrama de clases de un patrón dado, aplicándolo a sus propios proyectos; en este generador de código, el usuario puede elegir el patrón que desea trabajar y enseguida escoger un elemento de ese patrón para modificar su nombre, sus atributos y sus métodos, pudiendo editar así todos los elementos de dicho patrón y finalmente generar el código correspondiente en Java.
Cited by 0Open access
Janardan Misra, Annervaz Km, Vikrant Kaulgud et al. · ACM SIGSOFT Software Engineering Notes · 2013
This is a report from an international workshop on "Social and Algorithmic Issues in Business Support" (SAIBS), which was organized in conjunction with the 16th ADBIS Conference in Poznan, Poland, on September 17, 2012. The main focus of this workshop was to provide a venue for the discussion whether social stands in opposition to algorithmic or systematic . We analyzed social contribution to business processes taking into account possible benefits and risk factors. Questions raised in collected research and discussion related to how far business could relay on social input and what were the limits or what were the areas where introducing crowdsourced components might increase overall risk value to unacceptable level? Algorithmic approach to observe and collect social behaviour was discussed in the context of internet auctions participants and car drivers equipped in mobile application for instant route planning and collecting feedback cartracking data. Having in mind Andrew Keen's critique of social contribution in Web 2.0-related phenomena we looked for the Wisdom of Crowds [1]. Collected conclusions and further dissemination of research results should lead to an improvement in utilizing social impact on software development and business processes.
Cited by 0Open access
Dhika Rizki Anbiya, Teddy Ferdinan, Grzegorz Kołaczek · Procedia Computer Science · 2025
Vulnerability detection is one of the main focuses of the security domain. The rise of the Large Language Model (LLM) has shown promising performance compared to static code analysis and machine learning with neural architecture in vulnerability detection. These results motivate the researcher to dive deeper into the capabilities of large language models, exploring their potential to improve the performance of the existing method. This research explores vulnerability detection through the use of LLM model employing a combination of Abstract Syntax Tree (AST) and Code Property Graph (CPG) as the code representation at the granularity level. We investigate the effectiveness of concatenating both representations as well as utilizing them separately. We conducted an experiment using LLM that pre-trained with source code as well the model that trained with text corpus as a comparison. We compare the representation with the original source code in order to compare the significance of the contribution. The Software Assurance Reference Dataset (SARD) and CVEFixes are used as the dataset. The result reveals that the LLM pre-trained on a text corpus achieves effective vulnerability outcomes through combined representation, while the CPG representation delivers positive results for all pre-trained models that leverage source code.
Cited by 0Open access
Greg J. Badros · 2008
The classical plain-text representation of source code is convenient for programmers but requires parsing to uncover the deep structure of the program. While sophisticated software tools parse source code to gain access to the program’s structure, many lightweight programming aids such as grep rely instead on only the lexical structure of source code. I describe a new XML application that provides an alternative representation of Java source code. This XML-based representation, called JavaML, is more natural for tools and permits easy specification of numerous software-engineering analyses by leveraging the abundance of XML tools and techniques. A robust converter built with the Jikes Java compiler framework translates from the classical Java source code representation to JavaML, and an XSLT stylesheet converts from JavaML back into the classical textual form.
Cited by 0
Min Li, Yue Sun, Cong Hou et al. · 2023
By conducting security auditing on source code, the root cause of security issues can be identified, and the system security risk can be reduced after effective repair of vulnerabilities. The existing source code detection methods mainly include tools scanning and manual auditing, both of the above approaches have shortcomings. This article focuses on optimizing the detection method combining static tool scanning and manual auditing, and designs a JAVA source code vulnerability detection device. The device includes a high false positive vulnerability prediction module and a manual auditing auxiliary function module, aiming to reduce the false positive rate of source code vulnerability detection and improve the efficiency and accuracy of manual auditing.
Cited by 0
Schott, Stefan, Fischer, Wolfram, Ponta, Serena Elisa et al. · arXiv (Cornell University) · 2024
Java applications include third-party dependencies as bytecode. To keep these applications secure, researchers have proposed tools to re-identify dependencies that contain known vulnerabilities. Yet, to allow such re-identification, one must obtain, for each vulnerability patch, the bytecode fixing the respective vulnerability at first. Such patches for dependencies are curated in databases in the form of fix-commits. But fixcommits are in source code, and automatically compiling whole Java projects to bytecode is notoriously hard, particularly for non-current versions of the code. In this paper, we thus propose JESS, an approach that largely avoids this problem by compiling solely the relevant code that was modified within a given commit. JESS reduces the code, retaining only those parts that the committed change references. To avoid name-resolution errors, JESS automatically infers stubs for references to entities that are unavailable to the compiler. A challenge is here that, to facilitate the above mentioned reidentification, JESS must seek to produce bytecode that is almost identical to the bytecode which one would obtain by a successful compilation of the full project. An evaluation on 347 GitHub projects shows that JESS is able to compile, in isolation, 72% of methods and constructors, of which 89% have bytecode equal to the original one. Furthermore, on the Project KB database of fix-commits, in which only 8% of files modified within the commits can be compiled with the provided build scripts, JESS is able to compile 73% of all files that these commits modify.
Cited by 0Open access
Emily Brown · Zenodo (CERN European Organization for Nuclear Research) · 2024
Cited by 0Open access
André Schäfer, Wolfram Amme, Thomas S. Heinze · 2021
A lot of clone detection tools for Java have been introduced in recent years. On the one hand, many of these tools work on Java source code and can thus be conveniently evaluated with the state-of-the-art benchmark BigCloneBench and evaluation framework BigCloneEval. On the other hand, certain clone detectors deliberately address the Bytecode and cannot be applied to Java source code. Simple compilation often does not solve the problem due to missing required dependencies, as, e.g., in case of BigCloneBench. In this work, we therefore present the tool STUBBER for compiling Java source code into Bytecode without dependencies. We can show that using Stubber, Bytecode for over 95% of all Java source files and 92.5% of all code clones contained in BigCloneBench can be successfully generated. As a consequence, the evaluation of Bytecode-based clone detectors on BigCloneBench becomes possible and such tools can also be applied to Java source files, even beyond BigCloneBench.
Cited by 16
Peyrona, Francisco Morero · Zenodo (CERN European Organization for Nuclear Research) · 2023
Java source code to make the validation of the Une language against Java language
Cited by 0Open access
Pablo Becker, Luis Olsina, María Fernanda Papa · Communications in computer and information science · 2023
Cited by 2
Dávid Tengeri, Ferenc Horváth, Árpád Beszédes et al. · SZTE Publicatio Repozitórium (University of Szeged) · 2016
Code coverage measurement is an important element in white-box testing, both in industrial practice and academic research. Other related areas are highly dependent on code coverage as well, including test case generation, test prioritization, fault localization, and others. Inaccuracies of a code coverage tool sometimes do not matter that much but in certain situations they can lead to serious confusion. For Java, the prevalent approach to code coverage measurement is to use bytecode instrumentation due to its various benefits over source code instrumentation. However, if the results are to be mapped back to source code this may lead to inaccuracies due to the differences between the two program representations. In this paper, we systematically investigate the amount of differences in the results of these two Java code coverage approaches, enumerate the possible reasons and discuss the implications on various applications. For this purpose, we relied on two widely used tools to represent the two approaches and a set of benchmark programs from the open source domain.
Cited by 16Open access
Oscar Karnalim, Rila Mandala · 2014
Information from computer programs can be extracted from its source code, external documentation, and compiled code. Although compiled code is an assured information source which is always exists in published computer programs, it is seldom used by the existing search engines since some reverse engineering tasks are needed. In this research, a search engine for Java archives that uses byte code (compiled code for Java Archive) as its information source is developed. It enables user to search within a collection of Java Archives without relying with source code and external documentation. Compared with Penta and FindJar [2] [7], A novel term extraction process beyond the file and class name is proposed, which includes field name, method name, string literal used in program, program flow weighting, and method expansion. Exclusive tokenization, stopping, and stemming are also implemented to improve effectiveness. Based on evaluation, it has a fairly good effectiveness although it may vary based on terms stored on index. Its effectiveness is higher than FindJar main features reimplementation which indicates that detailed compiled code has positive influences in computer programs search engine. Efficiency depends on how many terms stored on index and how many process used at certain step.
Cited by 11
Natarajan Meghanathan · 2012
Cited by 0
Alexander Gerhard Lercher, David Jamnig, Christian Macho et al. · Zenodo (CERN European Organization for Nuclear Research) · 2026
This repository contains the replication package for the Paper on "Generating Accurate OpenAPI Descriptions from Java Source Code". It consists of: the source code for the AutoOAS approach the CI integration files for GitHub and GitLab the improved evaluation dataset and the evaluation results answering research questions 1-3.
Cited by 0Open access
Alexander Gerhard Lercher, David Jamnig, Christian Macho et al. · Zenodo (CERN European Organization for Nuclear Research) · 2026
This repository contains the replication package for the Paper on "Generating Accurate OpenAPI Descriptions from Java Source Code". It consists of: the source code for the AutoOAS approach the CI integration files for GitHub and GitLab the improved evaluation dataset and the evaluation results answering research questions 1-3.
Cited by 0Open access
Gopinath Ganapathy, S. Sagayaraj · 2011
Abstract—Software development teams design new components and code by employing new developers for every new project. If the company archives the completed code and components, they can be reused with no further testing unlike the open source code and components. Program File components can be extracted from the Application files and folders using API’s. The proposed framework extracts the metadata from the source code using QDox code generators and stores it in the OWL using Jena framework automatically. The source code will be stored in the HDFS repository. Code stored in the repository can be reused for software development. By Archiving all the project files in to one ontology will enable the developers to reuse the code efficiently.
Cited by 6
Hassin, Dlobitul · eTheses of Maulana Malik Ibrahim State Islamic University (Maulana Malik Ibrahim State Islamic University) · 2012
ABSTRAK \n \nSource Code merupakan elemen penting dalam membangun suatu program. Dalam pembuatan suatu program, source code merupakan hal yang seharusnya paling dirahasiakan oleh seorang programmer atau penulis program. Namun kenyataannya berbeda, banyak pihak yang melakukan plagiarisme terhadap hasil programmer lain, baik hanya sebagian kode atau bahkan seluruh bagian utuh dari kode yang telah ditulis. Plagiarisme atau sering disebut plagiat adalah penjiplakan atau pengambilan karangan, pendapat, dan sebagainya dari orang lain dan menjadikannya seolah karangan dan pendapat sendiri. Salah satu contohnya adalah plagiarisme source code yang dilakukan mahasiswa informatika dalam memenuhi tugas-tugas pemrograman, seperti pemrograman bahasa java. \n \nSalah satu bidang yang dapat diterapkan untuk masalah ini adalah pencocokan kata (String Matching). Dalam penelitian ini algoritma string matching yang akan digunakan adalah Algoritma Brute Force. Adapun metodenya adalah dengan membandingkan urutan-urutan tiap reserved word dan keyword yang terdapat pada masing-masing prosedur atau fungsi, serta menghitung dan mencocokkan variabel yang ada. \n \nAdapun tujuan penelitian ini adalah membuat perangkat lunak yang dapat mendeteksi plagiarisme source code pada program bahasa java. Kemudian menganalisa hasil yang didapatkan oleh perangkat lunak ini dengan membandingkan hasil penghitungan manual yang dilakukan oleh manusia. \n \n \nABSTRACT \n \nSource Code is an important element in building a program. In the manufacture of a program, source code is kept secret that should most by a programmer. But the reality is different, many people who do the plagiarism of the other programmers, either the code or even just a part throughout the whole of the code has been written. Plagiarism is taking essay, opinion, and so on from other people and make it as his own essays and opinion. One example is the source code plagiarism committed informatics students in fulfilling programming tasks, such as the Java programming language. \n \nOne area that can be applied to this problem is String Matching. In this study the string matching algorithm to be used is the Brute Force algorithm. The method is to compare the sequences of each reserved word and the keyword contained in each procedure or function, and calculate and match the existing variable. \n \nThe purpose of this study is to create software that detects plagiarism source code in Java language programs. Then analyzes the results obtained by this software by comparing the results of manual calculations performed by humans.
Cited by 0
Couto, Rui, Ribeiro, António Nestor, Campos, J. Creissac · Portuguese National Funding Agency for Science, Research and Technology (RCAAP Project by FCT) · 2012
The ever increasing number of platforms and languages available to software developers means that the software industry is reaching high levels of complexity. Model Driven Architecture (MDA) presents a solution to the problem of improving software development processes in this changing and complex environment. MDA driven development is based on models definition and transformation. Design patterns provide a means to reuse proven solutions during development. Identifying design patterns in the models of a MDA approach helps their understanding, but also the identification of good practices during analysis. However, when analyzing or maintaining code that has not been developed according to MDA principles, or that has been changed independently from the models, the need arises to reverse engineer the models from the code prior to patterns' identification. The approach presented herein consists in transforming source code into models, and infer design patterns from these models. Erich Gamma's cataloged patterns provide us a starting point for the pattern inference process. MapIt, the tool which implements these functionalities is described.
Cited by 0Open access
André Schäfer, Thomas S. Heinze, Wolfram Amme · 2023
Copied, reused and modified program code is a common phenomena in software development. As the resulting code clones are often not labeled as such and their proper detection is crucial to software quality and re-engineering, numerous techniques and tools for finding code clones have been developed. This as well applies to the Java programming language, though most clone detectors work on Java source code. Only some research addresses code clones in Java Bytecode and an even smaller fraction investigates the relationship between Java source code and Bytecode code clones. In this paper, we extend the source-code based clone detector StoneDetector to Java Bytecode. Using BigCloneBench as state-of-the-art benchmark, we are able to assess and analyze its effectiveness in detecting source code clones in Java Bytecode. We also report on differences in the performance of clone detection for stack-based and register-based representations of Java Bytecode. The results show that, while code clones found in Java source code and Bytecode in general can differ, source code clones can be detected in Java Bytecode with high recall and precision using the presented system.
Cited by 4