We have developed an incremental computer-aideddesign library thatprovides run-time facilities to link,unlink, execute, and listfunctions. At the heartofthelibrary is anincremental loader thathelps designers anduserscustomize theirbasic tool for theirdesign environ­ment. In thispaper, we discuss how four computer-aideddesign tools have benefited from using the library forsimulating Clanguage models, modifying and enhancinggraphical user interfaces, extending command languages,and rapidly testing new functionality. Using SCHEMA andMIDAS ascase studies, we also describe how thelibraryimproves quality and reduces time to market.

AN INCREMENTAL ENVIRONMENTFOR COMPUTER-AIDED DESIGN TOOLS

________ Judith L Schmidt, Thaddeus J. Kowalski, and David S. Smull _

Judith L. Schmidt is amember of technicalstaff in the Computer­Aided Engineering andDesign Department atAT&T Bell Laboratoriesin Allentown, Pennsyl­vania, and David S.Smull is a supervisor inthat department.Thaddeus J. Kowalskiis a member of tech­nical staff in the Soft­ware TechniquesResearch Departmentat AT&T Bell Labora­tories in Murray Hill,New Jersey.Ms. Schmidt is Introductioncurrently working on Rapid simulation and testing is crucial to the productivity ofincreasing developer AT&T's integrated-circuit andboarddesigners and to the quality ofproductivity through their designs. AT&T computer-aided design (CAD) tools! providecomputer-aided soft- state-of-the-art features to helpdesigners produce complex circuitsware engineering tools. rapidly. Asthe CAD tools themselves become morecomplex, providingHer interests also ever-increasing functionality to an expanding customer base,severalinclude network problems become evident. (Panel 1defines acronyms andterms usedmanagement and in this paper.)artificial intelligence. The tools must servea diverse user community that requiresMs. Schmidt joined the different features, options, and capabilities. This canleadto a prolifera­company in 1988. She tion ofcommands andfeature sets that differ insubtle but significanthas a B.S.E.E. from ways. Further,a user interface that is customized foronecommunityThe Johns Hopkins may notbe effective inother environments. Simulators, which useUniversity (Baltimore, Cfanguage models to describe the behavior ofcomponents, cannotMaryland) and holds an contain allavailable models without becoming tooexpensive andM.S. in computer sci- unwieldy. In addition, newClanguagemodels are constantly beingence from the Univer- developed. To designCAD tools that spana largeuser baseandsatisfysity of Delaware these diverse needswould be an unmanageable task.(Newark). Mr. Kowalski Wehavesolved the problem by integrating an incrementalis currently examining loader" with the CAD tools. Throughthe incremental loader, users(continued on page 110) tailor these tools to suit their needs. Designers canaddcode to

AT&T TECHNICAL JOURNAL. JANUARYIFEBRUARY 1991

101

Panel 1. Acronyms and Terms

Incremental LoaderThe incremental loaderis part ofthe AT&T

C-language interpreter (c in), which is contained in thecens 3 programming environment. Cens wasdevelopedatAT&T Bell Laboratories in the Software TechniquesResearch Department and is supported by the ArtificialIntelligence Systems Department. The incrementalloader is based on the UNIX® system (Research Version,Eighth Edition4) ld command, enhanced to include the

customize the basic toolfor their environment. Bylink­ingcodeas needed, toolusers can:- Augment a simulator usingC-language models for

designs.- Modify and enhancethe tool'suser interface.- Extend the tool's command set.- Rapidly test newfunctionality.This paperdescribesthe incremental loaderand howitincreases the productivity ofAT&T designers.

102

APICADcccenscicinlintmin/maxMOTIS3mouse

netlist

R&DSCHEMA

application programmer's interfacecomputer-aided designC-language compilerC-language environment systemC-language interpreterAT&T C-language interpreterC-language syntaxcheckeroptimistic and pessimisticAT&T simulatora pointing and drawing device that, when

moved across a flatsurface, causes thecursor to move on the screen. Buttonson the mouseare used for selectingactions or objects on the screen.

description ofthe electrical componentsin a circuitand their interconnections

research and developmentAT&T designcapturetool

incremental loading ofobject files. (UNIX is a registeredtrademark ofUNIX System Laboratories, Inc.)

With incremental loading, allfiles fora specificapplication do not need to be loaded at once; files canbeloaded individually, as needed. The loaderprovides thebasiccommands to linka file intomemory and executefunctions. It maintains its own symbol table, which isupdated as each file is loaded. Unlike ld, the cin loaderallows undefined and multiply defined symbols.

There are two major benefits to running a pro­gram with an incremental loader:- Rapid prototyping. Functions can be loaded and tested

without the need to write driver programs.- Reduced turnaround time. Only changed files need be

relinked.The Incremental Loader and CAD Tools. The incre­

mental loaderadds to the power andflexibility ofAT&TCAD tools, enhancing the productivity ofusers in severalways. For example, users can linkcodeto modify andextendthe user interface and the command language.Theycanadd menusand dialog boxesto the tool'sinter­face, or add commands that are customized for theirenvironment. The AT&T designcapture tool, SCHEMA,5provides this functionality directly to users.Some groupshavecreatedentire products basedon the incrementalloading ability in SCHEMA. One such project, Carousel, isdescribed later in this paper.

C-language models inAT&Tsimulators6.7 providea goodexample ofhowthe loaderdirectly affects designerproductivity. These models allow designers to model thelogical behavior ofa circuit. The models are linked withthe simulator to test a particular circuit. Before the incre­mental loading functionality wasadded, the models hadto be linked directly with the simulator's object code. Ineffect, this technique createda newsimulator, customizedfora particular model. With the incremental loader, themodels can be directly linked intothe simulator at runtime, eliminating multiple versions ofthe simulators.

Other tools use the incremental loaderto linkfunctions that provide a specific feature. Forexample, a

AT&TTECHNICALJOURNAL • JANUARY/FEBRUARY 1991

BaseApplication

sqrt(double num){}

Figure 1. Applicationand loader symboltables. Loader rou­tines enable theapplication's symboltable to know aboutfunctions and datalocated in theloader's symbol table.ThUS, users can linkfunctions and accessdata internal to theapplication. Explicitfunction calls to theincremental loadermake buffer andsbrk available to theincremental applica­tion. Other functionsand variables areaccessible to onlyone part of the appli­cation.

103

user selects a toolfeatureby clicking (i.e., depressing) abuttonon a mouse. The loaderincrementally links, exe­cutes, and unlinksthe functions without anyfurtherinteraction. The toolprovider can ship a small executablefile, plus separatefunctions that supply extra capabilities.Only those functions that the user requests are linkedand executed.

Detailed examples ofhow SCHEMAand theAT&T simulators use the incremental loading ability arediscussedlater.

Integration with AT&T CAD. In choosing the incre­mentalloader, functionality wasmostimportant. Besidesproviding the desiredfunctionality, the c in incrementalloader fulfilled four basic requirements: robustness,availability on the appropriate platforms, internal sup­port,and suitability forproduction-quality tools.

Oncewedecided that the loaderwasthe rightsolution, wedeveloped an integration plan. First, wespecified the functionality requiredby the CAD tools.Next,wedeveloped a method for integrating future

AT&T TECHNICAL JOURNAL.JANUARYIFEBRUARY 19Y1

104

versions ofthe c in loaderthat minimizes disruption tothe CAD tools, their developers, and the tools' users.Finally, weconsulted with tooldevelopers to determinehow best to present the incremental loaderto users.

Required functionality. After discussions with vari­ous CAD developers, wedecided that,at minimum, a userneedsto linkand unlink files, execute functions, listwhatfiles andfunctions are linked, and specify whatfunctionsare active within each file. In addition, the users need toaccessvarious application dataandfunctions. However,interaction between the application and the user-linkedcodeis hampered becausethe loadermaintains its ownsymbol table.

Whenthe loaderis integrated intoa CAD tool,there are two symbol tablesassociated with the runningtool: the application's symbol table and the loader's sym­boltable, which is completely enclosed within the appli­cation memory. Thus, a function that is loaded intotheincremental loader'ssymbol tabledoesn'tautomaticallyhave accessto the application's symbol table. To over­come this problem, weused routines in the loaderthatmake functions and datalocated in the loader'ssymboltable known to the application's symbol table. Thisallows users to linkfunctions and accessdatainternalto the application.

Figure 1 shows a base application that contains:- Amain function that doesn'treturn a value.- A sqrt function that returns a double (i.e., a double-

precision, floating-point value).- Acharacterpointer p. (A character pointer contains

the addressofa memory location that stores a charac­ter value.)

- The incremental loader.- Acharacter arraybuffer.- An sbrk function that returns a characterpointer.Incrementally loaded into this base application is:- A sqrt function that returns a double.- Amain function that doesn'treturn a value.- Aprintf function that returns an integer.- A sleep function that doesn'treturn a value.

AT&TTECHNICALJOURNAL • JANUARY/FEBRUARY 1991

- Acharacterpointer p.- Awrite function that returnsan integer.Variables andfunctions canbe made available to theincremental application byexplicit function calls to theincremental loader. In the example inFigure 1,bufferand sb r k are available to the writer ofthe incrementalapplication. Thus, a user canwrite incremental functionsthat interactdirectly with the application, which meansthat morepowerful functions canbe written. In addition,to prevent sideeffects, it is also important that somefunctions-such as the memory-allocation functions-besharedbythe baseand incremental applications. If theincremental application andthe baseapplication bothhad copies of sbrk, seriousproblems could develop.Otherfunctions andvariables are accessible to only onepart ofthe application.

Integration of future versions. CAD developers mustbe able to integrate the loaderquickly andpainlessly,and to adoptnewversions ofthe loader with little disrup­tionto the tool and tool users. In addition, the CAD toolshould be protected from platform dependencies. So, wedecided to wrap the loaderinan application program­mer's interface (API),which insulates the CAD tools fromthese changes. The loaderandAPI are provided by theComputer Aided Engineering andDesign Departmentas a library that canbe linked with the application.

Presentation to users. Once the loader is inte­grated,it canbe presentedto users in two basic ways:- In the explicit approach, the CAD tool provides a com­

mand lineor graphic interface. The user executesspecific commands to linkfiles andexecute functions.

- In the implicit approach, the linking ability becomesinvisible to users. For example, if a user selects a but­ton to run a certain command, the tool could automati­cally linkthe desiredfunction, execute it,and unlinkthe file without additional input.

Technology TransferAsthe strategic business unitswithin AT&T

seek morebenefit from basic researchefforts, technol-

ogytransferassumesgreater importance within theR&D community. Before wediscussdetails ofhowtheAT&T CAD toolsuse the incremental loader, it is instruc­tiveto see howthe technology transferbetween theresearch and development organizations wasaccom­plished. The methodwe used worked well. It fostered aspiritofteamwork and cooperation, and led to directbenefits for both laboratories.

SCHEMA contained a partial C-Ianguage inter­preter (c L}, which compiled sourcefiles intopseudo­objectfiles. SCHEMA and c i wereavailable under DigitalEquipment Corporation's VAX/VMSTM operating systemand the UNIX operating system. (VAX/VMS andVMSare trademarks of Digital Equipment Corporation.) Atthe timethat the VMS™ environment wasphasedout,the CAD developers alsowanted to upgrade c i to allowuser-defined structures.The developers decided thatc in, designed in the UNIX systemenvironment, wouldresult in a faster productand presentedan excellentopportunity forsoftware reuse. Developers Angelina andFajardo contacted Kowalski, the researcher responsiblefor c in. They discussed the problems with c i andhowthese problems mightbe solved by using c in.

Although c in would haveprovided additionalfunctionality for SCHEMA, they decided a moreappropri­ate solution wasto separatethe incremental loaderfromc in and incorporate it into the c i function library.Kowalski provided the incremental loader, while thedevelopers created a prototype replacement c i functionlibrary and benchmarked the solutions. TableI showsthat the newroutinesused 6G-percent less memory and96-percent less timethan the original c i systemto exe­cute a 71-line program. Withthis success, Christman(anotherdeveloper) assistedin portingthe incrementalloaderto the Amdahl computer's UNIX time-sharingoperating system.

Afew months later,one memberofeach labora­toryassumeddirect responsibility for the transfer.Kowalski provided the basiccode,expertknowledge,and technical supportas the loaderwasintegrated into

Table I. Size and Time for ci System

System withOriginal incremental

Test system loader

Size (bytes)Program 83564 32784Input 5984 1272

TIme (seconds)Compile and link 3 3.3Linkonly < 1 <1Execute 27 < 1

the first few tools. Schmidt, a developer from the CADlaboratory, developed the API functions, performed theintegration into SCHEMA, andservedas the single pointofcontact between the two laboratories.

SCHEMA wasselected for the initial integrationbecauseit already contained a partial C-Ianguage inter­preter.Thus, the interface appropriate foran incrementalloaderwaslargely inplace. Moreover, the initial proto­typehad demonstrated that the integration wasfeasibleandworthwhile.

Asthe loaderwasintegrated into SCHEMA, theteamaddedfeatures in response to needs that arose dur­ing the process. The integrated product wasthen sup­plied to alphaandbeta users, in turn. Feedback fromthese users helped the teamto streamline and enhancethe loaderinterface. Oncethis initial effort wascom­pleted, the loaderAPI wasreleased to alldevelopers. Theindividual tooldevelopers then worked to integrate thetool, with helpfrom the CAD laboratory developer whowasresponsible for the loader.

Asfeature requests and errors were reported,somewerefixed within the CAD laboratory, andotherswererelayed to research. Oneexample ofa majorrequestwasa portofthe loaderto a SunMicrosystems'Spare"chip-based architecture. (Spare is a registeredtrademark ofSPARC International, Inc.) After discus­sionsbetween membersofresearch and development,the CAD laboratory agreed to handlethe port, with

AT&TTECHNICAL JOURNAL.JANUARY/FEBRUARY 1991

105

106

guidance from the research staff. The ported codewasthen integrated into c in. The resultwasa bigwin forbothdevelopment and research.

Examples of Loader-Tool InteractionTwo ofthe first tools to take advantage ofthe

incremental loading ability were SCHEMA and MIDAS,6

AT&T's logic simulator with min/maxtiming, which pro­ducesbothan optimistic anda pessimistic timing simula­tion. These tools use the loaderin many different ways tohelp designers increase productivity.

Design Capture. SCHEMA, AT&T's design capturesystem, is a powerful andflexible application used fordesign jobsthat include full custom integrated circuits(i.e., circuits designed at the transistorlevel), circuitpacks, backplanes, andequipment rackcabling.

SCHEMA users havebeen ableto linkcodethrough c i for sometime. The interpreter, c i, recog­nized a subset ofthe Clanguage. It allowed a user toaccess a set ofinternal SCHEMA functions that could becalled from a user-linked function. (Thefunctions weremade available to the internal application throughexpli­citcalls to the loader, as depicted in Figure 1.) Userscould also customize their environment byadding orredefining user-interface objects (i.e., menus, panels,andbuttons) andcreating newcommands. The availablefunctions included display-eontrol routines, datastruc­tureaccessroutines, and built-in command-executionroutines. The functions permitted users to:- Obtain accessto the internal database.- Change the user interface byadding buttons, menus,

anddialog boxes.- Retrieve information ongraphics primitives, symbols,

pages, and coordinates, as well as othervariables.However, c i had disadvantages. It only recog­

nized a subset ofthe Clanguage; i.e., datastructureswere missing. This led to someawkward coding styles.Forexample, multiple, parallel arrayshad to be usedinstead ofa linked listofdatastructures. Asa result, it

AT&TTECHNICAL JOURNAL • JANUARY/FEBRUARY 1!lY1

wasdifficult to maintain andenhance the code. Althoughc i didprovide users with two elements that weredefined as datastructures, these elements didnot followthe C-Ianguage standard. Moreover, c i was an inter­pretedlanguage andwas, therefore, considerably slowerthan compiled code.

Advantages of the Incremental loader. The integra­tionofthe incremental loader provides two main advan­tages to c i users. First, users now cantakeadvantageofallC-Ianguage features, including datastructures.Second, user functions execute more quickly, becausethe loaderfunctions are compiled. The incrementallylinked (Le., compiled) codeis significantly fasterthaninterpreted code, decreasing execution time by as muchas 96percent. In addition, the memory size was greatlydecreased.

To takeadvantage ofincremental loading, userscreatefunctions outside SCHEMA and, then,issue a 1 inkfunction command at the SCHEMA command prompt.Throughthe incremental loader, SCHEMA addsthe file tothe internal symbol table andupdates the listoffiles andfunctions that are linked. The user canthen executelinked functions simply bytyping the function nameatthe SCHEMA command prompt.

Userscanlistthe functions theyhave linked byexecuting the show functions command at the com­mand prompt. Options permit users to selectallfiles thatare linked, allfunctions that are linked, functions that arelinked within a particular file, or all files andfunctions.Linked files canbe unlinked if theyare nolongerneeded.

The incremental loading ability has become soimportant to SCHEMA users that some user communitiesare now using SCHEMA andthe incremental loaderas aframework overwhich theyare integrating customizeddesign-support systems. Forexample, the Carouselproject uses SCHEMA to offer analog integrated-eircuitdesigners an integrated design environment. Tools inthis environment include design capture, graphics edi­tors, simulators, netlist comparators, andlayout extrac-

tors. In this environment, the internal SCHEMA databasecanbe editedby allthe tools that are incrementally linkedto SCHEMA. Editsbyone toolthen become immediatelyavailable to allthe other tools that share the database.

In addition, incrementally linked Cprograms cancustomize SCHEMA'S user interface. Theycan add high­level functionality for several schematic entryand designentry tasks, andfordirecting tasks to other applicationprograms, such as simulators, that run concurrently butdo not share the internal database.

Without this incremental loading capability,the interaction between the tools would have to occurthroughdatabase files. That is,whenone database ischanged, each ofthe other tools must resynchronizeits own database. Clearly, this is muchmoretime­consuming than a directinteraction.

Challenges of Integration. Integrating the loaderinto SCHEMA presentedsomeuncommon challenges.For many years, SCHEMA users had been usingci tolinktheir code. The changeto a full C-Ianguage, incre­mentally linked environment had to be effected withminimum disturbance to the established user commun­ity. Asubstantial amount ofworkwasdoneto maketheconversion as transparentas possible. In general,SCHEMA users should notice little changein the waytheywork. Wherethe existing user functions are syntac­tically and semantically correctC-Ianguage code,theconversion is trivial.

Discrepancies between e i and standard Clan­guagecould causeproblems. For example, e i didnotwarnusers whenit encountered an undeclared variable;it simply assumed the variable wasan integer. Code thattookadvantage ofthese differences had to be corrected.

Another feature of e i allowed users to specifyC-Ianguage codeoutside the boundsofanyfunction.This "start-up" codewasexecuted whenthe file waslinked. To provide the samefunctionality while adheringto conventional C-Ianguage syntax, users encasetheirstart-up codeina function called file_inir. SCHEMA

has been modified to lookforthis function eachtime afile is linked and then execute the function, if present.

Quality Improvements. Userscannow make use ofthe UNIX system tools, lint and ee, to checkthe syn­taxandsemantic correctness oftheir code. In addition,theycanuse cin, the C-Ianguage interpreter, to debugthe individual functions. These checksshould resultinhigher quality code. In the SCHEMA user community, theconversion from e i files to standard Clanguage codeuncovered many syntax and semantic errors.For exam­ple,oneuser's 750G-line e i module required over80syn­tactic and semantic corrections to conform to standardClanguage.

Simulation. In the AT&T simulators, MOTI S3 7and MIDAS, the incremental loaderallows users to createand debugC-Ianguage models andto createdrivers andmonitors fora circuit. Wewill describe the enhance­mentsto MIDAS as an example.

MIDAS provides a set offunction calls that per­mitcommunication between a C-Ianguage model andthesimulator. Forexample, a model canuse calls to accessand reportinformation abouta simulated component,control simulation activity, or begin special actions dur­ing power-up. (These MIDAs-provided functions wouldbe the functions that are made available to the incremen­tal application throughexplicit calls to the loader, asdepicted in Figure 1.) Both circuit elements andexternalsystems (i.e., buses,memory, etc.) canbe simulatedthroughCdanguage models.

Clanguage models are functions written in theClanguage that describe the logical behavior ofcom­ponents. The models are linked with the simulator'sobject codeto createa customized run-time simulatorthat calls the modeled routines as needed. BecauseC-Ianguage models give users a way to model circuitbehavior ina familiar language, theyhave helped popu­larize model writing.

Panel 2 presentsa C'language model for a simpleAND gate. It shows two structuresthat are passed as

AT&T TECHNICAL JOURNAL.JANUARY/FEBRUARY 1991

107

108

Panel 2. C-Language Model for an AND Gate

tinclude <stdio.h>typedef struct {

int num, a, b;} XXAND2I;

typedef struct {int num, z;

} XXAND20;

intxxand2(in, out)register XXAND21 *in;XXAND20 *out;{

/* test inputs and outputs */if (in->num != (sizeof(XXAND2I) / sizeof(int)) - 1) {

fprintf(stderr,II \n \ tERROR: ETYPE () - wrong # of inputs \n ") ;

return (-1) ;}if (out->num != (sizeof(XXAND20) / sizeof(int)) - 1) {

fprintf (stderr,"\n\tERROR: ETYPE () - wrong t of outputs\n");

return(-2);}/* AND == set the result to the AND of the two inputs */out->z = «in->a) == 0 I I (in->b) == 0) ? 0

: «(in->a) == 1 && (in->b) == 1) ? 1 : 2);return(O);

parameters and correspond to the inputsand outputsofthe gate. First, the Clanguage model checksthe numberofinputs and outputs. Next, it performs a logical ANDofthe inputs. Thus, it sets the outputto:- A'1' if both inputsare '1'- A'0' if either inputis '0'- A'2' if the inputsare neither '0' nor '1'.

AT&TTECHNICAL JOURNAL • JANUARYIFEBRUARY 1991

Cfanguage models have been usedwith thesimulators for sometime, despite a variety ofproblems.For example, the models had to be linked directly to thesimulator's object code,which produced a newexecut­ablefile foreach set ofmodels linked. Thus, to simulatetwo versions ofthe circuit, the developer builttwo com­pleteversions ofthe simulator. This wasa tremendous

waste ofdisk space, becauseeach designerhad a copyofthe simulator for each set ofmodels that neededto besimulated. Corrections to a model requiredthe recompi­lation ofthe bad section ofcode,plusa relinkoftheentire simulator. This practice directly affects designerproductivity and,therefore, designschedules.

The incremental loaderdirectly addresses theseproductivity issues.Ratherthan linking the simulatorand models to create a newsimulator, the user incremen­tally linksthe model intothe simulator at run time. Thesimulator's executable file remainsunchanged. If themodel has an error, the designersimply relinks thecorrectedmodel on topofthe oldmodel, replacing theoldmodel with the correctedone.The alternative wouldbe to exit the tool, remove the bad executable code,relinkthe whole simulator, and restart the simulator.

The development ofnewC-Ianguage modelsillustrates another aspectofthe benefits of incrementalloading. Currently, MIDAS linksto the standard,Clanguage model library. Whena newmodel is added,the model is incrementally linked intoMIDAS andtested.Duringthe debugging process, the newmodel canbealteredand relinked without affecting previously linkedClanguage models. Otherwise, each change to aCfanguage model would requirea recompilation andrelinkofallClanguage models, a time-consuming task.

Userscan alsowrite functions that serveasdrivers and monitors for the circuit, linkthose functionsto the program, and observethe result.The driver func­tiongenerates the inputvectorsfor the circuit, while themonitor function validates or records the outputsofthecircuit. Asimple example is a driverfunction that pro­videsthe clock to drive a counter.

ConclusionIncremental loading allows users to customize

a CAD toolto suit their needs. It increasestheir produc­tivity by helping them to customize the interface, extendthe command set, andwriteapplication programs. Simu­latorusers can take advantage ofthe incremental loader

to write and debugC-Ianguage models quickly. Loadingand executing functions dynamically improves user effi­ciency and, therefore, affects the timeto marketfordesigns.

AcknowledgmentsWethank Healfdene Goguen andJohn Puttress

for the development and continued support ofthe c inincremental loader. Weare indebted to Helen Angelina,DonChristman, and Lincoln Fajardo for the conceptionand prototype ofthe replacement of c i with the incre­mental loader.

We'dliketo extendour appreciation to LeeDeschler, Jon Eiseman, JudyMiller, andSuthatNara­kornpichit forbeingamong the first to integrate theloaderintotheir tools. Theyprovided valuable feedback,which led to improvements in the loaderinterface andthe addition ofimportant features.

Weespecially thank Carl Seaquist for his energy,time, and interest, which madethis project possible.

Finally, wethank Lisa Kowalski, Basant Chawla,JohnTauke,andJames Coplien for useful comments onprevious versions ofthis paper.

References1. W.A. Burling, B.]. B.Lax, L. A. O'Neill, andT. P.Pennino, "Pro­

duct Design and Introduction Support Systems," AT&TTechnicaljournal, Vol. 66,No.5, September/October 1987, pp.21-38.

2. ].]. Puttressand H. H.Goguen, "Incremental Loading ofSubrou­tinesat Runtime," AT&T Bell Laboratories, Murray Hill, NewJer­sey,April 9, 1986.

3. T.]. Kowalski, Y.M. Huang, and H.V. Diamantidis, "An Interpre­tiveEnvironment forOperations Support Systems," AT&TTech­nicaljournal, Vol. 69, No.2, March/April 1990, pp.42-51.

4. UNIX Time-Sharing System Programmer's Manual, Research Ver­sion, EighthEdition, Vol. 1,M.D.McIlroy (ed.) , AT&T BellLaboratories, MurrayHill, NewJersey, February 1985.

5. A. K. Bose,B.R. Chawla, and H. K. Gummel, "AVLSI Design Sys­tem,"Proceedings ofthe 1983IEEE International Symposium onCircuits andSystems, Vol. 2,Newport Beach, California, May 2through 4,1983, IEEE, NewYork, May 1983, pp.734-737.

6. ]. Bierbauer, ]. A. Eiseman, F.A. Fazal, and]. ]. Kulikowski, "Sys­tem Simulation withMIDAS," AT&TTechnical journal, Vol. 70,

AT&TTECHNICAL JOURNAL • JANUARY/FEBRUARY 1991

109

110

No. 1,January/February 1991, pp.36-51.7. R. Beale, R. Chadha, C.-F. Chen,A Prosser,and K.-M. Tham,

"Design Methodology andSimulation Toolfor Mixed Analog­Digital IntegratedCircuits," 1990IEEE International SymposiumonCircuits andSystems, Vol. 2, NewOrleans, Louisiana, May1through3,1990, IEEE, NewYork, 1990, pp. 1351-1355.

Biographies (continued)how programmer productivity can be increased. His interestsalso include artificial intelligence, operating systems,computer-aided design, text-processing environments, andreal-time systems. Mr. Kowalski joined the company in 1978.He has a 8.S.E. from the University of Michigan (Ann Arbor)and holds an M.S.E.E. and Ph.D. in electrical engineering

AT&T TECHNICAL JOURNAL.JANUARYIFEBRUARY 1991

from Carnegie-Mellon University (Pittsburgh, Pennsylvania).Mr. Smull is currently responsible for SCHEMA, AT&T's designcapture tool. His interests include programming environ­ments, human factors, and computer graphics. Mr. Smulljoined the company in 1982. He has a 8.5. in computer sci­ence from Pennsylvania State University (University Park) andan M.S.£. from the University of Texas (El Paso).

(Manuscript received October 17, 1990)