Higher-order lazy functional slicing

Program slicing is a well known family of techniques intended to identify and isolate code fragments which depend on, or are depended upon, specific program entities. This is particularly useful in the areas of reverse engineering, program understanding, testing and software maintenance. Most slicing methods, and corresponding tools, target either the imperative or the object oriented paradigms, where program slices are computed with respect to a variable or a program statement. Taking a complementary point of view, this paper focuses on the slicing of higher-order functional programs under a lazy evaluation strategy. A prototype of a Haskell slicer, built as proof-of-concept for these ideas, is also introduced

Slicing functional programs by calculation

Program slicing is a well known family of techniques used to identify code fragments which depend on or are depended upon specific program entities. They are particularly useful in the areas of reverse engineering, program understanding, testing and software maintenance. Most slicing methods, usually targeting either the imperative or the object oriented paradigms, are based on some sort of graph structure representing program dependencies. Slicing techniques amount, therefore, to (sophisticated) graph transversal algorithms. This paper proposes a completely different approach to the slicing problem for functional programs. Instead of extracting program information to build an underlying dependencies’ structure, we resort to standard program calculation strategies, based on the so-called Bird- Meertens formalism. The slicing criterion is specified either as a projection or a hiding function which, once composed with the original program, leads to the identification of the intended slice. Going through a number of examples, the paper suggests this approach may be an interesting, even if not completely general alternative to slicing functional programs

Program slicing by calculation

Program slicing is a well known family of techniques used to identify code fragments which depend on or are depended upon specific program entities. They are particularly useful in the areas of reverse engineering, program understanding, testing and software maintenance. Most slicing methods, usually oriented towards the imperative or object paradigms, are based on some sort of graph structure representing program dependencies. Slicing techniques amount, therefore, to (sophisticated) graph transversal algorithms. This paper proposes a completely different approach to the slicing problem for functional programs. Instead of extracting program information to build an underlying dependencies’ structure, we resort to standard program calculation strategies, based on the so-called Bird-Meertens formalism. The slicing criterion is specified either as a projection or a hiding function which, once composed with the original program, leads to the identification of the intended slice. Going through a number of examples, the paper suggests this approach may be an interesting, even if not completely general, alternative to slicing functional programs

A creative solution for rapid and inexpensive model-making in product design processes

Rapid prototyping (RP) is an approach for automatically building a physical object through solid freeform fabrication. Nowadays, RP has become a vital aspect of most product development processes, due to the significant competitive advantages it offers compared to traditional manual model making. Even in academic environments, it is important to be able to quickly create accurate physical representations of concept solutions. Some of these can be used for simple visual validation, while others can be employed for ergonomic assessment by potential users or even for physical testing. However, the cost of traditional RP methods prevents their use in most academic environments on a regular basis, and even for very preliminary prototypes in many small companies. That results in delaying the first physical prototypes to later stages, or creating very rough mock-ups which are not as useful as they could be. In this paper we propose an approach for rapid and inexpensive model-making, which was developed in an academic context, and which can be employed for a variety of objects.

Palco: a multisensor realtime 3D cartoon production system

This paper presents Palco, a prototype system specifically designed for the production of 3D cartoon animations. The system addresses the specific problems of producing cartoon animations, where the main obj ective is not to reproduce realistic movements, but rather animate cartoon characters with predefined and characteristic body movements and facial expressions. The techniques employed in Palco are simple and easy to use, not requiring any invasive or complicated motion capture system, as both body motion and facial expression of actors are captured simultaneously, using an infrared motion detection sensor, a regular camera and a pair of electronically instrumented gloves. The animation process is completely actor-driven, with the actor controlling the character movements, gestures, facial expression and voice, all in realtime. The actor controlled cartoonification of the captured facial and body motion is a key functionality of Palco, and one that makes it specifically suited for the production of cartoon animations.