International audience

Summary When analyzing legacy code, generating a high‐level model of an application during the reverse engineering process helps the developers understand how the application is structured and how the dependencies relate the different software entities. Within the context of procedural programming languages (such as C), the existing approaches to get a model of the code require documentation and/or implicit knowledge that stakeholders acquire during the software building. These approaches use the code itself to build a syntactic model where we see the different software artifacts, such as variables, functions, and modules. However, there is no supporting methodology to detect and analyze if there are relationships/dependencies between those artifacts, such as which variable in a module is declared using an abstract data type described in another one, or which are the functions that are using parameters typed with an abstract data type; or any design decision taken by original developers, such as how the developer has implemented functions in different modules. On the other hand, current developers use object‐oriented (OO) paradigm to implement not only business applications but also useful methodologies/tools that allow semiautomatic analysis of any application. We must remark the legacy procedural code still has worth and is working in several industries, and as any evolving code, the developers have to be able to perform maintenance tasks minimizing the limitations offered by the language. Based on useful properties that the OO paradigm (and their supporting analysis tools) provide, such as UML models, we propose M2K as a methodology to generate a high‐level model from legacy procedural code, mainly written in Ansi C. To understand how C‐based applications were implemented is not a new problem in software reengineering. However, our contribution is based on building an OO model and suggesting different refactorings that help the developer to improve it and to eventually guide a new implementation of the target application. Specifically, the methodology builds cohesive software entities mapped from procedural code and makes the coupling between C entities explicit in the high‐level model. The result of our methodology is a set of refactored class candidates: a structure that groups a set of variables and a set of functions obtained from the C applications. Based on the class candidate model, we propose refactorings based on OO design principles to improve the design of the application. The most relevant design improvements were obtained with algorithm abstraction by applying the strategy pattern, attributes/methods relocalization, variables types generalization, and removing/renaming methods/attributes. Besides a methodology and the supporting tool, we provide 14 case studies based on real projects implemented in C, and we showed how the results validate our proposal.

Within the context of Argentina universities that have computer science degrees in their curricula, one of the major challenges is to teach an introductory programming course for the first semester. The problem appears because the students come with serious deficiencies from their previous education level (secondary schools). Among these deficiencies, we identify their lack of abstraction capabilities and mathematical skills, which are usually considered as prerrequisites to take a programming course. This article introduces the GOBSTONES method for teaching an introductory programming course. The method was developed at the Universidad Nacional de Quilmes in Argentina, taking into account the described background of the students, and has shown a positive impact by improving the passing rate of those students. GOBSTONES method's main goal was to foster abstraction and abstract thinking to students that have not developed good abstraction skills. A programming language, also called GOB-STONES, was developed to implement the ideas presented herein. The method focuses on the representation of information, both at the level of code in the form of procedures to express abstraction, and at the level of the universe of discourse, which is a concrete one, but allowing the representation of information in a simple way. Moreover, the tools implementing GOBSTONES have a feature that enables the student to see a visualization of the represented elements.

When analyzing legacy code, generating a high-level model of an application helps the developers understand how the application was structured and how the dependencies relate the different software entities. Based on useful properties that the object-oriented paradigm (and their supporting analysis tools) provide, such as UML models, we propose M2K as a methodology (supported by our own tool) that generates a high-level model from legacy C code and proposes differents refactorings. To understand how procedural-based applications were implemented is not a new problem in software reengineering, however our contribution is based on building automatically an object-oriented model and help the experts to define manually different refactorings that let the developer to improve the application. Besides a methodology and the supporting tool, we provide a summary of thirteen case studies based on small-scaled real projects implemented in C and we showed how the results validate our proposal.

SUMMARY Because objects need to be stored and reloaded on different environments, serializing object graphs is a very important activity. There is a plethora of serialization frameworks with different requirements and design trade‐offs. Most of them are based on recursive parsing of the object graphs, an approach which often is too slow. In addition, most of them prioritize a language‐agnostic format instead of speed and language‐specific object serialization. For the same reason, such serializers usually do not support features such as class‐shape changes, global references or executing pre and post load actions. Looking for speed, some frameworks are partially implemented at Virtual Machine (VM) level, hampering code portability and making them difficult to understand, maintain and extend. In this paper, we present Fuel, a general‐purpose object serializer based on these principles: (1) speed, through a compact binary format and a pickling algorithm which invests time in serialization for obtaining the best performance on materialization; (2) good object‐oriented design, without special help at VM; and (3) serialize any object, thus have a full‐featured language‐specific format. We implement and validate this approach in Pharo, where we demonstrate that Fuel is faster than other serializers, even those with special VM support. The extensibility of Fuel made possible to successfully serialize various objects: classes in Newspeak, debugger stacks, and full content management system object graphs. Copyright © 2012 John Wiley & Sons, Ltd.

This paper presents a methodology to detect and measure the complexity of traceable transactions from requirements (use cases) to code (source code) of a system.

Traits are basically mixins or interfaces but with method bodies. In languages that support traits, classes are composed out of traits. There are two main advantages with traits. Firstly, decomposing existing classes into traits from which they can be recomposed improves the factoring of hierarchies. Secondly it increases the library reuse potential by providing more reusable traits. Identifying traits and decomposing class hierarchies into traits is therefore an important and challenging task to facilitate maintainability and evolution. In this paper we present how we use Formal Concept Analysis to identify traits in inheritance hierarchies. Our approach is two-staged: first we identify within a hierarchy maximal groups of methods that have a set of classes in common, second we cluster cohesive groups of methods based on method invocations as potential traits. We applied our approach on two significant hierarchies and compare our results with the manual refactorization of the same code which was done by the authors of traits.

Understanding the internal workings of classes is a key prerequisite to maintaining an object-oriented software system. Unfortunately, classical editing and browsing tools offer mainly linear and textual views of classes and their implementation. These views fail to expose the semantic relationships between the internal parts of a class. We propose X-Ray views - a technique based on concept analysis - which reveal the internal relationships between groups of methods and attributes of a class. X-Ray views are composed of elementary collaborations between attributes and methods, and help the engineer to build a mental model of how a class works internally. In this paper we present X-Ray views, and illustrate the approach by applying it on the Smalltalk class UIBuilder.

Software is more and more becoming the major cost factor for embedded devices. Already today, software accounts for more than 50 percent of the development costs of such a device. However, software development practices in this area lag far behind those in the traditional software industry. Reuse is hardly ever heard of in some areas, development from scratch is common practice and component-based software is usually a foreign word. PECOS is a collaborative project between industrial and research partners that seeks to enable component-based technology for a certain class of embedded systems known as "field devices" by taking into account the specific properties of this application area. In this paper we introduce a component model for field device software. Furthermore we report on the PECOS component composition language CoCo and the mapping from CoCo to Java and C++.