Graph‐based tools for re‐engineering

Cremer, Katja; Marburger, André; Westfechtel, Bernhard

doi:10.1002/smr.254

Cited by 23 publications

(7 citation statements)

References 35 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Nevertheless call-graphs are widely used for various empirical studies [50], [45], [20]. They have also been extensively used in architecture recovery [19], [12], [33], [36], [29].…”

Section: Research Goalsmentioning

confidence: 99%

Assert Use in GitHub Projects

Casalnuovo

Dévanbu

Oliveira

et al. 2015

2015 IEEE/ACM 37th IEEE International Conference on Software Engineering

View full text Add to dashboard Cite

Asserts have long been a strongly recommended (if non-functional) adjunct to programs. They certainly don't add any user-evident feature value; and it can take quite some skill and effort to devise and add useful asserts. However, they are believed to add considerable value to the developer. Certainly, they can help with automated verification; but even in the absence of that, claimed advantages include improved understandability, maintainability, easier fault localization and diagnosis, all eventually leading to better software quality. We focus on this latter claim, and use a large dataset of asserts in C and C++ programs to explore the connection between asserts and defect occurrence. Our data suggests a connection: functions with asserts do have significantly fewer defects. This indicates that asserts do play an important role in software quality; we therefore explored further the factors that play a role in assertion placement: specifically, process factors (such as developer experience and ownership) and product factors, particularly interprocedural factors, exploring how the placement of assertions in functions are influenced by local and global network properties of the callgraph. Finally, we also conduct a differential analysis of assertion use across different application domains.

show abstract

“…Nevertheless call-graphs are widely used for various empirical studies [50], [45], [20]. They have also been extensively used in architecture recovery [19], [12], [33], [36], [29].…”

Section: Research Goalsmentioning

confidence: 99%

Assert Use in GitHub Projects

Casalnuovo

Dévanbu

Oliveira

et al. 2015

2015 IEEE/ACM 37th IEEE International Conference on Software Engineering

View full text Add to dashboard Cite

show abstract

“…In contrast, in previous work (e.g. [11,20]) rules have been executed atomically (but not necessarily automatically) without making the user aware of conflicts among the offered rules.…”

Section: Contributionmentioning

confidence: 99%

“…Rather, applications of triple graph grammars were built using the PROGRES environment. In the reengineering projects VARLET [20] and REFORDI [11], synchronous triple rules were transformed manually into forward rules (for transforming the old system into a renovated one being based on object-oriented concepts). The PRO-GRES system was used to execute forward rules in an atomic way.…”

Section: Related Work On Triple Graph Grammarsmentioning

confidence: 99%

A graph-based algorithm for consistency maintenance in incremental and interactive integration tools

et al. 2007

Self Cite

View full text Add to dashboard Cite

Development processes in engineering disciplines are inherently complex. Throughout the development process, the system to be built is modeled from different perspectives, on different levels of abstraction, and with different intents. Since state-ofthe-art development processes are highly incremental and iterative, models of the system are not constructed in one shot; rather, they are extended and improved repeatedly. Furthermore, models are related by manifold dependencies and need to be maintained mutually consistent with respect to these dependencies. Thus, tools are urgently needed which assist developers in maintaining consistency between inter-dependent and evolving models. These tools have to operate incrementally, i.e., they have to propagate changes performed on one model into related models which are affected by these changes. In addition, they need to support user interactions in settings where the effects of changes cannot be determined automatically and deterministically. We present an algorithm for incremental and interactive consistency maintenance which meets these requirements. The algorithm is based on graphs, which are used as the data model for representing the models to be integrated, and graph transformation rules, which describe the modifications of the graphs to be performed on a high level of abstraction.

show abstract

“…Cremer et al [9] described a graph-based approach for reengineering COBOL programs. Since the focus of their work is on source code transformation, their visualizations are very detailed but do no support abstractions to higher levels.…”

Section: Related Workmentioning

confidence: 99%

Package patterns for visual architecture recovery

Lungu

Lanza

2006

Conference on Software Maintenance and Reengineering (CSMR'06)

View full text Add to dashboard Cite

Recovering the architecture is the first step towards reengineering a software system. Many reverse engineering tools use top-down exploration as a way of providing a visual and interactive process for architecture recovery. During the exploration process, the user navigates through various views on the system by choosing from several exploration operations. Although some sequences of these operations lead to views which, from the architectural point of view, are mode relevant than others, current tools do not provide a way of predicting which exploration paths are worth taking and which are not.In this article we propose a set of package patterns which are used for augmenting the exploration process with information about the worthiness of the various exploration paths. The patterns are defined based on the internal package structure and on the relationships between the package and the other packages in the system. To validate our approach, we verify the relevance of the proposed patterns for real-world systems by analyzing their frequency of occurrence in six open-source software projects.

show abstract

Graph‐based tools for re‐engineering

Cited by 23 publications

References 35 publications

Assert Use in GitHub Projects

Assert Use in GitHub Projects

A graph-based algorithm for consistency maintenance in incremental and interactive integration tools

Package patterns for visual architecture recovery

Contact Info

Product

Resources

About