Anh-Hoang Truong

Learn More
Narrowing the wide conceptual gap between problem and implementation domains is considered a significant factor within software engineering. Currently, such a relation is often obtained using mappings between metamodels for a structural semantics. This paper proposes an approach based on the integration of Triple Graph Grammars (TGGs) and the Object(More)
interpretation techniques have played a major role in advancing the state-of-the-art in program analysis. Traditionally, stand-alone tools for these techniques have been developed for the numerical domain which may be sufficient for lower levels of program correctness. To help us analyze a wider range of programs, we have developed a tool to compute(More)
A software program requesting a resource that is not available usually raises an out-of-resource exception. Component software is software that has been assembled from standardized, reusable components which, in turn, may also composed from other components. Due to the independent development and reuse of components, component software has a high risk of(More)
Component composition can lead to multiple instances of the same component. Some components can have only one instance loaded at a time, for example, when a unique external resource is used. We give an abstract component language and a type system ensuring the safe instantiation of components. Language features are instantiation, composition and a simple(More)
Component software is software that has been assembled from various pieces of standardized, reusable computer programs, so-called components. Executing component software creates instances of these components. For several reasons, for example, limited resources and/or application requirements, it can be important to have control over the number of such(More)
We present a static, compositional analysis based on a type and effect system to estimate an upper bound for the resource consumption of nested and multi-threaded transactional programs. This work extends our previous type system for Transactional Featherweight Java to allow more liberal use of transactions in the semantics. The new types are also more(More)
In this paper, we present an approach to find upper bounds of heap space for Java Card applets. Our method first transforms an input bytecode stream into a control flow graph (CFG), and then collapses cycles of the CFG to produce a directed acyclic graph (DAG). Based on the DAG, we propose a linear-time algorithm to solve the problem of finding the(More)
Porting an application written for personal computer to embedded devices requires conversion of floating-point numbers and operations into fixed-point ones. Testing the conversion hence requires the latter be as close as possible to the former. The closeness is orthogonal to code coverage and requires different strategies to generate a test suite that(More)
—We introduce an approach to find upper bounds of heap space for Java Card applets. Our approach analyzes and transforms bytecodes of Java Card applets into equivalent programs in a language that already has a type system for finding the sharp upper bounds of resource use. We then point out a linear-time algorithm to compute the maximum heap units that may(More)