Search

In recent years, code obfuscation has attracted both researchers and software developers as a useful technique for protecting secret properties of proprietary programs. The idea of code obfuscation is to modify a program, while preserving its functionality, in order to make it more difficult to analyze. Thus, the aim of code obfuscation is to conceal certain properties to an attacker, while revealing its intended behavior. However, a general methodology for deriving an obfuscating transformation from the properties to conceal and reveal is still missing. In this work, we start to address this problem by studying the existence and the characterization of function transformers that minimally or maximally modify a program in order to reveal or conceal a certain property. Based on this general formal framework, we are able to provide a characterization of the maximal obfuscating strategy for transformations concealing a given property while revealing the desired observational behavior. To conclude, we discuss the applicability of the proposed characterization by showing how some common obfuscation techniques can be interpreted in this framework. Moreover, we show how this approach allows us to deeply understand what are the behavioral properties that these transformations conceal, and therefore protect, and which are the ones that they reveal, and therefore disclose. [ABSTRACT FROM AUTHOR]

We present a static analysis for determining whether and to what extent functions in JavaScript programs are pure. To this end, the analysis classifies functions as pure functions, observers, or procedures. A function is pure if none of its executions generate or depend upon externally observable side effects. A function is an observer as soon as one of its executions depends on an external side effect, but none of its executions generate observable side effects. Otherwise, the function is classified as a procedure. Function executions and associated callers are found by traversing all reachable function execution contexts on the call stack at the point where an effect occurs. Our approach is based on a flow analysis that, in addition to computing traditional control and value flow, keeps track of read and write effects. To increase the precision of our purity analysis, we combine it with an intraprocedural analysis that determines freshness of variables and objects. We formalize the core aspects of our technique and discuss its implementation and results on common JavaScript benchmarks. Results show that our approach is capable of determining function purity in the presence of higher-order functions, dynamic property expressions, and prototypal inheritance. When compared with existing purity analyses, we find that our approach is as precise or more precise than the existing analyses. [ABSTRACT FROM AUTHOR]

This paper presents PinMesh, a very fast algorithm with implementation to preprocess a polyhedral mesh, also known as a multi-material mesh, in order to perform 3D point location queries. PinMesh combines several innovative components to efficiently handle the largest available meshes. Because of a 2-level uniform grid, the expected preprocessing time is linear in the input size, and the code parallelizes well on a shared memory machine. Querying time is almost independent of the dataset size. PinMesh uses exact arithmetic with rational numbers to prevent roundoff errors, and symbolic perturbation with Simulation of Simplicity (SoS) to handle geometric degeneracies or special cases. PinMesh is intended to be a subroutine in more complex algorithms. It can preprocess a dataset and perform 1 million queries up to 27 times faster than RCT (Relative Closest Triangle), the current fastest algorithm. Preprocessing a sample dataset with 50 million triangles took only 14 elapsed seconds on a 16-core Xeon processor. The mean query time was 0.6μs. [ABSTRACT FROM AUTHOR]

Nonlinear dynamical system optimization problems exist in many scientific fields, ranging from computer vision to quantitative finance. In these problems, the underlying optimized parameters exhibit a certain degree of continuity, which can be formulated as a discrete sequence of nonlinear functions. Traditionally, such problems are either solved by ad-hoc algorithms or via independent optimization of the underlying functions. The former solutions are difficult to define and develop, requiring expertise in the field, while the latter approach does not take advantage of the inherent sequential properties of the functions. This paper presents a parallel spline-based algorithm for nonlinear optimization of function sequences, with emphasis on dataset sequences that represent dynamically evolving systems. The presented algorithm provides results that are more coherent with fewer evaluations than independent optimization of the sequence functions. We elaborate on the heuristic approach, the motivation behind using splines to model dynamical systems, and the various tiers of concurrency built into the algorithm. Furthermore, we present two distributed variants of the algorithm and compare their convergence with the serial version. The performance of the algorithm is demonstrated on benchmarks and real-world problems in audio signal decomposition, small angle X-ray scattering analysis, and video tracking of arbitrary objects. [ABSTRACT FROM AUTHOR]

We present a declarative debugger for sequential Erlang programs. The tool is started when a program produces some unexpected result, and proceeds asking questions to the user about the correctness of some subcomputations until an erroneous program function is found. Then, the user can refine the granularity by zooming in the function, checking the values bound to variables and the if/case/try-catch branches taken during the execution. We show by means of an extensive benchmark that the result is a usable, scalable tool that complements already existing debugging tools such as the Erlang tracer and Dialyzer. Since the technique is based on a formal calculus, we are able to prove the soundness and completeness of the approach. [ABSTRACT FROM AUTHOR]

The gridGraphics package provides a function, grid.echo(), that can be used to convert a plot drawn with the graphics package to a visually identical plot drawn using grid. This conversion provides access to a variety of grid tools for making customisations and additions to the plot that are not possible with the graphics package. [ABSTRACT FROM AUTHOR]

This paper continues the publication of the "SPARK 2014 Rationale", which started in the December 2013 issue of the Ada User Journal. In this instalment, we present two contributions regarding data dependencies and information flow in SPARK. [ABSTRACT FROM AUTHOR]

Although several distance or similarity functions for trees have been introduced, their performance is not always satisfactory in many applications, ranging from document clustering to natural language processing. This research proposes a new similarity function for trees, namely Extended Subtree (EST), where a new subtree mapping is proposed. EST generalizes the edit base distances by providing new rules for subtree mapping. Further, the new approach seeks to resolve the problems and limitations of previous approaches. Extensive evaluation frameworks are developed to evaluate the performance of the new approach against previous proposals. Clustering and classification case studies utilizing three real-world and one synthetic labeled data sets are performed to provide an unbiased evaluation where different distance functions are investigated. The experimental results demonstrate the superior performance of the proposed distance function. In addition, an empirical runtime analysis demonstrates that the new approach is one of the best tree distance functions in terms of runtime efficiency. [ABSTRACT FROM AUTHOR]

The article discuses the features of the SPARK 2014, a computer program language based on the Ada language. This language contains contract-based programming constructs as part of the core language and strengthens the specification capabilities of the language. Its added features include generic subprograms and packages, discriminated types and array slicing.

Abstract: In functional programming it is common to write programs as compositions of other simpler functions. This makes it possible to take advantage of the well-known benefits of modular programming. However, in many cases, the resulting programs have efficiency problems caused by the generation of data structures that are solely used for communication between the functions that take part in the compositions. Many of those intermediate structures can be eliminated by an appropriate combination of the codes of the involved functions using a technique called program fusion. In this work, we propose a program fusion technique for accumulations, which are recursive functions that use additional parameters, called accumulators, for keeping intermediate results. Accumulations are known to be difficult to be fused because of the presence of the accumulators and the fact that results are usually computed in those parameters. Our technique is based on a shortcut fusion approach which turns out to be effective in the case of accumulations. We present benchmarks that illustrate the impact of shortcut fusion on accumulations. [Copyright &y& Elsevier]

Abstract: This study reviews the theory, programming designs and merits of two new Matlab-based routines for the forward and inverse Radon transform. These routines offer users flexible choices of integration path functions to take advantage of improved Radon-domain identification and isolation of seismic phases. Least-squares inversion of frequency components and judicious choices of regularization techniques enables additional noise suppression and signal enhancement in the Radon domain. The forward Radon transform routine has the added benefit of spatial interpolation for irregularly sampled data. The accuracy and applicability of these two new routines are demonstrated using data sets containing long-period SS precursors and high-frequency receiver functions. With minimal modifications these two highly portable, carefully documented Radon-transform routines could be easily adapted for a broad range of applications. [Copyright &y& Elsevier]

Abstract: Many languages viz. COBOL, C, C++, Java, Python etc have emerged and evolved in the arena of formal systems over the past few decades,. Programming language processors are designed to convert a high level language written source code to equivalent object code viz. interpreter, compiler etc. There exist variations in programming paradigm, like procedure-oriented, object–based, object oriented, low-level and logic/invariant. But irrespective of the programming methodology, trivial issues related with errors or bugs are often faced. Bug is always undesired to occur. So, need for a debugger embedded to compiler exists. Almost every language has a debugger module mostly dependent on involvement of developers. But again programmer needs to eliminate errors from the source code manually by dint of debugger module. The presented approach, a framework is proposed in which the elimination of the errors from the program source code is developer independent. The function of this module is to remove of the error one by one and to generate a debugged i.e. error-free form of the whole program. Then we will execute than debugged form of the source code to obtain our intended result. The framework is well-documented in the works of Gupta et al. . However, the issue ‘if the debugged form of the source code is non-unique i.e. more than one debugged form is found’ is not widely circulated in the literature. Effort has been made to get rid of the problems. The work presents an auto-debugger module in the interdisciplinary area of compiler design and machine intelligence that can take care of non-unique errors. The concept is accompanied by a developed compiler named SHARP. SHARP facilitates use of variable length of data type and further a framework of floating-point arithmetic different from the standard practice of mantissa-exponent scheme. It is expected that this will navigate the study of automated language processor to a new horizon. [Copyright &y& Elsevier]

Free theorems establish interesting properties of parametrically polymorphic functions, solely from their types, and serve as a nice proof tool. For pure and lazy functional programming languages, they can be used with very few preconditions. Unfortunately, in the presence of selective strictness, as provided in languages like Haskell, their original strength is reduced. In this paper we present an approach for overcoming this weakness in specific situations. Employing a refined type system which tracks the use of enforced strict evaluation, we rule out unnecessary restrictions that otherwise emerge. Additionally, we provide (and implement) an algorithm determining all refined types for a given term. [ABSTRACT FROM AUTHOR]

Abstract: Almost all subspace clustering algorithms proposed so far are designed for numeric datasets. In this paper, we present a k-means type clustering algorithm that finds clusters in data subspaces in mixed numeric and categorical datasets. In this method, we compute attributes contribution to different clusters. We propose a new cost function for a k-means type algorithm. One of the advantages of this algorithm is its complexity which is linear with respect to the number of the data points. This algorithm is also useful in describing the cluster formation in terms of attributes contribution to different clusters. The algorithm is tested on various synthetic and real datasets to show its effectiveness. The clustering results are explained by using attributes weights in the clusters. The clustering results are also compared with published results. [Copyright &y& Elsevier]

Abstract: We show that there exist translations between polymorphic -calculus and a subsystem of minimal logic with existential types, which form a Galois insertion (embedding). The translation from polymorphic -calculus into the existential type system is the so-called call-by-name CPS-translation that can be expounded as an adjoint from the neat connection. The construction of an inverse translation is investigated from a viewpoint of residuated mappings. The duality appears not only in the reduction relations but also in the proof structures, such as paths between the source and the target calculi. From a programming point of view, this result means that abstract data types can interpret polymorphic functions under the CPS-translation. We may regard abstract data types as a dual notion of polymorphic functions. [Copyright &y& Elsevier]

Independent component analysis (ICA) problem is often posed as the maximization/minimization of an objective/cost function under a unitary constraint, which presumes the prewhitening of the observed mixtures. The parallel adaptive algorithms corresponding to this optimization setting, where all the separators are jointly trained, are typically implemented by a gradient-based update of the separation matrix followed by the so-called symmetrical orthogonalization procedure to impose the unitary constraint. This article addresses the convergence analysis of such algorithms, which has been considered as a difficult task due to the complication caused by the minimum-(Frobenius or induced 2-norm) distance mapping step. We first provide a general characterization of the stationary points corresponding to these algorithms. Furthermore, we show that fixed point algorithms employing symmetrical orthogonalization are monotonically convergent for convex objective functions. We later generalize this convergence result for nonconvex objective functions. At the last part of the article, we concentrate on the kurtosis objective function as a special case. We provide a new set of critical points based on Householder reflection and we also provide the analysis for the minima/maxima/saddle-point classification of these critical points. [ABSTRACT FROM AUTHOR]

Maximum-likelihood estimation subject to nonlinear measurement functions is generally performed through optimization algorithms when accuracy is required and enough processing time is available, or with recursive filters for real-time applications but at the expense of a loss of accuracy. In this paper, we propose a new estimator for parameter estimation based on a polynomial approximation of the measurement signal. The raw dataset is replaced by n + 1 independent polynomial samples (PS) for a smoothing polynomial of order n, resulting in a reduction of the computational burden. It is shown that the PSs must be sampled at some deterministic instants and an approximate formula for the variance of the PSs is also provided. Moreover, it is also proved and illustrated on three examples that the new estimator which processes the PSs is equivalent to the standard maximum-likelihood estimator based on the raw dataset, provided that the measurement function and its first derivatives can be approximated with a polynomial of order n. Since this algorithm proceeds from a compact representation of a measurement signal, it can find applications in real-time processing, power saving processing, or estimation based on compressed data, even if this latter field has not been investigated from a theoretical perspective. Its structure which is made up of several separate tasks is also adapted to distributed processing problems. Because the performance of the method is related to the polynomial approximation quality, the algorithm is well suited for smooth measurement functions like in trajectory estimation applications. [ABSTRACT FROM AUTHOR]

Abstract: The aim of this paper is to describe an efficient method to connect two independent softwares so as to jointly use best qualities of each software around a complex problem solved by the finite element method (FEM). This connection makes it possible to extend quickly and easily the applicability of new models developed in academic softwares, by their simultaneous use with commercial softwares. This is particularly interesting when these models are very difficult to implement directly in commercial softwares. Most of the commercial FEM applications allow users to add additional features, physical models or boundary conditions via a programming interface. Within these user routines, access to internal data structures is possible, either through subroutine parameters and global variables, or via internal modules for reading and storing data. We use these capabilities to link the commercial software ABAQUS and an academic object-oriented C++ software HEREZH++, via the user-defined mechanical material behaviour (Umat). In this interface, HEREZH++ computes the mechanical behaviour of material and the code coupling performs a communication procedure between ABAQUS and HEREZH++. This paper describes this architecture which allows to implement easily original behaviour law in the commercial ABAQUS code. The asynchronous code coupling is made with a named piped interprocess communication method and an interface written in c/C++. Several test samples are presented to show the efficiency and accuracy of the proposed implementations concerning the computational time. In particular, an industrial test is carried out with an original behaviour model of elasto–visco-hysteresis which would have been very difficult to implement directly in ABAQUS. [Copyright &y& Elsevier]

AbstractThis paper describes a technique for assembling both data types and functions from isolated individual components. We also explore how the same technology can be used to combine free monads and, as a result, structure Haskell's monolithic IO monad. [ABSTRACT FROM AUTHOR]

The article offers information on the Native Call Interface (NCI) of Parrot, the virtual machine for the Perl programming language. NCI allows computer programmers to interface directly with functions defined in a C library using only Parrot code to do so. Parrot provides a routine for loading shared libraries and another routine for accessing subroutine symbols defined in those libraries by exposing them as Parrot Magic Cookies (PMC).

The author relates how he uses Practical Extraction and Report Language (PERL) to make functions easier to use and more readable.

Java is normally compiled to bytecode, which is verified and then executed by the Java Virtual Machine. Bytecode produced via compilation must pass verification. The main cause of complexity for bytecode verification is subroutines, used by compilers to generate more compact code. The techniques to verify subroutines proposed in the literature reject certain programs produced by mundane compilers, are difficult to realize within an implementation of the Java Virtual Machine or are relatively complicated. This paper presents a novel technique which is very simple to understand, implement and prove sound. It is also very powerful: the set of accepted programs has a simple characterization which most likely includes all the code produced by current compilers and which enables future compilers to make more extensive use of subroutines. Copyright © 2004 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

New direction in Artificial Intelligence research have led to the need for certain novel features to be embedded in programming languages. This paper gives an overview of the nature of these features, and their implementation in four principal families of AI languages: SAIL; PLANNER/CONNIVER; QLISP/INTERLISP; AND POPLER/POP-2. The programming features described include: new data types and accessing mechanisms for stored expressions; more flexible control structures, including multiple processes and backtracking; pattern matching to allow comparison of data item with a template, and extraction of labeled subexpressions; and deductive mechanisms which allow the programming system to carry out certain activities including modifying the data base and deciding which subroutines to run next using only constraints and guidelines set up by the programmer. [ABSTRACT FROM AUTHOR]

A significant barrier to the reuse of software is the rigid interface presented by a subroutine. For nontrivial data structures, it is unlikely that the existing form of the data of an application will match the requirements of a separately written subroutine. We describe two methods of interfacing existing data to a subroutine: generation of a program to convert the data to the form needed by the subroutine, and rewriting the subroutine, through compilation, to fit the existing data. Both methods can be invoked through easily used menu-based negotiation with the user. These methods have been implemented using the GLISP language and compiler. [ABSTRACT FROM AUTHOR]

Several inequalities are derived for use in certifying function subroutines by means of black box testing. It is assumed that a function is approximated by means of a polynomial of limited degree on a closed interval. These inequalities give upper bounds on the error of the approximation over the entire interval based on the error measured over a finite sample and known properties of the function. [ABSTRACT FROM AUTHOR]

The article focuses on the computer program that helps in producing superior specimens of Melopsittacus Undulatus, a parakeet native to Australia. It was programmed in BASIC on a Digital Equipment Corp. 20/50 mainframe. Some subroutines of the program was changed and certain syntax differences in the BASIC were adapted in order to conform on the IBM-XT personal computer. To avoid prohibitive processing time, a subroutine was designed which could be evaluated by other subroutine within the program. This subroutine allows a reduction in processing time. A pro forma data-input sheet was also created which matches to the data file layout. This is used to provide efficient data input related to the birds.

This paper considers the programming of passive (cold and warm standbys) and active replicated systems in Ada 95. We show that it is relatively easy to develop systems which act as standbys using the facilities provided by the language and the Distributed Systems Annex. Arguably, active replication in Ada 95 can be supported in a manner which is transparent to the application. However, this is implementation-dependent, requires a complex distributed consensus algorithm (or a carefully chosen subset of the language to be used) and has little flexibility. We therefore consider two extensions to the Distributed Systems Annex to help give the application programmer more control. The first is a via a new categorization pragma which specifies that a RCI package can be replicated in more than one partition. The second is through the introduction of a coordinated type which has a single primitive operation. Objects which are created from extensions to coordinated types can be freely replicated across the distributed system. When the primitive operation is called, the call is posted to all sites where a replica resides, effectively providing a broadcast (multicast) facility. We also consider extensions to the partition communication subsystem which implement these new features. [ABSTRACT FROM AUTHOR]