Comparison of Abstract Data Type and Abstract State Encapsulation Detection Techniques for Architectural Understanding

Transcription

1 Copyright by IEEE. Published i Proceedigs of the Workig Coferece o Reverse Egieerig, pp , IEEE Computer Society. Compariso of Abstract Data Type ad Abstract State Ecapsulatio Detectio Techiques for Architectural Uderstadig Jea-Fraçois Girard Frauhofer Istitute for Experimetal Software Egieerig Sauerwiese 6 D Kaiserslauter, Germay girard@iese.fhg.de Abstract I the cotext of the authors research o architectural features recovery, abstract data type (ADT) ad abstract state ecapsulatio (ASE, also called abstract object) have bee idetified as two of the smallest compoets which are useful to build a sigificat architectural overview of the system. The authors have amed these the atomic compoets of a architecture. This paper compares five published techiques which extract ADT ad ASE from source code. A prototype tool implemetig each techique has bee developed ad applied to three medium-size systems writte i C (each over 30 Kloc). The results from each approach are compared with the atomic compoets idetified by had by a group of software egieers. These people did ot kow the automatic techiques which were goig to be applied to the systems. 1. Itroductio The Bauhaus project aims at recoverig multiple views of the software architecture of a system as it is implemeted. That is, a overview would idicate the mai compoets of the system, their coectors (how they commuicate), ad the costraits o these coectors ad compoets. More complex compoets ad coectors ca be decomposed ito simpler compoets ad coectors. For example, a scaer ad a parser are compoets of a compiler, whereas the scaer might have as a subcompoet a iput buffer. We have called atomic compoets the smallest compoets that are sigificat at the architectural level. While performig a c study [Gira97a], we have observed that abstract data types ad abstract state ecapsulatios (also called abstract objects) are two istaces of these atomic Raier Koschke, Georg Schied Uiversity of Stuttgart Breitwiesestr D Stuttgart, Germay {koschke, schied}@iformatik.ui-stuttgart.de compoets. Accordig to Sommerville [Somm92] a abstract data type (ADT) is a abstractio of a type which ecapsulates all the type s valid operatios ad hides the details of the implemetatio of those operatios by providig access to the types exclusively through a well-defied set of operatios. A abstract state ecapsulatio (ASE) is a group of global variables together with the routies which access them. These clusters are also called abstract objects or object istaces. I real systems, these atomic compoets ofte correspod to implemetatio of well-uderstood cocepts which are a good startig poit to look for more complex compoets. Such a startig poit is crucial i architectural descriptio recovery. I additio, ADT s ad ASE s are importat parts of a system eve outside the architectural poit of view. Their role has bee recogized to provide iformatio hidig ad to support maitaiability [Ghez91] ad reuse [Somm92]. The questio is, how to detect such atomic compoets whe facig a laguage which does ot have a mechaism to express them directly or whe programmers do break the ecapsulatio ad directly access the iteral data. There is rich literature i reverse egieerig o their detectio. I this paper, five techiques have bee selected ad implemeted, to be empirically studied. The results of each approach are compared with atomic compoets idetified by software egieers, i order to idetify the approach or combiatio of techiques which could help recover ADT ad ASE closest to those idetified by software egieers ad which hece would be able to best support architecture recovery. Paper Overview The remaider of the article is orgaized as follows: Sectio 2 gives a brief overview of each of the five

2 techiques compared. The followig sectio describes the systems studied, shows the istructios which were give to the software egieers who idetified atomic compoets maually, ad explais how the results are compared. Sectio 4 discusses the results. The last sectio presets the coclusios ad proposes further research. 2. Techiques to Detect Atomic Compoets This sectio itroduces five existig techiques to extract abstract state ecapsulatios or abstract data types. These techiques have bee implemeted i Refie [Rea90] o top of the Refie/C [Rea95]. The termiology used i the descriptio of the method will be defied first. Operatioal Defiitios Some programmig laguages, such as C, do ot provide cocepts for ecapsulatio of abstract data types. Ad eve i high-level programmig laguages we fid examples where programmers break the ecapsulatio priciple. Therefore, we wide the defiitio of idealized abstract state ecapsulatios ad abstract data types preseted i the itroductio to clusters of types respectively variables with their accessor routies. The iteral represetatio of abstract data types ad state ecapsulatios ca be public. This paper uses the followig defiitios: A routie is either a procedure or a fuctio. A abstract state ecapsulatio (ASE) is a group of global variables together with the routies which access them. A abstract data type (ADT) is a abstractio of a data structure ad all the type s valid operatios o that data structure. The key differece betwee ADT ad ASE is that a ADT is built aroud a type ad a ASE aroud a set of global variables. A hybrid atomic compoet (ADT/ASE) is a abstract data type that uses global variables to save state iformatio. For example, a implemetatio ca cout i a global variable how may lists have bee created. A atomic compoet is the smallest compoet which is sigificat at the architectural level. I this paper, it is either a abstract state ecapsulatio, a abstract data type, or a hybrid atomic compoet Routie Sigatures ad Refiemets This subsectio presets three techiques of extractig ADT. Their commo b is preseted first, the the variatios are explaied. At a higher level of abstractio, a abstract data type cosists of a domai of values for the type ad some allowed operatios o that type [Somm92]. I a implemetatio of a abstract data type, the domai of values is implemeted by a data structure which is read ad set by routies - its operatios. The user of a abstract data type ca declare objects of that type ad pass them as actual parameters to the operatios. Cosequetly, it is a ecessary prerequisite for operatios of a abstract data type to metio the data type i their sigature, i.e. their parameter list or their retur type i c of fuctios. That is, all routies with a data type T i their sigature are cadidates for a operatio of the abstract data type T. However, this prerequisite is ecessary but ot sufficiet. Some routies simply pass a value of T to other routies ad are o true operatios of T. May routies have more tha oe parameter type, makig it ecessary to decide which oe they belog to. For all sorts of routies which covert oe type to aother type this ca be very hard to judge. Sometimes - especially i programmig laguages that do ot provide record types such as Fortra77 - we eve have to look at several types i a parameter list to form oe abstract data type. For example, we ca have a stack implemetatio that passes the stack cotets realized by a array ad the stack poiter give as a iteger as two distict parameters. I order to distiguish betwee operatios of a abstract data type ad routies that do ot really belog to the abstract data type, several heuristics have bee proposed: Same Module heuristic: It groups together oly those routies, global variables, ad types that are declared i the same module. We used this heuristic i [Gira97a]. Part Type heuristic: It filters types i a parameter list that are part of aother type i the list. Liu ad Wilde proposed this heuristic i [Oga94, Liu90]. Access heuristic: It cosiders oly those routies as operatios of a abstract data type that access compoets of that type. Yeh et al. preseted this heuristic i [Yeh95]. Same Module Heuristic. Oe simple heuristic that follows programmig covetios ad is easy to apply is to group together oly those routies, data types, ad global variables which are declared i the same module. I c of Ada, a package body ad its specificatio would form a module. I C, modules do ot exist, but programmers simulate the lackig cocept by a header file f.h for the specificatio ad a C file f.c for the body. The Same Module heuristic assumes that programmers

3 are disciplied ad follow this covetio. Moreover, for modules with several distict abstract data types with coversio routies betwee each other this heuristic groups all those routies ad data types together. Part Type Heuristic. Ofte, we fid abstract data types that represet some sort of cotaier of other abstract data types. For example, queues are cotaiers of processes, or a accout cotais data about its ower ad the deposited moey. For such sorts of abstract data types we will have a operatio that takes a elemet ad puts it ito the cotaier. For the process queue, for example, there will be a isert routie with two argumets: the process that has to be iserted ad the queue itself. We would ot cosider isert to be a operatio for processes but for queues. The Part Type heuristic reflects that: a type PT which is used i the declaratio of aother type T is called a part type of T deoted PT < T the part type relatioship is trasitive; i.e. if PT < T1 ad T1 < T the PT < T holds a routie R belogs to a type T if T is cotaied i R s sigature ad there is o other type T i R s sigature with T < T As opposed to the Same Module heuristic, the Part Type heuristic is ivariat agaist a programmer s distributio of routies ito modules. But it assumes that a part type is actually used to put it ito its cotaier or to retrieve it from it, respectively. Sice it does ot further aalyze the actual usage, it is goig to fail if the assumptio is false. For example, if the part type relatioship is oly by accidet, or if the routie just passes the two argumets to a real operatio of the abstract data types, it will cosider the routie to be a operatio of the abstract data type. Access Heuristic. Accordig to Sommerville, a abstract data type is a abstractio of a type which ecapsulates all the type s valid operatios ad hides the details of the implemetatio of those operatios by providig access to the types exclusively through a well-defied set of operatios. From this idealized defiitio it follows that all routies that access iteral compoets of the abstract data type are cosidered to be the data type s operatios which is exactly the attitude of the Access heuristic. access for a type T meas (Yeh et. al. origially oly proposed to cosider iteral access to record types, but the same ca be applied to arrays ad poiters as well): if T is a array the ay idex subscript is a iteral access; if T is a record the ay field selectio is a iteral access; if T is a poiter the ay dereferece is a iteral access. As opposed to the Part Type heuristic, the Access heuristic really checks how the parameter type is used. However, i real programs we ofte fid Sommerville s rule broke. This ofte happes for reasos of efficiecy or coveiece i c of data types of which the programmer is coviced that their represetatio will ever chage. For example, a abstract data type for complex umbers will always have a imagiary ad a real part. However, eve the all routies which access iteral compoets of a type have to be chaged whe the represetatio of this type chages. This idicates a high couplig Global Variable Refereces Two of the techiques preseted i the last subsectio have bee exteded by their authors to idetify ASE. The Same Module heuristic produces ASE cadidates by groupig global variables ad routies which access them, oly if they are declared i the same module. Yeh et al. add a similar strategy to their Access heuristic to idetify ASE. It groups global variables ad all the routies which access them, regardless of where they are declared. We will refer to this strategy as global access. A alterative to exted iteral access heuristic to detect ASE is to keep oly the routies which access the iteral parts of a variable. We will refer to this strategy as pure iteral access. Each approach merges the results of ASE ad ADT detectio ito a hybrid cadidate if there is a routie that belogs to both a ADT ad a ASE Itercoectivity Metric The approach proposed by Cafora et al. [Caf93, Caf96] uses a heuristic to geerate ASE cadidates. These cadidates are the raked accordig to a idex which measures the variatio iteral coectivity of the system due to the itroductio of these ASE. The method selects cadidates with a value of iteral coectivity above a threshold obtaied by statistical samplig. The heuristic ad the evaluatio metric are defied o a bipartite graph which describes the usage of global variables by fuctios. They ca be explaied more easily i terms of the followig defiitios, give a fuctio f ad a global variable v: the cotext of f is the set of all variables it sets or uses fuctios related to f are all fuctios which set or use variables i the cotext of f closely-related fuctios of f are all fuctios which set or use oly variables i the cotext of f

4 fuctios referecig v are the set of all fuctios which set or use v The cadidates geerated aroud fuctio f cosist of: the cotext of f closely-related fuctios of f The iteral coectivity measure (IC) ad improvemet i iteral coectivity ( IC) are defied respectively as: closely related fuctios of F IC(F) = fuctios related to F { f ' cotext of f ' = { v} } IC(F) = IC(F) fuctios referecig v v i cotext of F The origial approach preseted i [Caf96] uses the followig algorithm: repeat build type-variable-referece graph create cluster cadidates usig a heuristic for each cadidate compute improvemet i cohesio metric ( IC) itroducig these cadidates if improvemet >= threshold the select cadidate else slice remaiig fuctios usig differet clusters variables util graph cotais oly isolated subgraphs cosistig of oe variable groupig with oe or more fuctios I this paper, the reported thresholds were established by ruig the prototype with all threshold values betwee 0.1 ad 0.9 by icremets of 0.1; idetifyig the threshold which produced the best results; ad performig more rus i itervals of 0.1 cetered o this threshold usig icremets of The threshold correspodig to the best results is reported. The curret paper leaves out the slicig step (removig the slicig step reduces this approach to cosiderig oly oe iteratio), because this would modify the fuctios of the resultig system, hece makig the compariso with maual results ad results from other techiques more ambiguous Clusterig Bd o proposed a clusterig of routies ito modules bd o a similarity metric [Schw91]. His work was aimed at detectig subsystems ad therefore, he oly cosidered routies. This approach was exteded to detect atomic compoets i [Gira97b]. It cosiders routies, types, global variables, ad relatioships amog them. The clusterig algorithm used i this approach works as follows: place each routie i a group by itself repeat idetify the most similar groups combie them util the existig groups are satisfactory I each iteratio, the most similar groups are combied. This group similarity is bd o a similarity betwee simple etities, so it is explaied first. These simple etities are routies, global variables, ad types. Give two simple etities A ad B, the similarity metric used durig clusterig is defied as follows: Commo( A, B) + k Liked( A, B) Sim( A, B) = Commo( A, B) + d Distict( A, B) wherei Commo (A,B) reflects the umber of commo attributes of A ad B ad Distict (A,B) reflects the umber of distict attributes. Attributes of A are all programmig laguage etities (preseted i figure 1) that have a edge to or from A. 1 m calls retur-type routie parameter-of-type m user-defied type is-part-of-type m Figure 1. Programmig Laguage Etities ad Relatioships. Liked (A,B) is 1 if A shares a edge with B, otherwise it is 0. The two parameters k 0 ad d 0 are weights give to Liked ad Distict i Sim. They have to be ascertaied by experimets o a sample of the subject system. The parameter 0 is used for ormalizatio purposes, i this paper it is set to 0. The similarity betwee compoets to merge is computed i each iteratio of the clusterig algorithm as Sim(A B, X) = (Sim(A,X) + Sim(B,X)) / Ivestigated Techiques of-type actual-parameter uses m sets m m etity global variable The previous sectios itroduced idividual techiques of detectig ADT ad ASE. Table 1 lists the combiatios 1 1 relatioship of cardiality 1:

5 of these techiques ivestigated i the experimet described i sectio 3. Note that ot all approaches detect both ASE ad ADT. Method Table 1. Ivestigated Approaches. 3. Experimet Setup I order to evaluate the proposed techiques, they were applied to three medium-size programs ad the results were compared to the atomic compoets idetified by software egieers. The compoets idetified by the approach are called the cadidate compoets. The atomic compoets idetified by software egieers will be called referece compoets. This sectio explais the experimetal setup ad the aalysis method used Systems Studied The aalyses described above were applied to the followig C programs (see Table 2 for their characteristics): Aero is a X-widow-bd simulator for rigid body systems [Kell95], bash is a Uix shell, ad CVS is a tool for cotrollig cocurret software developmet Huma Aalysts ADT detectio techique ASE detectio techique Same Module Same Module Same Module Global ad Access/ Pure Access Access Access Part Type Part Type --- Global Access Access Delta-IC --- Delta-IC System Name Table 2. Subject Systems i the Experimet. Versio Lies of Code # user defied types # global variables aero Kloc # user defied routies bash Kloc cvs Kloc Software egieers were give the task of idetifyig atomic compoets i each system. The systems were completely ukow to them. Table 3 summarizes their experiece ad how the task was divided amog them. There was o overlap of their work. They eeded about 20 hours for each system to gather the atomic compoets of the respective systems. software egieer Table 3. Huma Aalysts. Programmig Experiece se1 2 years research bash se2 2 years research bash se3 5 years research bash se4 5 years research cvs se5 > 5 years idustry; 1.5 years research aero System Aalyzed The software egieers were provided with the source code from each system, a summary of coectios betwee global variables, types, ad fuctios, ad the guidelies give i Figure 2. Idetify the existig atomic compoets preset i this system. These are ASE, ADT, or a combiatio of both. Here we gave the defiitios of abstract data type ad abstract state ecapsulatio that we already preseted i the itroductio (sectio 1) of this paper. The key differece of ADT ad ASE is that a ADT is built aroud a type ad a ASE aroud a set of simple global variables. This ca be decided automatically, so do ot waste time writig it dow. Just idetify the fuctios, variables, ad types which belog together because they are cohesive ad correspod to the idea of ASE ad/or ADT. I practice, programmers sometimes break the ecapsulatio priciple, therefore we wide the defiitio of abstract state ecapsulatios ad abstract data types to clusters of types or variables respectively with their accessor routies. The iteral represetatio of ADTs ad ASEs ca be public. NB ot all fuctios, variables or types have to be put ito ASE, ADT & ADT/ASE. I geeral, your experiece ad uderstadig has more value tha rules, you are the last judge of what costitutes a ASE/ ADT. Figure 2. Guidelies for Huma Aalysts. Table 4 shows the respective umbers of all forms of atomic compoets (abstract data types, abstract state ecapsulatio, hybrid atomic compoets) that were idetified by the group of software egieers for each studied system. Table 4. Referece Atomic Compoets. System #ADT #ASE #Hybrid Aero Bash CVS

6 The variatio i experiece ad the umber of people workig o each system prevet compariso of differet techiques across systems util cross-validatio ad future studies characterize the importace of these factors. However, prelimiary ispectio of the atomic compoets idetified foud o aberrat compoets. Furthermore, the fact that oe of the software egieers kew the automatic to be applied to the systems, preveted bias toward a specific approach Compariso of Cadidate ad Referece Compoets This subsectio explais how imperfect matches betwee cadidate ad referece compoets are classified ad compared. The followig compariso defies a approximate matchig to accommodate the fact that the distributio of fuctios, global variables, ad types is sometimes subjective. That is, software egieers do sometimes come up with differet ADT s ad ASE s give the same program. We treat oe compoet S to be part of aother compoet T (deoted by S << T) if at least 70 percet of the elemets of S are also i T. The relatioship betwee the cadidates ad referece compoets ca be classified ito six differet cs: 1~1 is a relatioship betwee a cadidate C ad a referece compoet R; where C << R ad R << C. 1~ is a relatioship betwee a cadidate C ad referece compoets R i : R i << C ( i > 1 ). I other words, the cadidate was ot detailed eough. ~1 is a relatioship where several cadidates C i together built oe referece compoet R: C i << R ( i > 1 ). I this c the cadidate was too detailed. 1<~1 is a relatioship betwee a cadidate C ad a referece compoet R whe C<<R, but ot R<<C ad there is o C ( C C ) such that C <<R. 1>~1 is a relatioship betwee a cadidate C ad a referece compoet R whe R<<C, but ot C<<R ad there is o R ( R R ) such that C<<R. ~m is a relatioship where cadidates ad referece compoets have o recogizable coectio. The best result is a 1~1 relatioship, of course. But eve 1~, ~1, 1<~1, ad 1>~1 relatioships are useful. A software egieer, give these cadidates, could easily combie or split them ito atomic compoets. A ~m relatioship does ot provide useful iformatio to the users of the approach. These six cs ca be classified ito 3 categories accordig to their usefuless to a software egieer lookig for atomic compoets: good (1~1) - they require a quick verificatio to idetify the few elemets which should be removed or added to the atomic compoet; ok (1~, ~1, 1<~1, ad 1>~1) - they require more attetio to split, combie or refie a compoet. This category ca be further subdivided: - too detailed (~1, 1<~1) - eed to be combied to produce cadidate comparable to referece; - too large (1~, 1>~1) - eed to be split to produce cadidate comparable to referece. bad (~m) - they are ot close eough to the real compoets to guide the software egieer s work. This correspods to the false positives of a approach Accuracy I order to idicate the quality of imperfect matches of cadidate ad referece compoets, a accuracy factor has bee associated with each match. The accuracy betwee a cadidate C ad a referece R is computed by the followig formula: C R accuracy( C, R) = C R For matches betwee more tha two compoets (~1, ad 1~), the uio of all elemets of the compoets is used to compute the accuracy. The accuracy is ot defied for ~m matches, because the m refereces are ot always uique. 4. Results This sectio compares the atomic compoets recovered by the approaches to those idetified by software egieers, both at the quatitative ad qualitative level. Note that the huma itervetio suggested i Access ad Delta-IC methods was ot performed i order to make the compariso fair to the other techiques Quatitative Compariso The recovered umbers of ADT ad ASE compoets for each system by each method (see sectio 2.5) are reported i Tables 5, 6 ad 7. The recovered compoets are classified accordig to the categories: good, too detailed, ad too large. Each umber i the shaded area uder the good ad ok colum is the absolute umber (#) of recovered compoets ad the average accuracy (acc). As some techiques produce oly ADT or ASE, they are ot preseted i table where they do ot apply.

7 Method Same Module Table 5. Detected ADT. System Good ADT too large OK too detailed # acc. # acc # acc Aero Bash CVS Part Type Aero Pure Access Global & Access/ Method Same Module Pure Access Global & Access/ Bash CVS Aero Bash CVS Aero Bash CVS Aero Bash CVS Table 6. Detected ASE. System Good ADT/ASE too large OK too detailed # acc. # acc # acc. Aero Bash CVS Aero Bash CVS Aero Bash CVS Aero Bash CVS Method Same Module Pure Access Global & Access Table 7. Detected Hybrid ADT/ASE. System Good ASE too large These results ca be summarized i Table 8. The etries of this table are computed as the accuracy multiplied by the umber of compoets summed up for the good, too large, ad too detailed categories. The best results are shaded i this table. These results idicate that Same Module ad Part Type are overall better tha the other techiques, but the false positives of each approach have to be cosidered i the compariso. False Positives The accuracy is ot defied for the bad (~m) category. Table 9 shows the umber of compoets wrogly ideti- OK too detailed # acc. # acc # acc Aero Bash CVS Aero Bash CVS Aero Bash CVS Delta IC Aero Bash CVS Aero Bash CVS Table 8. Overall Compariso. Met aero bash cvs adt adt / adt adt / SM , PT , PIA GIA DIC adt adt/ SS

8 fied by each techique, i.e., the false positives. It is iterestig to ote that Same Module ad Part Type are both the techiques with the best results ad with the lowest umber of false positives. Table 9. Number of False Positives. Method aero bash cvs Same Module Pure Access Global & Access Part Type Delta IC Complemetarity of Techiques Before decidig to select oe approach ad exclude the others, oe has to cosider the additioal iformatio provided by the other techiques. As a first estimate of the cotributio of each approach, we cosidered the good cadidates from each techique. For each compoet idetified by our software egieers ad for each approach, we looked at the closest sigle cadidates with a accuracy of more tha 60%. The we looked at how may ew correct atomic compoets each approach foud which were ot idetified by the Same Module heuristic. This iformatio is preseted i Table 10. Table 10. New Correct Atomic Compoets. Method aero bash cvs Idetified by Software Egieers These data suggest that few ew cadidates that could ot be foud by Same Module aloe are foud by other techiques, except for bash, where Part Type foud may Qualitative Compariso Foud by ay approach Foud by more tha 1 approach Foud by Same Module Foud by Part Type aloe Foud by Delta IC aloe Foud by Global & Access aloe Foud by Pure Access aloe After the quatitative compariso described i the last sectio we aalyzed divergeces betwee cadidate ad referece compoets for the respective methods. Same Module. Same Module groups all coected routies, variables, ad types i the same module. The postulate is that the programmer structures files accordig to atomic compoets. Detectio of abstract data types with this heuristic did ot work well for all systems. Ofte, there was a header file with system-wide type declaratios. The routies, however, were implemeted i several other C files that icluded the type declaratios. Detectio of abstract state ecapsulatio succeeded better, sice global variables are ever declared i header files (they ca oly be declared there as exteral). Large files ca be a problem for the Same Module heuristic. I CVS, for example, we foud a type RCS ode which ecapsulates depedecies o the uderlyig revisio cotrol system (RCS) of CVS. This ode type was declared i oe huge file where may routies used it as a parameter. Cosequetly, Same Module created a very large atomic compoet cadidate. The group of software egieers has refied this cadidate ito differet aspects of the RCS subsystem. Part Type. The Part Type heuristic is a refiemet for detectig abstract data types to overcome erroeously large compoets. It attaches a routie to those types of its sigature that do ot have a cotaiig type that is listed i the routie s sigature. The assumptio is that the part type is put ito the cotaier or retrieved from it. Compared to the other techiques, Part Type revealed most abstract data types with the highest accuracy rate. However, it still detected oly a fractio of all referece compoets. Moreover, it does ot check how the parameters are actually used, ad therefore may routies which do ot directly use the value of a parameter, but oly pass this parameter to a routie they call (probably the true operator of the ADT) would be icluded ito ADT. I c of CVS this could be observed for the RCS ode type ad the hash table type already metioed. Access. The Access heuristic groups user-defied data types ad global variables with the routies that access their iteral parts. This aalysis goes beyod the Part Type heuristic i that it really checks how routies treat types ad variables. This heuristic did badly i the compariso for at least two reasos. First, if there is a global table, such as a array of error messages, all readers of this table are cosidered operators of this abstract state ecapsulatio which yields a erroeously large compoet. Secod, it does ot work for primitive types, such as a file descriptor i Uix which is represeted as a iteger type. It is a commo pheomeo for abstract state ecapsulatio to have separate global variables that together form a object. For example, stacks are ofte

9 declared as two distict variables, oe for the cotets ad oe for the stack poiter. The latter is declared as iteger ad used as a idex to the array implemetatio for the cotets. The the stack poiter will ot be recogized as part of the abstract state ecapsulatios, sice iteral access to a primitive data type is meaigless. Sice abstract state ecapsulatios have exactly oe istace (otherwise they would be abstract data types), programmers do ot make the effort to put them together i a record which would make their coectio more obvious. But eve if the routies are ot cosidered operators of the atomic compoet, this aalysis still recovers useful iformatio. All these routies might have to be updated whe the represetatio of the type chages.. similarity iteratively merges compoets with maximum similarity util the maximum similarity value falls short of a give threshold. After mergig two compoets we must compute the similarities of the ew compoet to all other compoets. We ivestigated two differet variats. Usig Sim(A B, X) = max(sim(a,x), Sim(B,X)) typically produced oe huge compoet cotaiig most of the system ad a large umber of very small compoets. Useful cluster sizes could be achieved usig the average istead of the maximum, i.e. Sim(A B, X) = (Sim(A,X) + Sim(B,X)) / 2. The similarities betwee the iitial compoets ad the clusterig process itself deped o several parameters. Oe fudametal problem was to fix these parameters i a sesible way. We did ot succeed i fidig (by trial ad error) a parameter combiatio that produces good results for ay of the three systems though we ra dozes of aalyses with various parameters. Fially, we used threshold (aero & bash =0.1, cvs= 0.2) for the clusterig loop. The factors k=1.0 ad d=3.0 tured out to be appropriate. Delta-IC. Delta-IC-bd clusterig uses a heuristic to geerate cadidates aroud each fuctio. For a fuctio F this cadidate is composed of all the variables set or used by F ad all the fuctios which oly access those variables. Oce these cadidates are geerated, the approach computes the improvemet i a iteral coectivity metric (delta-ic) due to the cadidate itroductio. Every cadidate with a threshold above delta-ic is kept. Due to the compariso betwee techiques, we could ot slice fuctios which beloged to more tha oe cadidate. As a result, we decided to merge overlappig cadidates before comparig them to the referece compoets i order to have o-overlappig cadidates for compariso. The major difficulty is establishig the right thresholds. They deped o the specificity of the system studied ad caot be directly reused (bash & aero = 0.18 cvs = 0.51). Oe practical solutio is to take a sample of the system ad perform maual recovery by applyig the approach o the sample ad adjustig the threshold accordigly. It is ecessary to compromise betwee the efforts required to aalyze a sample maually ad the quality of the results. With the metioed threshold, relatively iterestig results were obtaied. It is a topic of further research to establish the relatioship betwee sample size ad result quality. Factors to Cosider. The software egieers were ot always sure whether a routie belogs to oe atomic compoet or to aother. Examples for such debatable cs are trasformatio routies from oe atomic compoet ito aother. It is ot always clear whether they belog to the target type of the trasformatio, if there is a high couplig to the source type as well. Aother problem are closely-related types. For example, i CVS there is a hash table implemetatio that cotais two itertwied types, oe for lists ad oe for odes. The oe for odes has a poiter that deotes the ext elemet i the list. Nevertheless, the group of software egieers cosidered them as two distict abstract data types. That is, the cocepts of abstract data type ad state ecapsulatio are vague, ad therefore o approach will ever detect atomic compoets with absolute accuracy. However, they are the basic compoets of software architectures. They have to be uderstood to uderstad the whole system. 5. Coclusios A previous c study lead the authors to regard abstract data types ad abstract state ecapsulatios as atomic compoets which are useful i producig a architectural view of a system. I this paper we compared five existig techiques to detect atomic compoets by applyig them to three publicly available medium-size systems writte i C (bash, cvs, aero). Two groups of software egieers compiled a list of referece atomic compoets for each system. These lists were used to compare the results of the techiques with huma judgemet. Accordig to this compariso, the Same Module heuristic idetifies more abstract state ecapsulatios ad hybrid atomic compoets ad produces less false positives tha ay other approach. However, it relies o the assumptio that programmers usually declare distict atomic compoets i distict modules. This assumptio might be too strog for systems other tha those studied, especially for legacy systems. For the idetificatio of abstract data types (ADT), the Part Type heuristic performed slightly better tha the other techiques. I the c of bash, it showed that it ca complemet the Same Module approach well. However, it ca oly recover ADT s.

10 There are three alteratives to replace Same Module heuristic whe its assumptio does ot hold: Delta-IC, ad Access. Both ad Delta-IC have parameters which deped o the system studied ad have to be adjusted. This calibratio requires time, ad fidig the ideal parameter or a close approximatio quickly is ot likely. did ot perform well i this study. Delta-IC performed well for bash ad cvs, but it ca oly extract ASE. Access seems to offer a better compromise, it has reasoable results ad does ot require the adjustmet of parameters. This study hited at the level of support that tools could provide i idetifyig atomic compoets. The techiques ca quickly yield cadidates that ca be checked by software egieers withi miutes. However, all techiques could oly recover a small portio of the atomic compoets that were listed by software egieers. Ad may cadidates they provide correspod oly roughly to those atomic compoets; i.e., elemets of these atomic compoets were superfluous or lackig. Whereas the groups of software egieers eeded about 20 hours to compile the list of atomic compoets for each of our subject systems, each atomic compoet produced by the techiques ca be checked by software egieers withi miutes. Future Work This experimet will be exteded to a larger umber of systems to obtai more sigificat results ad to be able to evaluate how far these coclusios ca be geeralized. Studyig the behavior of automatic techiques to recover atomic compoets o a set of systems where they are idetified by humas ca help us see possibilities for improvig these techiques. Combiatios of techiques will be explored to try to obtai more complete results ad filter the false positives. However, it is already clear that ew techiques which could idetify more atomic compoets are eeded to obtai most of the atomic compoets which are useful to idetify the more complex compoets of the architecture of a system. Ackowledgmet We would like to thak Jea-Marc DeBaud ad Erhard Plödereder for their support of this project ad their isightful iputs to this research. We thak the reviewers for their valuable suggestios ad remarks. We would like to express special thaks to Joachim Bayer, Hiltrud Betz, Kristia Ludqvist, Mia Mäkäräie, ad Klaus Schmid for their maual aalysis of the three subject systems used i our compariso. Refereces [Caf93] G. Cafora, A. Cimitile, M. Muro, ad C. J. Taylor. Extractig abstract data type from c programs: A c study. I Iteratioal Coferece o Software Maiteace, pages IEEE Computer Society Press, September [Caf96] G. Cafora, A. Cimitile, ad M. Muro. A improved algorithm for idetifyig objects i code. Joural of Software Practice ad Experiece, 26(1):25 48, Jauary [Ghez91] C. Ghezzi, M. Jazayeri, ad D. Madrioli. Fudametal Software Egieerig. Pretice Hall Iteratioal, [Gira97a] J.F Girard ad R. Koschke. Fidig compoets i a hierarchy of modules: a step towards architectural uderstadig. I Iteratioal Coferece o Software Maiteace, [Gira97b] J.F Girard ad R. Koschke. A metric-bd approach to detect abstract data types ad abstract state ecapsulatio. submitted for publicatio, [Kell95] H. Keller, H. Stolz, A. Ziegler, ad T. Bräul. Virtual mechaics simulatio ad aimatio of rigid body systems with aero. Simulatio for Uderstadig, 65(1):74 79, July [Liu90] S.S. Liu ad N. Wilde. Idetifyig objects i a covetioal procedural laguage: A example of data desig recovery. I Coferece o Software Maiteace, pages IEEE Computer Society Press, November [Oga94] R.M. Ogado, S.S. Yau, ad N. Wilde. A object fider for program structure uderstadig i software maiteace. Joural of Software Maiteace, 6(5):261 83, September-October [Rea90] Reasoig Systems, Ic., 3260 Hillview Aveue, Palo Alto, CA Refie User s Guide, [Rea95] Reasoig Systems, Ic., 3260 Hillview Aveue, Palo Alto, CA Refie/C Programmer s Guide, [Schw91] R. W.. A itelliget tool for re-egieerig software modularity. I Iteratioal Coferece o Software Egieerig, pages 83 92, May [Somm92] I. Sommerville. Software Egieerig. Addiso Wesley, fourth editio, [Yeh95] A.S. Yeh, D.Harris, ad H. Reubestei. Recoverig abstract data types ad object istaces from a covetioal procedural laguage. I Proc. of. the Secod Workig Coferece o Reverse Egieerig, pages , July IEEE Computer Society Press.