Determining Interfaces Using Type Inference

Porting software usually requires understanding what library functions the program being ported uses since this functionality must be either found or reproduced in the ported program's new environment. This is usually done manually through code inspections. We propose a type inference algorithm able to infer basic information about the library functions a particular C program uses in the absence of declaration information for the library (e.g., without header files). Based on a simple but efficient inference algorithm, we were able to infer declarations for much of the PalmOS API from the source of a twenty-seven-thousand-line C program. Such a tool will aid in the problem of program understanding when porting programs, especially from poorly-documented or lost legacy environments

Automated FORTRAN conversion

The most pratical solution to the conversion of FORTRAN to other programming languages which STO and a few others have adopted, uses an intermediate language that is easy to translate FORTRAN into, and allows for source codes in other languages to be generated automatically. The intermediate language is the union of all other programming languages (and the trick is to create a useful union) with some extensions that reflect the nature of the algorithms. The benefits of this approach are many. First the original FORTRAN program has to be rewritten only once, and then only parts of the program: most FORTRAN code passes through without and change (i.e., assignment and simple IF statements). Software tools are provided to ease this initial translation. Once in the intermediate language, the algorithm can then be obtained in any other language automatically. An example of a subroutine from the Rispack library in ten different languages is given

Algorithm-Based Fault Tolerance for Numerical Subroutines

A software library implements a new methodology of detecting faults in numerical subroutines, thus enabling application programs that contain the subroutines to recover transparently from single-event upsets. The software library in question is fault-detecting middleware that is wrapped around the numericalsubroutines. Conventional serial versions (based on LAPACK and FFTW) and a parallel version (based on ScaLAPACK) exist. The source code of the application program that contains the numerical subroutines is not modified, and the middleware is transparent to the user. The methodology used is a type of algorithm- based fault tolerance (ABFT). In ABFT, a checksum is computed before a computation and compared with the checksum of the computational result; an error is declared if the difference between the checksums exceeds some threshold. Novel normalization methods are used in the checksum comparison to ensure correct fault detections independent of algorithm inputs. In tests of this software reported in the peer-reviewed literature, this library was shown to enable detection of 99.9 percent of significant faults while generating no false alarms

Development of Library Codes for Programming the Humanoid Robot Based on CM-510 Module

Since twenty years ago, when the Indonesia robot contest firstly was held, the techniques and methods of mapping cruising as a aspect of the mobile robot ability undergone more progress. In the contest, the robot teams of Universitas Ahmad Dahlan (UAD) has been using the humanoid robot type or the boloid robot type. The robot programmed by the original software i.e. roboplus. This roboplus program had limitations, particularly in the task programs, because the functions and values was given by the manufacturer so that the programmers in difficult circumstances. This research will develop the library codes for programming the humanoid robots based on the CM-510 module. The library codes developed uses the programming language of Atmel Studio 6 based on C language that can ease for programmer. The methods used in this research are the design, implementation and testing. Firstly, the designing was done by exploring the functions that provided by the task roboplus. Exploration results used to develop the algorithm and flowchart of the developed library codes. Furthermore, the algorithm implemented by the programming using Atmel Studio 6 software. Testing was done by comparing the results of running the library codes to the default roboplus programs. The research done has produced five library codes for access: (1) LED (light emitting diode) on the CM-510 module, (2) ADC ports; (3) accelerometer sensor, (4) gyroscope sensor, and (5) LM-35 sensor. Functions produced from this research are two i.e.: (1) to make the robot motion, and (2) to access the switch on the CM-510 module. The developed library codes and functions are simpler and make programmers feel easier

C-Sheep: Controlling Entities in a 3D Virtual World as a Tool for Computer Science Education

One of the challenges in teaching computer science in general and computer programming in particular is to maintain the interest of students, who often perceive the subject as difficult and tedious. To this end, we introduce C-Sheep, a mini-language-like system for computer science education, using a state of the art rendering engine, usually found in entertainment systems. The intention is to motivate students to spend more time programming, which can be achieved by providing an enjoyable experience. Computer programming is an essential skill for software developers and as such is always an integral part of every computer science curriculum. However, even if students are pursuing a computer science related degree, it can be very difficult to interest them in the act of computer programming, the writing of software, itself. In the C-Sheep system this is addressed by using the visual gimmickry of modern computer games, which allows programs to provide instant visualisation of algorithms. This visual feedback is invaluable to the understanding of how the algorithm works, and - if there are unintended results - how errors in the program can be debugged. The C-Sheep programming language is a (100% compatible) subset of the ANSI C programming language. Apart from just being a tool for learning the basics of the C programming language, C-Sheep implements the C control structures that are required for teaching the basic computer science principles encountered in structured programming. Unlike other teaching languages which have minimal syntax and which are variable free to provide an environment with minimal complexity, C-Sheep allows the declaration and use of variables. C-Sheep also supports the definition of sub-routines (functions) which can be called recursively. "The Meadow" virtual environment is the virtual world in which entities (in our case sheep) controlled by C-Sheep programs exist. This micro world provides a graphical representation of the algorithms used in the programs controlling the virtual entities. Their position and orientation within the virtual world visualise the current state of the program. "The Meadow" is based on our proprietary "Crossbow" game engine which incorporates a virtual machine for executing CSheep programs. The Crossbow Engine is a compact game engine which is flexible in design and offers a number of features common to more complex engines. The Crossbow Virtual Machine used with C-Sheep in "The Meadow" - an improvement on the ZBL/0 virtual machine - is a module of the Crossbow Engine. The C-Sheep system also provides a counterpart library for C, mirroring the CSheep library functions of the virtual machine. This allows C-Sheep programs to be compiled into an executable using a normal off-the-shelf C/C++ compiler. This executable can then be run from within the native working environment of the operating system. The purpose of this library is to simplify the migration from the educational mini-language to real-world systems by allowing novice programmers to make an easy transition from using the C-Sheep system to using the C programming language

Modular Optimizer for Mixed Integer Programming MOMIP Version 1.1

This Working Paper documents the Modular Optimizer for Mixed Integer Programming (MOMIP). MOMIP is an optimization solver for middle-size mixed integer programming problems, based on a modified branch-and-bound algorithm. It is designed as part of a wider linear programming modular library being developed within the IIASA CSA project on "Methodology and Techniques of Decision Analysis". The library is a collection of independent modules, implemented as C++ classes, providing all the necessary functions of data input, data transfer, problem solution, and results output. The Input/Output module provides data structure to store a problem and its solution in a standardized form as well as standard input and output functions. All the solver modules take the problem data from the Input/Output module and return the solutions to this module. Thus, for straightforward use, one can configure a simple optimization system using only the Input/Output module and an appropriate solver module. More complex analysis may require use of more than one solver module. Moreover, for complex analysis of real-life problems, it may be more convenient to incorporate the library modules into an application program. This will allow the user to proceed with direct feeding of the problem data generated in the program and direct withdrawal results for further analysis. The paper provides the complete description of the MOMIP module. Methodological background allows the user to understand the implemented algorithm and efficient use of its control parameters for various analyses. The module description provides all the information necessary to make MOMIP operational. It is additionally illustrated with a tutorial example and a sample program. Modeling recommendations are also provided, explaining how to built mixed integer models in order to speedup the solution process. These may be interesting, not only for the MOMIP users, but also for users of any mixed integer programming software

Software Helps Retrieve Information Relevant to the User

The Adaptive Indexing and Retrieval Agent (ARNIE) is a code library, designed to be used by an application program, that assists human users in retrieving desired information in a hypertext setting. Using ARNIE, the program implements a computational model for interactively learning what information each human user considers relevant in context. The model, called a "relevance network," incrementally adapts retrieved information to users individual profiles on the basis of feedback from the users regarding specific queries. The model also generalizes such knowledge for subsequent derivation of relevant references for similar queries and profiles, thereby, assisting users in filtering information by relevance. ARNIE thus enables users to categorize and share information of interest in various contexts. ARNIE encodes the relevance and structure of information in a neural network dynamically configured with a genetic algorithm. ARNIE maintains an internal database, wherein it saves associations, and from which it returns associated items in response to a query. A C++ compiler for a platform on which ARNIE will be utilized is necessary for creating the ARNIE library but is not necessary for the execution of the software

Taxonomies and Toolkits: uses for the Mathematics of program construction

In this extended abstract, we present a brief description of the tutorial. The primary reference material, a book and some software (1] , is available for ftp from the Eindhoven University of Technology. In this tutorial, we will consider a mathematical approach to the derivation of families of algorithms solving a particular problem. These families of algorithms are easily translated into practical toolkits of algorithms (C++ class libraries in our case). In the following paragraphs, we briefly describe why we need such toolkits, algorithm derivations, and a slightly non-standard algorithm derivation method. Generic programming (or template programming in C++) forms one of the cornerstones (along with object-oriented programming) of component programming. Generic algorithm libraries fill the need for standard algorithms such as sorting and string searching algorithms, freeing the programmer from re-implementing such error prone components. The algorithms in a generic library do not make unnecessary assumptions about the nature of the data being operated upon. For example, a string searching library would work well with strings of characters or strings of floating point numbers. The very nature of generic programs make them extremely difficult to debug and test. Exhaustive testing is generally not possible since the number of types (for the template parameter) is usually infinite. These practical difficulties can be alleviated by using the mathematics of program construction to design the program correctly in the first place. In the next paragraph, we will consider the mathematical appeal of taxonomies of algorithms. There are a number of mature areas of computer science (such as finite automata construction and string pattern matching) for which there are literally dozens of known algorithms. Many of these algorithms remain without rigorous proof, despite the fact that they were developed over twenty years ago. The differing presentation styles, and half-derivations of some of the algorithms makes them particularly difficult to compare to one another, and even more difficult to implement correctly. Dijkstra's approach to correct program construction is rarely, if ever, used by software engineers working on "real-life" projects. A great deal of time, patience, and practice are required to learn and apply the method. Unfortunately, the strict use of Dijkstra's calculus is still best suited to programming-in-the-small (the development of elegant algorithms solving small problems, such as greatest-common-divisor). We will present a method of constructing taxonomies of algorithms. The method starts with a naive first algorithm, which is easy to prove correct but is impractical to implement. The taxonomy will be grown as a ''family tree" , with the naive algorithm at the root. At each step, a variant of Dijkstra's discipline of programming is used to add either an algorithm detail (some algorithm transformation) or a problem detail (a problem restriction which allows an algorithmic improvement). The details are always added in a correctness-preserving manner, meaning that the correctness proof of any derived algorithm is in the composition of the details. The aim is to arrive at all of the known algorithms and hopefully derive some new ones. Once such a taxonomy has been developed, it is finally possible to provide implementations (in the form of class libraries) of all of the known algorithms solving a particular problem. The presence of the correctness proofs in the taxonomy has yielded impressive code quality in the class libraries (fewer than five bugs per 10,000 of code in the first release). In the tutorial, we will also discuss the implementation of one such class library