Tao Xie, Wolfram Schulte, Suresh Thummalapenta et al. · 2009
An objective of unit testing is to achieve high structural cov-erage of the code under test. Achieving high structural cov-erage of object-oriented code requires desirable method-call sequences that create and mutate objects. These sequences help generate target object states such as argument or re-ceiver object states (in short as target states) of a method under test. Automatic generation of sequences for achieving target states is often challenging due to a large search space of possible sequences. On the other hand, code bases us-ing object types (such as receiver or argument object types) include sequences that can be used to assist automatic test-generation approaches in achieving target states. In this paper, we propose a novel approach, called MSeqGen, that mines code bases and extracts sequences related to receiver
Cited by 0
Juan José, Ramos González, Miquel Àngel et al. · 2015
To cope with the growing demands for simulation models of ever increasing complex industrial systems, the research community effort has been mainly focused in creating different software tools which simplify the modeling process. This work describes how the Object-Oriented Modeling language PML automates the modeling process by using physical knowledge in order to set the mathematical model of the system. The modeling language introduces a new modularization of the physical knowledge required to model a system, making a clear separation between the physical behavior representation (declarative knowledge) and the computational aspects of model simulation (procedural knowledge).The mathematical model can be formulated by means of an equation based language like EL or Modelica.
Cited by 0
Fábio Pasini, Fernando Luís Dotti · Electronic Notes in Theoretical Computer Science · 2007
During the development of a parallel application, besides being able to analyze performance aspects, it is highly desirable to be able to assure functional properties as early as possible. Assuring functional properties about a model of the parallel applicationcan lead to important savings since it reduces the time spent in application development and debugging. In this direction, model-checking and automatic code generation can be used as complementary tools during the development, making possible to analyze the system behavior and allowing the fast generation of corresponding code. In this paper we propose the use of Object-Based Graph Grammars (OBGG) for the specification of parallel applications. OBGG is a formal, visual language suited for the description of concurrent systems based on asynchronous message passing. Models described using OBGG can be verified through model checking. Following this approach, a translation from OBGG models to C code using MPI (Message Passing Interface), which is suited for clusters, is presented. To illustrate the contribution, a sample parallel application is modelled in OBGG; functional properties of the model are proven by model-checking; the C/MPI corresponding model is presented and performance results of the translated model are discussed and compared with an analogous C/MPI application built by hand.
Cited by 4Open access
Ananda Basu, Saddek Bensalem, Marius Bozga et al. · HAL (Le Centre pour la Communication Scientifique Directe) · 2012
International audience
Cited by 2Open access
Andrianjaka Miary Rapatsalahy, Hajarisena Razafimahatratra, Thomas Mahatody et al. · SYSTEM THEORY CONTROL AND COMPUTING JOURNAL · 2021
The final executable code should no longer be considered as a central element in a software development process but rather a naturally important component that results from a model transformation. The objective of the MDA (Model Driven Architecture) approach is to lift the lock of software development automation from the CIM (Computation Independent Model) requirements until the code of an application is obtained. Therefore, we have proposed in the framework of MDA an approach that consists of automatically generating object-oriented code from the CIM model represented by ReLEL (Restructuring extended Lexical Elaborate Language). ReLEL is a natural language-oriented model that represents both the client requirements and the conceptual level of a system. However, the MDA framework does not recommend the type of UML model that corresponds to each business activity. Consequently, automating the software development process from the CIM model specified by ReLEL becomes a complex task. Our strategy in this paper includes the instantiation of the ReLEL model in the Praxeme methodology, which models each of the company's concerns, grouped in a homogeneous whole, using the UML (Unified Modeling Language) and which considers the articulation of these aspects by adopting the MDA principle. To do this, we propose to automate the articulation that covers the intentional, semantic, logical, and software aspects of Praxeme. To validate our approach, we measure the coupling and cohesion of the UML class diagram obtained from the Java code generated from this article using the slicing technique. The results show that the coupling is weak, and the cohesion is strong. It can be deduced that the method proposed in this paper can produce a more reliable and efficient system.
Cited by 2Open access
Ronaldo Rodrigues Ferreira · 2008
This work tailors an Alloy model translator to Java code and an estimate tool for physical resources optimization into a design-flow. Experimental results show distinct implementation strategies only varying data structures used in generated Java code.
Cited by 5
Ridwan Rismanto · Jurnal Teknologi Informasi · 2016
The increase towards Object Oriented Design creates a big gap between OO and relational database. In the other side, relational database still a big favor in designing business-powered application. Developers use Object Relational Mapping (ORM) to fill the gap between OO and RDBMS but still, the problem in the association of RDBMS and OO exists which caused underestimation towards ORM methodology. This research provides a solution to detect relationship inside tables of database, generate LINQ query to map the field of tables to the attribute of the entity classes. Using T4 text templating we are able to generate the whole Data Access Object class which provides transparent encapsulation and relational mapping for the system. Keywords : Object Relational Mapping, Relational Database, Object Technology, LINQ, Multi Tier Architecture, Text Templating, T4
Cited by 0Open access
Batuhan Aşıroğlu, Sibel Senan, Pelin Görgel et al. · 2022 International Congress on Human-Computer Interaction, Optimization and Robotic Applications (HORA) · 2022
The Graphical User Interfaces (GUIs) of web applications include visuals and designs that allow users to interact with machines. Once the GUI design is done, it is necessary to generate its GUI code. However, the GUI code generation process is highly time consuming as well as highly dependent on software developers. Therefore, the development of automatic GUI code generating systems is of great importance recently. In this study, a GUI code generating system for web sites is designed using the Deep Learning (DL) approach. The dataset including “coordinate, width, height and type” of GUI objects is created using 7500 webpages. The created dataset is applied to the proposed system in order to detect objects in the GUI image and generate DSL mark-up code. Experiments were carried out to analyze the effectiveness of the proposed system and the performance evaluations were made.
Cited by 4
Donald M. Needham, Thomas Peters, S. A. Demurjian · IFIP advances in information and communication technology · 1997
Cited by 2
LIU Zhuang, GU Kangzheng, TAN Xin, ZHANG Yuan · SHILAP Revista de lepidopterología · 2025
Developing exploits for vulnerabilities is the primary method of evaluating the exploitability of kernel vulnerabilities. Heap spraying objects are widely used in the exploitation process to execute malicious behaviors, such as malicious content injection and memory layout manipulation. Currently, the basic types of heap spraying objects have received limited attention, and code that can edit the content of heap spraying objects has not been generated. Therefore, this paper proposes the automated technplogy for heap spraying objects manipulationg code for kernel vulnerabilities exploitation. This technology includes heap spraying object recognition based on usage-definition chain analysis and heap spraying object control code generation based on guided fuzzy testing. Usage-definition chain analysis is used to statically identify heap spraying objects within the target kernel and the key code positions that can manipulate these objects. Using the identified key codes as target points, guided fuzzy testing technology is applied to dynamically generate control codes for the target heap spraying object to assist in vulnerability exploitation. Experimental results show that the techniques can identify and generate the control code of 28 heap spraying objects in Linux 5.15, which covers all heap spraying objects identified in existing works. 23 generated codes can control the heap spraying object to achieve the expected target with a success rate of 82.1%. The case analysis shows that the manipulating code generated by these techniques can be used to exploit real-world kernel vulnerabilities.
Cited by 0Open access
Jialun Cao, Zhiyong Chen, Jiarong Wu et al. · 2024
Code generation benchmarks such as HumanEval are widely adopted to evaluate LLMs' capabilities. However, after consolidating the latest 24 benchmarks, we noticed three significant imbalances. First, imbalanced programming language. 95.8% of benchmarks involve Python, while only 5 benchmarks involve Java, resulting in an insufficient understanding of LLMs' capability to generate Java code. Second, imbalanced code granularity. Function-/statement-level benchmarks account for over 83.3% of benchmarks. Only a mere handful extends to class-/project-levels, and all are limited to Python. Third, lacking advanced features. Existing benchmarks primarily assess basic coding skills (e.g., variables, operators, and control structures), while overlooking advanced Object-Oriented Programming (OOP) features (i.e., encapsulation, inheritance, and polymorphism). Considering the prevalence of these advanced features in real-world Java project development, constructing benchmarks to test LLMs on handling OOP features is necessary.
Cited by 9
Karim El Guemhioui, S. A. Demurjian, Thomas Peters · 1993
In the past five years, there has been an increased emphasis and interest in the object-oriented approack with its benefits of data encapsulation irtfortnation hiding, snd inheritance, for design and development. We are about to enter a titne-frame when Ada83 and Ada9X will both be available. Thus, there is a need for support in training artd educatimt of software engineers aqd students, to facilitate a smooth transition between the two language dialects. Our efforts to support this trsn$tion involve the object-oriented tool ADAM (Active Design and Analyses Model) that allows graphical and interactive language-independent design which is complemented with multiple language-specific code generators (i.e., Ada83, C++, Ontos-Ci+, with Modttla-3 and Ada9X in the plsrtning stages) that automatically provide a si~lcant portion of the application's code. ADAM will be employed during 1993-1994 in our junior year software engineering sequence to investigate the integration of object-oriented design and Ada83. We tdso believe software engineers who are familiar with Ada83, but not with Ada9X or the object-oriented approach can utilize ADAM to learn Ada9Xs language syntax and semantics by contrasting the generated Ada9X and Ade83 code for the same object-oriented design (another goal of our research and education efforts). This paper examines many of the aforementioned issues, with a focus on translation of an ADAM-created object-oriented design into Ada83 co&.
Cited by 5Open access
Ganesan Karthigeyan · Zenodo (CERN European Organization for Nuclear Research) · 2025
Low-cost vision-based object reconstruction has gained significant interest due to advancements in embedded computing and additive manufacturing. This paper presents an end-to-end system for vision-based object reconstruction using a Raspberry Pi and an OV5467 camera module. The proposed pipeline captures two-dimensional images of physical objects, extracts object contours using classical computer vision techniques, converts the contours into scalable vector graphics (SVG), and generates corresponding G-code for fabrication using a 3D printer. In the current implementation, the Z-axis is maintained constant, enabling accurate reconstruction of the object’s geometry in the X–Y plane. Experimental results demonstrate that the generated toolpaths closely match the original object contours. The system provides a scalable foundation for future integration of depth mapping techniques to enable full three-dimensional reconstruction.
Cited by 0Open access
Gernot Gebhard · 2007
Abstract. Retargeting a compiler’s back end to a new architecture is a time-consuming process. This becomes an evident problem in the area of programmable graphics hardware (graphics processing units, GPUs) or embedded processors, where architectural changes are faster than elsewhere. We propose the object-oriented rewrite system OORS to overcome this problem. Using the OORS language, a compiler developer can express the code generation and optimization phase in terms of costannotated rewrite rules supporting complex non-linear matching and replacing patterns. Retargetability is achieved by organizing rules into profiles, one for each supported target architecture. Featuring a rule and profile inheritance mechanism, OORS makes the reuse of existing specification possible. This is an improvement regarding traditional approaches. Altogether OORS increases the maintainability of the compiler’s back end and thus both decreases the complexity and reduces the effort of the retargeting process. To show the potential of this approach, we have implemented a code generation and a code optimization pattern matcher supporting different target architectures using the OORS language and introduced them in a GPU compiler. 1
Cited by 0
Marcellus Antonius de Castro Tavares · 2011
Cited by 0
Ganesan Karthigeyan · Zenodo (CERN European Organization for Nuclear Research) · 2025
Low-cost vision-based object reconstruction has gained significant interest due to advancements in embedded computing and additive manufacturing. This paper presents an end-to-end system for vision-based object reconstruction using a Raspberry Pi and an OV5467 camera module. The proposed pipeline captures two-dimensional images of physical objects, extracts object contours using classical computer vision techniques, converts the contours into scalable vector graphics (SVG), and generates corresponding G-code for fabrication using a 3D printer. In the current implementation, the Z-axis is maintained constant, enabling accurate reconstruction of the object’s geometry in the X–Y plane. Experimental results demonstrate that the generated toolpaths closely match the original object contours. The system provides a scalable foundation for future integration of depth mapping techniques to enable full three-dimensional reconstruction.
Cited by 0Open access
M. Kuhl, C. Reichmann, I. Protel et al. · 2003
In this paper a new high-level system design approach for electronic systems is presented. It supports object-oriented system modeling of software intensive components with the Unified Modeling Language and time-discrete and time-continuous modeling concepts. Our approach supports structural and behavioral modeling with front-end tools and simulation/emulation with back-end tools. The XMI (XML Metadata Exchange) format and the UML metamodel is used for an exchange and storage of CASE data. The CASE tool chain, which we present in this paper, supports concurrent engineering with versioning and configuration management and provides tool adaptors for MATLAB/Simulink and ARTiSAN Real-Time Studio. Using the Unified Modeling Language notation for an overall system design cycle, the focus of this paper lies on the subsystem coupling of different modeling domains and a new code generation approach.
Cited by 13
TAVARES, Marcellus Antonius de Castro · LA Referencia (Red Federada de Repositorios Institucionales de Publicaciones Científicas) · 2011
Antonius de Castro Tavares, Marcellus; Pierre Louis Robin, Jacques. Behavioral java code generation from imperative object constraint language expressions in plataformindependent UML models. 2011. Dissertação (Mestrado). Programa de Pós-Graduação em Ciência da Computação, Universidade Federal de Pernambuco, Recife, 2011.
Cited by 0Open access
Ashraf Syed · International Journal of Multidisciplinary Research and Growth Evaluation · 2023
The convergence of low-code platforms with cloud services represents a paradigm shift in enterprise application development, enabling rapid, scalable solutions for unstructured data management and dynamic document creation. This paper proposes a low-code architectural framework integrating Oracle Application Express (APEX) with Oracle Cloud Infrastructure (OCI) Object Storage for durable file handling and OCI Document Generation for serverless template-based output. Rooted in APEX's metadata-driven database architecture, the framework utilizes PL/SQL packages like DBMS_CLOUD for storage operations and APEX_WEB_SERVICE for RESTful calls to OCI APIs, ensuring seamless data flow and minimal custom coding. The methodology outlines declarative integration patterns, emphasizing security through OCI Identity and Access Management (IAM) and performance optimization via serverless execution. Discussions evaluate architectural synergies, including cost reduction and scalability, while business cases demonstrate applications in invoice automation and legal workflows. Future trends highlight AI-assisted enhancements for no-code evolution. This work contributes a practical blueprint for organizations seeking efficient, compliant integrations, to address gaps in low-code cloud synergies.
Cited by 0Open access
Youngbae Kim, Heekyung Kim, Nandakishor Yadav et al. · Electronics · 2020
In the implementation process of a convolution neural network (CNN)-based object detection system, the primary issues are power dissipation and limited throughput. Even though we utilize ultra-low power dissipation devices, the dynamic power dissipation issue will be difficult to resolve. During the operation of the CNN algorithm, there are several factors such as the heating problem generated from the massive computational complexity, the bottleneck generated in data transformation and by the limited bandwidth, and the power dissipation generated from redundant data access. This article proposes the low-power techniques, applies them to the CNN accelerator on the FPGA and ASIC design flow, and evaluates them on the Xilinx ZCU-102 FPGA SoC hardware platform and 45 nm technology for ASIC, respectively. Our proposed low-power techniques are applied at the register-transfer-level (RT-level), targeting FPGA and ASIC. In this article, we achieve up to a 53.21% power reduction in the ASIC implementation and saved 32.72% of the dynamic power dissipation in the FPGA implementation. This shows that our RTL low-power schemes have a powerful possibility of dynamic power reduction when applied to the FPGA design flow and ASIC design flow for the implementation of the CNN-based object detection system.
Cited by 21Open access