David Eng · ACM SIGSOFT Software Engineering Notes · 2002
The task of developing, tuning, and debugging compiler optimizations is a difficult one which can be facilitated by software visualization. There are many characteristics of the code which must be considered when studying the kinds of optimizations which can be performed. Both static data collected at compile-time and dynamic runtime data can reveal opportunities for optimization and affect code transformations. In order to expose the behavior of such complex systems, visualizations should include as much information as possible and accommodate the different sources from which this information is acquired.This paper presents a visualization framework designed to address these issues. The framework is based on a new, extensible language called JIL which provides a common format for encapsulating intermediate representations and associating them with compile-time and runtime data. We present new contributions which extend existing compiler and profiling frameworks, allowing them to export the intermediate languages, analysis results, and code metadata they collect as JIL documents. Visualization interfaces can then combine the JIL data from separate tools, exposing both static and dynamic characteristics of the underlying code. We present such an interface in the form of a new web-based visualizer, allowing JIL documents to be visualized online in a portable, customizable interface.
Cited by 0
2008
The task of developing, tuning, and debugging compiler optimizations is a difficult one which can be facilitated by software visualization. There are many characteristics of the code which must be considered when studying the kinds of optimizations which can be performed. Both static data collected at compile-time and dynamic runtime data can reveal opportunities for optimization and affect code transformations. Visualization of such complex systems must include as much information as possible, and accommodate the different sources from which this information is acquired. This paper presents a visualization framework designed to address these issues. The framework is based on a new, extensible language called JIL which provides a common format for encapsulating intermediate representations and associating them with compile-time and runtime data. Custom visualization interfaces can then combine JIL data from separate tools, exposing both static and dynamic characteristics of the underlying code.
Cited by 0
CORAZZA, GIOVANNI EMANUELE, PALESTINI, CLAUDIO, PEDONE, RAFFAELLA et al. · Archivio istituzionale della ricerca (Alma Mater Studiorum Università di Bologna) · 2006
The problem of code acquisition for Galileo receivers is considered in this paper, with the aim of improve the receiver\nsensitivity, enabling indoor positioning. Non-Coherent Soft combining with Post Detection Integration (PDI) is proposed to cope with the presence of the unwanted secondary code data transitions as well as non-ideal carrier recovery. Analytical and simulated results show that the proposed approach is an interesting solution to provide satisfactory performance with limited complexity.
Cited by 1
I. Martı́n, B. Honary · Electronics Letters · 2000
A novel code combining system based on Reed-Muller codes is presented. Because of their simple structure RM codes are simple to decode using a trellis based soft maximum likelihood decoder (SMLD). The decoder exploits the modular structure of the RM code to construct a set of nested trellises which minimise the complexity of the decoder by re-using the results of previous decoding attempts. A protocol utilising this technique to produce an efficient code combining ARQ-scheme is also introduced.
Cited by 1
Jonathan Cairns, Kelly Fleming · OSTI OAI (U.S. Department of Energy Office of Scientific and Technical Information) · 1977
The STADIC computer code uses a Monte Carlo simulation technique for combining probability distributions. The specific function for combination of the input distribution is defined by the user by introducing the appropriate FORTRAN statements to the appropriate subroutine. The code generates a Monte Carlo sampling from each of the input distributions and combines these according to the user-supplied function to provide, in essence, a random sampling of the combined distribution. When the desired number of samples is obtained, the output routine calculates the mean, standard deviation, and confidence limits for the resultant distribution. This method of combining probability distributions is particularly useful in cases where analytical approaches are either too difficult or undefined.
Cited by 1Open access
Nathan Whitehead · 2005
We propose creating a general mechanism for specifying and enforcing authorization policies that rely on both reason and trust. In particular, it will support extensible software systems that employ both digitally signed code and language-based security, especially proof-carrying code. Our system will be a combination of an authorization logic based on the Binder language with a logical framework, Coq, able to express semantic properties of programs. We give a short overview of our dissertation proposal which includes a preliminary plan for the project. We then present details of our project related to the design, analysis, implementation and validation of our proposed system. We also consider some possible extensions such as short probabilistic proofs and a secure version control
Cited by 0
Valerio Bertone, Stefano Carrazza · arXiv (Cornell University) · 2016
We present sets of parton distribution functions (PDFs), based on the NNPDF3.0 family, which include the photon PDF from the NNPDF2.3QED sets, and leading-order QED contributions to the DGLAP evolution as implemented in the public code APFEL. The aim is to combine our state-of-the-art determination of quark and gluon PDFs with the so far only direct determination of the photon PDF from LHC data. In addition, the use of APFEL allowed us to employ a solution of the DGLAP equation that, differently from that used for the NNPDF2.3QED sets, includes QED corrections in a more accurate way. We briefly discuss how these sets are constructed and investigate the effect of the inclusion of the QED corrections on PDFs and parton luminosities. Finally, we compare the resulting sets, which we dubbed NNPDF3.0QED, to the older NNPDF2.3QED sets and to all presently available PDF sets that include QED corrections, namely CT14QED and MRST2004QED.
Cited by 8Open access
WANG Runzheng, GAO Jian, TONG Xin, YANG Mengqi · SHILAP Revista de lepidopterología · 2021
In recent years, with the diversification of malicious code family and the enhancement of confounding countermeasures, traditional detection methods for malicious code are difficult to achieve good classification effect. Therefore, a malicious code family classification model combining attention mechanism is proposed. Firstly, this paper uses the reverse disassembly tool to obtain the features of each section of the malicious sample, and uses visualization technology to convert each section into each channel of RGB color image. Secondly, the channel domain and spatial domain attention mechanism are introduced to build the depthwise separable convolution network based on the mixed domain attention mechanism, and the image texture features of the malicious samples are extracted from the channel and space dimensions. Finally, nine categories of malicious code family are selected to train and test the model. The experimental result shows that the accuracy of the classification of malicious code family by a single section feature is lower than that by fusion feature, which can effectively distinguish various types of malicious code family. Compared with traditional neural network models, the proposed model achieves better classification effect and the classification accuracy of the model reaches 98.38%.
Cited by 0Open access
Qin Ma, Sam Schmit, Christian Glodt et al. · Open Repository and Bibliography (University of Luxembourg) · 2014
In the pure model-driven view of software engineering, models are the sole artifacts to be created and maintained and executable source code is entirely generated from the models. However, due to the variety of modern platforms and the complexity of capturing them correctly in models, this vision has not yet been fully realized. In this paper, we propose an approach that allows combining high-level models with low-level code into an executable system. The approach is based on two modeling languages, one presenting a common abstraction of modeling and programming languages, and the other allowing to express the bridge between the model and code. We illustrate our approach using a running example of an invoicing system for which the business logic requirements are captured by an executable model and the requirements on the graphical user interface are directly mocked up using a GUI designer tool that generates Java code.
Cited by 0Open access
A. Yu. Gerasimov, Sevak Sargsyan, S.Sh. Kurmangaleev et al. · Proceedings of the Institute for System Programming of RAS · 2018
This paper describes a new approach for dynamic code analysis. It combines dynamic symbolic execution and static code analysis with fuzzing to increase efficiency of each component. During fuzzing we recover indirect function calls and pass that information to the static analysis engine. This improves static path detection in the control flow graph of a program. Detected paths are used in dynamic symbolic execution to construct inputs which will cover new paths during execution. These inputs are used by the fuzzing tool to improve test-case generation and increase code coverage. The proposed approach can be used for classic fuzzing when the main goal is achieving high code coverage. As well it can be used for targeted analysis of paths and code fragments in the program. In this case the fuzzing tool accepts a set of programs addresses with potential defects and passes them to the static analysis engine. The engine constructs all paths connecting program entry point to the given addresses. Finally, dynamic symbolic execution is used to construct the set of inputs, which will cover these paths. Experimental results have shown that the proposed method can effectively detect different program defects.
Cited by 6Open access
Narasimhan, Krishna · Publication Server of Goethe University Frankfurt am Main (Goethe University Frankfurt) · 2017
Software evolves. Developers and programmers manifest the needs that arise due to evolving software by making changes to the source code. While developers make such changes, reusing old code and rewriting existing code are inevitable. There are many challenges that a developer faces when manually reusing old code or rewriting existing code. Software tools and program transformation systems aid such reuse or rewriting of program source code. But there are significantly occuring development tasks that are hard to accomplish manually, where the current state-of-the-art tools are still not able to adequately automate these tasks. In this thesis, we discuss some of these unexplored challenges that a developer faces while reusing and rewriting program source code, the significance of such challenges, the existing automation support for these challenges and how we can improve upon them. Modern software development relies on code reuse, which software developers typically realize through hand-written abstractions, such as functions, methods, or classes. However, such abstractions can be challenging to develop and maintain. An alternative form of reuse is \emph{copy-paste-modify}, in which developers explicitly duplicate source code to adapt the duplicate for a new purpose. Copy-pasted code results in code clones, i.e., groups of code fragments that are similar to each other. Past research strongly suggests that copy-paste-modify is a popular technique among software developers. In this paper, we perform a small user study that shows that copy-paste-modify can be substantially faster to use than manual abstraction. One might propose that software developers should forego hand-written abstractions in favour of copying and pasting. However, empirical evidence also shows that copy-paste-modify complicates software maintenance and increases the frequency of bugs. Furthermore, the developers in an informal poll we conducted strongly preferred to read code written using abstractions. To address the concern around copy-paste-modify, we propose a tool that merges similar pieces of code and automatically creates suitable abstractions. Our tool allows developers to get the best of both worlds: easy reuse together with custom abstractions. Because different kinds of abstractions may be beneficial in different contexts, our tool provides multiple abstraction mechanisms, which we selected based on a study of popular open-source repositories. To demonstrate the feasibility of our approach, we have designed and implemented a prototype merging tool for C++ and evaluated our tool on a number of clones exhibiting some variation, i.e near clones, in popular Open Source packages. We observed that maintainers find our algorithmically created abstractions to be largely preferable to existing duplicated code. Rewriting existing code can be considered as a form of program transformation, where a program in one form is transformed into a program in another form. One significant form of program transformation is data representation migration that involves changing the type of a particular data structure, and then updating all of the operations that has a control or data dependence on that data structure according to the new type. Changing the data representation can provide benefits such as improving efficiency and improving the quality of the computed results. Performing such a transformation is challenging, because it requires applying data-type specific changes to code fragments that may be widely scattered throughout the source code connected by dataflow dependencies. Refactoring systems are typically sensitive to dataflow dependencies, but are not programmable with respect to the features of particular data types. Existing program transformation languages provide the needed flexibility, but do not concisely support reasoning about dataflow dependencies. To address the needs of data representation migration, we propose a new approach to program transformation that relies on a notion of semantic dependency: every transformation step propagates the transformation process onward to code that somehow depends on the transformed code. Our approach provides a declarative transformation specification language, for expressing type-specific transformation rules. We further provide scoped rules, a mechanism for guiding rule application, and tags, a device for simple program analysis within our framework, to enable more powerful program transformations. We have implemented a prototype transformation system based on these ideas for C and C++ code and evaluate it against three example specifications, including vectorization, transformation of integers to big integers, and transformation of array-of-structs data types to struct-of-arrays format. Our evaluation shows that our approach can improve program performance and the precision of the computed results, and that it scales to programs of at least 3700 lines.
Cited by 0Open access
Zillay Huma · 2025
Cited by 0Open access
Марат Халимович Ахин, Михаил Анатольевич Беляев, Владимир Михайлович Ицыксон · Modeling and Analysis of Information Systems · 2015
Bounded model checking (BMC) of C/C++ programs is a matter of scientific enquiry that attracts great attention in the last few years. In this paper, we present our approach to this problem. It is based on combining several recent results in BMC, namely, the use of LLVM as a baseline for model generation, employment of high-performance Z3 SMT solver to do the formula heavy-lifting, and the use of various function summaries to improve analysis efficiency and expressive power. We have implemented a basic prototype; experiment results on a set of simple test BMC problems are satisfactory.
Cited by 0Open access
Davison, Robert M., Wong, Louie H. M., Alter, Steven · Journal of the Association for Information Systems · 2024
We explore a novel context where employees engage in low-code no-code work, enabled by software-based workarounds that don’t comply with organizational norms and aren’t endorsed by corporate management, yet are essential to organizational success. We describe how employees at a warehouse that supports a major retailer in Hong Kong engage in work practices combining low-code/no-code approaches with noncompliant workaround behaviors. We consider the practical implications and potential contributions of such noncompliant work and provide recommendations for business managers overseeing low-code/no-code efforts.
Cited by 0
Robert M. Davison, Louie H.M. Wong, Steven Alter · MIS Quarterly Executive · 2024
We explore a novel context where employees engage in low-code no-code work, enabled by software-based workarounds that don’t comply with organizational norms and aren’t endorsed by corporate management, yet are essential to organizational success. We describe how employees at a warehouse that supports a major retailer in Hong Kong engage in work practices combining low-code/no-code approaches with noncompliant workaround behaviors. We consider the practical implications and potential contributions of such noncompliant work and provide recommendations for business managers overseeing low-code/no-code efforts.
Cited by 3
D. Chase · IRE Transactions on Communications Systems · 1985
It is well known that if the data rate is chosen below the available channel capacity, error-free communication is possible. Furthermore, numerous practical error-correction coding techniques exist which can be chosen to meet the user's reliability constraints. However, a basic problem in designing a reliable digital communication system is still the choice of the actual code rate. While the popular rate-1/2 code rate is a reasonable, but not optimum, choice for additive Gaussian noise channels, its selection is far from optimum for channels where a high percentage of the transmitted bits are destroyed by interference. Code combining represents a technique of matching the code rate to the prevailing channel conditions. Information is transmitted in packet formats which are encoded with a relatively high-rate code, e.g., rate 1/2, which can be repeated to Obtain reliable communications when the redundancy in a rate-1/2 code is not sufficient to overcome the channel interference. The receiver combines noisy packets (code combining) to obtain a packet with a code rate which is low enough such that reliable communication is possible even for channels with extremely high error rates. By combining the minimum number of packets needed to overcome the channel conditions, the receiver optimizes the code rate and minimizes the delay required to decode a given packet. Thus, the receiver adapts to the actual jammer-to-signal <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">(J/S)</tex> ratio which is critical when the level of interference <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">J</tex> is not known a priori.
Cited by 915
Alexandra Savin, Lucian Trifina · 2013
In this paper, we present a scheme combining a parallel turbo code and a space-time block code for multiple input multiple output (MIMO) systems. The space-time block code is represented by the full rate Golden code characterized by the Golden number -1+√5/2. The turbo code consists of the parallel concatenation of two recursive systematic convolutional codes and an interleaver. For the purpose of demonstrating the interleavers efficiency and importance, three different types of interleavers were used. Compared with the similar scheme that uses a nonrecursive non-systematic convolutional code instead of the turbo code for BER=10 <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">-4</sup> a 3dB coding gain is obtained.
Cited by 0
José Martins, Frederico Branco, Henrique São Mamede · Intelligent Systems with Applications · 2023
Low-code tools are a trend in software development for business solutions due to their agility and ease of use. There are a certain number of vendors with such solutions. Still, in most Western countries, there is a clear need for the existence of greater quantities of certified and experienced professionals to work with those tools. This means that companies with more resources can attract and maintain those professionals, whilst other smaller organizations must rely on an endless search for this scarce resource. We will present and validate a model designed to transform ChatGPT into a low-code developer, addressing the demand for a more skilled human resource solution. This innovative tool underwent rigorous validation via a focus group study, engaging a panel of highly experienced experts. Their invaluable insights and feedback on the proposed model were systematically gathered and meticulously analysed.
Cited by 25Open access
Brussel , W.L. van · Theses database, Tilburg University · 2025
Cited by 0
Bembenek, Aaron · Digital Access to Scholarship at Harvard (DASH) (Harvard University) · 2023
Datalog and SAT solving are powerful forms of automated logic that are both used to reason about the correctness of software. However, they are very different, and they are not typically combined in the same automated reasoning tool. This dissertation explores how to build code-reasoning tools that combine these complementary technologies, through two main thrusts: 1) the design and implementation of the logic-centric programming language Formulog, and 2) a progression of tools for Datalog program synthesis. In doing so, it explores the challenge of combining Datalog and SAT-based reasoning at multiple levels, viewing it variously as a language design problem, a system implementation problem, and a constraint solving problem. A domain-specific language for writing static analyses (programs that analyze other programs), Formulog augments Datalog with first-order functional programming and SMT solving, an extension to SAT solving. In Formulog, SMT formulas are data that can be constructed and inspected; a novel type system allows expressive SMT formulas while ensuring that neither normal evaluation nor SMT solving crashes. Formulog’s combination of features makes it possible to state a range of SMT-based analyses in a way that is both close to their formal specifications, and amenable to high-level optimizations and efficient evaluation. In addition to the design of Formulog, this dissertation presents implementation strategies for achieving good runtime performance. This includes a compiler from Formulog to Soufflé (an established Datalog system), as well as “eager evaluation,” a novel parallel execution algorithm for Datalog that leads to improved SMT solving times when used to evaluate Formulog programs. Thanks to these techniques, Formulog’s performance is competitive with (and sometimes much better than) non-Datalog reference implementations on diverse SMT-based case studies: refinement type checking, bottom-up points-to analysis, and symbolic execution. Finally, the dissertation presents a progression of tools for synthesizing Datalog programs (i.e., generating them automatically from specifications). Each tool explores a different way of combining Datalog and SAT/SMT solving; the ultimate solution takes advantage of answer set programming (ASP)—a constraint solving paradigm that subsumes Datalog and SAT-like reasoning—and achieves nearly order-of-magnitude geometric mean speedups over the prior state-of-the-art solution. This work elucidates connections between Datalog and SAT/SMT solving (for example, it shows that every Datalog program is the basis of a theoretically efficient SMT theory), and suggests the potential of using ASP to reason about Datalog programs.
Cited by 0Open access