Clarity Guided Belief Revision for Domain Knowledge Recovery
in Legacy Systems
Yang Li and Hongji Yang
Computer Science Department
De Montfort University
England
E-mail: yangli, hyang@strl.dmu.ac.uk
Abstract
Program understanding is the process of acquiring
knowledge from a computer program. Although research
work utilising knowledge engineering techniques has been
undertaken in this field, it is our observation that a thor-
ough application of AI methodology has not been suffi-
ciently explored. In this paper, we present a clarity guided
belief revision approach to domain knowledge recovery in
legacy software systems. Novel solutions are given to three
key AI issues in the context of domain knowledge recovery
from source code: knowledge representation, where con-
crete semantic network is separated from abstract semantic
network to better accommodate uncertainty reasoning and
propagation; uncertainty reasoning, which borrows ideas
from confirmation theory and recasts them in the context
of semantic network reasoning; heuristic search, which is
designed on the principle of programming psychology. Our
approach is light-weighted. It can be used stand-alone or as
a complement to traditional heavy-weighted domain knowl-
edge recovery methods.
Keywords : program understanding, knowledge re-
covery, semantic network, belief revision, heuristic
search, programming psychology
1. Introduction
After decades’ software development, software indus-
try has arrived at a point where the majority of software
engineering effort is being spent on maintaining existing
systems rather than developing new ones. Domain knowl-
edge, the core of software, which has been accumulated
over years reaches a certainty degree of “saturation”. Cur-
rent practice suggests that software maintainers spend most
William Chu
Computer Science Department
TungHai University
Taiwan
chu@cis.thu.edu.tw
of their time developing an understanding of the software
being maintained [15]. One of the primary reasons for this
is that software documentation is often inadequate or unre-
liable. As a result, source code becomes the only reliable
analysis source for developing understanding [2].
Techniques ranging from syntax analysis, through struc-
tural analysis, to Domain Knowledge Base Analysis
(DKBA) are integrated in Computer Aided Reverse Engi-
neering (CARE) tools to help maintainers with program
understanding. Due to the interest and space limit of
this paper, we discuss the third issue only. Traditional
DKBA methods are heavy-weighted where the effective-
ness of domain knowledge recovery relies heavily on the
use of knowledge at different abstract layer and therefore
hinders the efficiency of these methods. Table 1 lists re-
lated work on DKBA, categorised by typical knowledge
engineering issues. It is our observation that important is-
sues such as knowledge representation, uncertainty reason-
ing and program space management have not been suffi-
ciently addressed in the context of domain knowledge re-
covery from source code. In this paper, we present a light-
weighted approach to DKBA where a suit of novel solutions
are given to these three issues.
The rest of the paper is organised as follows: in Sec-
tion 2, a variant of semantic network used as a supporting
knowledge representation in our system is introduced. In
Section 3, a novel belief revision model for semantic net-
work is illustrated which recasts the ideas borrowed from
confirmation theory in our new context. The issues of be-
lief initialisation and belief propagation are also discussed.
Section 4 introduces a new idea on heuristic search, where
programming psychology is used as an efficient way to de-
cide good searching path at singular-way belief propagation
stage. A comparison between our work and related work is
given in Section 5. Finally, we summarise the paper and a
future plan.
 Knowledge Representation
Reasoning Techniques
Control Strategies for Reasoning
Knowledge Base Management
Program Space Management
Assessment Environment
Embedded in Other Tasks
plan [1, 3, 9, 10, 11, 13, 14, 18, 19], semantic/connectionist network [4],
graph (chart) [21, 22],tree/outline/hierarchy [1, 3]
classic reasoning [1, 3, 9, 10, 11, 13, 14, 19], uncertainty reasoning [4],
inductive reasoning [6]
bottom-up [4, 9, 10, 13, 19], top-down [4], dynamic programming/hybrid
search [11], flexible/multi-purpose application [21]
hierarchy [1]
dominance tree [5]
MACS [7], Medona [12]
transformation [8, 20], bug-seeking [10]

Table 1. A Survey of DKBA research categorised by Knowledge Engineering Issues

inter-relationships examples
objects-objects instance-of, part-of, etc.
objects-actions receiver-of, sender-of.
actions-actions sub-plan-of, precedent-of, etc.

Table 2. Inter-relationship examples among nodes in semantic network

2. Two-layer Semantic Network
We use semantic network as domain knowledge repre-
sentation in our approach. The definition of semantic net-
work in our context is described as follows:
Let S N be a semantic network, S N = (N; E ), where
N denotes the total set of concepts and E denotes the to-
tal set of inter-relationships among these concepts. N is
classified into two kinds of concepts, namely, objects and
actions. Object represents class, instance, features, etc.,
whereas action represents operation or event which oc-
cur among several objects. E is therefore classified into
the inter-relationships between objects and objects, objects
and actions, actions and actions. Table 2 describes inter-
relationship examples in each category.
We introduce a new concept called domain knowledge
slice in the context of DKBA. A domain knowledge slice is
defined as a set of strongly related domain concepts linked
by a set of inter-relationships among these concepts. Mul-
tiple domain knowledge slices could exist for a single set
of domain concepts depending on the number of different
group of inter-relationships among these concepts. Domain
knowledge is therefore regarded as a collection of domain
knowledge slices which are linked with each other through
common concepts.
In order to accommodate this idea, we change classic se-
mantic network into two-layer network, namely, concrete
semantic network and abstract semantic network. Concrete
semantic network contains detailed information on concepts
and inter-relationships among them. Each concrete seman-
tic sub-net is associated with a single knowledge slice. Ab-
stract semantic network contains only domain concepts and
links to corresponding concrete semantic sub-nets. It acts
as a connection among different knowledge slices and pro-
vides an infrastructure for belief propagation. Concrete se-
mantic network is, on the other hand, used to accommodate
belief revision. Figure 1 shows an abstract semantic net-
work in telecommunication domain, whereas, Figure 2 is
an example of concrete semantic sub-net.
3. Belief Initialisation, Revision and Propaga-
tion
In this section, we introduce the uncertainty reasoning
method used in our approach. The uncertainty reasoning
model is built on the axiom system of confirmation theory
[17] for its simplicity to use. The calculus system of con-
firmation theory has been completely adapted in our new
context. Three topics involved are discussed, namely, belief
initialisation, belief revision and belief propagation.
3.1. Belief Initialisation
A pre-defined semantic network exists in knowledge
base. A working semantic network is held in black-
board, which is obtained by checking concepts and inter-
relationships in knowledge base with the source code be-
ing analysed. Once a match is found between a concept
 AA1

Transfer

AO1

Source Destination File

OO4 OO5 OO6

Connect Server Communicate

AO2

Client AA3 AA4

AA2
OO3
Accept AO7 Client-Information Record

AO6 AO3
Listen OO2 Send
AO4
Bind Server-Information
AO5
Receive
Allocate Socket

AO8 OO1

Domain-Name Host-Name IP-Address

Figure 1. An example of Abstract Semantic Network in Telecommunication Domain

Connect part-of
Accept

part-of

part-of part-of precedent-of

Listen

Allocate

precedent-of precedent-of
Bind

Figure 2. An example of concrete semantic sub-net

and a name in the code, the linkage between the concept
and its location in the code is recorded in the blackboard.
The check of an inter-relationship is performed in the pro-
gram region constrained by the participating concepts of
the inter-relationship. Moreover, to avoid the combinato-
rial explosion of search in program space, the search for
an inter-relationship is only carried out in specific program
constructs. For example, the search for inherit relation is
only carried out in the following structure:
class Clock : public Click {
} collected. For example:
The initial belief of a concept in the blackboard comes
from the matching degree between a concept and a name
in the source code being analysed. In real world, pro-
grammers often write abbreviation of meaningful names in
source code, which leaves ambiguity to these names. We
have a database called name dictionary to contain name re-
covery rules.
A single domain concept can be represented as either an
atomic name or a compound name. An atomic name is an
individable lexicon unit whereas a compound name consti-
tutes several atomic names. Two classifications are given to
atomic name recovery rules, namely, regular atomic name
recovery rules and irregular atomic name recovery rules.
One example of regular atomic name recovery rule is: “first
three letters (0.15)” which means if a name in the code is
matched with the first three letters of a concept, the name
can be linked with this concept with an assigned belief,
0.15. Irregular abbreviation usually comes from the pronun-
ciation of a word which is difficult to write standard rules
for it and therefore different irregular abbreviation cases are
========================================
Atomic Name irregular cases
----------------------------------------
Information info (0.90), infor (0.85)
========================================
If a name in the code is matched with one of a concept’s ir-
regular cases directly, a quantified linkage between the con-
cept and the name can be set up.
A single compound name is composed of several atomic
names with connecting symbols like ’-’ or ’ ’, etc. The am-
biguity of a compound name mainly comes from the am-
biguity of each composite atomic name. We also give two
classifications to compound name recovery rules, namely,
regular compound name recovery rule and irregular com-
pound name recovery rules. The regular compound name
recovery rule will check each of its composite name by
using atomic name recovery rules; the belief of the whole
name is assigned to the minimum belief among all its com-
posite atomic names. Irregular compound name abbrevi-
ations are commonly used abbreviations without standard
rules. Irregular abbreviations are also collected, for exam-
ple,
===============================================
Compound Name Composite Names Irregular Cases
-----------------------------------------------
Domain-Name Domain, Name DN (0.7)
===============================================
The check of an irregular compound name is done by
matching its irregular cases directly.
For both atomic names and compound names, we give
relatively higher belief to irregular name recovery rules than
to regular name recovery rules, which is accorded with
common-sense. Nevertheless, name recovery is an exhaus-
tive process where direct matching, irregular name recov-
ery rules and regular name recovery rules have to be tested
without exception.
The belief of an inter-relationship is dependent on the
belief of its participating concepts. We therefore need not
give initial belief to inter-relationships.
3.2. Belief Revision
In the context of DKBA, we take the view that domain
knowledge is a set of cooperative domain knowledge slices
and a domain knowledge slice is composed of a set of coop-
erative domain concepts, where a domain concept could get
support from other concepts in the same domain knowledge
slice or even from other knowledge slices. The belief of
a domain concept is therefore subjected to be revised once
the belief of its cooperative concepts changes. In this sub-
section, we discuss the dynamics of such a belief revision
process.
3.2.1 Calculating The Authenticity of A Knowledge
Slice
Empirically, each concept or inter-relationship within a
knowledge slice can make different contribution to the
recognition of authenticity of the knowledge slice. Take
Figure 2 for example, the actions of connect, listen and ac-
cept will contribute more than allocate and bind to recog-
nise the scenario where sub-actions are taken to fulfill the
task of connect. Moreover, the absence of a domain con-
cept or an inter-relationship would totally refute the linkage
of a particular knowledge slice to a program. We hereby in-
troduce two concepts, namely, Contribution Strength (C S )
and Refutation Strength (RS ). C S indicates the strength
the presentation of a domain concept or an inter-relationship
has to build up positive belief in the context of a knowledge
slice. RS indicates the destructing power the absence of
a domain concept or an inter-relationship has to refute the
context of a knowledge slice. Both C S and RS are real
numbers belonging to [0; 1:0]. By default, C S and RS are
set to 0.
Let S N = fc1 ; :::; cm ; r1 ; :::; rk g be a domain knowl-
edge slice, where ci ; 1  i  m and rj ; 1  j  k denote
domain concepts and inter-relationships in the knowledge
slice respectively; f(C S (i); RS (i))j1  i  m + k g be
the contribution strength and refutation strength of each el-
ement in S N respectively; fC F (i)j1  i  m + k g be
the current belief of each element in S N ; fC F 0 (i)j1 
i  m + k g be the prepared belief of each element in S N ;
AU be the authenticity degree of S N . The calculation of
0 0 0
C F (i) is: C F (i) = C F (i), if i is a concept; C F (i) =
the production of beliefs of all participating concepts, if i
is an inter-relationship. The algorithm of calculating AU is
described as follows:
===================================================
Algorithm for calculating Authenticity of context
---------------------------------------------------
MB <- 0
FOR i <- 1 TO m+k DO
IF CF’(i) > 0 THEN
MB <- MB + (1-MB)*CF’(i)*CS(i)
ENDFOR
MD <- 0
FOR i <- 1 TO m+k DO
IF CF’(i) < 0 THEN
MD <- MD + (1-MD)*(-CF’(i))*RS(i)
ENDFOR
AU <- (1-MD)*MB-MD
----------------------------------------------------
Note:
<- stands for the operation of ordinary assignment
====================================================
Script 1
Theorem 3.2.1 The calculation of M B (or M D) in Script
1 constitutes an Abel group in the field of [ 1; 1].
A proof for Theorem 3.2.1 can be easily obtained accord-
ing to the definition of Abel group. Due to space limitation,
we will not give the proof in this paper. Theorem 3.2.1 sug-
gests that the computation of AU is actually independent
of the order of concepts and inter-relationships. M B col-
lects the beliefs that favour the context of a knowledge slice
while M D collects the beliefs that against it. The compu-
tation of AU through M B and M D makes it possible that
M D has higher priority than M B . This is a desirable prop-
erty, because a refutation is normally issued by users and
therefore should be given higher weight. It is easy to ver-
ify that 1  AU  1. Initially, AU is set to be 0. The
calculation of AU is done in concrete semantic network.
3.2.2 Revising The Belief of A Concept within A Single
Knowledge Slice
The authenticity of a knowledge slice is calculated by syn-
thesising the “votes” from all its participating concepts and
inter-relationships. The concepts in the knowledge slice
can therefore be re-evaluated once the authenticity of the
knowledge slice is changed. We hereby provide formulas
for calculating the effect the revised authenticity of a knowl-
edge slice has on its participating concepts. We don’t revise
the belief of inter-relationships. Let Æ (AU ) = AU AU 0 ,
where AU 0 is the previous authenticity of a knowledge
slice; D(CFi ) be the ratio of belief-revising for concept i
in the knowledge slice. The other notations used in these
formulas are accorded with the definition in section 3.2.1.
We have

Æ (AU )  CS (i) if Æ (AU ) > 0
D(CFi ) =
Æ (AU )  RS (i) else
We note that when authenticity of a context is positive,
the positive belief of a concept in the context is stretched at
the rate of contribution strength; otherwise, the negative be-
lief of a concept increases at the rate of refutation strength.
D(CFi ) is also calculated in concrete semantic network.
The result is written in abstract semantic network.
3.2.3 Synthesising The Beliefs of A Concept in Multi-
ple Knowledge Slices
A domain concept can have different roles in different con-
texts. After the beliefs of a concept are revised in different
contexts, a final synthesis of the beliefs of the concept is
needed. Let D(CF 0 (i; j )) be the ratio of belief-revising for
concept i in context j; 1  j  m. CF 0 (i) be the old belief
of concept i, CF (i) be the synthesised belief for concept
i. The algorithm for calculating CF (i) is described as fol-
lows:
===================================================
Algorithm for Synthesising Multiple Beliefs
---------------------------------------------------
MB <- 0
FOR j <- 1 TO m DO
IF D(CF’(i, j)) > 0 THEN
MB <- MB + (1-MB)*D(CF’(i, j))
ENDFOR
MD <- 0
FOR j <- 1 TO m DO
IF D(CF’(i, j)) < 0 THEN
MD <- MD + (1-MD)*(-D(CF’(i, j)))
ENDFOR
D(CF’(i)) <- MB - MD
CF(i) <- CF’(i) + (1-CF’(i)) * D(CF’(i))
Script 2
Similar to Section 3.2.1, we have:
Theorem 3.2.3 The calculation of MB (or MD) consti-
tutes an Abel group in the field of [ 1; 1].
Theorem 3.2.3 suggests that the computation of CF (i)
is independent of the order of D(CF 0 (i; j )). In the above
algorithm, we first synthesise the ratios of belief-revising
of a concept in different knowledge slices prior to updating
the old belief of the concept by the synthesised ratio. The
calculation of CF (i) is done in abstract semantic network.
3.3. Belief Propagation
The revised belief of a concept can again revise the au-
thenticity of the knowledge slices it occurs and in turn, af-
fects the beliefs of the concepts contained in these knowl-
edge slices, and so on. A propagation of the effect of revised
belief of a concept will occur in the semantic network. We
describe two different kinds of belief propagation, namely,
dual-way belief propagation and singular-way belief prop-
agation.
3.3.1 Dual-way Belief Propagation
Dual-way belief propagation is carried out immediately af-
ter the beliefs of domain concepts are initialised. Suppose,
we regard a domain knowledge slice as a domain expert, the
belief of a domain concept as the viewpoint of a domain ex-
pert on the concept. At the stage when the beliefs of domain
concepts are just initialised, the viewpoints of domain ex-
perts have not been imposed on these concepts yet. A sub-
stantial of exchange of viewpoints among domain experts
on concepts is therefore needed. The viewpoints are ex-
changed through the belief revision of concepts. The three
steps in Section 3.2 describe how the viewpoint of a domain
expert is imposed on a concept. We use the word of “dual-
way”, because the exchange of viewpoints here is in two
directions where a domain expert can both influence other
domain experts and vice verse.
Dual-way belief propagation is an iterative process. Af-
ter one pass, only closely linked domain experts can ex-
change viewpoints; as the process goes on, alienate domain
experts can exchange their viewpoints. In our system, a
----------------------------------------------------
Note:
<- stands for the operation of ordinary assignment
====================================================
constraint  1 is set to limit the number of iterative rounds
because closely-related domain experts should not over in-
fluence each other and alienate experts have less influence
on each other.
3.3.2 Singular-way Belief Propagation
Singular-way Belief Propagation is invoked when users in-
tervene the reasoning process by manually specifying the
belief of a concept. We assume that a user is the domain ex-
pert with highest authority. It is not allowed for other “do-
main experts” (refer to knowledge slices) to revise a user’s
and their successors’ (refer to those knowledge slices cho-
sen for belief revision after users’ intervention) belief. The
belief propagation is therefore in a singular-way. With the
same concern given in Section 3.3.1, a constraint DC is set
to limit the number of propagation layers. Script 3 gives an
algorithm for controlling the singular-way belief propaga-
tion.
=====================================================
STACK <= (knowledge slices affected by the concept
revised by a user, 1).
WHILE not-empty(STACK) DO
(CKS, layer) <= STACK.
IF (not-marked(CKS)) AND (layer <= DC) THEN
1. Compute the authenticity of CKS.
2. Revise the beliefs of all the concepts in CKS.
3. Synthesise the multiple beliefs of a concept
if needed.
4. Marks CKS as ’processed’.
5. CKS’ <- knowledge slices affected by the
concepts in CKS.
6. STACK <= (CKS’, layer+1)
ENDIF
ENDWHILE
------------------------------------------------------
Note:
<= stands for the operation of POP or PUSH on a STACK.
<- stands for the operation of general assignment.
======================================================
Script 3
Because singular-way belief propagation is an irretractable
process and different propagation tracks give different re-
sults. We thereby design a heuristic rule to choose the good
path, which is discussed in next section.
4. Programming Psychology Based Program
Space Partitioning and Heuristic Search
Although work has been done for program space parti-
tioning [5], enough concern has not been given in the con-
text of DKBA. In this section, we present a novel method
for program space partitioning based on the principle of pro-
gramming psychology. A heuristic rule for selecting good
searching path at singular-way belief propagation stage is
designed based on such a method.
4.1. Motivation for Programming Psychology
A large software program is generally co-written by a
group of programmers. Each programmer is responsible for
only part of the whole program. Each part of the program is
usually a self-contained component with relatively indepen-
dent functionality. Empirical studies [16] suggests that each
programmer, having different training background and tem-
perament, tends to consistently use a particular code-writing
style. If we can identify different programming styles in a
program, we will find out different programmers who wrote
the program and in turn, partition the program into smaller
self-contained sub-modules. The benefits of this method in
the context of DKBA are: (1) the search for good path at
singular-way belief propagation stage can be concentrated
in a single self-contained module where strongly-coupled
domain knowledge exists; (2) the priority of search can be
given to program regions with good readability.
4.2. Program Partitioning
Three groups of key features in source code can be used
to distinguish different programming styles. They are style
of comments, style of names and style of indent. We have
given taxonomy to each group of features. Due to space
limit, we will not illustrate them here. Program partition-
ing is divided into three stages, namely, programming style
sampling, program cutting and program re-healing. An al-
gorithm for creating sampling function for programming
styles is given in Script 4. Some abbreviations are Program-
ming Styles (PS), Current Program Line (CPL), Sampling
Function (SF), Sample Interval (SI).
==================================================
Algorithm for Creating Sampling Function of
Programming Styles for A Program
==================================================
PS <- null
CPL <- 1
SF <- null
WHILE CPL <> END-OF-PROGRAM DO
ps <- programming style in CPL
IF ps in PS THEN
PS[ps] <- PS[ps] + 1
ELSE
PS <= ps
PS[ps] <- 1
ENDIF
IF (CPL mod SI) == 0 THEN
SF <= PS
PS <- null
ENDIF
CPL <- CPL + 1
ENDWHILE
---------------------------------------------------
Note:
<- stands for the operation of general assignment
<= stands for the operation of adding a element
to a set
===================================================
Script 4
A programmer can occasionally use other programming
styles. By setting a threshold to sample function, such
noise can be filtered out and main features of programming
style for a programmer remain. Some programming styles
can also commonly be shared by different programmers.
The correct cutting points of a program is where new pro-
gramming styles come up or old programming styles dis-
appear. Script 5 provides an algorithm for program cut-
ting. Some abbreviations are Sample Pointer (Sp), Sample
Number (SN), Programming Style Numbers (PSN), Parti-
tion (Par), programming style pointer (ps).
===================================================
Algorithm for Program Cutting
===================================================
Sp <- 1
Par <- null
WHILE Sp <> SN DO
ps <- 1
WHILE ps <> PSN DO
IF (PS[ps][Sp]==0 AND PS[ps][Sp+1]>0) OR
(PS[ps][Sp]>0 AND PS[ps][Sp+1]==0) THEN
Par <= Sp
ENDIF
ps <- ps + 1
ENDWHILE
Sp <- Sp + 1
ENDWHILE
----------------------------------------------------
Note:
<- stands for the operation of general assignment
<= stands for the operation of adding an element
into a set.
====================================================
Script 5
The cutting of a program is done in sequential program
space, whilst a self-contained module can spread across
separated program regions which needs to be re-healed
again. The healing is done by matching exactly the same
programming styles among different program regions.
4.3. Heuristic Search
We first address the issue of evaluating the quality of a
program section. Let Quai be the quality of a program sec-
tion i, C W and N W be the weights for comment and name
respectively where C W > 0; N W > 0; C W + N W = 1,
C Di and N Di be the density of comments and names in
program section i respectively. Both C Di and N Di can be
easily calculated based on the algorithm described in Script
4. We have:
Quai = CW  C Di + NW  N Di
The key point for selecting a good search path at
singular-way belief propagation stage is to select a good
knowledge slice. Let K S be a knowledge slice, P S S be
the set of program sections corresponding to the participat-
ing domain concepts of this knowledge slice, QP S S be the
qualities of these program sections, QK S be the quality of
K S . We have QK S = minfQP S S g. The priorities for
choosing good knowledge slices are, in turn, given to: (1)
knowledge slices with high QK S ; (2) knowledge slices in
the same program partition of the currently selected knowl-
edge slice.
5. A Comparison to Related Work
Traditional concept assignment methods for linking pro-
gram sections with domain concepts are heavy-weighted.
Biggerstaff, et. al. [4] proposed an approach to concept as-
signment. A hybrid semantic/connectionist network is used
as their knowledge representation. A neural network-like
mechanism is used to propagate uncertainty across mul-
tiple layers, ranging from syntax level, through structure
level, to domain concept level. The propagation of uncer-
tainty is one-way, i.e., bottom-up. The uncertainty is im-
plicitly represented in the connectionist network, where a
training is needed to acquire knowledge. Although an in-
teresting work for concept assignment for a single knowl-
edge slice, Biggerstaff didn’t address the issue of how re-
covered knowledge slices affect each other. The reason is
that concept assignment in a single knowledge slice, by us-
ing their approach, needs substantial supporting knowledge
across many layers which already constitutes a big prob-
lem. In contrast, we provide a light-weighted approach to
domain knowledge recovery from source code, which con-
centrates on the “width” rather than “depth”of DKBA. The
rationale we hold is that a deep-level analysis/check on a
legacy program is not that necessary since the legacy sys-
tem has been running correctly over years! Our approach
can be used stand-alone or as a complement to traditional
DKBA methods.
MYCIN [17], an early expert system for disease diag-
nosis uses production rule as its knowledge representation.
The uncertainty reasoning mechanism is built on the axiom
system of confirmation theory where a set of calculus are
designed for the rule-based uncertainty reasoning. Our un-
certainty reasoning model is also built on the axiom system
of confirmation theory, however a set of calculus are spe-
cially designed for semantic network-oriented uncertainty
reasoning in the new context.
It is also noticed that quite a lot of work has been done
for partitioning program. Burd [5], for example, proposes
a dominance tree as a representation for program and de-
signs a set of metrics to cut out components from the tree.
Their work is structure-oriented where thought has not been
given to the context of DKBA. In contrast, special concerns
are given to domain-oriented program partitioning when we
search for an “empirically effective and efficient to use”
heuristic rule for selecting good belief propagation path.
6. Concluding Remark and Future Work
Domain knowledge recovery from legacy systems con-
stitutes a big challenge in the new era of software engineer-
ing. Software engineering is always believed to be an ideal
test-bed for AI methodology which unfortunately has not
been sufficiently addressed by existing DKBA methods. We
develop an approach to domain knowledge recovery from
source code based on our understanding on AI over years.
It is a light-weighted approach which is a good complement
to traditional DKBA methods.
Our approach has been implemented in Reverse engi-
neering Assistant (RA) [23] and tested on a database ap-
plication from a major telecommunication company with
which a research collaboration was set up to discover ontol-
ogy from legacy system. The experience will be reported
elsewhere.
Several branches of work in the future can be discerned.
A theoretical model analysis for the network-oriented un-
certainty propagation will be given; More tests of our ap-
proach in different kinds of “knowledge to program” sce-
narios, such as network protocol, interface, etc. are needed;
the implication of our approach to other AI areas, such
as information retrival from web, image or speech recog-
nition need to be pondered on; the roles of programming
psychology-based program partitioning method in other
software engineering tasks need to be found out; also ex-
pected is that research on the study of knowledge point,
knowledge pattern and programming pattern of different
programmers will be involved in our context.
References
[1] S. K. Abd-El-Hafiz and V. R. Basili. Documenting programs
using a library of tree structured plans. In Proceedings of the
International Conference on Software Maintenance 1993,
pages 152–161. IEEE Computer Society Press, Sep 1993.
[2] G. Antoniol, G. Canfora, and A. D. Lucia. Recovery code to
documentation links in oo systems. In Proceedings of Work-
ing Conference on Reverse Engineering, Atlanta, Georgia,
Oct 1999.
[3] F. Balmas. Toward a framework for conceptual and formal
outlines of programs. In Fourth Working Conference on Re-
verse Engineering, pages 226–235, Amsterdam, Oct 1997.
IEEE Computer Society.
[4] T. J. Biggerstaff, B. G. Mitbander, and D. Webster. The con-
cept assignment problem in program understanding. In Pro-
ceedings of the 15th International Conference on Software
Engineering.
[5] E. Burd, M. Munro, and C. Wezeman. Extracting reusable
modules from legacy code: Considering the issues of mod-
ule granularity. In Proceedings of Working Conference on
Reverse Engineering.
[6] W. W. Cohen. Inductive specification recovery: Understand-
ing software by learning from example behaviors. Auto-
mated Software Engineering, 1995.
[7] C. Desclaux and M. Ribault. Macs: Maintenance assistance
capability for software maintenance. In Proceedings of the
International Conference on Software Maintenance 1991.
[8] A. Engberts, W. Kozaczynski, and J. Q. Ning. Concept
recognition-based program transformation. In Proceedings
of the International Conference on Software Maintenance
1991.
[9] J. Hartman. Understanding natural programs using proper
decomposition. In Proceedings of the 13th International
Conference on Software Engineering.
[10] W. L. Johnson and E. Soloway. (proust): Knowldge-based
program understanding. In Porceedings of the 7th Interna-
tional Conference on Software Engineering.
[11] K. Kontogiannis, R. DeMori, M. Bernstein, and E. Meirlo.
Localization of design concepts in legacy systems. In Pro-
ceedings of the International Conference on Software Main-
tenance 1994.
[12] N. C. Mendonca and J. Kramer. A quality-based analysis of
architecture recovery. In 1st Euromicro Working Conference
on Software Maintenance and Reengineering CSMR 97.
[13] A. Quilici. A hybrid approach to recognizing programming
plans. In Proceedings of the 1st Working Conference on Re-
verse Engineering.
[14] A. Quilici. Reverse engineering of legacy systems: A path
toward success. In Proceedings of the 17th International
Conference on Software Engineering.
[15] S. Rugaber. White paper on reverse engineering, Mar 1994.
[16] S. Rugaber and V. Tisdale. Software psychology require-
ment for software maintenance activities. Technical report,
Software Engineering Centre Georgia Institute of Technol-
ogy, Atlanta, GA, 1994.
[17] E. H. e. a. Shortliffe. A model of inexact reasoning.
Medicine Mathematical Bioscience, 23:351–379, 1975.
[18] Tan and Dietz. Abstracting plan-like program informa-
tion: A demonstration. In Proceedings of the International
Conference on Software Maintenance 1994, pages 262–271.
IEEE Computer Society Press, Sep 1994.
[19] P. Tonella, R. Fiutem, G. Antoniol, and E. Merlo. Augment-
ing pattern-based architectural recovery with flow analysis:
Mosaic - a case study. In Working Conference on Reverse
Engineering. IEEE Computer Society, 1996.
[20] R. C. Waters. Program translation via abstraction and reim-
plementation. IEEE Transactions on Software Engineering,
1988.
[21] L. Wills. Flexible control for program recognition. In Pro-
ceedings of the 1st Working Conference on Reverse Engi-
neering.
[22] L. M. Wills. Automated program recognition by graph pars-
ing. Technical report, Massachusetts Institute of Technology
- Artificial Intelligence Laboratory, 1992.
[23] H. Yang and K. Bennett. Extension of a transformation sys-
tem for maintenance – dealing wtih data-intensive programs.
In Proceedings of the International Conference on Software
Maintenance 1994, pages 344–353. IEEE Computer Society
Press, Sep 1994.