Abstract

Abstract
The knowledge of software developers materializes itself as software artifacts, that may be seen at two different levels (information and structure), which are difficult to change independently from each other. This work explores how the expression of software knowledge using adaptive software techniques, may support the creation of adaptive software artifacts, to improve the effectiveness of capturing knowledge under constant evolution. Some work already exists in the context of the Weaki Wiki, which will be extended into a full environment supporting the creation and evolution of software artifacts beyond their initial form. We intend to validate this work experimentally.

Abstract
The success of the digital game industry is spawning several undergraduate degrees aiming at the training of digital game developers. Building adequate new courses curricula is not a trivial task and demands a profound analysis of the scientific areas to introduce as well as the dependencies throughout the entire degree. Another important aspect of every academic educational plan are the satellite projects that promote entrepreneurship and provide practical professional experiences to students. This paper presents the main guidelines adopted in the creation of the first digital game development undergraduate degree created in Portugal. © 2010 IEEE.

Abstract
A large and growing amount of software systems rely on non-trivial coordination logic for making use of third party services or components. Therefore, it is of outmost importance to understand and capture rigorously this continuously growing layer of coordination as this will make easier not only the verification of such systems with respect to their original specifications, but also maintenance, further development, testing, deployment and integration. This paper introduces a method based on several program analysis techniques (namely, dependence graphs, program slicing, and graph pattern analysis) to extract coordination logic from legacy systems source code. This process is driven by a series of pre-defined coordination patterns and captured by a special purpose graph structure from which coordination specifications can be generated in a number of different formalisms.

Abstract
Clone detection is well established for imperative programs. It works mostly on the statement level and therefore is ill-suited for functional programs, whose main constituents are expressions and types. In this paper we introduce clone detection for functional programs using a new intermediate program representation, dubbed Functional Control Tree. We extend clone detection to the identification of non-trivial functional program clones based on the recursion patterns from the so-called Bird-Meertens formalism.

Abstract
Current software development often relies on non-trivial coordination logic for combining autonomous services, eventually running on different platforms. As a rule, however, such a coordination layer is strongly woven within the application at source code level. Therefore, its precise identification becomes a major methodological (and technical) problem and a challenge to any program understanding or refactoring process. The approach introduced in this paper resorts to slicing techniques to extract coordination data from source code. Such data are captured in a specific dependency graph structure from which a coordination model can be recovered either in the form of an ORC specification or as a collection of code fragments corresponding to the identification of typical coordination patterns in the system. Tool support is also discussed.