Volume

Dagstuhl Seminar Proceedings, Volume 5451

Publication Details

  • published at: 2006-07-07
  • Publisher: Schloss Dagstuhl – Leibniz-Zentrum für Informatik

Access Numbers

Documents

No documents found matching your filter selection.
Document
DOI: 10.4230/DagSemProc.05451.1
05451 Abstracts Collection – Beyond Program Slicing

Authors: Dave Binkley, Mark Harman, and Jens Krinke

Abstract
From 06.11.05 to 11.11.05, the Dagstuhl Seminar 05451 ``Beyond Program Slicing'' was held in the International Conference and Research Center (IBFI), Schloss Dagstuhl. During the seminar, several participants presented their current research, and ongoing work and open problems were discussed. Abstracts of the presentations given during the seminar as well as abstracts of seminar results and ideas are put together in this paper. The first section describes the seminar topics and goals in general. Links to extended abstracts or full papers are provided, if available.
Cite as

Dave Binkley, Mark Harman, and Jens Krinke. 05451 Abstracts Collection – Beyond Program Slicing. In Beyond Program Slicing. Dagstuhl Seminar Proceedings, Volume 5451, pp. 1-16, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{binkley_et_al:DagSemProc.05451.1,
  author =	{Binkley, Dave and Harman, Mark and Krinke, Jens},
  title =	{{05451 Abstracts Collection – Beyond Program Slicing}},
  booktitle =	{Beyond Program Slicing},
  pages =	{1--16},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5451},
  editor =	{David W. Binkley and Mark Harman and Jens Krinke},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05451.1},
  URN =		{urn:nbn:de:0030-drops-6016},
  doi =		{10.4230/DagSemProc.05451.1},
  annote =	{Keywords: Program slicing, source code analysis and manipulation, program dependece, dependence graph}
}
Document
DOI: 10.4230/DagSemProc.05451.2
05451 Executive Summary – Beyond Program Slicing Dagstuhl Seminar

Authors: Mark Harman, Dave Binkley, and Jens Krinke

Abstract
The aim of the "beyond program slicing" seminar was to explore emergent applications of program slicing and ways in which slicing techniques and ideas could be combined with those from other areas of program analysis and manipulation.
Cite as

Mark Harman, Dave Binkley, and Jens Krinke. 05451 Executive Summary – Beyond Program Slicing Dagstuhl Seminar. In Beyond Program Slicing. Dagstuhl Seminar Proceedings, Volume 5451, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{harman_et_al:DagSemProc.05451.2,
  author =	{Harman, Mark and Binkley, Dave and Krinke, Jens},
  title =	{{05451 Executive Summary – Beyond Program Slicing Dagstuhl Seminar}},
  booktitle =	{Beyond Program Slicing},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5451},
  editor =	{David W. Binkley and Mark Harman and Jens Krinke},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05451.2},
  URN =		{urn:nbn:de:0030-drops-5843},
  doi =		{10.4230/DagSemProc.05451.2},
  annote =	{Keywords: Summary}
}
Document
DOI: 10.4230/DagSemProc.05451.3
05451 Group 5 – Bananas, Dark Worlds, and AspectH

Authors: Silvia Breu, Marc Schlickling, and Nuno Miguel Feixa Rodrigues

Abstract
This report summarises our idea of code clone detection in Haskell code and refactorings based on identified clones as it evolved in our working group-of-three discussion at the Dagstuhl seminar "Beyond Program Slicing".
Cite as

Silvia Breu, Marc Schlickling, and Nuno Miguel Feixa Rodrigues. 05451 Group 5 – Bananas, Dark Worlds, and AspectH. In Beyond Program Slicing. Dagstuhl Seminar Proceedings, Volume 5451, pp. 1-8, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{breu_et_al:DagSemProc.05451.3,
  author =	{Breu, Silvia and Schlickling, Marc and Rodrigues, Nuno Miguel Feixa},
  title =	{{05451 Group 5 – Bananas, Dark Worlds, and AspectH}},
  booktitle =	{Beyond Program Slicing},
  pages =	{1--8},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5451},
  editor =	{David W. Binkley and Mark Harman and Jens Krinke},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05451.3},
  URN =		{urn:nbn:de:0030-drops-4910},
  doi =		{10.4230/DagSemProc.05451.3},
  annote =	{Keywords: Haskell, code clone detection, refactoring, functional control graph}
}
Document
DOI: 10.4230/DagSemProc.05451.4
And Now For Something Completely Different...

Authors: Sue Black and Philipp Bouillon

Abstract
A pilot experiment was conducted at Dagstuhl using the 'Beyond program slicing' seminar attendees. Attendees were split into three groups: all were given the same program to understand and a list of program comprehension related questions to answer. Group one had only the source code, group two had the source code and the dynamic trace of the program, group three had the source and a control-flow graph of the program.
Cite as

Sue Black and Philipp Bouillon. And Now For Something Completely Different.... In Beyond Program Slicing. Dagstuhl Seminar Proceedings, Volume 5451, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{black_et_al:DagSemProc.05451.4,
  author =	{Black, Sue and Bouillon, Philipp},
  title =	{{And Now For Something Completely Different...}},
  booktitle =	{Beyond Program Slicing},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5451},
  editor =	{David W. Binkley and Mark Harman and Jens Krinke},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05451.4},
  URN =		{urn:nbn:de:0030-drops-5833},
  doi =		{10.4230/DagSemProc.05451.4},
  annote =	{Keywords: Group experiment, program comprehension, source code, dynamic trace, control flow graph}
}
Document
DOI: 10.4230/DagSemProc.05451.5
And-Or Dependence Graphs for Slicing Statecharts

Authors: Chris Fox and Arthorn Luangsodsai

Abstract
The construction of an And-Or dependence graphs is illustrated, and its use in slicing statecharts is described. The additional structure allows for more precise slices to be constructed in the event of additional information, such as may be provided by static analysis and model checking, and with constraints on the global state and external events.
Cite as

Chris Fox and Arthorn Luangsodsai. And-Or Dependence Graphs for Slicing Statecharts. In Beyond Program Slicing. Dagstuhl Seminar Proceedings, Volume 5451, pp. 1-12, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{fox_et_al:DagSemProc.05451.5,
  author =	{Fox, Chris and Luangsodsai, Arthorn},
  title =	{{And-Or Dependence Graphs for Slicing Statecharts}},
  booktitle =	{Beyond Program Slicing},
  pages =	{1--12},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5451},
  editor =	{David W. Binkley and Mark Harman and Jens Krinke},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05451.5},
  URN =		{urn:nbn:de:0030-drops-4932},
  doi =		{10.4230/DagSemProc.05451.5},
  annote =	{Keywords: Slicing, statecharts, And-Or depdence graphs, interference, conditioning}
}
Document
DOI: 10.4230/DagSemProc.05451.6
Extending C Global Surveyor

Authors: Silvia Breu

Abstract
Software failure are noted for their blowing large sums of money and sometimes even human life, in particular in the area of safety critical mission software. The most well-known desaster happened in 1996 when Ariane 501 exploded shortly after launch. The least it did was to cost the European space program half a billion US$ due to an overflow in an arithmetic conversion. The Automated Software Engineering Group at the NASA Ames Research Center has developed C Global Surveyor (CGS), a static analysis tool based on abstract interpretation. It particularly concentrates on runtime errors that are hard to find during development such as out-of-bound array accesses, acesses to non-initialised variables, and de-references of null pointers. CGS proved to analyse large, pointer intensive and heavily multithreaded code (up to 280 KLoC) in a couple of hours with a constant precision of 80%. It is used to successfully analyse mission-critical flight software of NASA's "Mars Path-Finder" (MPF) and Deep Space 1 (DS1) legacy as well as software of the Mars Exploration Rover (MER) mission (650 KLoC) and other JPL-based missions. However, the abstract interpretation techniques on which CGS is based, need to be augmented by complimentary program analysis techniques in order to enhance CGS and support the developer when analysing very large systems. As a first step, we included the construction of control flow graphs that represent the programs to be analysed. It is a first step towards the application of more advanced techniques such as program slicing.
Cite as

Silvia Breu. Extending C Global Surveyor. In Beyond Program Slicing. Dagstuhl Seminar Proceedings, Volume 5451, pp. 1-5, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{breu:DagSemProc.05451.6,
  author =	{Breu, Silvia},
  title =	{{Extending C Global Surveyor}},
  booktitle =	{Beyond Program Slicing},
  pages =	{1--5},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5451},
  editor =	{David W. Binkley and Mark Harman and Jens Krinke},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05451.6},
  URN =		{urn:nbn:de:0030-drops-4878},
  doi =		{10.4230/DagSemProc.05451.6},
  annote =	{Keywords: Static program analysis, abstract interpretation, program slicing}
}
Document
DOI: 10.4230/DagSemProc.05451.7
Making Slicing Mainstream How can we be Weiser?

Authors: Karl Trygve Kalleberg, Tracy Hall, and Ran Ettinger

Abstract
By now, the concept of program slicing has been known in the research community for around 25 years. As a research topic, it has enjoyed a fair share of popularity, evidenced by the number of articles published on the topic following Mark Weiser's seminal paper. However, outside research circles, program slicing appears to be virtually unknown. In this report, we take the premise that program slicing is both technically relevant, and has a sufficient theoretical foundation, to be applied in practice within the software industry. With this premise in mind, we ask ourselves, ``what are the mechanisms by which we as a community could make program slicing mainstream''?
Cite as

Karl Trygve Kalleberg, Tracy Hall, and Ran Ettinger. Making Slicing Mainstream How can we be Weiser?. In Beyond Program Slicing. Dagstuhl Seminar Proceedings, Volume 5451, pp. 1-11, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{kalleberg_et_al:DagSemProc.05451.7,
  author =	{Kalleberg, Karl Trygve and Hall, Tracy and Ettinger, Ran},
  title =	{{Making Slicing Mainstream How can we be Weiser?}},
  booktitle =	{Beyond Program Slicing},
  pages =	{1--11},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5451},
  editor =	{David W. Binkley and Mark Harman and Jens Krinke},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05451.7},
  URN =		{urn:nbn:de:0030-drops-4861},
  doi =		{10.4230/DagSemProc.05451.7},
  annote =	{Keywords: Program Slicing, Popularization}
}
Document
DOI: 10.4230/DagSemProc.05451.8
Slicing Functional Programs by Calculation

Authors: Nuno Miguel Feixa Rodrigues and Luís S. Barbosa

Abstract
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.
Cite as

Nuno Miguel Feixa Rodrigues and Luís S. Barbosa. Slicing Functional Programs by Calculation. In Beyond Program Slicing. Dagstuhl Seminar Proceedings, Volume 5451, pp. 1-12, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{rodrigues_et_al:DagSemProc.05451.8,
  author =	{Rodrigues, Nuno Miguel Feixa and Barbosa, Lu{\'\i}s S.},
  title =	{{Slicing Functional Programs by Calculation}},
  booktitle =	{Beyond Program Slicing},
  pages =	{1--12},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5451},
  editor =	{David W. Binkley and Mark Harman and Jens Krinke},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05451.8},
  URN =		{urn:nbn:de:0030-drops-4845},
  doi =		{10.4230/DagSemProc.05451.8},
  annote =	{Keywords: Program Slicing, Algebra of Programming, Functional Programming}
}
Document
DOI: 10.4230/DagSemProc.05451.9
Towards Probabilistic Program Slicing

Authors: Jeremy Singer

Abstract
This paper outlines the concept of extit{probabilistic} program slicing. It walks through a simple example before describing some algorithmic concerns. Then three motivating applications are described. Finally it highlights existing work that may be built upon, and future work that needs immediate attention if this idea is to succeed.
Cite as

Jeremy Singer. Towards Probabilistic Program Slicing. In Beyond Program Slicing. Dagstuhl Seminar Proceedings, Volume 5451, pp. 1-14, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{singer:DagSemProc.05451.9,
  author =	{Singer, Jeremy},
  title =	{{Towards Probabilistic Program Slicing}},
  booktitle =	{Beyond Program Slicing},
  pages =	{1--14},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5451},
  editor =	{David W. Binkley and Mark Harman and Jens Krinke},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05451.9},
  URN =		{urn:nbn:de:0030-drops-4856},
  doi =		{10.4230/DagSemProc.05451.9},
  annote =	{Keywords: Probability, slicing, speculation}
}
Document
DOI: 10.4230/DagSemProc.05451.10
Using Attribute Slicing to Refactor Large Classes

Authors: Douglas Kirk, Marc Roper, and Neil Walkinshaw

Abstract
It can often be the case in object-oriented programming that classes bloat, particularly if the represent an ill-formed abstraction. A poorly formed class tends to be formed from disjoint sets of methods and attributes. This can result in a loss of cohesion within the class. Slicing attributes can be used to identify and make explicit the relationships between attributes and the methods that refer to them. This can be a useful tool for identifying code smells and ultimately refactoring. Attribute slicing can also be used to examine the relationships between attributes, as is the case in decomposition slicing. This paper introduces attribute slicing in the context of refactoring bloated classes.
Cite as

Douglas Kirk, Marc Roper, and Neil Walkinshaw. Using Attribute Slicing to Refactor Large Classes. In Beyond Program Slicing. Dagstuhl Seminar Proceedings, Volume 5451, pp. 1-12, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{kirk_et_al:DagSemProc.05451.10,
  author =	{Kirk, Douglas and Roper, Marc and Walkinshaw, Neil},
  title =	{{Using Attribute Slicing to Refactor Large Classes}},
  booktitle =	{Beyond Program Slicing},
  pages =	{1--12},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5451},
  editor =	{David W. Binkley and Mark Harman and Jens Krinke},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05451.10},
  URN =		{urn:nbn:de:0030-drops-4907},
  doi =		{10.4230/DagSemProc.05451.10},
  annote =	{Keywords: Refactoring, cohesion, object-oriented slicing}
}
Document
DOI: 10.4230/DagSemProc.05451.11
Using Program Slicing to Identify Faults in Software

Authors: Sue Black, Steve Counsell, Tracy Hall, and Paul Wernick

Abstract
This study explores the relationship between program slices and faults. The aim is to investigate whether the characteristics of program slices can be used to identify fault-prone software components. Slicing metrics and dependence clusters are used to characterise the slicing profile of a software component, then the relationship between the slicing profile of the component and the faults in that component are then analysed. Faults can increase the likelihood of a system becoming unstable causing problems for the development and evolution of the system. Identifying faultprone components is difficult and reliable predictors of faultproneness not easily identifiable. Program slicing is an established software engineering technique for the detection and correction of specific faults. An investigation is carried out into whether the use of program slicing can be extended as a reliable tool to predict fault-prone software components. Preliminary results are promising suggesting that slicing may offer valuable insights into fault-proneness.
Cite as

Sue Black, Steve Counsell, Tracy Hall, and Paul Wernick. Using Program Slicing to Identify Faults in Software. In Beyond Program Slicing. Dagstuhl Seminar Proceedings, Volume 5451, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{black_et_al:DagSemProc.05451.11,
  author =	{Black, Sue and Counsell, Steve and Hall, Tracy and Wernick, Paul},
  title =	{{Using Program Slicing to Identify Faults in Software}},
  booktitle =	{Beyond Program Slicing},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5451},
  editor =	{David W. Binkley and Mark Harman and Jens Krinke},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05451.11},
  URN =		{urn:nbn:de:0030-drops-5873},
  doi =		{10.4230/DagSemProc.05451.11},
  annote =	{Keywords: Program slicing, slicing metrics, fault proneness, software quality}
}

Filters

  • Authors
  • B
  • Barbosa, Luís S.
  • Binkley, Dave
  • Black, Sue
  • Bouillon, Philipp
  • Breu, Silvia
  • C
  • Counsell, Steve
  • E
  • Ettinger, Ran
  • F
  • Fox, Chris
  • H
  • Hall, Tracy
  • Harman, Mark
  • K
  • Kalleberg, Karl Trygve
  • Kirk, Douglas
  • Krinke, Jens
  • L
  • Luangsodsai, Arthorn
  • R
  • Rodrigues, Nuno Miguel Feixa
  • Roper, Marc
  • S
  • Schlickling, Marc
  • Singer, Jeremy
  • W
  • Walkinshaw, Neil
  • Wernick, Paul

Any Issues?
X

Feedback on the Current Page

CAPTCHA

Thanks for your feedback!

Feedback submitted to Dagstuhl Publishing

Could not send message

Please try again later or send an E-mail
© 2023-2025 Schloss Dagstuhl – LZI GmbH About DROPS Imprint Privacy Contact