A cognitive approach to program understanding, K. Bertels and Ph. Vanneste and C. de Backer
@InProceedings{ bertels.vanneste.ea:cognitive,
author = {K. Bertels and Ph. Vanneste and C. de Backer},
title = {A cognitive approach to program understanding},
booktitle = {Proceedings of the 1st Working Conference on Reverse
Engineering },
pages = {1--7},
year = {1993},
note = { Presents a method of program understanding based on a
cognitive model of programming knowledge. The approach
involves the generation of a high level, abstract,
description that is robust with respect to conceptual
errors and syntactic variations},
class = {Software_Reverse_Engineering,
Cognitive_Processes_in_Human_Program_Understanding}
}
A Cognitive Approach to Program Understanding , K. Bertels and P. Vanneste and C. De~Backer
@InProceedings{ bertels.vanneste.ea:cognitive*1,
author = { K. Bertels and P. Vanneste and C. {De~Backer} },
title = { A Cognitive Approach to Program Understanding },
booktitle = { WCRE~'93: Proceedings of the 1993 Working Conference on
Reverse Engineering, {\rm (Baltimore, Maryland; May 21-23,
1993)}},
year = { May 1993 },
pages = { 1-7 },
publisher = { IEEE Computer Society Press (Order Number 3780-02)},
abstract = { },
class = {Software_Reverse_Engineering,
Cognitive_Processes_in_Human_Program_Understanding }
}
Towards a theory of the comprehension of computer programs, Ruven Brooks
@Article{ brooks:towards,
author = {Ruven Brooks},
title = {Towards a theory of the comprehension of computer
programs},
journal = {International Journal of Man-Machine Studies},
year = {1983},
pages = {543-554},
volume = {18},
abstract = {A sufficiency theory is presented of the process by which
a computer programmer attempts to comprehend a program. The
theory is intended to explain four sources of variation in
behavior on this task: the kind of computation the program
performs, the intrinsic properties of the program text,
such as language and documentation, the reason for which
the documentation is needed, and differences among the
individuals performing the task. The starting point for the
theory is an analysis of the structure of the knowledge
required when a program is comprehended which views the
knowledge as being organized into distinct domains which
bridge between the original problem and the final program.
The program comprehension process is one of reconstructing
knowledge about these domains and the relationship among
them. This reconstrucing process is theorized to be a
top-down, hypothesis driven one in which an initially vague
and general hypothesis is refined and elaborated based on
information extracted from the program text and other
documentation.},
contents = {A theory of how programs are comprehended: 1) The
programming process is one of constructing mappings from a
problem domain, possibly through several intermediate
domains, into the programming domain. 2) Comprehending a
program involves reconstructing part or all of these
mappings. 3) This reconstruction process is expectation
driven by the creation, confirmation, and refinement of
hypotheses.
The reconstruction process (in top-down and depth-first
manner) constructs subsidiary hypotheses from initial
hypotheses. Confirmation is done by finding ``beacons''
(set of features that typically indicate the occurence of
certain structures or operations whithin the code). The
discovery of a beacon results in a further refinement and
specification of the hypothesis itself. Usually, problems
will occur which will manifest themselves as one of three
symptoms: the programmer will be unable to find code to
bind to a particular subsidiary hypothesis, or the same
code will be bound to two different hypotheses, or ther
will be some parts of the code which cannot be beound to
any hypotheses. All these kinds of errors could be cured
either by adopting different hypotheses or by altering and
adding to the bindings of code to hypotheses.
Indicators for the meaning of a program:
Internal to the program text 1. Prologue comments,
including data and variable dicitionaries 2. Variable,
structure, procedure and label names 3. Declarations or
data divisions 4. Interline comments 5. Indentation or
pretty-printing 6. Subroutines or module structure 7. I/O
formats, header, and device or channel assignments
External 1. Users' Manual 2. Program logic manuals 3.
Flowcharts 4. Cross-reference listing 5. Published
descriptions of algorithms or techniques
},
class = {Software_Reverse_Engineering,
Cognitive_Processes_in_Human_Program_Understanding}
}
Towards a Theory of the Cognitive Processes in Computer Programming, Ruven Brooks
@Article{ brooks:towards*1,
author = {Ruven Brooks},
title = {Towards a Theory of the Cognitive Processes in Computer
Programming},
journal = {International Journal of Man-Machine Studies},
year = {1977},
volume = {9},
pages = {737-751},
abstract = {Another early Brooks paper on domain-bridging. Describes a
theory of programmign behavior based on problem-solving
theory.},
class = {Software_Reverse_Engineering,
Cognitive_Processes_in_Human_Program_Understanding }
}
Towards a Theory of the Comprehension of Computer Programs, Ruven Brooks
@Article{ brooks:towards*2,
author = {Ruven Brooks},
title = {Towards a Theory of the Comprehension of Computer
Programs},
journal = {International Journal of Man-Machine Studies},
year = {1983},
volume = {18},
pages = {543-554},
abstract = {},
class = {Software_Reverse_Engineering,
Cognitive_Processes_in_Human_Program_Understanding }
}
Using a Behavioral Theory of Program Comprehension in Software Engineering, Ruven Brooks
@InProceedings{ brooks:using,
author = {Ruven Brooks},
title = {Using a Behavioral Theory of Program Comprehension in
Software Engineering},
booktitle = {ICSE'3: Proceedings of the 3rd International Conference on
Software Engineering, {\rm (Atlanta, Georgia; May 10-12,
1978)}},
year = {May 1978},
pages = {196-201},
abstract = {Early paper on bridging knowledge domains. Differentiates
between internal and external clues to PU. ** Quotes
Kernighan and Plauger: "The best documentation for a
computer program is a clean structure. The only reliable
documentation of a computer program is the code itself. The
reason is simple: whenever there are multiple
representations of a program, the chance for discrepancy
exists." [Thus, solution is to keep 'live documentation';
VSS.] },
class = {Software_Reverse_Engineering,
Cognitive_Processes_in_Human_Program_Understanding }
}
A Concept-Oriented Belief Revision Approach to Domain Knowledge Recovery from Source Code, Yang Li and Hongji Yang and William Chu
@Article{ li.yang.ea:concept-oriented,
author = {Yang Li and Hongji Yang and William Chu},
title = {A Concept-Oriented Belief Revision Approach to Domain
Knowledge Recovery from Source Code},
journal = {Journal of Software Maintenance: Research and Practice},
year = {2000},
volume = {12},
number = {6},
abstract = {Domain knowledge is the soul of software systems. After
decades of software development, domain knowledge has
reached a certain degree of saturation. The recovery of
domain knowledge from source code is beneficial to many
software engineering activities, in particular, software
evolution. In the real world, the ambiguous appearance of
domain knowledge embedded in source code constitutes the
biggest barrier to recovering reliable domain knowledge. In
this paper, we introduce an innovative approach to
recovering domain knowledge with enhanced reliability from
source code. In particular, we divide domain knowledge into
inter-connected knowledge slices and match these knowledge
slices against the source code. Each knowledge slice has
its own authenticity evaluation function which takes the
belief of the evidences it needs as input and the
authenticity of the knowledge slice as output. Moreover,
the knowledge slices are arranged to exchange beliefs with
each other through inter-connections, i.e., concepts, so
that a better evaluation of the authenticity of these
knowledge slices can be obtained. The decision on
acknowledging recovered knowledge slices can therefore be
made more easily. Rooted in cognitive science and social
psychology, our approach is also widely applicable to other
knowledge recovery tasks. },
keywords = {domain knowledge recovery, uncertainty reasoning,
cooperative behaviour, semantic network},
note = {It is the first attempt of applying social psychology
theory to the field of knowledge recovery, in particular
design recovery.},
class = {Knowledge-Based_Concept_Assignment Using_graphs
Model_Generating Reverse_Specification
Cognitive_Processes_in_Human_Program_Understanding
Reverse_Design Domain_Analysis
Human_Oriented_Concept_Assignment_by_Informal_Reasonin
Intermediate_Representations_of_Source_Code
Software_Reverse_Engineering }
}
Generating Linkage between Source Code and Evolvable Domain Knowledge for the Ease of Software Evolution, Yang Li and Hongji Yang and William Chu
Available as .
@InProceedings{ li.yang.ea:generating,
author = {Yang Li and Hongji Yang and William Chu},
title = {Generating Linkage between Source Code and Evolvable
Domain Knowledge for the Ease of Software Evolution},
booktitle = {Proceedings of IEEE International Symposium on Principles
of Software Evolution (ISPSE2000)},
publisher = {IEEE Computer Society Press},
year = {2000},
editor = {},
chapter = {},
pages = {},
address = {Kanazawa, Japan},
month = {Nov},
url = {},
abstract = {Business software systems unexceptably need to be evolved
to cater for new/changed requirement coming from market or
adapt to new operating environment. One of the most
significant problems in current software evolution practice
is that software maintainers usually find it quite
difficult to locate the program sections in source code
which need to be modified and to identify the extent to
which the changes in these program sections could affect
the rest of the software system. In this paper, we propose
a knowledge engineering based approach to solving this
problem. In particular, we match a software program with a
pre-defined domain knowledge base in the representation of
simplified semantic network we proposed in order to link
the source program with its domain level interpretation.
The domain knowledge base contains only important domain
knowledge where potential evolutions could occur, which
reduces the size of the knowledge base. Moreover, a domain
oriented program partitioning method is also proposed to
cut a program into self-contained modules with manageable
size. In these ways, the computational complexity involved
in generating the linkage is significantly reduced which
makes this approach applicable. An example shows that
software evolution can be easily carried out as the domain
knowledge it links with evolves. },
keywords = {software evolution, knowledge engineering, program
partitioning, evolvable domain knowledge, semantic
network},
note = {This paper gives engineering-oriented considerations to
link generation between domain knowledge and source code
prior to successful software evolution.},
class = {Software_Evolution Knowledge-Based_Concept_Assignment
Using_graphs Change_Impac
Cognitive_Processes_in_Human_Program_Understanding Metrics
Reverse_Design Re-Design System_Modularization
Recovery_of_Software_Architecture
Metric-Based_Methods_in_Reverse_Design Alteration
Human_Oriented_Concept_Assignment_by_Informal_Reasoning
Intermediate_Representations_of_Source_Code
Software_Reverse_Engineering }
}
Towards Building a Smarter Domain Knowledge Recovery Assistant, Yang Li and Hongji Yang and William Chu
Available as .
@InProceedings{ li.yang.ea:towards,
author = {Yang Li and Hongji Yang and William Chu},
title = {Towards Building a Smarter Domain Knowledge Recovery
Assistant},
booktitle = {Proceedings of the 24th IEEE Annual Computer Software and
Applications Conference (COMPSAC2000)},
publisher = {IEEE Computer Society Press},
year = {2000},
editor = {},
chapter = {},
pages = {},
address = {},
month = {Oct},
url = {},
abstract = {Legacy systems need to be ``salvaged'' to prolong their
life circle. One way for such a salvation is to recover and
maintain domain knowledge embedded in legacy code. It is
our observation that existing methods or tools for domain
knowledge recovery from source code did not provide
maintainers with sufficient assistance to reduce the size
of analysable program sections, identify program sections
having intensive domain knowledge and maintain the belief
of a network of domain knowledge extracted from source code
which can accommodate change of belief coming from a user.
In this paper, we introduce techniques which can provide
software maintainers with smart assistance for the
above-mentioned three issues. },
keywords = {program partitioning, program readability metric, belief
network, domain knowledge recovery},
note = {We incorpate human psychology knowledge with the design of
a domain knowledge recovery tool.},
class = {Automated_Reverse_Design
Knowledge-Based_Concept_Assignment Reverse_Engineering_Tool
Model_Generating Reverse_Specification
Cognitive_Processes_in_Human_Program_Understanding Metrics
Reverse_Design System_Modularization Domain_Analysis
Recovery_of_Software_Architecture
Metric-Based_Methods_in_Reverse_Design
Human_Oriented_Concept_Assignment_by_Informal_Reasoning
Software_Reverse_Engineering }
}
Fusing Ambiguous Domain Knowledge Slices in a Reverse Engineering Process, Yang Li and Hongji Yang
Available as .
@InProceedings{ li.yang:fusing,
author = {Yang Li and Hongji Yang},
title = {Fusing Ambiguous Domain Knowledge Slices in a Reverse
Engineering Process},
booktitle = {Proceedings of the 7th Asia-Pacific Software Engineering
Conference (APSEC2000)},
publisher = {IEEE Computer Society Press},
year = {2000},
editor = {},
chapter = {},
pages = {},
address = {Singapore},
month = {Dec},
url = {},
abstract = {Recovering domain knowledge from legacy code plays an
important role in the new information technology era, which
can be of help for program understanding, system evolution
and software reuse. Traditional methods for domain
knowledge recovery from source code did not sufficiently
address the issue of ambiguity handling, in particular, the
propagation of ambiguity among multiple domain knowledge
slices recovered from source code in software reverse
engineering process. In this paper, we present a novel
approach to recovering unambiguous domain knowledge from
legacy code, where isolated ambiguous domain knowledge
slices are ``fused'' together in an iterative ambiguity
propagation process and hence the disambiguity of these
recovered knowledge slices is increased. },
keywords = {reverse engineering, domain knowledge recovery,
co-operative behaviour, belief revision},
note = {This is the first of this kind of work which deals with
the ambiguity involved in recovering large-scale domain
knowledge from source code.},
class = {Automated_Reverse_Design
Knowledge-Based_Concept_Assignment Using_graphs
Model_Generating Reverse_Specification
Cognitive_Processes_in_Human_Program_Understanding
Reverse_Design Domain_Analysis
Recovery_of_Software_Architectur
Metric-Based_Methods_in_Reverse_Design
Human_Oriented_Concept_Assignment_by_Informal_Reasoning
Intermediate_Representations_of_Source_Code
Software_Reverse_Engineering }
}
Software Psychology Requirements for Software Maintenance Activities, Spencer Rugaber and Victoria Tisdale
@TechReport{ rugaber.tisdale:software,
author = {Spencer Rugaber and Victoria Tisdale},
title = {Software Psychology Requirements for Software Maintenance
Activities},
year = {1994},
institution = {Software Engineering Center Georgia Institute of
Technology, Atlanta, GA},
abstract = {Software psychology attempts to discover and describe
human limitations in interacting with computers. These
limitations can place restrictions on and form requirements
for computing systems intended for human interaction.
Hypermaint is such a system. Hypermaint is designed, with
human limitations in mind, to facilitate the human task of
maintaining software. Software maintenance encompases all
activities performed on a piece of software intending to
keep it useful. This includes efforts to keep software at
the same level of performance/usability, as well as efforts
to improve it. In the process of software maintenance,
source code of the software must be examined and understood
by the maintainer. The task of maintenance can be
facilitated by a system congruent with human abilities and
limitations.
This paper describes areas of programming activity (namely
program comprehension, program composition, program
debugging, and program modification). It describes the
models of program comprehension of Shneiderman and Greeno.
A number of factors play a role in the transformation of
code to an internal semantic form. These factors deal with
the viewing and the style of the program code. Experiments
have been performed to determine the extent to which these
factors affect the comprehension of programs: Commenting,
Variable Names, and Indentation.},
ftp = {ftp.cc.gatech.edu//pub/groups/reverse/repository/softpsych.ps}
,
class = {Software_Reverse_Engineering,
Cognitive_Processes_in_Human_Program_Understanding}
}
Program Comprehension for Reverse Engineering, Spencer Rugaber
@Unpublished{ rugaber:program*1,
author = {Spencer Rugaber},
title = {Program Comprehension for Reverse Engineering},
organization = {College of Computing, Georgia Institute of Technology},
address = {Atlanta, Georgia 30332-0280},
email = {spencer@cc.gatech.edu},
class = {Software_Reverse_Engineering,
Cognitive_Processes_in_Human_Program_Understanding}
}
Empirical Studies of Programming Knowledge, Elliot Soloway and Kate Ehrlich
@Article{ soloway.ehrlich:empirical,
author = {Elliot Soloway and Kate Ehrlich},
title = {Empirical Studies of Programming Knowledge},
journal = {IEEE Transactions on Software Engineering},
year = {1984},
volume = {SE-10},
number = {5},
pages = {595-609},
month = sep,
abstract = { We suggest that expert programmers habe and use two types
of programming knowledge: 1) programming plans, which are
generic program fragments that represent stereotypic action
sequences in programming and 2) rules of programming
discourse, which capture the conventions in programming and
govern the composition of the plans into programs. We
report here on two empirical studies that attempt to
evaluate the above hypothesis. Results from these studies
do in fact support our claim. },
keys = {Cognitive models of programming, novice/expert
differences, program comprehension, software psychology.},
class = {Software_Reverse_Engineering,
Cognitive_Processes_in_Human_Program_Understanding,
Software_Reverse_Engineering, Reverse_Design,
Knowledge-Based_Concept_Assignment,
Program_Plan_Assignment_by_Parsing}
}
Cognitive Models of Program Comprehension, Tim Tiemens
@Unpublished{ tiemens:cognitive,
author = {Tim Tiemens},
title = {Cognitive Models of Program Comprehension},
abstract = {This paper describes some cognitive models in program
comprehension. The goal is to use this knwoledge about
cognitive models to produce a tool (the Cognitive Support
Tool, CST) which can reduce the amount of effort needed to
understand a program. The models discussed here were
derived from both a human perspective ans from a source
code perspective. After reviewing these models, a synthesis
section suggests some implications of the information
presented. Finally, a section describing a sample
interactive sessions with CST is presented.},
organization = {Software Engineering Research Center},
month = dec,
year = {1989},
class = {Software_Reverse_Engineering,
Cognitive_Processes_in_Human_Program_Understanding}
}