Valid HTML 4.0! Valid CSS!
%%% -*-BibTeX-*-
%%% ====================================================================
%%%  BibTeX-file{
%%%     author          = "Nelson H. F. Beebe",
%%%     version         = "1.00",
%%%     date            = "01 August 2018",
%%%     time            = "17:23:52 MDT",
%%%     filename        = "sigsoft2000.bib",
%%%     address         = "University of Utah
%%%                        Department of Mathematics, 110 LCB
%%%                        155 S 1400 E RM 233
%%%                        Salt Lake City, UT 84112-0090
%%%                        USA",
%%%     telephone       = "+1 801 581 5254",
%%%     FAX             = "+1 801 581 4148",
%%%     URL             = "http://www.math.utah.edu/~beebe",
%%%     checksum        = "25452 51329 265945 2517875",
%%%     email           = "beebe at math.utah.edu, beebe at acm.org,
%%%                        beebe at computer.org (Internet)",
%%%     codetable       = "ISO/ASCII",
%%%     keywords        = "ACM SIGSOFT Software Engineering Notes;
%%%                        bibliography; BibTeX",
%%%     license         = "public domain",
%%%     supported       = "yes",
%%%     docstring       = "This is a COMPLETE bibliography of ACM
%%%                        SIGSOFT Software Engineering Notes (CODEN
%%%                        SFENDP, ISSN 0163-5948 (print), 1943-5843
%%%                        (electronic)) for the years 2000--2009.
%%%                        Other decades are covered in companion
%%%                        bibliographies named sigsoftYYY0.bib.
%%%
%%%                        Publication began with volume 1, number 1, in
%%%                        May 1976, and there are up to 8 issues per
%%%                        annual volume.
%%%
%%%                        The journal has Web sites at:
%%%
%%%                            http://www.sigsoft.org/
%%%                            https://dl.acm.org/citation.cfm?id=J728
%%%
%%%                        At version 1.00, the COMPLETE year coverage
%%%                        looked like this:
%%%
%%%                             2000 ( 221)    2004 ( 161)    2008 (  70)
%%%                             2001 ( 146)    2005 ( 398)    2009 ( 133)
%%%                             2002 ( 102)    2006 ( 156)
%%%                             2003 (  26)    2007 (  90)
%%%
%%%                             Article:       1503
%%%
%%%                             Total entries: 1503
%%%
%%%                        The checksum field above contains a CRC-16
%%%                        checksum as the first value, followed by the
%%%                        equivalent of the standard UNIX wc (word
%%%                        count) utility output of lines, words, and
%%%                        characters.  This is produced by Robert
%%%                        Solovay's checksum utility.",
%%%  }
%%% ====================================================================
@Preamble{
    "\ifx \undefined \booktitle \def \booktitle #1{{{\em #1}}}    \fi" #
    "\ifx \undefined \TM        \def \TM          {${}^{\sc TM}$} \fi"
}

%%% ====================================================================
%%% Acknowledgement abbreviations:
@String{ack-nhfb = "Nelson H. F. Beebe,
                    University of Utah,
                    Department of Mathematics, 110 LCB,
                    155 S 1400 E RM 233,
                    Salt Lake City, UT 84112-0090, USA,
                    Tel: +1 801 581 5254,
                    FAX: +1 801 581 4148,
                    e-mail: \path|beebe@math.utah.edu|,
                            \path|beebe@acm.org|,
                            \path|beebe@computer.org| (Internet),
                    URL: \path|http://www.math.utah.edu/~beebe/|"}

%%% ====================================================================
%%% Journal abbreviations:
@String{j-SIGSOFT               = "ACM SIGSOFT Software Engineering Notes"}

%%% ====================================================================
%%% Bibliography entries, sorted by publication order with ``bibsort
%%% --byvolume'':
@Article{Neumann:2000:RPCa,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "22--26",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340856",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Demeyer:2000:WOO,
  author =       "Serge Demeyer and Harald Gall",
  title =        "{Workshop on Object-Oriented Reengineering
                 (WOOR'99)}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "27",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340857",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rajlich:2000:RWS,
  author =       "V. T. Rajlich and S. Rank and N. Wilde and K. H.
                 Bennett",
  title =        "Report on a workshop on software change and
                 evolution",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "28--29",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340858",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper provides a brief overview and report on the
                 main out-comes of the software change and evolution
                 (SCE99) workshop held in Los Angeles on May 17, 1999,
                 as part of the International Conference on Software
                 Engineering 1999. The purpose of the workshop was to
                 gather the most active of researchers and practitioners
                 in the field of software evolution and change. The
                 overall conclusion of the workshop was that this is a
                 topic of enormous importance to industry, and there is
                 a growing community of both practitioners and
                 researchers who are working in the field. It would
                 therefore make sense to arrange further workshops to
                 support this expanding community.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Evangelist:2000:NIT,
  author =       "Michael Evangelist",
  title =        "The {NSF} information technology research program",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "30",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340859",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tracz:2000:NSE,
  author =       "Will Tracz and Wayne Stidolph",
  title =        "{NSF} software engineering and language program
                 summaries",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "30--32",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.352130",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Alur:2000:CAV,
  author =       "Rajeev Alur",
  title =        "Computer-aided verification of reactive systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "32--33",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340861",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ammann:2000:STM,
  author =       "Paul Ammann",
  title =        "System testing via mutation analysis of model checking
                 specifications",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "33",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340862",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Attie:2000:EFM,
  author =       "Paul C. Attie",
  title =        "Efficient formal methods for the synthesis of
                 concurrent programs",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "34",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340864",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bastani:2000:RP,
  author =       "Farokh B. Bastani",
  title =        "Relational programs",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "34--35",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340865",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The objective of this research is to produce useful,
                 low-cost methods for developing correct concurrent
                 programs from formal specifications. In particular, we
                 address the design and verification of the
                 synchronization and communication portions of such
                 programs. Often, this portion can be implemented using
                 a fixed, finite amount of synchronization related data,
                 i.e., it is ``finite-state.'' Nevertheless, even when
                 each program component contains only one bit of
                 synchronization related data, the number of possible
                 global synchronization states for K components is about
                 $ 2^K $, in general. Because of this
                 ``state-explosion'' phenomenon, the manual verification
                 of large concurrent programs typically requires
                 lengthy, and therefore error-prone, proofs. Using a
                 theorem prover increases reliability, but requires
                 extensive formal labor to axiomatize and solve
                 verification problems. Automatic verification methods
                 (such as reachability analysis and temporal logic model
                 checking) use state-space exploration to decide if a
                 program satisfies its specification, and are therefore
                 also subject to state-explosion. To date, proposed
                 techniques for ameliorating state-explosion either
                 require significant manual labor, or work well only
                 when the program is highly symmetric and regular (e.g.,
                 many functionally similar components connected in
                 similar ways). To overcome these drawbacks, we advocate
                 the synthesis of programs from specifications. This
                 approach performs the refinement from specifications to
                 programs automatically. Thus, the amount of formal
                 labor is reduced to writing a formal specification and
                 applying the appropriate synthesis step at each stage
                 of the derivation. While nontrivial, writing a formal
                 specification is necessary in any methodology that
                 guarantees correctness.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Binkley:2000:RCR,
  author =       "David Binkley",
  title =        "Reducing the cost of regression testing",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "35--36",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340866",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Boothe:2000:FCB,
  author =       "Bob Boothe",
  title =        "A fully capable bidirectional debugger",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "36--37",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340867",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The goal of this research project is to develop a
                 bidirectional program debugger with which one can move
                 as easily backwards as current debuggers move forward.
                 We believe this will be a vastly more useful debugger.
                 A programmer will be able to start at the manifestation
                 of a bug and proceed backwards investigating how the
                 program arrived at the incorrect state, rather than the
                 current and often tedious practice of the user stepping
                 and breakpointing monotonically forward and then being
                 forced to start over from the beginning if they skip
                 past a point of interest. Our experimental debugger has
                 been implemented to work with C and C++ programs on
                 Digital/Compaq Alpha based UNIX workstations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bultan:2000:CMC,
  author =       "Tevfik Bultan",
  title =        "A composite model checking toolset for analyzing
                 software systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "37--38",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340868",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Burnett:2000:NAV,
  author =       "Margaret M. Burnett",
  title =        "{NYI} award: visual programming languages",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "38",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340870",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Carter:2000:CCR,
  author =       "Larry Carter and Jeanne Ferrante",
  title =        "{CROPS}: coordinated restructuring of programs and
                 storage",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "38--39",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340871",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Carver:2000:SBT,
  author =       "Richard H. Carver",
  title =        "Specification-based testing of concurrent programs",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "39--40",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340872",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Cheng:2000:IOO,
  author =       "Betty H. C. Cheng",
  title =        "Integrating object-oriented analysis and formal
                 specifications",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "40--41",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340873",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Clarke:2000:AVH,
  author =       "Edmund M. Clarke",
  title =        "Automatic verification of hardware and software
                 systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "41--42",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340875",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Cleaveland:2000:SFC,
  author =       "Rance Cleaveland",
  title =        "Specification formalisms for component-based
                 concurrent systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "42--43",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340876",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This project builds on my ongoing research into design
                 formalisms for, and the automatic verification of,
                 concurrent systems. The difficulties such systems pose
                 for system engineers are well-known and result in large
                 part from the the complexities of process interaction
                 and the possibilities for nondeterminism. My work is
                 motivated by a belief that mathematically rigorous
                 specification and verification techniques will
                 ultimately lead to better and easier-to-build
                 concurrent systems. My specific research interests lie
                 in the development of fully automatic analysis methods
                 and process-algebraic design formalisms for modeling
                 system behavior. I have worked on algorithms for
                 checking properties of, and refinement relations
                 between, system descriptions [CH93, CS93]; the
                 implementation and release of a verification tool, the
                 CWB-NC [CS96] (see http://www.cs.sunysb.edu/~rance to
                 obtain the distribution); case studies [BCL99, ECB97];
                 and the formalization of system features, such as real
                 time, probability, and priority, in process algebra
                 [BCL99, CDSYar]. The aims of this project include the
                 development of expressive and usable formalisms for
                 specifying and reasoning about properties of open,
                 component-based concurrent systems. More specifically,
                 my colleagues and I have been investigating new
                 approaches for describing component requirements and
                 automated techniques for determining when finite-state
                 components meet their requirements. The key topics
                 under study include the following. A temporal logic for
                 open systems. We are working on a notation for
                 conveniently expressing properties constraining the
                 behavior of open systems. Implicit specifications.
                 Implicit specifications use system contexts, or ``test
                 harness,'' to define requirements for open systems. We
                 are studying expressiveness issues and model-checking
                 algorithms for such specifications. Automatic
                 model-checker generation. We have been developing a
                 model-checker generator that, given a temporal logic
                 and ``proof rules'' for the logic, automatically
                 produces an efficient model checker.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Cleaveland:2000:PTD,
  author =       "Rance Cleaveland and Philip M. Lewis and Scott A.
                 Smolka",
  title =        "Practical techniques for the design, specification,
                 verification, and implementation of concurrent
                 systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "43--44",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340878",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Cook:2000:SPA,
  author =       "Jonathan E. Cook",
  title =        "Software process analysis: integrating models and
                 data",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "44",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340881",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Devanbu:2000:FDD,
  author =       "Premkumar Devanbu",
  title =        "Framework for debugging domain-specific languages",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "45",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340882",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Dillon:2000:AST,
  author =       "Laura K. Dillon",
  title =        "Automated support for testing and debugging of
                 real-time programs using oracles",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "45--46",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340884",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Dwyer:2000:APL,
  author =       "Matthew B. Dwyer and John Hatcliff",
  title =        "Adapting programming languages technologies for
                 finite-state verification",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "46--49",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340885",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Program verification and program transformation are
                 two research areas that have different goals. Program
                 verification aims to increase confidence in software
                 through the use of formal methods and systematic
                 testing. Program transformation rearranges the
                 structure of programs to increase their efficiency or
                 to make them more amenable to some other form of
                 processing. Despite being funded under different NSF
                 awards from the Software Engineering and Languages
                 program on the two different areas above the authors
                 are collaborating to apply results from both awards to
                 develop a set of tools, called Bandera, for
                 transforming Java programs into a form that is amenable
                 to verification using existing model checking tools.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Emerson:2000:AFM,
  author =       "E. Allen Emerson",
  title =        "Automated formal methods: model checking and beyond",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "49",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340886",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Felleisen:2000:CPA,
  author =       "Matthias Felleisen",
  title =        "Components and program analyses",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "49--50",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340887",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Model checking has been applied quite successfully to
                 hardware verification and shows promise for software
                 verification. The key obstacle is the well-known state
                 explosion problem. This report describes work done by
                 the investigator under NSF support, in particular
                 grants CCR 980-4736 and CCR 941-5496, to ameliorate
                 state explosion.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Anonymous:2000:AES,
  author =       "Anonymous",
  title =        "Assessing and enhancing software testing
                 effectiveness",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "50--51",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340888",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Although many techniques for testing software have
                 been proposed over the last twenty years, there is
                 still not enough solid evidence to indicate which (if
                 any) of these techniques are effective. It is difficult
                 to perform meaningful comparisons of the cost and
                 effectiveness of testing techniques; in fact, even
                 defining these terms in a meaningful way is
                 problematic. Consider an erroneous program P, its
                 specification S, and a test data adequacy criterion C
                 (such as 100\% branch coverage). Even if we restrict
                 the size of the test sets to be considered, there are a
                 huge number of different test sets that satisfy
                 criterion C for P and S. Since these adequate test sets
                 typically have different properties, in order to
                 investigate effectiveness (or other properties)
                 rigorously, the entire space of test sets must be
                 considered (according to some reasonable probability
                 distribution) and appropriate probabilistic analysis
                 and/or statistical sampling techniques must be used. In
                 earlier research, supported by NSF Grant CCR-9206910,
                 we developed analytical tools and an experiment design
                 to address these issues and applied them to comparing a
                 number of well-known testing techniques. The primary
                 measure of effectiveness considered was probability
                 that an adequate test set would detect at least one
                 fault and the most of the experiment subjects were
                 fairly small. The main thread of this research project
                 extends that work in several directions: additional
                 measures of cost and effectiveness are considered,
                 analytical and experimental tools are developed for
                 these measures, and experiments are conducted on larger
                 programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Goguen:2000:HAC,
  author =       "Joseph Goguen",
  title =        "Hidden algebra and concurrent distributed software",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "51--52",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340889",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Cleverly designed software often fails to strictly
                 satisfy its specifications, but instead satisfies them
                 behaviorally, in the sense that they appear to be true
                 under all possible experiments. Hidden algebra extends
                 prior work on abstract data types and algebraic
                 specification [2, 6] to concurrent distributed systems,
                 in a surprisingly simple way that also handles
                 nondeterminism, internal states, and more [4, 3].
                 Advantages of an algebraic approach include
                 decidability results for problems that are undecidable
                 for more expressive logics, and powerful algorithms
                 like term rewriting and unification, for implementing
                 equational logic tools. Much work in formal methods has
                 addressed code verification, but since empirical
                 studies show that little of software cost comes from
                 coding errors, our approach focuses on behavioral
                 specification and verification at the design level,
                 thus avoiding the distracting complications of
                 programming language semantics.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Goyal:2000:ADS,
  author =       "Deepak Goyal and Y. Annie Liu",
  title =        "Automated development of software for program analysis
                 and transformation",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "52--53",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340890",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Gunter:2000:AAS,
  author =       "Carl A. Gunter",
  title =        "Automated analysis of standard {ML}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "53",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340950",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Gunter:2000:FSE,
  author =       "Carl A. Gunter and Elsa L. Gunter and Pamela Zave",
  title =        "Formal software engineering",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "54",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340951",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Gupta:2000:PIP,
  author =       "Gopal Gupta",
  title =        "Parallel implementation of {Prolog}: the {ACE}
                 project",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "54--55",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340954",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Heineman:2000:MDA,
  author =       "George T. Heineman",
  title =        "A model for designing adaptable software components",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "55--56",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340956",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "An important aim of software engineering is to produce
                 reliable and robust software systems. As software
                 systems grow in size, however, it becomes infeasible to
                 design and construct software systems from scratch.
                 Most software developers are familiar with reusing code
                 from component libraries to speed up tedious
                 programming tasks, such as constructing graphical user
                 interfaces. However, it is still an elusive goal to
                 construct applications entirely from pre-existing,
                 independently developed components. We believe that
                 such component-based development will only occur when
                 application builders can adapt software components to
                 suit their needs. The goal of this research is to
                 develop novel techniques for designing software
                 components that provide a mechanism for adapting their
                 behavior. We aim to achieve higher levels of component
                 use/reuse than existing approaches for reusing software
                 components. The Active Interface technique we propose
                 enables software components to provide two interfaces
                 --- one for behavior and one for adapting that behavior
                 as needed. We make a distinction between software
                 evolution, where the component designer modifies the
                 software component, and adaptation, where an
                 application builder adapts the component for a
                 different use. We also differentiate adaptation from
                 customization; an end-user customizes a software
                 component by choosing from a fixed set of options. An
                 end-user adapts a software component by writing new
                 code to alter existing functionality.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Henzinger:2000:NDC,
  author =       "Thomas A. Henzinger",
  title =        "New directions in computer-aided verification",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "56--57",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340957",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Hind:2000:NNP,
  author =       "Michael Hind",
  title =        "{NPIC} --- {New Paltz interprocedural compiler}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "57--58",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340958",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Horwitz:2000:DRT,
  author =       "Susan Horwitz",
  title =        "Debugging via run-time type checking",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "58",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340960",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Java programmers have the security of knowing that
                 errors like out-of-bounds array indexes or attempts to
                 dereference a null pointer will be detected and
                 reported at run time. C and C++ programmers count on
                 tools like Purify to achieve a similar level of
                 confidence. The run-time checks provided by Purify have
                 proved to be extremely useful to programmers in
                 debugging their programs. Java also provides security
                 via its strong type system. For example: * There are no
                 union types in Java, so it is not possible for a
                 program to write into a field of one type and then
                 access that value via a field of a different type. *
                 Only very restricted kinds of casting are allowed; for
                 example, it is not possible to treat a pointer as if it
                 were an integer or vice versa. * When an object is
                 down-cast to a subtype, a run-time check will be
                 performed to ensure that the actual type of the object
                 is consistent with the cast. However, tools like Purify
                 do not provide similar checks for C/C++ programs. This
                 research involves the design and implementation of a
                 tool to provide new kinds of run-time checks based on
                 type information. That is, the goal of the tool is to
                 help C/C++ programmers find errors in their programs
                 that manifest themselves as bad run-time types, in the
                 same way that Purify helps programmers find errors in
                 their programs that manifest themselves as bad run-time
                 memory accesses. The basic idea is to associate a
                 run-time type with every piece of data. Whenever data
                 is used by some operation, a check is performed to
                 ensure that its run-time type is consistent with the
                 type expected by the operation. For example, when a
                 pointer is dereferenced, its run-time type must be
                 ``pointer'' (not ``int'', ``float'', ``uninitialized'',
                 etc). When an integer multiplication is performed, the
                 operands' run-time types must be ``int'' (not
                 ``pointer'', ``float'', ``uninitialized'', etc).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Hudak:2000:PFR,
  author =       "Paul Hudak",
  title =        "Principles of functional reactive programming",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "59",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340961",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Jagadeesan:2000:TP,
  author =       "R. Jagadeesan and K. L{\"a}ufer and V. Gupta",
  title =        "The {Triveni} project",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "59",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340962",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Jayaraman:2000:RSC,
  author =       "Bharat Jayaraman",
  title =        "Research on sets, constraints, and preferences",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "60",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340963",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Johann:2000:TEP,
  author =       "Patricia Johann",
  title =        "Testing and enhancing a prototype program fusion
                 engine",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "60--61",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340964",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Johnson:2000:PLL,
  author =       "Philip M. Johnson",
  title =        "Project {LEAP}: lightweight, empirical,
                 anti-measurement dysfunction, and portable software
                 developer improvement",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "61",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340966",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kfoury:2000:TTR,
  author =       "A. J. Kfoury",
  title =        "Type theory and rewriting theory for expressive,
                 efficient and reliable programming languages",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "61--62",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340968",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Leavens:2000:FMM,
  author =       "Gary T. Leavens",
  title =        "Formal methods for multimethod software components",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "62--63",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340971",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mairson:2000:PLF,
  author =       "Harry Mairson",
  title =        "Programming language foundations of computation
                 theory",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "63",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340972",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mancoridis:2000:TDE,
  author =       "Spiros Mancoridis",
  title =        "Toward a design environment for recovering and
                 maintaining the structure of software systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "63--64",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340973",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mesenguer:2000:SIO,
  author =       "Jos{\'e} Mesenguer and Carolyn Talcott",
  title =        "Semantic interoperation of open systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "64--65",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340976",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Minsky:2000:TAI,
  author =       "Naftaly H. Minsky",
  title =        "Towards architectural invariants of evolving systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "65",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340977",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mislove:2000:SMC,
  author =       "Michael W. Mislove",
  title =        "Semantic models for concurrency",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "65--66",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340980",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Nadathur:2000:FRD,
  author =       "Gopalan Nadathur",
  title =        "A framework for realizing derivation systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "66--67",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340982",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Necula:2000:LBA,
  author =       "George C. Necula and Shree Rahul",
  title =        "A logic-based approach to software system safety and
                 security",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "67--68",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340983",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Offutt:2000:STA,
  author =       "Jeff Offutt",
  title =        "Software testing and analysis of object-oriented
                 software",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "68",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340986",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Our work has studied new language mechanisms for
                 accessing message invocations in message passing based
                 concurrent programming languages. Invocation handling
                 mechanisms in many concurrent languages have
                 significant limitations that make it difficult or
                 costly to solve common programming situations
                 encountered in program visualization, debugging, and
                 scheduling scenarios. We have defined and implemented
                 new such mechanisms within the SR concurrent language
                 and have gained some experience with them. This work
                 has led us to want a cleaner, higher-level way of
                 defining mechanisms for message invocation. We are,
                 therefore, now taking an object-oriented approach. As a
                 step toward that goal, we are currently applying our
                 ideas to Java. Below, we briefly summarize these two
                 areas.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Olsson:2000:CPL,
  author =       "Ronald A. Olsson",
  title =        "Concurrent programming language support for invocation
                 handling: design and implementation",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "68--69",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340987",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Pierce:2000:EO,
  author =       "Benjamin C. Pierce",
  title =        "The essence of objects",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "69--71",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340989",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "``The Essence of Objects'' is an ongoing program of
                 research in programming languages, type systems, and
                 distributed programming at the University of
                 Pennsylvania, supported by the National Science
                 Foundation under Career grant CCR-9701826, Principled
                 Foundations for Programming with Objects. Papers on
                 most of the topics discussed in this outline can be
                 found via http://www.cis.upenn.edu/bcpierce/papers.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Pontelli:2000:PDE,
  author =       "Enrico Pontelli",
  title =        "Parallel and distributed execution of constraint
                 programs",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "71--72",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340992",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The goal of this research project is to study
                 techniques and methodologies for execution of
                 Constraint logic programs on parallel and distributed
                 architectures. These models will be applied to implicit
                 and explicit parallelization of complex and irregular
                 symbolic applications, such as those arising in Natural
                 Language Processing, Knowledge-based Systems, and
                 Digital Libraries, and to provide novel frameworks for
                 advanced World-Wide Web programming and coordination of
                 software components.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rajlich:2000:MTC,
  author =       "V{\'a}clav Rajlich",
  title =        "A model and a tool for change propagation in
                 software",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "72",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340993",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ramakrishnan:2000:TLP,
  author =       "C. R. Ramakrishnan",
  title =        "Tabled logic programming for verification and program
                 analysis",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "73",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340996",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ramakrishnan:2000:SEL,
  author =       "C. R. Ramakrishnan and I. V. Ramakrishnan and Scott A.
                 Smolka and David S. Warren",
  title =        "Specification and evaluation of logic-based model
                 checking",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "73--74",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340997",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Redmiles:2000:IDI,
  author =       "David F. Redmiles",
  title =        "Improving the design of interactive software",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "74--75",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.340999",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This NSF sponsored CAREER project combines elements of
                 research in human-computer interaction with research in
                 software engineering. Three objectives are (1) to
                 develop a model of software development as a process of
                 on-going communication; (2) to support this model
                 through active mechanisms in software tools; and (3) to
                 improve the accessibility and acceptance of usability
                 methods by software practitioners. In general, the
                 objectives reflect a theory of human-centered software
                 development.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Reynolds:2000:DDI,
  author =       "John C. Reynolds",
  title =        "The design, definition and implementation of
                 programming languages",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "75",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341002",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rine:2000:PCB,
  author =       "D. Rine and N. Nada",
  title =        "Public case-base and tool kit using a validated
                 {RRM}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "76",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341003",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Software systems are important, yet poorly understood
                 entities. Users, and at times even developers, do not
                 always understand what is occurring within the software
                 in use. The Exploratory Visualization project attempts
                 to address the technical issues involved in helping
                 users understand running computations, especially
                 long-lived distributed computations. The three facets
                 of this problem that we investigate in our project are
                 (1) creating accurate views of a running execution, (2)
                 providing comprehensive and efficient access to a
                 computation, and (3) responding to the user's
                 interactions to promote understanding and optimize data
                 collection.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Roman:2000:EV,
  author =       "Gruia-Catalin Roman and Delbert Hart and Eileen
                 Kraemer",
  title =        "Exploratory visualization",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "76--77",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341005",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Roman:2000:RDD,
  author =       "Gruia-Catalin Roman and Amy L. Murphy",
  title =        "Rapid development of dependable applications over Ad
                 hoc networks",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "77--78",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341007",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Advances in wireless communication and network
                 computing technologies make possible new kinds of
                 applications involving transient interactions among
                 physical components that move across a wide range of
                 spaces, from the confines of a room to the airspace
                 across an ocean, and require no fixed networking
                 infrastructure to communicate with one another. Such
                 components may come together to form ad hoc networks
                 for the purpose of exchanging information or in order
                 to engage in cooperative task-oriented behaviors. Ad
                 hoc networks are assembled, reshaped and taken apart as
                 components move in and out of communication range; all
                 interactions are transient; computations become highly
                 decoupled and rely on weak forms of data consistency;
                 disconnections are frequent and unpredictable; and
                 component behavior is sensitive to changes in location,
                 context, quality of service, or administrative domain.
                 Our objective is to develop software engineering
                 methods and an associated software infrastructure that
                 will facilitate rapid development of dependable mobile
                 applications executing over ad hoc networks.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rosenblum:2000:CME,
  author =       "David S. Rosenblum",
  title =        "{CAREER}: mechanisms for ensuring the integrity of
                 distributed object systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "78--79",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341008",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rothermel:2000:TME,
  author =       "Gregg Rothermel",
  title =        "Testing and maintaining evolving software systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "79--80",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341012",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rugaber:2000:SEI,
  author =       "Spencer Rugaber and Linda Wills",
  title =        "Software evolution and interleaving",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "80",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341015",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Scedrov:2000:LBS,
  author =       "Andre Scedrov",
  title =        "A language-based security analysis",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "80--81",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341016",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Schmidt:2000:AIP,
  author =       "David Schmidt",
  title =        "Abstract interpretation and program modelling",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "81--82",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341017",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Shao:2000:TCI,
  author =       "Zhong Shao",
  title =        "Typed common intermediate format",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "82",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341019",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Shull:2000:EVP,
  author =       "Forrest Shull and Victor R. Basili and Marvin
                 Zelkowitz",
  title =        "The experimental validation and packaging of software
                 technologies",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "82--83",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341021",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Sistla:2000:FMC,
  author =       "A. Prasad Sistla",
  title =        "Formal methods in concurrent and distributed systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "84",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341022",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Smidts:2000:AAG,
  author =       "Carol S. Smidts",
  title =        "An approach to the automatic generation of software
                 functional architecture",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "84--85",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341025",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Smith:2000:BRI,
  author =       "Geoffrey Smith and Dennis Volpano",
  title =        "Basic research in information privacy",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "86",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341026",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Stewart:2000:AAF,
  author =       "David B. Stewart",
  title =        "Automated analysis and fine-tuning of timing
                 properties in embedded real-time systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "86--87",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341028",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "An extremely time-consuming task of producing an
                 embedded real-time system is the final analysis and
                 fine-tuning of the system's timing. Existing CASE tools
                 focus on the software specification and design of
                 embedded systems. They provide little, if any, support
                 after the software has been implemented. Even if the
                 developer uses a CASE tool to design their system, it
                 likely does not meet the timing specifications on the
                 first try. This happens because the CASE tool's
                 software design and real-time analysis is based only on
                 estimated data and idealized models. The tools do not
                 take into account practical concerns such as operating
                 system overhead, interrupt handling, limitations of the
                 programming language or processor, inaccuracies in
                 estimating worst-case execution time of each process,
                 and software errors introduced at the implementation
                 phase by the programmers. Performance monitoring tools
                 allow developers to obtain raw data from the underlying
                 embedded system in real-time. These tools provide most,
                 if not all, of the data needed to pinpoint the problem.
                 Such data, however, is not provided in a symbolic
                 fashion, and thus could be very difficult to
                 understand. The monitors only show what happened during
                 run-time, without correlating those results to the
                 original specifications. Performance monitors also do
                 not perform any analysis on the data that is collected.
                 As a result, there is no means to easily differentiate
                 between parts of the execution that are ``normal''
                 versus those parts that have difficult-to-detect timing
                 errors. Only an expert's eye can quickly spot the
                 differences. We are investigating tools that can help
                 embedded system designers analyze, debug, and fine-tune
                 the timing characteristics of their embedded
                 implementations. Such a tool can have a major impact,
                 by allowing designers whose expertise is in an area
                 other than real-time system analysis, such as
                 communications, controls, or hardware design, to use
                 the tool and obtain valuable information on how to fix
                 their code that is not performing according to
                 specifications.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Swift:2000:PPA,
  author =       "Terrance Swift",
  title =        "Principles, practice, and applications of tabled logic
                 programming",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "87--88",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341031",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tai:2000:ATC,
  author =       "K. C. Tai",
  title =        "Analysis and testing of concurrent object-oriented
                 software",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "88",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341033",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tian:2000:EMI,
  author =       "Jeff Tian",
  title =        "Early measurement and improvement of software
                 reliability",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "89",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341034",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{VanHentenryck:2000:CP,
  author =       "Pascal {Van Hentenryck}",
  title =        "Constraint programming",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "89--90",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341036",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{VanderZanden:2000:NVD,
  author =       "Bradley T. {Vander Zanden}",
  title =        "New visualization and debugging technology for one-way
                 dataflow constraints",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "90--91",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341038",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Wand:2000:ABP,
  author =       "Mitchell Wand",
  title =        "Analysis-based program transformations",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "91--92",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341041",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Wand:2000:OMU,
  author =       "Mitchell Wand and William D. Clinger",
  title =        "Optimizing memory usage in higher-order programming
                 languages: theoretical and experimental studies",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "92",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341042",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{White:2000:GSD,
  author =       "Elizabeth L. White",
  title =        "General strategies for dynamic reconfiguration",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "93",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341044",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In recent years there has been a great deal of
                 attention in the software engineering community on the
                 development of techniques and tools that provide
                 support for dynamic reconfiguration, the ability to
                 make changes to a running application. The changes of
                 interest include (1) adding/removing/moving components;
                 (2) adding/removing bindings (communication channels);
                 (3) changing the characteristics of the components or
                 bindings. My work in this area has focused both on
                 software support for dynamic reconfiguration of
                 parallel applications and on frameworks and static
                 software analysis techniques for determining the
                 validity of component-level adaptations in the context
                 of dynamic reconfiguration.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Zeil:2000:RGM,
  author =       "Steven J. Zeil",
  title =        "Reliability growth modeling from fault failure rates",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "94",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341045",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A variety of reliability growth models provide
                 quantified measures of test effectiveness in terms that
                 are directly relevant to project management [Lyu96],
                 but at the cost of restricting testing to
                 representative selection, in which test data is chosen
                 to reflect the operational distribution of the
                 program's inputs. During testing, data is collected on
                 the observed times between program failures (or,
                 similarly, numbers of failures within a time interval).
                 These observations are fitted to one of various models,
                 which can then be used to estimate the current
                 reliability of the program.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Stidolph:2000:EDC,
  author =       "Wayne Stidolph",
  title =        "{Evolutionary Design of Complex Software (EDCS)}
                 demonstration days 1999",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "95",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341046",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This report summarizes the Product/Technology
                 demonstrations given at Defense Advanced Research
                 Projects Agency (DARPA) Evolutionary Design of Complex
                 Software (EDCS) Program Demonstration Days, held 28-29
                 June 1999 at the Sheraton National Hotel, Arlington,
                 VA.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Anonymous:2000:AA,
  author =       "Anonymous",
  title =        "{Acme} and {AcmeStudio}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "96",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341049",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Scherlis:2000:ACT,
  author =       "William L. Scherlis",
  title =        "Adaptation and commitment technology {(ACT)}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "96",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341051",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Taylor:2000:Aa,
  author =       "Richard Taylor and David Redmiles",
  title =        "Arabica",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "96",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341053",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Stavridou:2000:AAC,
  author =       "Victoria Stavridou",
  title =        "Architectural analysis of component-based systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "96--97",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341061",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Anonymous:2000:AAS,
  author =       "Anonymous",
  title =        "{ARGUS-1}: ``All-Seeing'' architectural analysis",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "97",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341066",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Taylor:2000:Ab,
  author =       "Richard Taylor and David Redmiles",
  title =        "{ArchStudio}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "97",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341063",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Taylor:2000:AU,
  author =       "Richard Taylor and David Redmiles",
  title =        "{Argo\slash {UML}}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "97",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341065",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Brannum:2000:CPA,
  author =       "Garry Brannum",
  title =        "Capability packages for avionics software {(CPAS)}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "98",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341070",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Carlson:2000:E,
  author =       "Bill Carlson and Chris Garrity",
  title =        "Ewatch",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "98",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341069",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kaiser:2000:IBIa,
  author =       "Gail E. Kaiser",
  title =        "{Internet}-based information management technology",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "98",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341073",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Taylor:2000:C,
  author =       "Richard Taylor and David Redmiles",
  title =        "{Chimera}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "98",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341074",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Heimbigner:2000:DSE,
  author =       "Dennis Heimbigner and Alexander L. Wolf",
  title =        "Distributed software engineering",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "99",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341078",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Luckham:2000:CEP,
  author =       "David Luckham",
  title =        "Complex event processing {(CEP)}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "99",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341080",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Teitelbaum:2000:C,
  author =       "Tim Teitelbaum",
  title =        "{CodeSurfer}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "99",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341076",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Wiederhold:2000:CMS,
  author =       "Gio Wiederhold and Dorothea Beringer and Neal Sample
                 and Laurence Melloul",
  title =        "Composition of multi-site software {(CHAIMS)}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "99--100",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341082",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Blazer:2000:CBD,
  author =       "Bob Blazer",
  title =        "A {COTS-based} design editor for user specified
                 domains",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "100",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341084",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Richardson:2000:BDA,
  author =       "Debra Richardson",
  title =        "{DAS-BOOT}: design-, architecture- and
                 specification-based approaches to object-oriented
                 testing",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "100",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341085",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Lieberherr:2000:DAP,
  author =       "Karl J. Lieberherr",
  title =        "{Demeter}\slash adaptive programming",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "100--101",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341088",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rugaber:2000:ECS,
  author =       "Spencer Rugaber",
  title =        "Esprit de {Corps} Suite",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "101",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341094",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Taylor:2000:E,
  author =       "Richard Taylor and David Redmiles",
  title =        "Endeavors",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "101",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341092",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Taylor:2000:EDE,
  author =       "Richard Taylor and David Redmiles",
  title =        "Expectation-driven event monitoring",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "101",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341095",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Vestal:2000:D,
  author =       "Steve Vestal",
  title =        "{DoME}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "101",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341089",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Osterweil:2000:F,
  author =       "Leon Osterweil and Lori A. Clarke",
  title =        "{FLAVERS}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "101--102",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341098",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bailin:2000:FAM,
  author =       "Sidney Bailin and Dean Allemang",
  title =        "Formal alternative management integrating logical
                 inference and rationals {(FAMILIAR)}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "102",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341100",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Vestal:2000:ICE,
  author =       "Steve Vestal",
  title =        "Incremental constraint engine",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "102--103",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341102",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kaiser:2000:IBIb,
  author =       "Gail E. Kaiser",
  title =        "{Internet}-based information management technology",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "103",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341107",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Lehoczky:2000:IIS,
  author =       "John Lehoczky",
  title =        "{INSERT} --- {Incremental Software Evolution for
                 Real-Time Systems}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "103",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341104",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Batory:2000:JTS,
  author =       "Don Batory",
  title =        "{Jakarta Tool Suite (JTS)}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "103--104",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341108",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Meseguer:2000:M,
  author =       "Jose Meseguer and Carolyn Talcott",
  title =        "{Maude}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "104",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341115",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Osterweil:2000:LJ,
  author =       "Leon Osterweil and Lori A. Clarke",
  title =        "{Little-JIL}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "104",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341113",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Taylor:2000:KD,
  author =       "Richard Taylor and David Redmiles",
  title =        "Knowledge depot",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "104",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341111",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Boehm:2000:MBS,
  author =       "Barry Boehm and Neno Medvidovic",
  title =        "Model-based (systems) architecting and software
                 engineering {(MBASE)}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "104--105",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341117",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Johnson:2000:MAG,
  author =       "Lewis Johnson and Stacy Marsella",
  title =        "{MediaDoc}: automated generation of multimedia
                 explanatory presentations",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "105",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341121",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Karsai:2000:MIC,
  author =       "Gabor Karsai",
  title =        "Model integrated computing {(MIC)}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "105",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341125",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Vestal:2000:M,
  author =       "Steve Vestal",
  title =        "{MetaH}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "105",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341124",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Reed:2000:OVC,
  author =       "Daniel Reed and Simon Kaplan",
  title =        "{ORBIT\slash VIRTUE} --- collaboration and
                 visualization support for complex systems evolution",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "105--106",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341127",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Boehm:2000:SAA,
  author =       "Barry Boehm and Neno Medvidovic",
  title =        "Software architecture, analysis, generation, and
                 evolution {(SAAGE)}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "106",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341131",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Young:2000:HAT,
  author =       "Michal Young",
  title =        "High assurance technologies",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "106",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341130",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Balzer:2000:SWC,
  author =       "Bob Balzer",
  title =        "Securely wrapping {COTS} products",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "106--107",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341134",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Richardson:2000:SAT,
  author =       "Debra Richardson",
  title =        "Siddhartha --- automated test driver-oracle
                 synthesis",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "106--107",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341136",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{McDonald:2000:S,
  author =       "Jim McDonald",
  title =        "Specware",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "107",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341139",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Richardson:2000:SSB,
  author =       "Debra Richardson",
  title =        "{SoBelt}: structural and behavioral execution
                 instrumentation tool",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "107",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341138",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Egyed:2000:UAS,
  author =       "Alexander Egyed",
  title =        "{UML\slash Analyzer} --- a system for defining and
                 analyzing the conceptual integrity of {UML} models",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "108",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341142",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Richardson:2000:TST,
  author =       "Debra Richardson",
  title =        "{TestTalk}: software test description language",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "108",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341141",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Taylor:2000:W,
  author =       "Richard Taylor and David Redmiles",
  title =        "{WebDAV}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "108",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341143",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Raccoon:2000:WNK,
  author =       "L. B. S. Raccoon",
  title =        "A whole new kind of engineering",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "109--113",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341144",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "There is a lot of momentum for software engineering to
                 become a title act branch of engineering. A brochure
                 from McMaster University
                 (www.cas.mcmaster.ca/cas/undergraduate/SEbrochure.pdf,
                 Fall 1999), reads, ``At McMaster we have taken the
                 position that software engineering is a branch of
                 engineering and have applied well established
                 principles of engineering education in this new
                 specialty.'' And, the Texas Board of Professional
                 Engineers is certifying software engineers as title act
                 engineers, today. If other states follow then software
                 engineering will become a title act branch of
                 engineering by fiat. While I agree that software
                 engineering resembles traditional engineering in many
                 ways, I also believe that software engineering is a
                 whole new kind of engineering that is equal to,
                 parallel to, and independent of traditional
                 engineering. I believe that if software engineers want
                 to be licensed, they should recognize their unique
                 reality and become licensed in a way that reflects this
                 reality. Software engineers should be professionalized
                 on their own terms, with their own regulatory
                 structure. Software engineers should create a whole new
                 kind of engineering, and not just follow the path
                 trodden by traditional engineers. In the first section,
                 I argue that software engineering is a real profession
                 that stands on its own and that its culture differs
                 substantially from that of traditional engineering.
                 Software engineering is big: it counts nearly as many
                 practitioners as traditional engineering; diverse: it
                 has many areas of specialized practice; and enduring:
                 it has grown steadily for more than fifty years. Every
                 facet of software engineering, from technology to
                 attitude to origins, differs from traditional
                 engineering, which profoundly affects the culture of
                 software engineering. Software engineering is not a
                 branch of traditional engineering. In the second
                 section, I argue that
                 all-of-software-engineering-combined should resemble
                 all-of-traditional-engineering-combined. Four kinds of
                 traditional engineering regulation are practiced today
                 that software engineering can emulate: unregulated,
                 title-act, practice-act, and
                 all-of-engineering-combined. Of these four kinds,
                 title-act and all-of-engineering-combined are the most
                 likely outcomes. There is a lot of momentum to regulate
                 software engineering as a title-act branch of
                 engineering. However, regulating software engineering
                 like all-of-engineering-combined will give software
                 engineers more control over their destiny, let them
                 define their own identity and culture, wield their own
                 power, and set their own curriculum and immigration
                 policy.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Traas:2000:SCM,
  author =       "Vincent Traas and Jos van Hillegersberg",
  title =        "The software component market on the {Internet}:
                 current status and conditions for growth",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "1",
  pages =        "114",
  month =        jan,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/340855.341145",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:50 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Component Based Development (CBD) promises a large
                 step forward in the quest for maximizing reuse in
                 software development. Although a variety of definitions
                 of CBD exists, key to CBD is the process of building
                 systems by way of combination and integration of
                 pre-engineered and pre-tested software components. For
                 CBD to be the long awaited breakthrough in software
                 development, the efficient reuse of software components
                 has to be organized by a market system; ``Components
                 develop their full potential only in a component
                 market'' [5]. Organizations may benefit from organizing
                 an internal component market. Software components can
                 then be reused over multiple projects saving valuable
                 resources. However, the most appropriate marketplace to
                 buy and sell components would be the Internet: an
                 international, freely accessible network, which is
                 perfectly suited for offering, promoting and
                 distributing components. A flourishing component market
                 on the Internet would really allow organizations to buy
                 and reuse against low-costs. Developers would only need
                 to focus on functionality specific to the project, and
                 on locating and integrating available components.
                 Industry watchers have predicted huge growth figures
                 for the software component market. Gartner predicts the
                 component market will grow to \$7 billion in 2001, of
                 which \$2 billion directly comes from component sales
                 [1]. Giga information group predicts an off-the-shelf
                 component market of \$3,3 billion in 2001 [6]. Ovum
                 goes further by estimating the size of the software
                 component market to be \$64 billion in 2002 [3]. But
                 does a component market on the Internet already exist,
                 and if so, what is its status? Also, if a component
                 market is so important for CBD to fulfil its promises,
                 what are the conditions for growth towards maturity?
                 Apart from rough estimations of the future size of the
                 market, little research has been done to investigate
                 the current component market and its growth. It is the
                 objective of the research reported on in this paper to
                 gain insight into these questions. The research
                 described in this article contained two phases: First,
                 an overview of the current status of the component
                 market on the Internet was created. Next, based on this
                 overview and a literature study, conditions for growth
                 of the market were developed. An email-survey was held
                 in which experts were asked to rate these conditions by
                 importance and comment on them. Section two and three
                 describe the results of these research phases
                 respectively.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Griswold:2000:GVC,
  author =       "William G. Griswold",
  title =        "Guilds or virtual countries? the future of software
                 professionals",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "2--2",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346061",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Doernhoefer:2000:SNSa,
  author =       "Mark Doernhoefer",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "8--16",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346062",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2000:RPCb,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "17--21",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346063",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Pulvermuller:2000:TGC,
  author =       "Elke Pulverm{\"u}ller and Andreas Speck",
  title =        "Towards generative components",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "22--24",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346064",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "On September, 28 --- 30, 1999, the First International
                 Symposium on Generative and Component-based Software
                 Engineering (GCSE'1999) took place at Erfurt,
                 Germany. This was the origin of a new international
                 forum bundling the research on all generative
                 techniques within the software development process,
                 especially those focused on components. The next
                 Symposium GCSE'2000 is intended to take place on
                 October, 10--12, 2000, Erfurt. This time co-hosted with
                 NET.OBJECTDAYS'2000.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Munson:2000:RTS,
  author =       "Ethan V. Munson",
  title =        "Representations, tools, and services for the complete
                 integration of software development documents",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "25--25",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346065",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mamone:2000:DT,
  author =       "Salvatore Mamone",
  title =        "Documentation testing",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "26--29",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346066",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "One definition of documentation is 'Any written or
                 pictorial information describing, defining, specifying,
                 reporting, or certifying activities, requirements,
                 procedures, or results.' (1). Documentation is as
                 important to a product's success as the product itself.
                 If the documentation is poor, non-existent, or wrong,
                 it reflects on the quality of the product and the
                 vendor. At the Bell Atlantic Systems Integration \&
                 Testing Center documentation testing is an important
                 function that receives as much attention as the testing
                 of software and hardware. Because the Bell Atlantic
                 Systems Integration \& Testing Center is ISO9001
                 certified, an enormous effort was undertaken to ensure
                 quality assurance of all products including
                 documentation. Both a test procedure and test plan for
                 documentation has been implemented to ensure this
                 quality. This article will describe what documentation
                 is, why document testing is important, and how document
                 testing is performed at the Bell Atlantic Systems
                 Integration \& Testing Center. Other information
                 pertaining to documentation, such as human factors, how
                 to achieve document comprehensiveness, and
                 comprehensibility, although important, are beyond the
                 reach of this report.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Adams:2000:GI,
  author =       "Tom Adams",
  title =        "The {God} of inspection",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "30--30",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346067",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Agarwal:2000:OEL,
  author =       "Rakesh Agarwal and Arup Ratan Raha and Bhaskar Ghosh",
  title =        "Our experience and learning in {ERP} implementation",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "31--34",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346068",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Information systems developed to support the
                 functional units of a complete enterprise (referred in
                 this paper as ``application package'') only serve
                 standard industry processes. Very often, the business
                 processes that differentiate an organization from
                 another are the processes that define their competitive
                 edge. This competitive edge can be achieved if the
                 implemented processes are based on the best practices
                 supported by these packages. This requires a strong
                 knowledge of Business Processes, adept IT capability
                 and a sound, tested implementation. This paper
                 describes our experience in using the COTS package
                 application MAC-PAC v10 for TOSHIBA sales \& services
                 (a subsidiary of Toshiba Corporation).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Juric:2000:ILS,
  author =       "Matjaz B. Juric and Ivan Rozman and Marjan Hericko and
                 Tomaz Domajnko",
  title =        "Integrating legacy systems in distributed object
                 architecture",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "35--39",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346069",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The ability of a new technology to reuse legacy
                 systems is very important for its economic success.
                 This paper presents a method for integrating legacy
                 systems within distributed object architectures. The
                 necessary steps required for integration are defined.
                 It is explained how to define object interfaces. A
                 detailed overview of how to implement the wrappers is
                 given. The paper also answers the question which
                 distributed object model is most suitable for legacy
                 integration. Therefore a decision model is defined and
                 the evaluation results are presented.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mei:2000:CAR,
  author =       "Hong Mei",
  title =        "A complementary approach to requirements
                 engineering---software architecture orientation",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "40--45",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346070",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper presents the idea of Software Architecture
                 Oriented Requirements Engineering, a complementary
                 approach to existing requirements engineering processes
                 and methods. The main objective is to introduce
                 concepts and principles of software architecture into
                 requirement analysis and requirement specification,
                 supporting requirement reuse, traceability between
                 requirement specifications and system design, and
                 consistency in the whole software development process
                 more effectively. The paper views connectors as the
                 first-class entities in the problem space, not just in
                 the solution space as most of current research on
                 software architecture does, hence the connector
                 recognition and specification are same important as
                 component recognition and specification in requirements
                 engineering. Based on this idea, the paper presents a
                 new software development process and corresponding
                 requirements engineering process, gives some guidelines
                 for connector recognition, and borrows the notations of
                 software architecture description to specify the
                 functional and behavioural requirements at a high
                 abstraction level. It must be pointed out that the
                 approach presented in this paper is not a substitute
                 for existing ones, but a complement to them from
                 another perspective and at a different abstraction
                 level.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Albizuri-Romero:2000:RVC,
  author =       "Miren Bego{\~n}a Albizuri-Romero",
  title =        "A retrospective view of {CASE} tools adoption",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "46--50",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346071",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper provides a retrospective view of the
                 adoption of CASE tools in organizations using some
                 empirical data from various research studies in this
                 field. First, relevant factors that influence the
                 decision to adopt such a tool are discussed. Such
                 factors include elements related to the organization
                 adopting such a technology, as well as other
                 characteristics associated with the application
                 environment and the alternative development methods
                 being used. Then, the advantages and disadvantages of
                 using CASE tools are discussed and some critical
                 success factors are identified. Finally, a taxonomy of
                 CASE tools in the 90's is presented. The paper provides
                 some explanations of why some organizations are
                 successful in adopting CASE tools and gives
                 recommendations for making a better use of such a
                 technology.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ramaswamy:2000:LDS,
  author =       "Ramkumar Ramaswamy",
  title =        "Latency in distributed, sequential application
                 designs",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "51--55",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346072",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Despite advances in hardware, communications and
                 software technology, latency remains a pressing problem
                 for designers of distributed applications. Even after
                 application functionality has been carefully
                 distributed amongst multiple sites, there is the
                 problem of the detailed design of client requests so
                 that network trips are efficiently made. Most solution
                 approaches (or compromises) for detailed design that
                 are encountered in practice either tend to be ad-hoc,
                 or are intended for use with a specific class of
                 development environment, such as object-oriented
                 languages. In this paper we take a fresh look at the
                 problem of designing client requests in the presence of
                 latency. We treat the client machine as a black box,
                 thus ignoring the details of intra-machine
                 communication and staying clear of specific
                 environments such as OO. We propose a generic,
                 intuitively appealing principle for the sequential
                 design of client requests that allows a designer to
                 systematically work around latency to meet
                 response-time requirements. Applicability of this
                 principle is shown using some simple but realistic
                 examples of business transactions.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Yuan:2000:OCH,
  author =       "Xiaodong Yuan and Ying Feng",
  title =        "The optimization of class hierarchy in object-oriented
                 design",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "56--59",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346073",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Constructing class hierarchies is an important step in
                 object-oriented design, but no formal and effective
                 methods of optimizing class hierarchies were previously
                 established. In this paper, we first divide the
                 relationship between object sets into four categories:
                 inclusion, superposition, separation, and cross. Then
                 the genres of inheritance are discussed from the point
                 of view of object set. Following that, we introduce the
                 concept of maximal uncrossed set used to optimize a
                 class hierarchy. Through finding all of these maximal
                 uncrossed sets, we present the method and steps of
                 constructing a reasonable, clear, and complete class
                 hierarchy. Various representations of inheritance
                 relationship in a class hierarchy diagram and a
                 recursion algorithm to get all the maximal uncrossed
                 sets are also provided in this paper.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Han:2000:CSO,
  author =       "Yan Han and Xu Chun-Gen and Zhang Gong-Xuan and Liu
                 Feng-Yu",
  title =        "Constraint specification for object model of access
                 control based on role",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "60--63",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346074",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Constraint specifications for access control organize
                 a set of constraints to control human-computer
                 interaction for users to perform their duties securely
                 and efficiently. Constraint specifications are
                 imperative for the access control and security
                 management of large and complex multi-user interactive
                 applications. Existing specifications of Role-based
                 Access Control are incomplete and complicated. This
                 paper proposes a framework of well-defined constraint
                 specifications for developers to build
                 application-level access control based on users' roles.
                 They ensure that each role is configured with
                 consistent privileges, each actor is authorized to
                 proper roles and then each actor can activate and play
                 his authorized roles without interest conflicts. These
                 formal specifications are consistent and inferable,
                 complete and simplified, abundant and scalable for
                 diversified multi-user applications.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Han:2000:OOM,
  author =       "Yan Han and Liu Fengyu and Zhang Hong",
  title =        "An object-oriented model of access control based on
                 role",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "2",
  pages =        "64--68",
  month =        mar,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/346057.346075",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:56 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "At present, majority access control models mainly deal
                 with data-protection at the back-end of applications.
                 However, they are not applicable for large and complex
                 multi-user applications. Though Object Technology has
                 turned into one of the mainstream approaches for large
                 and complex applications development, it still lacks a
                 general model of application-level access control.
                 While the existing models of role-based access control
                 could simplify privilege management, they neglect the
                 dynamic features of activated roles. This paper
                 proposes an object-oriented model in Unified Modeling
                 Language supporting application-level access control
                 based on users' roles. In the model, an interface type
                 is provided containing a set of operations as user
                 services, which are authorized to users via their
                 roles. To represent the activated roles, Role-Playing
                 is introduced, and it is modeled as an active class.
                 Every object of Role-Playing runs in particular
                 context, which restrict users' rights dynamically and
                 control users' interaction actively. The model is
                 suitable for multi-user interactive computing and
                 distributed information-processing systems.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Notkin:2000:SNS,
  author =       "David Notkin",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "5--10",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505865",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2000:RPCc,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "15--23",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505866",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Conradi:2000:SES,
  author =       "Reidar Conradi",
  title =        "Summary from {7th European Software Process Workshop
                 (EWSPT'7), Kaprun near Salzburg, 21--25 Feb. 2000}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "23--23",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505868",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kumar:2000:SAM,
  author =       "Bharath M. Kumar and R. Lakshminarayanan and Y. N.
                 Srikant",
  title =        "A study of automatic migration of programs across the
                 {Java} event models",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "24--29",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505870",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Evolution of a framework forces a change in the design
                 of an application, which is based on the framework. The
                 same is the case when the Java event model changed from
                 the Inheritance model to the Event Delegation model. We
                 summarize our experiences when attempting an automatic
                 and elegant migration across the event models. Further,
                 we also necessitate the need for extra documentation in
                 patterns that will help programs evolve better.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Lather:2000:SAS,
  author =       "Anu Singh Lather and Shakti Kumar and Yogesh Singh",
  title =        "Suitability assessment of software developers: a fuzzy
                 approach",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "30--31",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505871",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The right selection of software personnels helps keep
                 project cost low, deliver better quality software and
                 avoids the schedule slippage of a software project. We
                 have identified the 3 most essential
                 abilities/aptitudes which can decide comparative merit
                 of the software developers. These are Verbal Reasoning
                 (VR), Numerical Ability (NA) and Abstract Reasoning
                 (AR). As a fuzzy model is a best choice for managing
                 ambiguous, doubtful, contradicting and diverging
                 opinions we propose a three input and single output
                 fuzzy model to unify the crisp output of the 3 tests
                 (i.e., VR, NA, AR). The output of the proposed fuzzy
                 model a single numerical value that decides the merit
                 of a developer based on the scores he obtains in VR, NA
                 and AR.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Chen:2000:EME,
  author =       "Wang Chen and Zhou Ying and Zhang Defu",
  title =        "An efficient method for expressing active object in
                 {C++}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "32--35",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505872",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Object-Oriented technology is fit for the construction
                 of open systems. However, how to express distributed or
                 concurrent objects has not been resolved in nowadays OO
                 language. The active object concept is one kind of
                 generalization of concurrent or distributed objects. We
                 analyzed the characters of active objects in detail and
                 propose an efficient method to express active behaviors
                 in Object-Oriented language such as C++. What we lay
                 stress on is to express active objects' two major
                 features: concurrency and cooperative, especially the
                 latter. The reusability of active objects is emphasized
                 as well.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{PanYunhe:2000:AOA,
  author =       "Zhou Yonglin PanYunhe",
  title =        "Agent-oriented analysis and modeling",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "36--40",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505873",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Traditional requirements engineering (RE) are facing
                 challenge. With the continuous change of application
                 environment and software market, as well as the
                 development of new design approaches (e.g. software
                 architecture and component-based software engineering),
                 RE should also move its eyes from product-oriented and
                 function-centered view to problem-domain-oriented and
                 structure-centered view. In this paper we proposed a
                 new analysis and modeling approach: Agent-Oriented
                 Approach (AOA). AOA is problem-domain-oriented and
                 implementation-independent. It searches for a solution
                 strategy for a families of problems rather than a
                 special software requirements specification(SRS). It
                 focuses on entities with active behavior in problem
                 domain and pay attention to their interaction. It can
                 describe parallel and distributed entities commonly
                 existing in problem domains and it is more stable and
                 reuseful than SRS.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kokol:2000:ASS,
  author =       "Peter Kokol and Vili Podgorelec and Ana Isabel Cardoso
                 and Francis Dion",
  title =        "Assessing the state of the software process
                 development using the chaos theory",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "41--43",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505874",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Computer software and the software development process
                 belong to the class of complex systems. As a
                 consequence software development process can be
                 analysed by techniques and concepts used in the chaos
                 theory. It is the aim of this paper to present how we
                 can use the chaos theory (in particular the Logistic
                 map concept) to identify the state of the software
                 development process.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kokol:2000:IES,
  author =       "Peter Kokol and Vili Podgorelec and Francis Dion and
                 Rich de Loach",
  title =        "Intellectual energy in software design",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "44--45",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505875",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In the paper we use the sequential study approach to
                 empirical software engineering to research a novel idea
                 about assessing the intellectual energy built into the
                 software products. The study showed that we can use
                 product of Function Points and {\alpha} metric to
                 calculate both the intellectual energy reflected in the
                 software and the intellectual energy spend during the
                 software design.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Milicev:2000:COG,
  author =       "Dragan Milicev",
  title =        "Customizable output generation in modeling
                 environments using pipelined domains",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "46--50",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505876",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Domain-specific modeling and metamodeling environments
                 most often base their output generation capability on
                 wizards, output templates, grammar-based transformers,
                 or hard-coded output generators. The complexity of the
                 specification process for such generators, and their
                 dependence on the domain do not encourage
                 customization, flexibility, and reuse. This paper
                 proposes a solution to this problem. In the proposed
                 approach, the domains are (meta) modeled using the
                 standard object-oriented paradigm. Second, the
                 generation of a model in the target domain from a model
                 in the source domain is specified using extended UML
                 object diagrams that allow specification of
                 conditional, repetitive, and sequential creation of
                 instances of the target domain's abstractions. Finally,
                 the transformation of models may be performed in a
                 pipelined fashion, where each domain model and mapping
                 may be either created from the scratch or reused from
                 the repository. This approach allows more efficient,
                 incremental building of more abstract domains and their
                 mapping into less abstract domains, because each
                 transformation step is much less complicated to
                 specify, maintain, and reuse. Furthermore, by simple
                 choosing another pipeline, different versions of the
                 ultimate implementation from the same initial
                 high-level, user-defined model may be obtained
                 automatically. A prototypical supporting tool has been
                 implemented and briefly presented in the paper.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mondal:2000:CMW,
  author =       "Sakib Abdul Mondal and Kingshuk Das Gupta",
  title =        "Choosing a middleware for web-integration of a legacy
                 application",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "50--53",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505877",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Business applications today often face two
                 contradictory constraints: they have to deal with
                 heterogeneous platforms and at the same time meet the
                 quality requirements. A larger number of middleware
                 products are available to meet the first objective. An
                 architect invariably faces a problem of picking up the
                 right kind of middleware for the problem at hand.
                 Fortunately, the second objective of quality
                 requirements help an architect narrow down the choices
                 of middleware. In this article, we demonstrate this
                 fact through a project of web-integration of a legacy
                 invoicing system.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Zhao:2000:SQR,
  author =       "Luyin Zhao and Sebastian Elbaum",
  title =        "A survey on quality related activities in open
                 source",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "54--57",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505878",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Anantharam:2000:MS,
  author =       "Parasuram Anantharam",
  title =        "Modelling systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "58--58",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505880",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Anderson:2000:DSS,
  author =       "Tom Anderson",
  title =        "The distributed {Smalltalk} survival guide",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "58--58",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505881",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Benedicenti:2000:RSO,
  author =       "Luigi Benedicenti",
  title =        "Rethinking smart objects: building artificial
                 intelligence with objects",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "59--59",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505882",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Boyer:2000:TPI,
  author =       "Kenneth W. {Boyer, Jr.}",
  title =        "Test process improvement: a practical step-by-step
                 guide to structured testing",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "59--60",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505883",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Caci:2000:TOO,
  author =       "Claude Caci",
  title =        "Testing object-oriented systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "60--61",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505884",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Claussen:2000:TPL,
  author =       "Peter Claussen",
  title =        "Theories of programming languages",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "61--62",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505885",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Claussen:2000:CPM,
  author =       "Peter Claussen",
  title =        "Concurrent programming in {ML}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "62--63",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505886",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Dinishak:2000:OIF,
  author =       "Ron Dinishak",
  title =        "The optimal implementation of functional programming
                 languages",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "63--63",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505887",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Liu:2000:TRA,
  author =       "Chang Liu",
  title =        "Term rewriting and all that",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "63--63",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505888",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Nedunuri:2000:FAP,
  author =       "Srinivas Nedunuri",
  title =        "The functional approach to programming",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "63--65",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505889",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Varma:2000:AST,
  author =       "Tathagat Varma",
  title =        "Automated software testing: introduction, management
                 and performance",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "65--65",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505890",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Weber-Wulff:2000:OOS,
  author =       "Debora Weber-Wulff",
  title =        "Object-oriented software engineering: conquering
                 complex and changing systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "65--66",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505891",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Green:2000:STA,
  author =       "Bradley S. Green",
  title =        "Software test automation",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "3",
  pages =        "66--66",
  month =        may,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505863.505892",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:57 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2000:RPCd,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "4",
  pages =        "7--11",
  month =        jul,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/352342.352344",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:59 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Doernhoefer:2000:SNSb,
  author =       "Mark Doernhoefer",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "4",
  pages =        "12--20",
  month =        jul,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/352342.352345",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:59 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Schmietendorf:2000:MBA,
  author =       "Andreas Schmietendorf and Reiner Dumke and Erik
                 Foltin",
  title =        "Metrics based asset assessment",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "4",
  pages =        "51--55",
  month =        jul,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/352342.352347",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:59 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The re-use of software components during the software
                 development is considered to be an important factor to
                 improve the quality and productivity and thus to reduce
                 the time to market of the final product. In this paper
                 we will present a proposal for a description model for
                 re-usable components. We will also present the results
                 of case studies concerned with both telecom specific
                 and ``generic'' IT-components. These components have
                 been examined using the description model and a further
                 set of (empirical) criterions. Based on the results a
                 model concept for the empirical assessment of
                 JavaBeans, which is currently under development, is
                 presented.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bojic:2000:REU,
  author =       "Dragan Bojic and Dusan Velasevic",
  title =        "Reverse Engineering of Use Case Realizations in
                 {UML}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "4",
  pages =        "56--61",
  month =        jul,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/352342.2317216",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:59 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We propose a novel technique for recovering certain
                 elements of the UML model of a software system. These
                 include relationships between use cases as well as
                 class roles in collaborations that realize each use
                 case, identifying common functionality and thus
                 establishing a hierarchical view of the model. The
                 technique is based on dynamic analysis of the system
                 for the selected test cases that cover relevant use
                 cases. The theory of formal concept analysis is applied
                 to obtain classification of model elements, obtained by
                 a static analysis of code, in terms of use case
                 realizations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Cimpan:2000:OLS,
  author =       "Sorana C{\^\i}mpan and Flavio Oquendo",
  title =        "{OMEGA}: a language and system for on-line monitoring
                 of software-intensive processes",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "4",
  pages =        "62--68",
  month =        jul,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/352342.352350",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:59 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper presents an environment for monitoring
                 software-intensive processes: the Omega environment
                 (Omega stands for On-line Monitoring Environment:
                 General and Adaptable). The environment provides the
                 language Omega/MDL (Monitoring Definition Language) for
                 defining monitoring models as well as a mechanism for
                 the execution of such models Omega/EM (Execution
                 Mechanism). The executing monitoring models (i.e.
                 monitoring systems), observe the subject process and
                 detect deviations between it and an expected behavior,
                 i.e. indicated by the process model instantiation. For
                 monitoring modeling, Omega proposes a novel approach
                 based on fuzzy logic. This approach allows to establish
                 the level of conformance between the process enactment
                 and the process model for different aspects of the
                 process, like progress, cost, structure (order between
                 activities), etc. The use of fuzzy logic enables the
                 system to cope with uncertain and imprecise
                 information.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Manolescu:2000:BRP,
  author =       "Dragos Manolescu",
  title =        "Book Review: {{\booktitle{Production Workflow-Concepts
                 and Techniques}} by Frank Leymann and Dieter Roller
                 (Prentice Hall PTR, 2000, ISBN 0-13-02175-0, 479
                 pp.)}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "4",
  pages =        "69",
  month =        jul,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/352342.",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:13:59 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Pincus:2000:ANF,
  author =       "Jon Pincus",
  title =        "Analysis is necessary, but far from sufficient
                 (abstract only): Experiences building and deploying
                 successful tools for developers and testers",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "1--1",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.347826",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Why are there so few successful ``real-world''
                 programming and testing tools based on academic
                 research? This talk focuses on program analysis tools,
                 and proposes a surprisingly simple explanation with
                 interesting ramifications. For a tool aimed at
                 developers or testers to be successful, people must use
                 it --- and must use it to help accomplish their
                 existing tasks, rather than as an end in itself. If the
                 tool does not help them get their job done, or the
                 effort to learn and/or use the tool is too great, users
                 will not perceive enough value; the tool will not get
                 significant usage, even if it is free. This talk
                 focuses on the often-overlooked consequences of this
                 seemingly basic statement in two major areas: program
                 analysis, and the work beyond core analysis that must
                 be done to make a successful tool. Examples will be
                 drawn from tools that have been successfully used in
                 industry (sold commercially, and developed for internal
                 use).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bhargavan:2000:VFA,
  author =       "Karthikeyan Bhargavan and Carl A. Gunter and Moonjoo
                 Kim and Insup Lee and Davor Obradovic and Oleg Sokolsky
                 and Mahesh Viswanathan",
  title =        "{Verisim}: Formal analysis of network simulations",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "2--13",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.347833",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Why are there so few successful ``real-world''
                 programming and testing tools based on academic
                 research? This talk focuses on program analysis tools,
                 and proposes a surprisingly simple explanation with
                 interesting ramifications. For a tool aimed at
                 developers or testers to be successful, people must use
                 it --- and must use it to help accomplish their
                 existing tasks, rather than as an end in itself. If the
                 tool does not help them get their job done, or the
                 effort to learn and/or use the tool is too great, users
                 will not perceive enough value; the tool will not get
                 significant usage, even if it is free. This talk
                 focuses on the often-overlooked consequences of this
                 seemingly basic statement in two major areas: program
                 analysis, and the work beyond core analysis that must
                 be done to make a successful tool. Examples will be
                 drawn from tools that have been successfully used in
                 industry (sold commercially, and developed for internal
                 use).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Jackson:2000:FBC,
  author =       "Daniel Jackson and Mandana Vaziri",
  title =        "Finding bugs with a constraint solver",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "14--25",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.383378",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Lev-Ami:2000:PSA,
  author =       "Tal Lev-Ami and Thomas Reps and Mooly Sagiv and
                 Reinhard Wilhelm",
  title =        "Putting static analysis to work for verification: a
                 case study",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "26--38",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348031",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A method for finding bugs in code is presented. For
                 given small numbers j and k, the code of a procedure is
                 translated into a relational formula whose models
                 represent all execution traces that involve at most j
                 heap cells and k loop iterations. This formula is
                 conjoined with the negation of the procedure's
                 specification. The models of the resulting formula,
                 obtained using a constraint solver, are
                 counterexamples: executions of the code that violate
                 the specification. The method can analyze millions of
                 executions in seconds, and thus rapidly expose quite
                 subtle flaws. It can accommodate calls to procedures
                 for which specifications but no code is available. A
                 range of standard properties (such as absence of null
                 pointer dereferences) can also be easily checked, using
                 predefined specifications.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Buy:2000:ATC,
  author =       "Ugo Buy and Alessandro Orso and Mauro Pezze",
  title =        "Automated Testing of Classes",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "39--48",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348870",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Programs developed with object technologies have
                 unique features that often make traditional testing
                 methods inadequate. Consider, for instance, the
                 dependence between the state of an object and the
                 behavior of that object: The outcome of a method
                 executed by an object often depends on the state of the
                 object when the method is invoked. It is therefore
                 crucial that techniques for testing of classes exercise
                 class methods when the method's receiver is in
                 different states. The state of an object at any given
                 time depends on the sequence of messages received by
                 the object up to that time. Thus, methods for testing
                 object-oriented software should identify sequences of
                 method invocations that are likely to uncover potential
                 defects in the code under test. However, testing
                 methods for traditional software do not provide this
                 kind of information. In this paper, we use data flow
                 analysis, symbolic execution, and automated deduction
                 to produce sequences of method invocations exercising a
                 class under test. Since the static analysis techniques
                 that we use are applied to different subproblems, the
                 method proposed in this paper can automatically
                 generate information relevant to testing even when
                 symbolic execution and automated deduction cannot be
                 completed successfully.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Souter:2000:OST,
  author =       "Amie L. Souter and Lori L. Pollock",
  title =        "{OMEN}: a strategy for testing object-oriented
                 software",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "49--59",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348871",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper presents a strategy for structural testing
                 of object-oriented software systems with possibly
                 unknown clients and unknown information about invoked
                 methods. By exploiting the combined points-to and
                 escape analysis developed for compiler optimization,
                 our testing paradigm does not require a whole program
                 representation to be in memory simultaneously for
                 testing analysis. Potential effects from outside the
                 component under test are easily identified and reported
                 to the tester. As client and server methods become
                 known, the graph representation of object relationships
                 is easily extended, allowing the computation of test
                 tuples to be performed in a demand-driven manner,
                 without requiring unnecessary computation of test
                 tuples based on predictions of potential clients.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Hartmann:2000:UBI,
  author =       "Jean Hartmann and Claudio Imoberdorf and Michael
                 Meisinger",
  title =        "{UML-Based} integration testing",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "60--70",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348872",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Increasing numbers of software developers are using
                 the Unified Modeling Language (UML) and associated
                 visual modeling tools as a basis for the design and
                 implementation of their distributed, component-based
                 applications. At the same time, it is necessary to test
                 these components, especially during unit and
                 integration testing. At Siemens Corporate Research, we
                 have addressed the issue of testing components by
                 integrating test generation and test execution
                 technology with commercial UML modeling tools such as
                 Rational Rose; the goal being a design-based testing
                 environment. In order to generate test cases
                 automatically, developers first define the dynamic
                 behavior of their components via UML Statecharts,
                 specify the interactions amongst them and finally
                 annotate them with test requirements. Test cases are
                 then derived from these annotated Statecharts using our
                 test generation engine and executed with the help of
                 our test execution tool. The latter tool was developed
                 specifically for interfacing to components based on
                 COM/DCOM and CORBA middleware. In this paper, we
                 present our approach to modeling components and their
                 interactions, describe how test cases are derived from
                 these component models and then executed to verify
                 their conformant behavior. We outline the
                 implementation strategy of our TnT environment and use
                 it to evaluate our approach by means of a simple
                 example.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Hamlet:2000:STP,
  author =       "Dick Hamlet",
  title =        "On subdomains: Testing, profiles, and components",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "71--76",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348873",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Subdomains of a program's input space are a concept
                 around which ideas about testing can be organized. This
                 paper considers the questions, ``What are the best
                 subdomains for testing to detecting failures defining
                 operational profiles measuring component
                 reliability?''",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Peters:2000:RBM,
  author =       "Dennis K. Peters and David L. Parnas",
  title =        "Requirements-based monitors for real-time systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "77--85",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348874",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Before designing safety- or mission-critical real-time
                 systems, a specification of the required behaviour of
                 the system should be produced and reviewed by domain
                 experts. After the system has been implemented, it
                 should be thoroughly tested to ensure that it behaves
                 correctly. This is best done using a monitor, a system
                 that observes the behaviour of a target system and
                 reports if that behaviour is consistent with the
                 requirements. Such a monitor can be used both as an
                 oracle during testing and as a supervisor during
                 operation. Monitors should be based on the documented
                 requirements of the system. If the target system is
                 required to monitor or control real-valued quantities,
                 then the requirements, which are expressed in terms of
                 the monitored and controlled quantities, will allow a
                 range of behaviours to account for errors and
                 imprecision in observation and control of these
                 quantities. Even if the controlled variables are
                 discrete valued, the requirements must specify the
                 timing tolerance. Because of the limitations of the
                 devices used by the monitor to observe the
                 environmental quantities, there is unavoidable
                 potential for false reports, both negative and
                 positive. This paper discusses design of monitors for
                 real-time systems, and examines the conditions under
                 which a monitor will produce false reports. We describe
                 the conclusions that can be drawn when using a monitor
                 to observe system behaviour.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kolano:2000:CSA,
  author =       "Paul Z. Kolano and Richard A. Demmerer",
  title =        "Classification schemes to aid in the analysis of
                 real-time systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "86--95",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348875",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper presents three sets of classification
                 schemes for processes, properties, and transitions that
                 can be used to assist in the analysis of real-time
                 systems. These classification schemes are discussed in
                 the context of ASTRAL, which is a formal specification
                 language for real-time systems. Eight testbed systems
                 were specified in ASTRAL, and their proofs were
                 performed to determine proof patterns that occur most
                 often. The specifications were then examined in an
                 attempt to derive specific characteristics that could
                 be used to statically identify each pattern within a
                 specification. Once the classifications were obtained,
                 they were then used to provide systematic guidance for
                 analyzing real-time systems by directing the prover to
                 the proof techniques most applicable to each proof
                 pattern. This paper presents the set of classification
                 schemes that were developed and discusses how they can
                 be used to assist the proof process.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Cobleigh:2000:VPP,
  author =       "Jamieson M. Cobleigh and Lori A. Clark and Leon J.
                 Osterweil",
  title =        "Verifying properties of process definitions",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "96--101",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348876",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "It seems important that the complex processes that
                 synergize humans and computers to solve widening
                 classes of societal problems be subjected to rigorous
                 analysis. One approach is to use a process definition
                 language to specify these processes and to then use
                 analysis techniques to evaluate these definitions for
                 important correctness properties. Because humans demand
                 flexibility in their participation in complex
                 processes, process definition languages must
                 incorporate complicated control structures, such as
                 various concurrency, choice, reactive control, and
                 exception mechanisms. The underlying complexity of
                 these control abstractions, however, often confounds
                 the users' intuitions as well as complicates any
                 analysis. Thus, the control abstraction complexity in
                 process definition languages presents analysis
                 challenges beyond those posed by traditional
                 programming languages. This paper explores some of the
                 difficulties of analyzing process definitions. We
                 explore issues arising when applying the FLAVERS finite
                 state verification system to processes written in the
                 Little-JIL process definition language and illustrate
                 these issues using a realistic auction example.
                 Although we employ a particular process definition
                 language and analysis technique, our results seem more
                 generally applicable.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Elbaum:2000:PTC,
  author =       "Sebastian Elbaum and Alexey G. Malishevsky and Gregg
                 Rothermel",
  title =        "Prioritizing test cases for regression testing",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "102--112",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348910",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Test case prioritization techniques schedule test
                 cases in an order that increases their effectiveness in
                 meeting some performance goal. One performance goal,
                 rate of fault detection, is a measure of how quickly
                 faults are detected within the testing process; an
                 improved rate of fault detection can provide faster
                 feedback on the system under test, and let software
                 engineers begin locating and correcting faults earlier
                 than might otherwise be possible. In previous work, we
                 reported the results of studies that showed that
                 prioritization techniques can significantly improve
                 rate of fault detection. Those studies, however, raised
                 several additional questions: (1) can prioritization
                 techniques be effective when aimed at specific modified
                 versions; (2) what tradeoffs exist between fine
                 granularity and coarse granularity prioritization
                 techniques; (3) can the incorporation of measures of
                 fault proneness into prioritization techniques improve
                 their effectiveness? This paper reports the results of
                 new experiments addressing these questions.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Hind:2000:WPA,
  author =       "Michael Hind and Anthony Pioli",
  title =        "Which pointer analysis should I use?",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "113--123",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348916",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "During the past two decades many different pointer
                 analysis algorithms have been published. Although some
                 descriptions include measurements of the effectiveness
                 of the algorithm, qualitative comparisons among
                 algorithms are difficult because of varying
                 infrastructure, benchmarks, and performance metrics.
                 Without such comparisons it is not only difficult for
                 an implementor to determine which pointer analysis is
                 appropriate for their application, but also for a
                 researcher to know which algorithms should be used as a
                 basis for future advances. This paper describes an
                 empirical comparison of the effectiveness of five
                 pointer analysis algorithms on C programs. The
                 algorithms vary in their use of control flow
                 information (flow-sensitivity) and alias data
                 structure, resulting in worst-case complexity from
                 linear to polynomial. The effectiveness of the analyses
                 is quantified in terms of compile-time precision and
                 efficiency. In addition to measuring the direct effects
                 of pointer analysis, precision is also reported by
                 determining how the information computed by the five
                 pointer analyses affects typical client analyses of
                 pointer information: Mod/Ref analysis, live variable
                 analysis and dead assignment identification, reaching
                 definitions analysis, dependence analysis, and
                 conditional constant propagation and unreachable code
                 identification. Efficiency is reported by measuring
                 analysis time and memory consumption of the pointer
                 analyses and their clients.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Frankl:2000:CDR,
  author =       "Phyllis G. Frankl and Yuetang Deng",
  title =        "Comparison of delivered reliability of branch, data
                 flow and operational testing: a case study",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "124--134",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348926",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Many analytical and empirical studies of software
                 testing effectiveness have used the probability that a
                 test set exposes at least one fault as the measure of
                 effectiveness. That measure is useful for evaluating
                 testing techniques when the goal of testing is to gain
                 confidence that the program is free from faults.
                 However, if the goal of testing is to improve the
                 reliability of the program (by discovering and removing
                 those faults that are most likely to cause failures
                 when the software is in the field) then the measure of
                 test effectiveness must distinguish between those
                 faults that are likely to cause failures and those that
                 are unlikely to do so. Delivered reliability was
                 previously introduced as a means of comparing testing
                 techniques in that setting. This paper empirically
                 compares reliability delivered by three testing
                 techniques, branch testing, the all-uses data flow
                 testing criterion, and operational testing. The subject
                 program is a moderate-sized C-program (about 10,000
                 LOC) produced by professional programmers and
                 containing naturally occurring faults.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Hildebrandt:2000:SFI,
  author =       "Ralf Hildebrandt and Andreas Zeller",
  title =        "Simplifying failure-inducing input",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "135--145",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348938",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Given some test case, a program fails. Which part of
                 the test case is responsible for the particular
                 failure? We show how our delta debugging algorithm
                 generalizes and simplifies some failing input to a
                 minimal test case that produces the failure. In a case
                 study, the Mozilla web browser crashed after 95 user
                 actions. Our prototype implementation automatically
                 simplified the input to 3 relevant user actions.
                 Likewise, it simplified 896 lines of HTML to the single
                 line that caused the failure. The case study required
                 139 automated test runs, or 35 minutes on a 500 MHz
                 PC.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Clarke:2000:FSV,
  author =       "Lori A. Clarke",
  title =        "Finite state verification (abstract only): an emerging
                 technology for validating software systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "146--146",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348946",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Ever since formal verification was first proposed in
                 the late sixties, the idea of being able to
                 definitively determine if a program meets its
                 specifications has been an appealing, but elusive,
                 goal. Although verification systems based on theorem
                 proving have improved considerably over the years, they
                 are still inherently undecidable and require
                 significant guidance from mathematically astute users.
                 The human effort required for formal verification is so
                 significant that it is usually only applied to the most
                 critical software components. Alternative approaches to
                 theorem proving based verification have also been under
                 development for some time. These approaches usually
                 restrict the problem domain in some way, such as
                 focusing on hardware descriptions, communication
                 protocols, or a limited specification language. These
                 restrictions allow the problem to be solved by using
                 reasoning algorithms that are guaranteed to terminate
                 and by representing the problem with a finite state
                 model, and thus these approaches have been called
                 finite state verification. Systems based on these
                 approaches are starting to be effectively applied to
                 interesting software systems and there is increasing
                 optimism that such approaches will become widely
                 applicable. In this presentation, I will overview some
                 of the different approaches to finite state
                 verification. In particular I will describe symbolic
                 model checking, integer necessary constraints, and
                 incremental data flow analysis approaches. The
                 strengths and weaknesses of these approaches will be
                 described. In addition, I will outline the major
                 challenges that must be addressed before finite state
                 verification will become a common tool for the typical
                 well-trained software engineer.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Chays:2000:FTD,
  author =       "David Chays and Saikat Dan and Phyllis G. Frankl and
                 Filippos I. Vokolos and Elaine J. Weyuker",
  title =        "A framework for testing database applications",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "147--157",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348954",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Database systems play an important role in nearly
                 every modern organization, yet relatively little
                 research effort has focused on how to test them. This
                 paper discusses issues arising in testing database
                 systems and presents an approach to testing database
                 applications. In testing such applications, the state
                 of the database before and after the user's operation
                 plays an important role, along with the user's input
                 and the system output. A tool for populating the
                 database with meaningful data that satisfy database
                 constraints has been prototyped. Its design and its
                 role in a larger database application testing tool set
                 are discussed.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Steven:2000:JCR,
  author =       "John Steven and Pravir Chandra and Bob Fleck and Andy
                 Podgurski",
  title =        "{jRapture}: a Capture\slash Replay tool for
                 observation-based testing",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "158--167",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.348993",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "We describe the design of jRapture: a tool for
                 capturing and replaying Java program executions in the
                 field. jRapture works with Java binaries (byte code)
                 and any compliant implementation of the Java virtual
                 machine. It employs a lightweight, transparent capture
                 process that permits unobtrusive capture of a Java
                 programs executions. jRapture captures interactions
                 between a Java program and the system, including GUI,
                 file, and console inputs, among other types, and on
                 replay it presents each thread with exactly the same
                 input sequence it saw during capture. In addition,
                 jRapture has a profiling interface that permits a Java
                 program to be instrumented for profiling --- after its
                 executions have been captured. Using an XML-based
                 profiling specification language a tester can specify
                 various forms of profiling to be carried out during
                 replay.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Woodward:2000:TFS,
  author =       "Martin R. Woodward and Zuhoor A. Al-Khanjari",
  title =        "Testability, fault size and the domain-to-range ratio:
                 an eternal triangle",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "168--172",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.349016",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A number of different concepts have been proposed
                 that, loosely speaking, revolve around the notion of
                 software testability. Indeed, the concept of
                 testability itself has been interpreted in a variety of
                 ways by the software community. One interpretation is
                 concerned with the extent of the modifications a
                 program component requires, in terms of its input and
                 output variables, so that the entire behaviour of the
                 component is observable and controllable. Another
                 interpretation is the ease with which faults, if
                 present in a program, can be revealed by the testing
                 process and the propagation, infection and execution
                 (PIE) model has been proposed as a method of estimating
                 this. It has been suggested that this particular
                 interpretation of testability might be linked with the
                 metric domain-to-range ratio (DRR), i.e. the ratio of
                 the cardinality of the set of all inputs (the domain)
                 to the cardinality of the set of all outputs (the
                 range). This paper reports work in progress exploring
                 some of the connections between the concepts mentioned.
                 In particular, a simple mathematical link is
                 established between domain-to-range ratio and the
                 observability and controllability aspects of
                 testability. In addition, the PIE model is
                 re-considered and a relationship with fault size is
                 observed. This leads to the suggestion that it might be
                 more straightforward to estimate PIE testability by an
                 adaptation of traditional mutation analysis. The latter
                 suggestion exemplifies the main goals of the work
                 described here, namely to seek greater understanding of
                 testability in general and, ultimately, to find easier
                 ways of determining it.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Schroeder:2000:BBT,
  author =       "Patrick J. Schroeder and Bogdan Korel",
  title =        "Black-box test reduction using input-output analysis",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "173--177",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.349042",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Test reduction is an important issue in black-box
                 testing. The number of possible black-box tests for any
                 non-trivial software application is extremely large.
                 For the class of programs with multiple inputs and
                 outputs, the number of possible tests grows very
                 rapidly as combinations of input test data are
                 considered. In this paper, we introduce an approach to
                 test reduction that uses automated input-output
                 analysis to identify relationships between program
                 inputs and outputs. Our initial experience with the
                 approach has shown that it can significantly reduce the
                 number of black-box tests.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Wittenberg:2000:PTC,
  author =       "Craig H. Wittenberg",
  title =        "Progress in testing component-based software (abstract
                 only)",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "178",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.349099",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Software components enable practical reuse of software
                 parts and amortization of investments over multiple
                 applications. Each part or component is well defined
                 and independently deployable. Composition is the key
                 technique by which systems of software components are
                 constructed. The composition step can be done before or
                 after the delivery of the system. It is this late
                 composition (or at least the possibility of it) which
                 yields the greatest challenges from a testing
                 standpoint. That is, a component-based application may
                 be composed out of parts that were never tested
                 together. Thus the most useful and reliable parts are
                 those which have been tested independently in as many
                 ways as possible. The Component Applications Group in
                 Microsoft Research is developing tools, techniques, and
                 a large component library to enable the development of
                 sophisticated office, home and web-based applications.
                 For the past three and a half years we have been
                 working on two main efforts. First, we have created a
                 prototype of a highly factored (i.e., customizable,
                 flexible, etc.) architecture for the construction of
                 the UI of applications. Our work can be applied to
                 traditional window-ed applications as well as to the
                 look and feel of Web applications. During this effort
                 we have developed a variety of design techniques, two
                 different composition mechanisms, a visual tool for
                 compositions, and have built several application
                 prototypes out of the same set of components. Most of
                 our time has been spent on tools and techniques for
                 building reliable components. Certain pieces of our
                 infrastructure formed the domain in which we tried out
                 our ideas. The first component we tested was one of our
                 composition mechanisms. That was followed by the
                 testing of a dynamic, binary, aspect composition
                 mechanism and of a particularly generic implementation
                 of collection classes. Our well-factored, versioned
                 build system will also be described. All of the results
                 of our work are compatible with COM. The talk will
                 focus on our key lessons in composition, specification,
                 processes, and tools with a particular emphasis on our
                 test harness and our results in testing. A discussion
                 of the last few bugs found in each of several projects
                 should prove interesting. Some comparisons will be made
                 with other projects inside and outside Microsoft. Since
                 we can only claim progress, not perfection, there are
                 still many areas for further research. As an example,
                 we are looking at ways we can use language annotations
                 to simplifying whole classes of problems (e.g., tests
                 for reentrancy). One of the points here is that we can
                 improve our ability to create reliable components by
                 improving the languages used to implement them (like
                 Java has popularized the use of a garbage collector).
                 Another example is that we hope to improve the
                 automation of the sequencing of test cases. Finally, as
                 a tribute to the power of standing on other's
                 shoulders, many of the roots of our ideas will be
                 traced to techniques published elsewhere. You might say
                 we only composed together many already good ideas. Our
                 group includes people who developed COM itself (myself
                 and Tony Williams), many people from within Microsoft
                 who have delivered successful component-based products
                 (e.g., in Visual Studio), and world-renowned
                 component-ologist (:-) Clemens Szyperski who wrote
                 Component Software: Beyond Object-Oriented
                 Programming.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Dill:2000:MCJ,
  author =       "David Dill",
  title =        "Model checking {Java} programs (abstract only)",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "179",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.349113",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Automatic state exploration tools (model checkers)
                 have had some success when applied to protocols and
                 hardware designs, but there are fewer success stories
                 about software. This is unfortunate, since the software
                 problem is worsening even faster than the hardware and
                 protocol problems. Model checking of concurrent
                 programs is especially interesting, because they are
                 notoriously difficult to test, analyze, and debug by
                 other methods. This talk will be a description of our
                 initial efforts to check Java programs using a model
                 checker. The model checker supports dynamic allocation,
                 thread creation, and recursive procedures (features
                 that are not necessary for hardware verification), and
                 has some special optimizations and checks tailored to
                 multi-threaded Java program. I will also discuss some
                 of the challenges for future efforts in this area.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Nanda:2000:SCP,
  author =       "Mangala Gowri Nanda and S. Ramesh",
  title =        "Slicing concurrent programs",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "180--190",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.349121",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Slicing is a well-known program analysis technique for
                 analyzing sequential programs and found useful in
                 debugging, testing and reverse engineering. This paper
                 extends the notion of slicing to concurrent programs
                 with shared memory, interleaving semantics and mutual
                 exclusion. Interference among concurrent threads or
                 processes complicates the computation of slices of
                 concurrent programs. Further, unlike slicing of
                 sequential programs, a slicing algorithm for concurrent
                 programs needs to differentiate between
                 loop-independent data dependence and certain
                 loop-carried data dependences. We show why previous
                 methods do not give precise solutions in the presence
                 of nested threads and loops and describe our solution
                 that correctly and efficiently computes precise slices.
                 Though the complexity of this algorithm is exponential
                 on the number of threads, a number of optimizations are
                 suggested. Using these optimizations, we are able to
                 get near linear behavior for many practical concurrent
                 programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Siegel:2000:IPI,
  author =       "Stephen F. Siegel and George S. Avrunin",
  title =        "Improving the precision of {INCA} by preventing
                 spurious cycles",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "191--200",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.349130",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The Inequality Necessary Condition Analyzer (INCA) is
                 a finite-state verification tool that has been able to
                 check properties of some very large concurrent systems.
                 INCA checks a property of a concurrent system by
                 generating a system of inequalities that must have
                 integer solutions if the property can be violated.
                 There may, however, be integer solutions to the
                 inequalities that do not correspond to an execution
                 violating the property. INCA thus accepts the
                 possibility of an inconclusive result in exchange for
                 greater tractability. We describe here a method for
                 eliminating one of the two main sources of these
                 inconclusive results.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Schulz:2000:TAD,
  author =       "Daniel Schulz and Frank Mueller",
  title =        "A thread-aware debugger with an open interface",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "5",
  pages =        "201--211",
  month =        sep,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/347636.349141",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:00 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "While threads have become an accepted and standardized
                 model for expressing concurrency and exploiting
                 parallelism for the shared-memory model, debugging
                 threads is still poorly supported. This paper
                 identifies challenges in debugging threads and offers
                 solutions to them. The contributions of this paper are
                 threefold. First, an open interface for debugging as an
                 extension to thread implementations is proposed.
                 Second, extensions for thread-aware debugging are
                 identified and implemented within the Gnu Debugger to
                 provide additional features beyond the scope of
                 existing debuggers. Third, an active debugging
                 framework is proposed that includes a
                 language-independent protocol to communicate between
                 debugger and application via relational queries
                 ensuring that the enhancements of the debugger are
                 independent of actual thread implementations. Partial
                 or complete implementations of the interface for
                 debugging can be added to thread implementations to
                 work in unison with the enhanced debugger without any
                 modifications to the debugger itself. Sample
                 implementations of the interface for debugging have
                 shown its adequacy for user-level threads, kernel
                 threads and mixed thread implementations while
                 providing extended debugging functionality at improved
                 efficiency and portability at the same time.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{DeMillo:2000:SDN,
  author =       "Richard A. DeMillo",
  title =        "Software development for next generation communication
                 networks",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "1",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355047",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Even casual observes have to notice the dramatic
                 changes in the telecommunications industry that have
                 taken place in the last five years. Giant companies
                 split, merge and are sometimes displaced by newer ones
                 that did not exist a decade ago. The business of
                 running the mighty circuit-switched telephone netwok is
                 under constant assault on one side from packet networks
                 and on the other side from the bewildering array of
                 wireless networks. Service providers compete for
                 customer sometimes with no network infrastructure at
                 all.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Robillard:2000:DRJ,
  author =       "Martin P. Robillard and Gail C. Murphy",
  title =        "Designing robust {Java} programs with exceptions",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "2--10",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355046",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Exception handling mechanisms are intended to help
                 developers build robust systems. Although an exception
                 handling mechanism provides a basis for structuring
                 source code dealing with unusual situations, little
                 information is available to help guide a developer in
                 the appropriate application of the mechanism. In our
                 experience, this lack of guidance leads to complex
                 exception structures. In this paper, we reflect upon
                 our experiences using the Java exception handling
                 mechanism. Based on these experiences, we discuss two
                 issues we believe underlie the difficulties
                 encountered: exceptions are a global design problem,
                 and exception sources are often difficult to predict in
                 advance. We then describe a design approach, based on
                 work by Litke for Ada programs, which we have used to
                 simplify exception structure in existing Java
                 programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Hollingsworth:2000:ERU,
  author =       "Joseph E. Hollingsworth and Lori Blankenship and Bruce
                 W. Weide",
  title =        "Experience report: using {RESOLVE\slash C++} for
                 commercial software",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "11--19",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355048",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Academic research sometimes suffers from the ``ivory
                 tower'' problem: ideas that sound good in theory do not
                 necessarily work well in practice. An example of
                 research that potentially could impact practice over
                 the next few years is a novel set of component-based
                 software engineering design principles, known as the
                 RESOLVE discipline. This discipline has been taught to
                 students for several years [23], and previous papers
                 (e.g., [24]) have reported on student-sized software
                 projects constructed using it. Here, we report on a
                 substantial commercial product family that was
                 engineered using the same principles --- an application
                 that we designed, built, and continue to maintain for
                 profit, not as part of a research project. We discuss
                 the impact of adhering to a very prescriptive set of
                 design principles and explain our experience with the
                 resulting applications. Lessons learned should benefit
                 others who might be considering adopting such a
                 component-based software engineering discipline in the
                 future.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Behrends:2000:UMA,
  author =       "Reimer Behrends and R. E. Kurt Stirewalt",
  title =        "The universe model: an approach for improving the
                 modularity and reliability of concurrent programs",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "20--29",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355049",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We present the universe model, a new approach to
                 concurrency management that isolates concurrency
                 concerns and represents them in the modular interface
                 of a component. This approach improves program
                 comprehension, module composition, and reliability for
                 concurrent systems. The model is founded on
                 designer-specified invariant properties, which declare
                 a component's dependencies on other concurrent
                 components. Process scheduling is then automatically
                 derived from these invariants. We illustrate the
                 advantages of this approach by applying it to a
                 real-world example.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Memon:2000:ATO,
  author =       "Atif M. Memon and Martha E. Pollack and Mary Lou
                 Soffa",
  title =        "Automated test oracles for {GUIs}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "30--39",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355050",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Graphical User Interfaces (GUIs) are critical
                 components of today's software. Because GUIs have
                 different characteristics than traditional software,
                 conventional testing techniques do not apply to GUI
                 software. In previous work, we presented an approach to
                 generate GUI test cases, which take the form of
                 sequences of actions. In this paper we develop a test
                 oracle technique to determine if a GUI behaves as
                 expected for a given test case. Our oracle uses a
                 formal model of a GUI, expressed as sets of objects,
                 object properties, and actions. Given the formal model
                 and a test case, our oracle automatically derives the
                 expected state for every action in the test case. We
                 represent the actual state of an executing GUI in terms
                 of objects and their properties derived from the GUI's
                 execution. Using the actual state acquired from an
                 execution monitor, our oracle automatically compares
                 the expected and actual states after each action to
                 verify the correctness of the GUI for the test case. We
                 implemented the oracle as a component in our GUI
                 testing system, called Planning Assisted Tester for
                 grapHical user interface Systems (PATHS), which is
                 based on AI planning. We experimentally evaluated the
                 practicality and effectiveness of our oracle technique
                 and report on the results of experiments to test and
                 verify the behavior of our version of the Microsoft
                 WordPad's GUI.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Godefroid:2000:AST,
  author =       "Patrice Godefroid and Lalita J. Jagadeesan and Radha
                 Jagadeesan and Konstantin L{\"a}ufer",
  title =        "Automated systematic testing for constraint-based
                 interactive services",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "40--49",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355051",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Constraint-based languages can express in a concise
                 way the complex logic of a new generation of
                 interactive services for applications such as banking
                 or stock trading, that must support multiple types of
                 interfaces for accessing the same data. These include
                 automatic speech-recognition interfaces where inputs
                 may be provided in any order by users of the service.
                 We study in this paper how to systematically test
                 event-driven applications developed using such
                 languages. We show how such applications can be tested
                 automatically, without the need for any
                 manually-written test cases, and efficiently, by taking
                 advantage of their capability of taking unordered sets
                 of events as inputs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Butkevich:2000:CTS,
  author =       "Sergey Butkevich and Marco Renedo and Gerald
                 Baumgartner and Michal Young",
  title =        "Compiler and tool support for debugging object
                 protocols",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "50--59",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355052",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We describe an extension to the Java programming
                 language that supports static conformance checking and
                 dynamic debugging of object ``protocols,'' i.e.,
                 sequencing constraints on the order in which methods
                 may be called. Our Java protocols have a statically
                 checkable subset embedded in richer descriptions that
                 can be checked at run time. The statically checkable
                 subtype conformance relation is based on Nierstrasz'
                 proposal for regular (finite-state) process types, and
                 is also very close to the conformance relation for
                 architectural connectors in the Wright architectural
                 description language by Allen and Garlan. Richer
                 sequencing properties, which cannot be expressed by
                 regular types alone, can be specified and checked at
                 run time by associating predicates with object states.
                 We describe the language extensions and their
                 rationale, and the design of tool support for static
                 and dynamic checking and debugging.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ye:2000:IAI,
  author =       "Yunwen Ye and Gerhard Fischer and Brent Reeves",
  title =        "Integrating active information delivery and reuse
                 repository systems",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "60--68",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355053",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Although software reuse can improve both the quality
                 and productivity of software development, it will not
                 do so until software developers stop believing that it
                 is not worth their effort to find a component matching
                 their current problem. In addition, if the developers
                 do not anticipate the existence of a given component,
                 they will not even make an effort to find it in the
                 first place. Even the most sophisticated and powerful
                 reuse repositories will not be effective if developers
                 don't anticipate a certain component exists, or don't
                 deem it worthwhile to seek for it. We argue that this
                 crucial barrier to reuse is overcome by integrating
                 active information delivery, which presents information
                 without explicit queries from the user, and reuse
                 repository systems. A prototype system, CodeBroker,
                 illustrates this integration and raises several issues
                 related to software reuse.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Walker:2000:ICE,
  author =       "Robert J. Walker and Gail C. Murphy",
  title =        "Implicit context: easing software evolution and
                 reuse",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "69--78",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355054",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Software systems should consist of simple,
                 conceptually clean software components interacting
                 along narrow, well-defined paths. All too often, this
                 is not reality: complex components end up interacting
                 for reasons unrelated to the functionality they
                 provide. We refer to knowledge within a component that
                 is not conceptually required for the individual
                 behaviour of that component as extraneous embedded
                 knowledge (EEK). EEK creeps into a system in many
                 forms, including dependences upon particular names and
                 the passing of extraneous parameters. This paper
                 proposes the use of implicit context as a means for
                 reducing EEK in systems by combining a mechanism to
                 reflect upon what has happened in a system, through
                 queries on the call history, with a mechanism for
                 altering calls to and from a component. We demonstrate
                 the benefits of implicit context by describing its use
                 to reduce EEK in the Java{\TM} Swing library.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Pethia:2000:BP,
  author =       "Richard D. Pethia",
  title =        "Bugs in the programs",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "79",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355056",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Security on the Internet is receiving increasing
                 attention as more and more organizations are becoming
                 dependent on the network. The use of the Internet for
                 electronic commerce, government operations, research
                 activities, and entertainment has now reached the point
                 that attacks against the network and the systems
                 connected to it have become major news items. While the
                 press highlights a few high-profile incidents, the
                 actual number of attacks is much higher. The CERT
                 Coordination Center works with the Internet community
                 to deal with incidents and responded to over 8,000
                 incidents in 1999. The incident projection for year
                 2000 is 17,000 to 20,000. At the same time, the amount
                 of damage resulting from the incidents is also
                 increasing. While the press often focuses on cases of
                 web site graffiti, more serious cases of financial
                 fraud, extortion, and debilitating denial of service
                 attacks are being reported at increasing rates.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Yamamoto:2000:AVF,
  author =       "Tetsuo Yamamoto and Makoto Matsushita and Katsuro
                 Inoue",
  title =        "Accumulative versioning file system Moraine and its
                 application to metrics environment {MAME}",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "80--87",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355057",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "It is essential to manage versions of software
                 products created during software development. There are
                 various versioning tools actually used in these days,
                 although most of them require the developers to issue
                 management commands for consistent versioning. In this
                 paper, we present a novel versioning file system
                 Moraine, which accumulatively and automatically
                 collects all files created or modified. Those files are
                 versioned and stored as compressed forms. The older
                 versions are easily retrieved from Moraine by the
                 time-stamps or tags if required. Using Moraine system,
                 we have developed a metrics (measurement) environment
                 called MAME (Moraine As a Metrics Environment). MAME
                 can collect various metrics data for on-going or past
                 projects, since its basis, Moraine, is able to retrieve
                 all versions of all products (files). Both Moraine and
                 MAME have been implemented. Using these systems, we
                 have evaluated the performance of Moraine and MAME with
                 various test data and student project data. The result
                 shows that disk space required by this approach is
                 several times larger than ordinary approaches; however,
                 it is acceptable at the current tendency of disk price
                 decrease. By this approach, an ideal metrics
                 environment has been easily established by developing
                 simple data-collection tools for version files.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Chu-Carroll:2000:CBB,
  author =       "Mark C. Chu-Carroll and Sara Sprenkle",
  title =        "{Coven}: brewing better collaboration through software
                 configuration management",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "88--97",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355058",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Our work focuses on building tools to support
                 collaborative software development. We are building a
                 new programming environment with integrated software
                 configuration management which provides a variety of
                 features to help programming teams coordinate their
                 work. In this paper, we detail a hierarchy-based
                 software configuration management system called Coven,
                 which acts as a collaborative medium for allowing teams
                 of programmers to cooperate. By providing a family of
                 inter-related mechanisms, our system provides powerful
                 support for cooperation and coordination in a manner
                 which matches the structure of development teams.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Sweeney:2000:ELB,
  author =       "Peter F. Sweeney and Frank Tip",
  title =        "Extracting library-based object-oriented
                 applications",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "98--107",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355059",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In an increasingly popular model of software
                 distribution, software is developed in one computing
                 environment and deployed in other environments by
                 transfer over the internet. Extraction tools perform a
                 static whole-program analysis to determine unused
                 functionality in applications in order to reduce the
                 time required to download applications. We have
                 identified a number of scenarios where extraction tools
                 require information beyond what can be inferred through
                 static analysis: software distributions other than
                 complete applications, the use of reflection, and
                 situations where an application uses separately
                 developed class libraries. This paper explores these
                 issues, and introduces a modular specification language
                 for expressing the information required for extraction.
                 We implemented this language in the context of Jax, an
                 industrial-strength application extractor for Java, and
                 present a small case study in which different
                 extraction scenarios are applied to a commercially
                 available library-based application.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Osterweil:2000:IPP,
  author =       "Leon J. Osterweil and Lori A. Clarke and Michael
                 Evangelist and Jeffrey Kramer and Dieter Rombach and
                 Alexander L. Wolf",
  title =        "The impact project (panel session): determining the
                 impact of software engineering research upon practice",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "108--109",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355060",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The purpose of this panel is to introduce the Impact
                 Project to the community, and to engage the community
                 in a broad ranging discussion of the project's goals,
                 approaches, and methods. Some of the project's early
                 findings and directions will be presented.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Hay:2000:CFR,
  author =       "Jonathan D. Hay and Joanne M. Atlee",
  title =        "Composing features and resolving interactions",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "110--119",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355061",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "One of the accepted techniques for developing and
                 maintaining feature-rich applications is to treat each
                 feature as a separate concern. However, most features
                 are not separate concerns because they override and
                 extend the same basic service. That is, ``independent''
                 features are coupled to one another through the
                 system's basic service. As a result, seemingly
                 unrelated features subtly interfere with each other
                 when trying to override the system behaviour in
                 different directions. The problem is how to coordinate
                 features' access to the service's shared variables.
                 This paper proposes coordinating features via feature
                 composition. We model each feature as a separate
                 labelled-transition system and define a 1conflict-free
                 (CF) composition operator that prevents enabled
                 transitions from synchronizing if they interact: if
                 several features' transitions are simultaneously
                 enabled but have conflicting actions, a non-conflicting
                 subset of the enabled transitions are synchronized in
                 the composition. We also define a conflict- and
                 violation-free (CVF) composition operator that prevents
                 enabled transitions from executing if they violate
                 features' invariants. Both composition operators use
                 priorities among features to decide whether to
                 synchronize transitions.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Luttgen:2000:CAS,
  author =       "Gerald L{\"u}ttgen and Michael von der Beeck and Rance
                 Cleaveland",
  title =        "A compositional approach to statecharts semantics",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "120--129",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355062",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Statecharts is a visual language for specifying
                 reactive system behavior. The formalism extends
                 traditional finite-state machines with notions of
                 hierarchy and concurrency, and it is used in many
                 popular software design notations. A large part of the
                 appeal of Statecharts derives from its basis in state
                 machines, with their intuitive operational
                 interpretation. The classical semantics of Statecharts,
                 however, suffers from a serious defect; it is not
                 compositional, meaning that the behavior of system
                 descriptions cannot be inferred from the behavior of
                 their subsystems. Compositionality is a prerequisite
                 for exploiting the modular structure of Statecharts for
                 simulation, verification, and code generation, and it
                 also provides the necessary foundation for reusability.
                 This paper suggests a new compositional approach to
                 formalizing Statecharts semantics as flattened labeled
                 transition systems in which transitions represent
                 system steps. The approach builds on ideas developed
                 for timed process calculi and employs structural
                 operational rules to define the transitions of a
                 Statecharts expression in terms of the transitions of
                 its subexpressions. It is first presented for a simple
                 dialect of Statecharts, with respect to a variant of
                 Pnueli and Shalev's semantics, and is illustrated by
                 means of a small example. To demonstrate its
                 flexibility, the proposed approach is then extended to
                 deal with practically useful features available in many
                 Statecharts variants, namely state references, history
                 states, and priority concepts along state
                 hierarchies.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Jackson:2000:AFO,
  author =       "Daniel Jackson",
  title =        "Automating first-order relational logic",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "130--139",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355063",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "An automatic analysis method for first-order logic
                 with sets and relations is described. A first-order
                 formula is translated to a quantifier-free boolean
                 formula, which has a model when the original formula
                 has a model within a given scope (that is, involving no
                 more than some finite number of atoms). Because the
                 satisfiable formulas that occur in practice tend to
                 have small models, a small scope usually suffices and
                 the analysis is efficient. The paper presents a simple
                 logic and gives a compositional translation scheme. It
                 also reports briefly on experience using the Alloy
                 Analyzer, a tool that implements the scheme.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bernardo:2000:FAT,
  author =       "Marco Bernardo and Paolo Ciancarini and Lorenzo
                 Donatiello",
  title =        "On the formalization of architectural types with
                 process algebras",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "140--148",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355064",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Architectural styles play an important role in
                 software engineering as they convey codified principles
                 and experience which help the construction of software
                 systems with high levels of efficiency and confidence.
                 We address the problem of formalizing and analyzing
                 architectural styles in an operational setting by
                 introducing the intermediate abstraction of
                 architectural type. We develop the concept of
                 architectural type in a process algebraic framework
                 because of its modeling adequacy and the availability
                 of means, such as Milner's weak bisimulation
                 equivalence, which allow us to reason compositionally
                 and efficiently about the well formedness of
                 architectural types.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Jackson:2000:CRT,
  author =       "Daniel Jackson and Kevin Sullivan",
  title =        "{COM} revisited: tool-assisted modelling of an
                 architectural framework",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "149--158",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355065",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Designing architectural frameworks without the aid of
                 formal modeling is error prone. But, unless supported
                 by analysis, formal modeling is prone to its own class
                 of errors, in which formal statements fail to match the
                 designer's intent. A fully automatic analysis tool can
                 rapidly expose such errors, and can make the process of
                 constructing and refining a formal model more
                 effective. This paper describes a case study in which
                 we recast a model of Microsoft COM's query interface
                 and aggregation mechanism into Alloy, a lightweight
                 notation for describing structures. We used Alloy's
                 analyzer to simulate the specification, to check
                 properties and to evaluate changes. This allowed us to
                 manipulate our model more quickly and with far greater
                 confidence than would otherwise have been possible,
                 resulting in a much simpler model and a better
                 understanding of its key properties.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Naumovich:2000:CPA,
  author =       "Gleb Naumovich and Lori A. Clarke",
  title =        "Classifying properties: an alternative to the
                 safety-liveness classification",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "159--168",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355066",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Traditionally, verification properties have been
                 classified as safety or liveness properties. While this
                 taxonomy has an attractive simplicity and is useful for
                 identifying the appropriate analysis algorithm for
                 checking a property, determining whether a property is
                 safety, liveness, or neither can require significant
                 mathematical insight on the part of the analyst. In
                 this paper, we present an alternative property
                 taxonomy. We argue that this taxonomy is a more natural
                 classification of the kinds of questions that analysts
                 want to ask. Moreover, most classes in our taxonomy
                 have a known, direct mapping to the safety-liveness
                 classification, and thus the appropriate analysis
                 algorithm can be automatically determined.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rashid:2000:STC,
  author =       "Richard F. Rashid",
  title =        "The shape of things to come?",
  journal =      j-SIGSOFT,
  volume =       "25",
  number =       "6",
  pages =        "169",
  month =        nov,
  year =         "2000",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/357474.355067",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:02 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The future of software engineering isn't what it used
                 to be. The nature of the software we write, the reasons
                 we write it and the way we write it and maintain it
                 have changed rapidly and dramatically over the last few
                 years. And software development is likely change even
                 faster over the next decade. In this talk I will
                 reflect on how commercial software has evolved and what
                 it might look like in the not-to-distant future.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bagert:2001:FSE,
  author =       "Donald J. Bagert",
  title =        "{FASE}: a software engineering, education, training
                 and professional issues publication",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "6--6",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505896",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "FASE (pronounced like ``phase''), the Forum for
                 Advancing Software engineering Education, was started
                 in 1991 by members of the software engineering
                 education community in order to have a electronic forum
                 for the dissemination and discussion of events related
                 to software engineering education. The original acronym
                 for FASE was Forum for Academic Software Engineering,
                 but was subsequently changed so that it was more
                 inclusive to industrial and government training issues
                 (which led to a co-editor in that area). In recent
                 years, FASE has also covered a wide variety of
                 professional issues (e.g. licensing, certification,
                 ethics, body of knowledge, and accreditation), which
                 has also led to the addition of yet another co-editor
                 for this area.FASE is an independently-published
                 newsletter, not affiliated with ACM, IEEE-CS or any
                 other organization. As of October 2000, 129 issues have
                 been published. Since August 1997, FASE has been
                 published monthly, and is released on the 15th of each
                 month in ASCII format. FASE has several hundred
                 subscribers in over 50 countries and provinces. There
                 is also a FASE-TALK discussion list. The FASE web page
                 is at http://www.cs.ttu.edu/fase. It contains
                 subscription information, article submission
                 guidelines, and an archive of all FASE issues and
                 FASE-TALK postings to date. The FASE Staff: Thomas B.
                 Hilburn, Academic Editor Embry-Riddle Aeronautical
                 University David Carter, Corporate/Government Editor
                 Independent Consultant Donald J. Bagert, P.E.,
                 Professional Issues Editor Texas Tech University Laurie
                 Werth, Advisory Committee Member The University of
                 Texas at Austin Nancy Mead, Advisory Committee Member
                 Software Engineering Institute",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Omitol:2001:AFP,
  author =       "Tope Omitol",
  title =        "{ACM Fellow} profile: {Roger Needham}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "7--10",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505898",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Doernhoefer:2001:SNSa,
  author =       "Mark Doernhoefer",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "11--13",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505899",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2001:RPCa,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "14--38",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505900",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Meseguer:2001:RE,
  author =       "Jos{\'e} Meseguer",
  title =        "Report on {ETAPS} 2000",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "39--39",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505902",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Penix:2001:FIW,
  author =       "John Penix and Nigel Tracey and Willem Visser",
  title =        "The {First International Workshop on Automated Program
                 Analysis, Testing and Verification}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "40--40",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505903",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper reports on the First International Workshop
                 on Automated Program Analysis, Testing and Verification
                 (WAPATV) held in Limerick on the 4th-5th June 2000, as
                 part of the International Conference on Software
                 Engineering 2000. We begin by presenting an overview of
                 the workshop aims and then focus on the workshop's
                 technical program.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Jahnke:2001:ITI,
  author =       "Jens H. Jahnke and Joerg P. Wadsack",
  title =        "{ISE3: the Third International Workshop on Intelligent
                 Software Engineering} open issues, new techniques,
                 challenge problems in software engineering",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "43--43",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505904",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Sim:2001:WWS,
  author =       "Susan Elliot Sim and Rainer Koschke",
  title =        "{WoSEF: Workshop on Standard Exchange Format}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "44--49",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505905",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A workshop was held at ICSE 2000 in Limerick, Ireland
                 to further efforts in the development of a standard
                 exchange format (SEF) for data extracted from and about
                 source code. WoSEF (Workshop on Standard Exchange
                 Format) brought together people with expertise in a
                 variety of formats, such as RSF, TA, GraX, FAMIX, XML,
                 and XMI, from across the software engineering
                 discipline. We had five sessions consisting of a
                 presentation and discussion period and a working
                 session with three subgroups. The five sessions were:
                 (1) Survey and Overview, (2) Language-level schemas and
                 APIs, (3) High-level schemas, (4) MOF/XMI/UML and CDIF,
                 and (5) Meta schemas and Typed Graphs. During that time
                 we reviewed previous work and debated a number of
                 important issues. This report includes descriptions of
                 the presentations made during these sessions. The main
                 result of the workshop is the agreement of the majority
                 of participants to work on refining GXL (Graph eXchange
                 Language) to be the SEF. GXL is an XML-based notation
                 that uses attributed, typed graphs as a conceptual data
                 model. It is currently a work in progress with
                 contributors from reverse engineering and graph
                 transformation communities in multiple countries. There
                 is a great deal of work to be done to finalise the
                 syntax and to establish reference models for schemas.
                 Anyone interested is welcome to join the effort and
                 instructions on how to get involved are found at the
                 end of the workshop report. Three papers from the
                 workshop have been reprinted here to promote reflection
                 and encourage participation in the work to develop an
                 SEF.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Godfrey:2001:PDE,
  author =       "Michael W. Godfrey",
  title =        "Practical data exchange for reverse engineering
                 frameworks: some requirements, some experience, some
                 headaches",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "50--52",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505906",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Reverse engineering systems hold great promise in
                 aiding developers regain control over long-lived
                 software projects whose architecture has been allowed
                 to ``drift''. However, it is well known that these
                 systems have relative strengths and weaknesses, and to
                 date relatively little work has been done on
                 integrating various subtools within other reverse
                 engineering systems. The design of a common interchange
                 format for data used by reverse engineering tools is
                 therefore of critical importance. In this position
                 paper, we describe some of our previous work with
                 TAXFORM (Tuple Attribute eXchange FORMat) [2,6], and in
                 integrating various ``fact extractors'' into the PBS
                 reverse engineering system. For example, we have
                 recently created translation mechanisms that enable the
                 Acacia system's C and C++ extractors to be used within
                 PBS, and we have used these mechanisms to create
                 software architecture models of two large software
                 systems: the Mozilla web browser (2.2 MLOC of C++ and
                 C) and the VIM text editor (150 KLOC of C) [6]. We also
                 describe our requirements for an exchange format for
                 reverse engineering tools and some problems that must
                 be resolved.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Lapierre:2001:DTS,
  author =       "S{\'e}bastien Lapierre and Bruno Lagu{\"e} and Charles
                 Leduc",
  title =        "Datrix {\TM} source code model and its interchange
                 format: lessons learned and considerations for future
                 work",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "53--56",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505907",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The Datrix team within Bell Canada has been offering
                 its source code analysis tools to the research
                 community for a number of years. These tools perform a
                 number of analyses that revolve around a central model
                 (Datrix-ASG) developed by the Datrix team, and use an
                 interchange format similar to TA, which we call
                 Datrix-TA. This paper intends to communicate the
                 modeling choices that were made when creating this
                 information model, and the lessons learned over a few
                 years of usage.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kienle:2001:EFB,
  author =       "Holger M. Kienle",
  title =        "Exchange format bibliography",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "56--60",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505908",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper gives a brief bibliographical overview of
                 exchange formats and related research areas. We
                 classify exchange formats and try to give a brief
                 assessment of the more interesting ones.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Dean:2001:CWC,
  author =       "John Dean and Patricia Oberndorf and Mark Vigder and
                 Chris Abts and Hakan Erdogmus and Neil Maiden and
                 Michael Looney and George Heineman and Michael
                 Guntersdorfer",
  title =        "{COTS} workshop: continuing collaborations for
                 successful {COTS} development",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "61--73",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505909",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In early June of 2000 a COTS Workshop entitled
                 ``Continuing Collaborations for Successful COTS
                 Development'' was held in Limerick, Ireland in
                 conjunction with ICSE 2000. The purpose of the workshop
                 was to collect experience reports regarding the use of
                 commercial off-the-shelf (COTS) software to build
                 systems, identify best-practices for the use of COTS
                 software, and to establish a research agenda for those
                 researchers interested in COTS-based software systems.
                 This one and a half day workshop was an extension of
                 the work begun during the workshop entitled ``Ensuring
                 Successful COTS Development'' held in conjunction with
                 ICSE '99. Results from that workshop demonstrated that
                 there were a number of common research areas, including
                 acquisition, planning and management, architecture and
                 implementation, and evaluation and testing, for which
                 researchers saw the possibility of collaboration. These
                 areas included specific topics such as estimating the
                 effort required to implement COTS-based systems,
                 classification of architectural styles, and
                 certification of COTS products for reliability and
                 safety. The group will reconvene at ICSE'01
                 (www.csr.uvic.ca/icse2001) to discuss further the
                 results achieved. The ICSE 2000 Workshop had about 26
                 participants and was formatted as a combination of
                 plenary sessions and small breakout groups that worked
                 on specific issues related to COTS-based systems. The
                 breakout groups investigated the impact of COTS
                 software usage in the following areas: Economic and
                 financial issues. Requirements definition Software
                 engineering process. Integration, maintenance and
                 system management. Business models. Each breakout group
                 tried to identify the current state of the art in COTS
                 software usage as well as open questions that could
                 provide the basis for further research in the coming
                 years. Each group was responsible for producing a
                 written summary of their discussions which are
                 included, without major editing, below. A more complete
                 description of the workshop, as well as all the
                 participants' position papers, can be found
                 at:http://seg.iit.nrc.ca/projects/cots/icse2000wkshp/index.html",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Palanque:2001:DSV,
  author =       "Philippe Palanque and Fabio Patern{\`o}",
  title =        "Design, specification, and verification of interactive
                 systems",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "74--75",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505910",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "More and more software applications are being
                 developed to allow users to access data and communicate
                 information. The parts of such applications dedicated
                 to supporting user interactions is increasingly
                 important and requires novel methods and techniques to
                 develop effective user interfaces. DSV-IS'2000 provided
                 experts from many countries of the world with the
                 unique opportunity to meet and discuss the current
                 state of art and new research results in this area.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Deshpande:2001:SSI,
  author =       "Yogesh Deshpande and San Murugesan",
  title =        "Summary of the {Second ICSE workshop on Web
                 Engineering}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "76--77",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505911",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The series of workshops on Web Engineering started in
                 1998 with the World Wide Web Conference WWW7 in
                 Brisbane, Australia, and has continued with WWW8
                 (Toronto, 1999) and WWW9 (Amsterdam, 2000). The first
                 such workshop with the International Conference on
                 Software Engineering (ICSE) took place in 1999 in Los
                 Angeles. The second workshop was held on 4-5 June 2000
                 in Limerick, Ireland and attracted about 30
                 participants. The main purpose behind these workshops
                 is to share and pool the collective experience of
                 people, both academics and practitioners, who are
                 actively working on Web-based systems. This workshop
                 consisted of two keynote addresses, 11 contributed
                 papers and two sessions of open discussions. The call
                 for papers elicited 18 submissions of which 11 were
                 accepted after peer reviews. The papers presented at
                 the workshop appear in the book Web Engineering (San
                 Murugesan and Yogesh Deshpande (eds.), LNCS,
                 Springer-Verlag, 2000).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tarr:2001:WMD,
  author =       "Peri Tarr and William Harrison and Harold Ossher and
                 Anthony Finkelsteiin and Bashar Nuseibeh and Dewayne
                 Perry",
  title =        "{Workshop on Multi-Dimensional Separation of Concerns
                 in Software Engineering}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "78--81",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505912",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Separation of concerns has been central to software
                 engineering for decades, yet its many advantages are
                 still not fully realized. A key reason is that
                 traditional modularization mechanisms do not allow
                 simultaneous decomposition according to multiple kinds
                 of (overlapping and interacting) concerns. This
                 workshop was intended to bring together researchers
                 working on more advanced modularization mechanisms, and
                 practitioners who have experienced the need for them,
                 as a step towards a common understanding of the issues,
                 problems and research challenges.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Raccoon:2001:DD,
  author =       "L. B. S. Raccoon",
  title =        "Definitions and demographics",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "82--91",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505914",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Who are software engineers? Answering this question
                 properly, by defining the profession clearly and
                 counting practitioners accurately, will help all
                 software engineers. Practitioners will better
                 understand the career paths that are available.
                 Managers will better understand the jobs that employees
                 fill. Researchers will better predict how the field
                 will evolve. The software engineering community will
                 better understand its identity and will better wield
                 its influence. And, everyone will be able to make more
                 responsible distinctions between who is and is not a
                 software engineer. In the first section, I propose a
                 definition of software engineers as those who focus
                 primarily on software development and who have some
                 depth and breadth of experience in the process, and I
                 propose a scaling model of software engineering
                 demographics. In the second section, I discuss the
                 difficulty of distinguishing between software engineers
                 and non-engineers. I believe that credentials will
                 evolve to help clarify this distinction. And in the
                 third section, I call for a new demographic study
                 tailored to the needs of software engineers. This study
                 should create a complete portrait of the field.I also
                 respond to several criticisms of A Whole New Kind of
                 Engineering: I explain why I believe that in 1998,
                 about 1,000,000 software engineers existed in the U.S.
                 and why software engineers do not need computer science
                 or even technical degrees to prove themselves today,
                 though this will surely change in the future.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Raccoon:2001:CEG,
  author =       "L. B. S. Raccoon",
  title =        "A conversation with Erwin Goodhack",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "92--92",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505915",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Abrahams:2001:PRT,
  author =       "Alan Abrahams",
  title =        "Planning for real time event response management",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "93--94",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505917",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ben-Menachem:2001:WEU,
  author =       "Mordechai Ben-Menachem",
  title =        "Writing effective use cases",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "94--95",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505918",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Boyer:2001:MCG,
  author =       "Kenneth W. {Boyer, Jr.}",
  title =        "More {C++} gems",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "95--95",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505919",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Frazer:2001:ACP,
  author =       "Ken Frazer",
  title =        "Accelerated {C++}: practical programming by example",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "95--96",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505920",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Huber:2001:CHP,
  author =       "Andy Huber",
  title =        "Creating high performance software development teams",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "96--97",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505921",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Larsen:2001:JPB,
  author =       "Albert L. Larsen",
  title =        "{Java} programming: from the beginning",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "97--98",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505922",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Law:2001:SPA,
  author =       "Jim Law",
  title =        "Selected papers on analysis of algorithms",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "98--99",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505923",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Madrigal:2001:FOD,
  author =       "Victor M. {Madrigal III}",
  title =        "Fundamentals of {OOP} and data structures in {Java}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "99--99",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505924",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Manolescu:2001:PWC,
  author =       "Dragos Manolescu",
  title =        "Production workflow: concepts and techniques",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "99--100",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505925",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kulak:2001:UCR,
  author =       "Daryl Kulak and Eamonn Guiney",
  title =        "Use cases: requirements in context",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "1",
  pages =        "101--101",
  month =        jan,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505894.505926",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:04 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2001:RPCb,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "5--11",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505778",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Cooper:2001:AFPa,
  author =       "Greg Cooper",
  title =        "{ACM Fellow} profile: {Frank L. Friedman}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "12--13",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505779",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Doernhoefer:2001:SNSb,
  author =       "Mark Doernhoefer",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "14--23",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505780",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Systa:2001:SRO,
  author =       "Tarja Syst{\"a} and Rudolf K. Keller and Kai
                 Koskimies",
  title =        "Summary report of the {OOPSLA 2000 Workshop on
                 Scenario-Based Round-Trip Engineering}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "24--28",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505782",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This report summarizes the Workshop on Scenario-Based
                 Round-Trip Engineering held in Minneapolis, Minnesota,
                 USA, on October 16, 2000, in conjunction with the
                 International Conference on Object-Oriented
                 Programming, Systems, Languages, and Applications
                 (OOPSLA 2000). The workshop consisted of a keynote and
                 seven presentations, which were organized into three
                 sessions: From Interaction Diagrams to State Machines,
                 Forward Engineering, and Reverse Engineering.
                 Altogether nine position papers were accepted. The
                 workshop web page, including the papers, the
                 presentations, and the electronic version of this
                 report, can be found at
                 \url{http://www.cs.uta.fi/~cstasy/oopsla2000/workshop.html}.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Knauber:2001:PSP,
  author =       "Peter Knauber and Giancarlo Succi",
  title =        "Perspectives on software product lines: report on
                 {First International Workshop on Software Product
                 Lines: Economics, Architectures, and Implications
                 Workshop} \#15 at {22nd International Conference on
                 Software Engineering (ICSE)}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "29--33",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505783",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Product line engineering is a concept that has emerged
                 in the 80's in the business schools and is now among
                 the hottest topics in software engineering. Software
                 product lines aim at achieving scope economies through
                 synergetic development of software products. Diverse
                 benefits like cost reduction, decreased time-to-market,
                 and quality improvement can be expected from reuse of
                 domain-specific software assets. But also non-technical
                 benefits can be expected as result of network
                 externalities, product branding, and sharing
                 organizational costs. Product lines introduce
                 additional complexity. In a sense they go against the
                 common adage of ``divide and conquer.'' Planning and/or
                 developing of more than one product at a time have to
                 be managed technically and organizationally. However,
                 the rate of innovation of the technology and the
                 intrinsic nature of software products do not let
                 alternatives to developers: users like to jump into the
                 bandwagon of new products, and old products often drive
                 preferences to new products. Research has been
                 conducted in software product lines for the past few
                 years. Some of it has focused on demonstrating that
                 existing systems and approaches were indeed
                 instrumental for product line development, such as
                 generative techniques, domain analysis and engineering
                 and software components. Another portion of the
                 research effort has tried to determine how it is
                 possible to create a comprehensive methodology and an
                 associated tool for product lines, starting from the
                 business idea of line of products down to the
                 development of a product and trying to exploit all the
                 possible synergies existing at each phase, from network
                 externalities to component reuse.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bernstein:2001:TOS,
  author =       "Lawrence Bernstein and David Klappholz",
  title =        "Teaching old software dogs, old tricks",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "33--34",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505785",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Laguna:2001:URE,
  author =       "Miguel Angel Laguna and Jos{\'e} Manuel Marqu{\'e}s
                 and Francisco Jos{\'e} Garc{\'\i}a",
  title =        "A user requirements elicitation tool",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "35--37",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505786",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Use cases are nowadays the favoured technique for
                 defining the functional requirements of a software
                 system. Their use implies that most of the desired
                 functionality of the new system is well known. The aim
                 of this work is a methodological proposal (and a tool
                 to support it) to accurately define this functionality,
                 starting from the way the end users currently do their
                 work. This method and tool are independent of the
                 development paradigm and could generate useful results
                 for the most frequently used CASE tools with the
                 addition of the appropriate translators.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mihajlovic:2001:TSP,
  author =       "Zorica Mihajlovic and Dusan Velasevic",
  title =        "Tracking software projects with the integrated version
                 control in {SMIT}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "38--43",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505787",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The purpose of the software project tracking and
                 oversight process is to provide visibility into actual
                 progress so that management can take corrective actions
                 when the project's performance deviates significantly
                 from the plans. The sequence of the project's
                 performances forms the project's change history. The
                 new SMIT tool for planning and tracking software
                 projects with the additional capability to process the
                 project's change history is presented in the paper.
                 This additional capability is based upon the
                 integration of version control into the standard
                 planning and tracking capabilities of the tool. It
                 facilitates the project's post-mortem analysis and
                 helps us to manage future projects. Since the history
                 contains valuable data it enables us to learn from
                 mistakes and good examples. Comparing two performances
                 is the important type of processing the project's
                 change history. SMIT accomplishes this type of
                 processing in the context of tracking and thus
                 surpasses the solution based on the standard tools for
                 project management and version control. In addition,
                 SMIT reduces the number of interactions needed to
                 compare two performances from 61\% to 88\% for the
                 example projects considered.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Zhang:2001:VUC,
  author =       "Lu Zhang and Dan Xie and Wei Zou",
  title =        "Viewing use cases as active objects",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "44--48",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505788",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this paper, we propose an idea of viewing use cases
                 as active objects in the analysis model. Based on the
                 idea, we present a new approach to use case-driven
                 object-oriented analysis. This approach gives a
                 systematic and natural way of incorporating use cases
                 into the analysis model, and an effective way of
                 localizing the effect of requirement changes.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Shaofeng:2001:RJR,
  author =       "Wang Shaofeng",
  title =        "The role of {Java RMI} in designing workflow
                 management system",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "49--52",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505789",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The development of the workflow management
                 system(WfMS) has become one of the most important
                 research areas in information system. The design of the
                 WfMS is a very complicated process, involving many
                 difficult tasks. In this paper, We discuss the design
                 of Java RMI-based workflow management system JWfMS,
                 mainly on the designing framework of the JWfMS.
                 According to our experience, we found that Java RMI is
                 suitable and practical for the design of heterogeneous,
                 distributed system such as WfMS because Java RMI makes
                 the design and maintenance work much simpler.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mei:2001:SCM,
  author =       "Hong Mei and Lu Zhang and Fuqing Yang",
  title =        "A software configuration management model for
                 supporting component-based software development",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "53--58",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505790",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Software configuration management (SCM) is viewed as
                 an important key technology in software development and
                 is being adopted in software industry more and more
                 widely. And component-based software development (CBSD)
                 is an emerging paradigm in software development.
                 However, the traditional SCM method can not support
                 CBSD effectively and efficiently. In this paper, we
                 analyze the objects that need to be managed in CBSD and
                 present a component-based SCM model to improve CBSD
                 with effective SCM support. In this model, components,
                 as the integral logical constituents in a system, are
                 managed as the basic configuration items in SCM, and
                 relationships between/among components are defined and
                 maintained, in order to support version control of
                 large objects and logical modeling of system
                 architecture. Also some key issues in the model are
                 discussed and an SCM system that supports this model is
                 introduced.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Sukhodolsky:2001:OSP,
  author =       "Jacob Sukhodolsky",
  title =        "Optimizing software process control",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "59--63",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505791",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "An important problem in software project management is
                 taking control decisions when a schedule slip occurs.
                 Usually such decisions are based only on the manager's
                 experience and intuition. They are often prohibitively
                 costly and still do not guarantee the project's
                 success. This article presents a method for finding the
                 optimal control actions the manager should take to meet
                 a project's deadline in a situation when a schedule
                 slip occurs. The method is based on using a discrete
                 optimization technique, such as dynamic programming.
                 Validation of the method's effectiveness is also
                 included.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bird:2001:XBA,
  author =       "Colin Bird and Andrew Sermon",
  title =        "An {XML-based} approach to automated software
                 testing",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "64--65",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505792",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The advantages of automating the functional testing of
                 application software are well-known, but the manner of
                 automation can lead to difficulties in authenticating
                 the test coverage. In this paper we consider the class
                 of automated tests in which a driver tool simulates the
                 input and responses of a human operator and
                 sequentially checks the output generated by the
                 application software. The driver tool commonly employs
                 its own language to describe the tasks it can be
                 required to perform, for example: $ \bullet $ Issue a
                 sequence of characters that simulate input from the
                 keyboard. $ \bullet $ Verify that a segment of the
                 display buffer contains the expected bit pattern.
                 Although these tasks are simply stated, the language to
                 effect them in a test script can become complex and
                 hard to maintain. Furthermore, reading the driver tool
                 program is not an effective way to confirm that the
                 test script performs its tasks to the test
                 specification. XML (eXtensible Markup Language) [1]
                 scripts offer a rigorous intermediate description that
                 can be readily translated into both the driver tool
                 test script and a readable statement of the task the
                 test performs. The advantages accruing from the use of
                 XML are: $ \bullet $ The XML scripts are easy to edit,
                 simplifying basic script maintenance. New steps can be
                 included for testing bug fixes. $ \bullet $ Content
                 review becomes much easier, as the relevant aspects of
                 the script can be rendered in a readily readable form,
                 such as HTML; $ \bullet $ Global changes become
                 feasible, as the structured nature of XML documents
                 makes it possible to search for specific element
                 content; $ \bullet $ The structure of the XML document
                 can itself be checked, for example using a validating
                 editor such as Xeena [2]. In the next section we
                 describe an example of automated testing using a driver
                 tool, based on XML scripts. The application being
                 tested is called Wired for Learning [3] and provides
                 the IT infrastructure for schools to: $ \bullet $
                 Enhance communication between teachers, students and
                 parents. $ \bullet $ Enable teachers to plan and share
                 ideas for lessons and activities, linking in with
                 national standards. $ \bullet $ Organize team projects
                 involving teachers and students across classes and
                 schools, with the option of inviting members of the
                 community to provide additional information. $ \bullet
                 $ Provide an events calendar to keep everyone up to
                 date with what is happening in the school. $ \bullet $
                 Allow teachers easily to create their own home pages
                 for information dissemination.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Romanovsky:2001:CAA,
  author =       "Alexander Romanovsky",
  title =        "Coordinated atomic actions: how to remain {ACID} in
                 the modern world",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "66--68",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505793",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bowen:2001:ETZ,
  author =       "Jonathan P. Bowen",
  title =        "Experience teaching Z with tool and web support",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "69--75",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505794",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This short paper describes experiences of presenting
                 the formal Z notation on one and later two course
                 modules to computer science undergraduates, especially
                 with respect to providing supporting web-based
                 resources and using tool support. The modules were part
                 of a more general course unit on formal methods.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Anantharam:2001:EJP,
  author =       "Parasuram Anantharam",
  title =        "Essentials of the {Java} programming language: a
                 hands-on guide",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "76--76",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505796",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Pentinmaki:2001:SCI,
  author =       "Isaac Pentinmaki",
  title =        "{Standard C++ IOStreams} and locales: advanced
                 programmer's guide and reference",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "76--77",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505797",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tanuan:2001:BAS,
  author =       "Meyer Tanuan",
  title =        "Building application servers",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "2",
  pages =        "77--77",
  month =        mar,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505776.505798",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:06 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Sitaraman:2001:PSS,
  author =       "Murali Sitaraman and Greg Kulczycki and Joan Krone and
                 William F. Ogden and A. L. N. Reddy",
  title =        "Performance specification of software components",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "3--10",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375223",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Component-based software engineering is concerned with
                 predictability in both functional and performance
                 behavior, though most formal techniques have typically
                 focused their attention on the former. Reasoning about
                 the (functional or performance) behavior of a
                 component-based system must be compositional in order
                 to be scalable. Compositional performance reasoning
                 demands that components include performance
                 specifications, in addition to descriptions of
                 functional behavior. Unfortunately, as explained in
                 this paper, classical techniques and notations for
                 performance analysis are either unsuitable or unnatural
                 to capture performance behaviors of generic software
                 components. They fail to work in the presence of
                 parameterization and layering. The paper introduces
                 elements of a compositional approach to performance
                 analysis using a detailed example. It explains that
                 performance specification problems are so basic that
                 there are unresolved research issues to be tackled even
                 for the simplest reusable components. These issues must
                 be tackled by any practical proposal for sound
                 performance reasoning. Only then will software
                 developers be able to engineer new systems by choosing
                 and assembling components that best fit their
                 performance (time and space) requirements.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rakic:2001:ICS,
  author =       "Marija Rakic and Nenad Medvidovic",
  title =        "Increasing the confidence in off-the-shelf components:
                 a software connector-based approach",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "11--18",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375228",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The promise of component-based software development is
                 that larger, more complex systems can be built
                 reasonably quickly and reliably from pre-fabricated (``
                 off-the-shelf'') building blocks. Additionally, such
                 systems can be upgraded incrementally, simply by
                 replacing individual components with their new
                 versions. However, practice has shown that while it may
                 improve certain aspects of an existing component, a new
                 component version frequently introduces unforeseen
                 problems. These problems include less efficient
                 utilization of system resources, errors in the newly
                 introduced functionality, and even new errors in the
                 functionality carried over from the old version. This
                 paper presents an approach intended to alleviate such
                 problems. Our approach is based on explicit software
                 architectures and leverages flexible software
                 connectors in ensuring that component versions can be
                 added and removed in the deployed, running system. Our
                 connectors, called multi-versioning connectors, also
                 unintrusively collect and compare the execution
                 statistics of the running component versions (e.g.,
                 execution time and results of invocations). We
                 illustrate our approach with the help of an example
                 application.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Braga:2001:UMO,
  author =       "Regina M. M. Braga and Marta Mattoso and Cl{\'a}udia
                 M. L. Werner",
  title =        "The use of mediation and ontology technologies for
                 software component information retrieval",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "19--28",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375229",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Component Based Developed aims at constructing
                 software through the inter-relationship between
                 pre-existing components. However, these components
                 should be bound to a specific application domain in
                 order to be effectively reused. Reusable domain
                 components and Their related documentation are usually
                 stored in a great variety of data sources. Thus, a
                 possible solution for accessing this information is to
                 use a software layer that integrates different
                 component information sources. We present a component
                 information integration data layer, based on mediators.
                 Through mediators, domain ontology acts as a
                 technique/formalism for specifying ontological
                 commitments or agreements between component users and
                 providers, enabling more accurate software component
                 information search.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Maruyama:2001:AME,
  author =       "Katsuhisa Maruyama",
  title =        "Automated method-extraction refactoring by using
                 block-based slicing",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "31--40",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375233",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Refactoring improves the design of existing code but
                 is not complex to do by hand. This paper proposes a
                 mechanism that automatically refactors methods of
                 object-oriented programs by using program slicing. To
                 restructure a method without changing its observable
                 behavior, the mechanism uses block-based slicing that
                 does not extract the fragments of code from the whole
                 program but from the region consisting of some
                 consecutive basic-blocks of the program. A refactoring
                 tool implementing the mechanism constructs a new method
                 that contains the extracted code and re-forms the
                 source method that contains this tool, a programmer
                 indicates only a variable of interest in the code that
                 he/she wants to refactor and then selects a suitable
                 method from among the candidates created by the tool.
                 The programmer does not have to test the refactored
                 code since the mechanism is based on data-and
                 control-flow analysis. Thus the tool enables
                 programmers to avoid manual refactoring whose process
                 is error-prone and time-consuming",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Price:2001:PRO,
  author =       "Margaretha W. Price and Donald M. Needham and Steven
                 A. {Demurjian, Sr.}",
  title =        "Producing reusable object-oriented components: a
                 domain-and-organization-specific perspective",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "41--50",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375236",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Developing reusable object-oriented software requires
                 a designer to determine how to structure a software
                 system so as to achieve the necessary functionality,
                 while at the same time increasing the reuse potential
                 of the software. We introduce a set of reusability
                 metrics intended to be iteratively applied during the
                 design and implementation parts of the software
                 life-cycle to help guide the production and
                 identification of reusable components. Component
                 identification centers on the application's domain,
                 with reuse focusing specifically on an organization's
                 future systems. Our approach requires the developer to
                 subjectively categorize classes, identify component
                 boundaries, and specify where components are related.
                 Our metrics provide reuse valuations on the couplings
                 between components. Based upon the results of applying
                 our metrics, we provide refactoring guidelines to
                 increase the separation between components in a manner
                 that improves component reusability. We include an
                 application of our metrics to a commercial
                 object-oriented framework.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Butler:2001:CRF,
  author =       "Greg Butler and Lugang Xu",
  title =        "Cascaded refactoring for framework",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "51--57",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375239",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Refactoring of source code has been studied as a
                 preliminary step in the evolution of object-oriented
                 software. We extend the concept of refactoring to the
                 whole range of models used to describe a framework in
                 our methodology: feature model, use case model,
                 architecture, design, and code. We view framework
                 evolution as a two-step process: refactoring and
                 extension. The refactoring step is a set of
                 refactorings, one for each model, that cascades through
                 them. The refactorings chosen for a model become the
                 rationale or constraints for the choice of refactorings
                 of the next model. The cascading of refactorings is
                 aided by the alignment of the models. Alignment is a
                 traceable mapping between models that preserves the
                 commonality-variability aspects of the models.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Jang:2001:ADR,
  author =       "Jun-Jang Jang",
  title =        "An approach to designing reusable service frameworks
                 via virtual service machine",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "58--66",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375242",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper proposes a new service-computing platform
                 named Virtual Service Machine (VSM). Service computing
                 is a new paradigm for manufacturing IT artifacts,
                 lifting up traditional focus of software development
                 from the level of applications to that of services.
                 Applications are constructed for machines; services are
                 built for people. Applications are targeted to run on a
                 particular platform; services are aimed for serving
                 user's needs. While service computing is getting much
                 more attention than before, its progress is slow and
                 outcomes are not so gratifying. Many service-computing
                 developers are striving to solve the same problems
                 encountered in their counterparts on application
                 development. Middleware is one of many means to address
                 the issue of development barriers for services.
                 However, current forms and functions of middleware
                 software are still impeded by customary mindsets that
                 have been exercised for last couple of decades. We need
                 a new breed of platforms that can further relieve the
                 developers from low-level platform concerns, e.g.
                 hardware, OS, or even middleware itself. VSM is a way
                 towards more effective service- computing development.
                 It provides developers with a reusable service-
                 computing platform to develop their service- based
                 frameworks and applications. This paper proposes an
                 approach of designing reusable service- computing
                 platform via VSM. VSM works by taking incoming service
                 requests and converting them to the executable tasks of
                 the underlying middleware or machine that it is running
                 on. This paper emphasizes on presenting the
                 functionality and major components inside VSM. The
                 comparative study with other service- computing
                 platforms with not be the focus of this paper.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Gomaa:2001:RCI,
  author =       "Hassan Gomaa and Daniel A. Menasc{\'e} and Michael E.
                 Shin",
  title =        "Reusable component interconnection patterns for
                 distributed software architectures",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "69--77",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375252",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper investigates the design of reusable
                 component interconnection in client/ server systems. In
                 particular, the paper describes the design of component
                 interconnection patterns, which define and encapsulate
                 the way client and server components communicate with
                 each other. This paper uses the Unified Modeling
                 Language (UML) to describe the component
                 interconnection patterns for synchronous, asynchronous,
                 and brokered communication. When designing a new
                 distributed application, the appropriate component
                 interaction patterns may then be selected and reused.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tahara:2001:SEM,
  author =       "Yasuyuki Tahara and Nobukazu Toshiba and Akihiko
                 Ohsuga and Shinichi Honiden",
  title =        "Secure and efficient mobile agent application reuse
                 using patterns",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "78--85",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375255",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "As wide-area open networks like the Internet and
                 intranets grow larger, mobile agent technology is
                 attracting more attention. Mobile agents are units of
                 software that can deal with environmental changes and
                 the various requirements of open networks through
                 features such as autonomy, mobility, intelligence,
                 cooperation, and reactivity. In addition, some people
                 consider the agent technology as a promising solution
                 to the reuse issue because of the aspect of the agents
                 as highly adaptable software components. However, since
                 the usual development methods of secure mobile agent
                 applications are not sufficiently investigated, the
                 technology is not yet widespread. In this paper, we
                 propose a formal framework that supports mobile agent
                 application development and reuse with consideration of
                 the trade-offs between the security issues and the
                 performance issues. In our framework, we design a
                 mobile agent application by building a computational
                 cost model and a security model, and combining patterns
                 so that the combination satisfies the models. Therefore
                 we can develop the application considering the security
                 and the performance trade-offs. Since the models and
                 the patterns are presented according to a formal
                 framework, we can make sure that the pattern
                 combination satisfies the models rigorously. In
                 addition, if the security policy of the new environment
                 is different from the old one in reusing the system in
                 a new organization, we can easily modify and adapt the
                 behavior because the pattern application can be figured
                 out automatically by an algorithm.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Stirewalt:2001:GVC,
  author =       "R. E. Kurt Stirewalt and Laura K. Dillon",
  title =        "Generation of visitor components that implement
                 program transformations",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "86--94",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375258",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The visitor pattern is appealing to developers of
                 program-analysis tools because it separates the design
                 of the data structures that represent a program from
                 the design of software that traverses these structures.
                 Unfortunately, the visitor pattern is difficult to
                 apply when the analysis involves transformation logic
                 that involves multiple program fragments
                 simultaneously. We encountered this problem in our work
                 on the {\proj} project and discovered a novel way to
                 use multiple cooperating visitor objects to
                 systematically implement such functions when they are
                 specified via a set of transformation rules. This paper
                 introduces our {\em curried-visitor framework} and
                 illustrates how we applied it to implement a key
                 component in the {\proj} framework. We are working on a
                 code generator that will automatically synthesize
                 curried-visitor frameworks from a description of a
                 program's abstract syntax and a set of pattern-matching
                 transformation rules.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mittermeir:2001:GDC,
  author =       "Roland T. Mittermeir and Andreas Bollin and Heinz
                 Pozewaunig and Dominik Rauner-Reithmayer",
  title =        "Goal-driven combination of software comprehension
                 approaches for component based development",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "95--102",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375264",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper reports on our approaches to combine
                 various software comprehension techniques (and
                 technologies) in order to establish confidence whether
                 a given reusable component satisfies the needs of the
                 intended reuse situation. Some parts of the problem we
                 are addressing result from differences in knowledge
                 representation about a component depending on whether
                 this component is a well documented in-house
                 development, some externally built componentry, or a
                 COTS-component.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Gacek:2001:IPL,
  author =       "Critina Gacek and Michalis Anastasopoules",
  title =        "Implementing product line variabilities",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "109--117",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375269",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Software product lines have numerous members. Thus, a
                 product line infrastructure must cover various systems.
                 This is the significant difference to usual software
                 systems and the reason for additional requirements on
                 the various assets present during software product line
                 engineering. It is imperative that they support the
                 description of the product line as a whole, as well as
                 its instantiation for the derivation of individual
                 products. Literature has already addressed how to
                 create and instantiate generic product line assets,
                 such as domain models and architectures to generate
                 instance specific ones [1, 2, 3], yet little attention
                 has been given on how to actually deal with this
                 genericity at the code level. This paper addresses the
                 issue of handling product line variability at the code
                 level. To this end various implementation approaches
                 are examined with respect to their use in a product
                 line context.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Niemela:2001:PLS,
  author =       "Eila Niemel{\"a} and Tuomas Ihme",
  title =        "Product line software engineering of embedded
                 systems",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "118--125",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375271",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In order to be able to determine whether the product
                 line approach is suitable, a company needs to analyse
                 its business drivers, commonality of existing products,
                 domain knowledge owned by the engineering staff, and
                 quality of the representations of existing software
                 artefacts. In this paper we present evaluation criteria
                 for the development of a product line and give an
                 overview of the current state of practices in the
                 embedded software area. Evaluation criteria are divided
                 into three classes. Business drivers of a product line
                 are defined by analysing product assortment and
                 business manners. Domains and personnel are considered
                 in the analysis of the preconditions and targets of a
                 product line. In the development of core assets,
                 elements that affect assets engineering are considered
                 as well as the mechanisms needed in their maintenance.
                 A product line architecture that brings about a balance
                 between subdomains and their most important properties
                 is an investment that must be looked after. However,
                 the subdomains need flexibility to use, change and
                 manage their own technologies, and evolve separately,
                 but in a controlled way.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bachmann:2001:MVS,
  author =       "Felix Bachmann and Len Bass",
  title =        "Managing variability in software architectures",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "126--132",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375274",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper presents experience with explicitly
                 managing variability within a software architecture.
                 Software architects normally plan for change and put
                 mechanisms in the architecture to support those
                 changes. Understanding the situations where change has
                 been planned for and recording the options possible
                 within particular situations is usually not done
                 explicitly. This becomes important if the architecture
                 is used for many product versions over a long period or
                 in a product line context where the architecture is
                 used to build a variety of different products. That is,
                 it is important to explicitly represent variation and
                 indicate within the architecture locations for which
                 change has been allowed. We will describe how the
                 management of variations in an architecture can be made
                 more explicit and how the use of variation points
                 connected to the choices a customer has when ordering a
                 product can help to navigate to the appropriate places
                 in the architecture.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Savolainen:2001:VAF,
  author =       "Juha Savolainen and Juha Kuusela",
  title =        "Violatility analysis framework for product lines",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "133--141",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375277",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Evolution of a software intensive system is
                 unavoidable. In fact, evolution can be seen as a part
                 of reuse process. During the evolution of the software
                 asset, the major part of the system functionality is
                 normally reused. So the key issue is to identify the
                 volatile parts of the domain requirements.
                 Additionally, there is promise that tailored tool
                 support may help supporting evolution in software
                 intensive systems. In this paper, we describe the
                 volatility analysis method for product lines. This
                 highly practical method has been used in multiple
                 domains and is able to express and estimate common
                 types of evolutional characteristics. The method is
                 able to represent volatility in multiple levels and has
                 capacity to tie the volatility estimation to one
                 product line member specification. We also briefly
                 describe current tool support for the method. The main
                 contribution of this paper is a volatility analysis
                 framework that can be used to describe how requirements
                 are estimated to evolve in the future. The method is
                 based on the definition hierarchy framework.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Eckstein:2001:TLC,
  author =       "Silke Eckstein and Peter Ahlbrecht and Karl Neumann",
  title =        "Techniques and language constructs for developing
                 generic informations systems: a case study",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "145--154",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375279",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "When creating a family of systems, i.e. several
                 systems of similar type which differ within some
                 aspects, it is desirable to be able to express these
                 differences already at the level of the specification,
                 and to automatically obtain systems from it which are
                 ready to run. The use of generic methods may lead to
                 substantial progress in this area. This report explores
                 two aspects: parameterization concepts at the
                 specification level, which can be used to describe
                 variants of a system, and generator programs, which
                 produce runnable systems from prefabricated
                 components.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Daneva:2001:EVA,
  author =       "Maya Daneva",
  title =        "Evaluating the value-added benefits of using
                 requirements reuse metrics in {ERP} projects",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "155--163",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375283",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Measurement programs often go astray and fail to reach
                 full success because of misconceptions and differences
                 in expectations about the benefits to be realized as a
                 result of a measurement exercise. This paper suggests
                 how to plan and apply requirements reuse measurement in
                 a business focussed way, by doing frequent benefits
                 assessments. We describe an approach to analyzing,
                 evaluating and tracking the reuse metrics usage
                 patterns in Enterprise Resource Planning (ERP) projects
                 and the benefits gained from integrating requirements
                 reuse measurement practices in the ERP requirements
                 elicitation--modelling--negotiation cycle.
                 Relationships between requirements measurement
                 activities and requirements engineering activities and
                 deliverables are studied in the context of SAP R/ 3
                 implementation projects.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Wong:2001:XIF,
  author =       "Tak Wong and Stan Jarzabek and Soe Myat Swe and Ru
                 Shen and Hongyu Zhang",
  title =        "{XML} implementation of frame processor",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "164--172",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375285",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A quantitative study has shown that frame technology
                 [1] supported by Fusion toolset can lead to reduction
                 in time-to-market (70\%) and project costs (84\%).
                 Frame technology has been developed to handle large
                 COBOL-based business software product families. We
                 wished to investigate how the principle of frame
                 approach can be applied to support product families in
                 other application domains, in particular to build
                 distributed component-based systems written in
                 Object-Oriented languages. As Fusion is tightly coupled
                 with COBOL, we implemented our own tools based on frame
                 concepts using the XML technology. In our solution, a
                 generic architecture for a product family is a
                 hierarchy of XML documents. Each such document contains
                 a reusable program fragment instrumented for change
                 with XML tags. We use a tool built on top of XML
                 parsing framework JAXP to process documents in order to
                 produce a custom member of a product family. Our
                 solution is cost-effective and extensible. In the
                 paper, we describe our solution, illustrating its use
                 with examples. We intend to make our solution available
                 to public in order to encourage investigation of frame
                 concepts in other application domains, implementation
                 languages and platforms.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Zand:2001:CPP,
  author =       "Manzour Zand and Paul Bassett and Rub{\'e}n
                 Prieto-D{\'\i}az",
  title =        "Closing panel (panel session): where are we standing?
                 can we say ``reuse is dead, long live reuse'' or is it
                 too soon?",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "173--175",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.375289",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Desikan:2001:MEE,
  author =       "Rajagopalan Desikan and Doug Burger and Stephen W.
                 Keckler",
  title =        "Measuring experimental error in microprocessor
                 simulation",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "3",
  pages =        "266--277",
  month =        may,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/379377.379271",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:07 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2001:RPCc,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "4",
  pages =        "3--12",
  month =        jul,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505482.505484",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:09 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Cooper:2001:AFPb,
  author =       "Greg Cooper",
  title =        "{ACM Fellow} profile: {Eugene H. Spafford}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "4",
  pages =        "13--16",
  month =        jul,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505482.505485",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:09 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Doernhoefer:2001:SNSc,
  author =       "Mark Doernhoefer",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "4",
  pages =        "17--26",
  month =        jul,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505482.505486",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:09 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mens:2001:FFS,
  author =       "Tom Mens and Michel Wermelinger",
  title =        "{Formal Foundations of Software Evolution}: workshop
                 report",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "4",
  pages =        "27--29",
  month =        jul,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505482.505488",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:09 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The workshop on Formal Foundations of Software
                 Evolution was co-located with the 5th European
                 Conference on Software Maintenance and Reengineering
                 (CSMR 2001), which took place at the Centro de
                 Congressos do Instituto Superior Tcnico in Lisbon,
                 Portugal, March 14 to 16, 2001. The workshop was
                 organised in the context of the Scientific Research
                 Network on Foundations of Software Evolution. This is a
                 research consortium coordinated by the Programming
                 Technology Lab of the Vrije Universiteit Brussel
                 (Belgium), and it involves 9 research institutes from
                 universities in 5 different European countries
                 (Belgium, Germany, Austria, Switzerland, and Portugal).
                 The consortium is financed by the Fund for Scientific
                 Research --- Flanders (Belgium). One full day was
                 allocated for the workshop (March 13, 2001). There were
                 14 participants, that all contributed with a position
                 paper which was reviewed and revised before the
                 workshop. Next to the submissions of the research
                 consortium partners, there were also participants from
                 research institutes in Spain, United Kingdom, Finland,
                 and Japan. In preparation to the workshop, participants
                 were requested to read all other submissions, and asked
                 to prepare a clear position statement and questions
                 that were likely to stimulate discussion. The goal of
                 the workshop was to get more insight into how formal
                 techniques can alleviate software evolution problems,
                 and how they can lead to tools for the evolution of
                 large and complex software systems that are more robust
                 and more widely applicable without sacrificing
                 efficiency. Preferably, the evolution-support tools
                 should not be restricted to a particular phase of
                 software evolution [BR00], but should be generally
                 applicable throughout the entire application lifetime.
                 The tools should also provide support for different
                 aspects of software engineering, such as forward
                 engineering, reverse engineering, re-engineering, and
                 team engineering. In order to stimulate discussions,
                 three general important questions were posed to the
                 participants at the beginning of the workshop: Which
                 aspects of software evolution need to be automated by
                 tools? Where and how can formalisms help us to achieve
                 tool support? How can we build formally-founded tools
                 that are as general and flexible as possible? Note that
                 the generality and flexibility of a tool involves many
                 different aspects: --- independence of the programming
                 language for which support should be provided; ---
                 customisability by the user of the tool;---
                 applicability in or across different stages of software
                 evolution; --- interoperability with other tools; ---
                 scalability to large and complex software systems with
                 multiple developers; --- usable for static
                 (design-time) as well as dynamic (runtime) evolution;
                 --- applicable to forward, reverse, and re-engineering;
                 --- usable before, during, and after evolution; ---
                 usable for facilitating, supporting, as well as
                 analysing evolution; --- to deal with the what and why
                 as well as the how of software evolution",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Anonymous:2001:LSE,
  author =       "Anonymous",
  title =        "Limits to software estimation",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "4",
  pages =        "54--59",
  month =        jul,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505482.505490",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:09 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Algorithmic (KCS) complexity results can be
                 interpreted as indicating some limits to software
                 estimation. While these limits are abstract they
                 nevertheless contradict enthusiastic claims
                 occasionally made by commercial software estimation
                 advocates. Specifically, if it is accepted that
                 algorithmic complexity is an appropriate definition of
                 the complexity of a programming project, then claims of
                 purely objective estimation of project complexity,
                 development time, and programmer productivity are
                 necessarily incorrect.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Anonymous:2001:ESP,
  author =       "Anonymous",
  title =        "Estimating software projects",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "4",
  pages =        "60--67",
  month =        jul,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505482.505491",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:09 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Software Cost Estimation (SCE) continues to be a weak
                 link in software project management. It is the
                 responsibility of the project manager to make accurate
                 estimations of effort and cost. This is particularly
                 true for projects subject to competitive bidding where
                 a bid too high compared with competitors would result
                 in loosing the contract or a bid too low could result
                 in a loss to the organization. From an estimate, the
                 management often decides whether to proceed with the
                 project. Industry has a need for accurate estimates of
                 effort and size at a very early stage in a project.
                 However, when software cost estimates are done early in
                 the software development process the estimate can be
                 based on wrong or incomplete requirements. Software
                 cost estimate process is the set of techniques and
                 procedures that organizations use to arrive at an
                 estimate. Why SCE is difficult and error prone?-
                 Software cost estimation requires a significant amount
                 of effort to perform it correctly.- SCE is often done
                 hurriedly, without an appreciation for the effort
                 required.- You need experience at developing estimates,
                 especially for large projects.- Human bias i.e. an
                 Estimator is likely to consider how long a certain
                 portion of the system would take, and then to merely
                 extrapolate this estimate to the rest of the system,
                 ignoring the non-linear aspects of software
                 development.- Costs and schedules are often
                 pre-determined by an outside source.- An in-depth
                 analysis of the software development process was not
                 undertaken or in many cases, is not fully understood.
                 There is a general lack of acceptance that developing
                 software is an expensive endeavor. The causes of poor
                 and inaccurate estimation are: (a) imprecise and
                 drifting requirements. (b) New software projects are
                 nearly always different form the last. (c) Software
                 practitioners don't collect enough information about
                 past projects. (d) Estimates are forced to match the
                 resources available. The software estimation process
                 discussed in this paper describes the steps required
                 for establishing initial software Life Cycle Cost
                 estimates and then tracking and refining those
                 estimates throughout the life of the project.
                 Establishment of this process early in the life cycle
                 will result in greater accuracy and credibility of
                 estimates and a clearer understanding of the factors
                 that influence software development costs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Long:2001:SRA,
  author =       "John Long",
  title =        "Software reuse antipatterns",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "4",
  pages =        "68--76",
  month =        jul,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505482.505492",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:09 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Software reuse is a productivity technique attempted
                 by many development organizations, with mixed success.
                 In analyzing reuse failures, a number of antipatterns
                 emerge. Antipatterns are obvious, but wrong, solutions
                 to recurring problems. This article outlines a number
                 of reuse antipatterns that have been observed within
                 the software industry.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rangarajan:2001:PQF,
  author =       "Krishnan Rangarajan and N. Swaminathan and Vishu Hegde
                 and Jacob Jacob",
  title =        "Product quality framework: a vehicle for focusing on
                 product quality goals",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "4",
  pages =        "77--82",
  month =        jul,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505482.505493",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:09 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Quality focus is generally on process quality, the
                 avoidance and elimination of defects. This is the most
                 relevant for manufacturing processes. In engineering
                 design, there is as much emphasis also on product
                 quality aspects, such as availability, performance,
                 usability, maintainability etc. Current systems and
                 software engineering practice generally puts the burden
                 of optimizing these attributes solely on the knowledge,
                 intuition and ability of architects and designers. The
                 product quality framework provides a systematic
                 approach that includes techniques for specifying,
                 optimizing, analyzing and measuring these attributes.
                 The framework also puts explicit emphasis on tradeoffs
                 between attributes, providing a direct relationship
                 between design and customer concerns. This paper
                 describes the framework and its use as a vehicle for
                 the engineering of high availability systems.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Anonymous:2001:AOV,
  author =       "Anonymous",
  title =        "An automated oracle for verifying {GUI} objects",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "4",
  pages =        "83--88",
  month =        jul,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505482.505494",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:09 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Recently, software testers have relied more on
                 automated testing to test software. Automated testing
                 method consists of the three modules: test case design,
                 execution, and verification. Yet, to accomplish these
                 three phases, we are always in a dilemma due to a lack
                 of a verification function. Nearly all the commercial
                 automated testing tools cannot efficiently compare
                 graphic objects though GUI (Graphic User Interface)
                 software is now more crucial than text based user
                 interface. This research develops a technique that aids
                 automatic behavior verification for a particularly
                 difficult problem: determining the correction of screen
                 output. Methodology to capture and compare screen
                 output is presented and a case study using
                 Microsoft{\reg} PowerPoint{\reg} is described.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Anantharam:2001:PR,
  author =       "Parasuram Anantharam",
  title =        "Programming ruby",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "4",
  pages =        "89--89",
  month =        jul,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505482.505496",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:09 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Boyer:2001:FPA,
  author =       "Kenneth W. {Boyer, Jr.}",
  title =        "Function point analysis: measurement practices for
                 successful software projects",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "4",
  pages =        "90--90",
  month =        jul,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505482.505497",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:09 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Horning:2001:BRS,
  author =       "Jim Horning",
  title =        "Book Review: {{\booktitle{Software fundamentals:
                 collected papers}} by David L. Parnas}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "4",
  pages =        "91--91",
  month =        jul,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505482.505498",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:09 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Law:2001:QCQ,
  author =       "Jim Law",
  title =        "Quantum computation and quantum information",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "4",
  pages =        "91--91",
  month =        jul,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505482.505499",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:09 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rosenblum:2001:TAE,
  author =       "David Rosenblum",
  title =        "Taming architectural evolution",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "1--10",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503211",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In the world of software development everything
                 evolves. So, then, do software architectures. Unlike
                 source code, for which the use of a configuration
                 management (CM) system is the predominant approach to
                 capturing and managing evolution, approaches to
                 capturing and managing architectural evolution span a
                 wide range of disconnected alternatives. This paper
                 contributes a novel architecture evolution environment,
                 called Mae, which brings together a number of these
                 alternatives. The environment facilitates an
                 incremental design process in which all changes to all
                 architectural elements are integrally captured and
                 related. Key to the environment is a rich system model
                 that combines architectural concepts with those from
                 the field of CM. Not only does this system model form
                 the basis for Mae, but in precisely capturing
                 architectural evolution it also facilitates automated
                 support for several innovative capabilities that rely
                 on the integrated nature of the system model. This
                 paper introduces three of those: the provision of
                 design guidance at the architectural level, the use of
                 specialized software connectors to ensure run-time
                 reliability during component upgrades, and the creation
                 of component-level patches to be applied to deployed
                 system configurations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Morisawa:2001:ASP,
  author =       "Yoshitomi Morisawa and Koji Torii",
  title =        "An architectural style of product lines for
                 distributed processing systems, and practical selection
                 method",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "11--20",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503212",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "When implementing an application system in a
                 distributed computing environment, several
                 architectural questions arise, such as how and where
                 computing resources are arranged, and how the
                 communication among computing resources are
                 implemented. To simplify the process of making these
                 choices, we have developed an architectural style for
                 distributed processing system. The style classifies
                 product lines for distributed processing systems into
                 nine categories based on the location of data storage
                 and the style of processing between client and server.
                 This paper describes our architectural style and
                 proposes a simple but practical method to select an
                 appropriate architectural style for developing an
                 application system. We apply this selection method in
                 concrete real application systems.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Wermelinger:2001:GBA,
  author =       "Michel Wermelinger and Ant{\'o}nia Lopes and Jos{\'e}
                 Luiz Fiadeiro",
  title =        "A graph based architectural (Re)configuration
                 language",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "21--32",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503213",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "For several different reasons, such as changes in the
                 business or technological environment, the
                 configuration of a system may need to evolve during
                 execution. Support for such evolution can be conceived
                 in terms of a language for specifying the dynamic
                 reconfiguration of systems. In this paper, continuing
                 our work on the development of a formal platform for
                 architectural design, we present a high-level language
                 to describe architectures and for operating changes
                 over a configuration (i.e., an architecture instance),
                 such as adding, removing or substituting components or
                 interconnectons. The language follows an imperative
                 style and builds on a semantic domain established in
                 previous work. Therein, we model architectures through
                 categorical diagrams and dynamic reconfiguration
                 through algebraic graph rewriting.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Sliski:2001:AFE,
  author =       "Timothy J. Sliski and Matthew P. Billmers and Lori A.
                 Clarke and Leon J. Osterweil",
  title =        "An architecture for flexible, evolvable process-driven
                 user-guidance environments",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "33--43",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503214",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Complex toolsets can be difficult to use. User
                 interfaces can help by guiding users through the
                 alternative choices that might be possible at any given
                 time, but this tends to lock users into the fixed
                 interaction models dictated by the user-interface
                 designers. Alternatively, we propose an approach where
                 the tool utilization model is specified by a process,
                 written in a process definition language. Our approach
                 incorporates a user-interface specification that
                 describes how the user-interface is to respond to, or
                 reflect, progress through the execution of the process
                 definition. By not tightly binding the user-guidance
                 process, the associated user-interfaces, and the
                 toolset, it is easy to develop alternative processes
                 that provide widely varying levels and styles of
                 guidance and to be responsive to evolution in the
                 processes, user interfaces, or toolset. In this paper,
                 we describe this approach for developing process-driven
                 user-guidance environments, a lossely coupled
                 architecture for supporting this separation of
                 concerns, and a generator for automatically binding the
                 process and the user interface. We report on a case
                 study using this approach. Although this case study
                 used a specific process definition language and a
                 specific toolset, the approach is applicable to other
                 process definition languages and toolsets, provided
                 they meet some basic, sound software engineering
                 requirements.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kaveh:2001:DDD,
  author =       "Nima Kaveh and Wolfgang Emmerich",
  title =        "Deadlock detection in distribution object systems",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "44--51",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503216",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The behaviour of a distributed system is largely
                 determined by the use of synchronization primitives and
                 threading policies of the underlying middleware. The
                 inherent parallel nature of distributed systems may
                 cause liveness problems, such as deadlocks and
                 livelocks. An increasing number of distributed systems
                 is built using object middleware. We exploit the fact
                 that modern object middleware offers only a few
                 built-in synchronization and threading primitives by
                 suggesting UML stereotypes to represent each of these
                 primitives in distributed object design. We define the
                 semantics of the stereotypes using a process algebra.
                 We use that semantics to translate UML diagrams into
                 behaviourally equivalent process algebra
                 representations and can then use model checking
                 techniques to find potential deadlocks. The paper also
                 shows how the model checking results can be related
                 back to the original UML diagrams.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Jagannathan:2001:ICS,
  author =       "Ramesh Jagannathan and Paolo A. G. Sivilotti",
  title =        "Increasing client-side confidence in remote component
                 implementations",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "52--61",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503217",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "When a client makes use of a remote component, it does
                 not have direct access to the remote component's
                 implementation or state information. By observing the
                 component's interactions with its environment, however,
                 the client can determine whether the component's
                 behavior conforms to its promised specification. We
                 present a distributed infrastructure with which a
                 client can make these observations and thereby increase
                 its confidence in the correctness of the remote
                 component. This infrastructure supports temporal
                 specifications of distributed components with
                 autonomous threads of control. It also supports
                 multiple levels of confidence, with commensurate
                 performance costs. As a proof-of-concept for this
                 design, we have implemented a prototype in Java for
                 distributed systems built using CORBA.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Jackson:2001:MM,
  author =       "Daniel Jackson and Ilya Shlyakhter and Manu
                 Sridharan",
  title =        "A micromodularity mechanism",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "62--73",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503219",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A simple mechanism for structuring specifications is
                 described. By modelling structures as atoms, it remains
                 entirely first-order and thus amenable to automatic
                 analysis. And by interpreting fields of structures as
                 relations, it allows the same relational operators used
                 in the formula language to be used for dereferencing.
                 An extension feature allows structures to be developed
                 incrementally, but requires no textual inclusion nor
                 any notion of subtyping. The paper demonstrates the
                 flexibility of the mechanism by application in a
                 variety of common idioms.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Uchitel:2001:DIS,
  author =       "Sebastian Uchitel and Jeff Kramer and Jeff Magee",
  title =        "Detecting implied scenarios in message sequence chart
                 specifications",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "74--82",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503220",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Scenario-based specifications such as Message Sequence
                 Charts (MSCs) are becoming increasingly popular as part
                 of a requirements specification. Scenario describe how
                 system components, the environment and users work
                 concurrently and interact in order to provide system
                 level functionality. Each scenario is a partial story
                 which, when combined with other scenarios, should
                 conform to provide a complete system description.
                 However, although it is possible to build a set of
                 components such that each component behaves in
                 accordance with the set of scenarios, their composition
                 may not provide the required system behaviour. Implied
                 scenarios may appear as a result of unexpected
                 component interaction. In this paper, we present an
                 algorithm that builds a labelled transition system
                 (LTS) behaviour model that describes the closest
                 possible implementation for a specification based on
                 basic and high-level MSCs. We also present a technique
                 for detecting and providing feedback on the existence
                 of implied scenarios. We have integrated these
                 procedures into the Labelled Transition System Analyser
                 (LTSA), which allows for model checking and animation
                 of the behaviour model.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Wendorff:2001:FAA,
  author =       "Peter Wendorff",
  title =        "A formal approach to the assessment and improvement of
                 terminological models used in information systems
                 engineering",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "83--87",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503221",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In the design and implementation of any information
                 system identifiers are used to designate concepts.
                 Typical examples are names of classes, variables,
                 modules, database fields, etc. A terminological model
                 is a set of identifiers together with a set of
                 abstractions and a set of links between identifiers and
                 abstractions. Naturally, terminological models embody
                 important knowledge of a system, and therefore they
                 play an important role during the development of
                 information systems. In this paper we propose a
                 metamodel for terminological models that is based on
                 category theory as conceptual and notational
                 framework.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Coady:2001:UAI,
  author =       "Yvonne Coady and Gregor Kiczales and Mike Feeley and
                 Greg Smolyn",
  title =        "Using {aspectC} to improve the modularity of
                 path-specific customization in operating system code",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "88--98",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503223",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Layered architecture in operating system code is often
                 compromised by execution path-specific customizations
                 such as prefetching, page replacement and scheduling
                 strategies. Path-specific customizations are difficult
                 to modularize in a layered architecture because they
                 involve dynamic context passing and layer violations.
                 Effectively they are vertically integrated slices
                 through the layers. An initial experiment using an
                 aspect-oriented programming language to refactor
                 prefetching in the FreeBSD operating system kernal
                 shows significant benefits, including easy
                 (un)pluggability of prefetching modes, independent
                 development of prefetching modes, and overall improved
                 comprehensibility.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Sullivan:2001:SVM,
  author =       "Kevin J. Sullivan and William G. Griswold and Yuanfang
                 Cai and Ben Hallen",
  title =        "The structure and value of modularity in software
                 design",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "99--108",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503224",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The concept of information hiding modularity is a
                 cornerstone of modern software design thought, but its
                 formulation remains casual and its emphasis on
                 changeability is imperfectly related to the goal of
                 creating added value in a given context. We need better
                 explanatory and prescriptive models of the nature and
                 value of information hiding. We evaluate the potential
                 of a new theory---developed to account for the
                 influence of modularity on the evolution of the
                 computer industry---to inform software design. The
                 theory uses design structure matrices to model designs
                 and real options techniques to value them. To test the
                 potential utility of the theory for software we apply
                 it to Parnas's KWIC designs. We contribute an extension
                 to design structure matrices, and we show that the
                 options results are consistent with Parnas's
                 conclusions. Our results suggest that such a theory
                 does have potential to help inform software design.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{deAlfaro:2001:IA,
  author =       "Luca de Alfaro and Thomas A. Henzinger",
  title =        "Interface automata",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "109--120",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503226",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Conventional type systems specify interfaces in terms
                 of values and domains. We present a light-weight
                 formalism that captures the temporal aspects of
                 software component interfaces. Specifically, we use an
                 automata-based language to capture both input
                 assumptions about the order in which the methods of a
                 component are called, and output guarantees about the
                 order in which the component calls external methods.
                 The formalism supports automatic compatability checks
                 between interface models, and thus constitutes a type
                 system for component interaction. Unlike traditional
                 uses of automata, our formalism is based on an
                 optimistic approach to composition, and on an
                 alternating approach to design refinement. According to
                 the optimistic approach, two components are compatible
                 if there is some environment that can make them work
                 together. According to the alternating approach, one
                 interface refines another if it has weaker input
                 assumptions, and stronger output guarantees. We show
                 that these notions have game-theoretic foundations that
                 lead to efficient algorithms for checking compatibility
                 and refinement.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Inverardi:2001:ASD,
  author =       "Paola Inverardi and Massimo Tivoli",
  title =        "Automatic synthesis of deadlock free connectors for
                 {COM\slash DCOM} applications",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "121--131",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503227",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Many software projects are based on the integration of
                 independently designed software components that are
                 acquired on the market rather than developed within the
                 project itself. Sometimes interoperability and
                 composition mechanisms provided by component based
                 integration frameworks cannot solve the problem of
                 binary component integration in an automatic way.
                 Notably, in the context of component based concurrent
                 systems, the binary component integration may cause
                 deadlocks within the system. In this paper we present a
                 technique to allow connectors synthesis for
                 deadlock-free component based architectures [2] in a
                 real scale context, namely in the context of COM/DCOM
                 applications. This technique is based on an
                 architectural, connector-based approach which consists
                 of synthesizing a COM/DCOM connector as a COM/DCOM
                 server that can route requests of the clients through a
                 deadlock free policy. This work also provides guide
                 lines to implement an automatic tool that derives the
                 implementation of routing dead-lock-free policy within
                 the connector from the dynamic behavior specification
                 of the COM components. It is then possible to avoid the
                 deadlock by using COM composition mechanisms to insert
                 the synthesized connector within the system while
                 letting the system COM servers unimodified. We present
                 a successful application of this technique on the (COM
                 version of the) problem known as ``The dining
                 philosophers''. Depending on the type of deadlock we
                 have a strategy that automatically operates on the
                 connector part of the system architecture in order to
                 obtain a suitably equivalent version of the system
                 which is deadlock-free.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Davis:2001:NPA,
  author =       "L. Davis and R. Gamble and J. Payton and G.
                 J{\'o}nsd{\'o}ttir and D. Underwood",
  title =        "A notation for problematic architecture interactions",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "132--141",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503228",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The progression of component-based software
                 engineering (CBSE) is essential to the rapid,
                 cost-effective development of complex software systems.
                 Given the choice of well-tested components, CBSE
                 affords reusability and increases reliability. However,
                 applications developed according to this practice can
                 often suffer from difficult maintenance and control,
                 problems that stem from improper or inadequate
                 integrate solutions. Avoiding such unfortunate results
                 requires knowledge of what causes the interoperability
                 problems in the first place. The time for this
                 assessment is during application design. In this paper,
                 we define problematic architecture interactions using a
                 simple notation with extendable properties.
                 Furthermore, we delineate a multi-phase process for
                 pre-integration analysis that relies on this notation.
                 Through this effort, potential problematic architecture
                 interactions can be illuminated and used to form the
                 initial requirements of an integration architecture.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Coen-Porisini:2001:USE,
  author =       "Alberto Coen-Porisini and Giovanni Denaro and Carlo
                 Ghezzi and Mauro Pezz{\'e}",
  title =        "Using symbolic execution for verifying safety-critical
                 systems",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "142--151",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503230",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Safety critical systems require to be highly reliable
                 and thus special care is taken when verifying them in
                 order to increase the confidence in their behavior.
                 This paper addresses the problem of formal verification
                 of safety critical systems by providing empirical
                 evidence of the practical applicability of symbolic
                 execution and of its usefulness for checking
                 safety-related properties. In this paper, symbolic
                 execution is used for building an operational model of
                 the software on which safety properties, expressed by
                 means of a Path Description Language (PDL), can be
                 assessed.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Fisler:2001:MVC,
  author =       "Kathi Fisler and Shriram Krishnamurthi",
  title =        "Modular verification of collaboration-based software
                 designs",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "152--163",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503231",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Most existing modular model checking techniques betray
                 their hardware roots: they assume that modules compose
                 in parallel. In contrast, collaboration-based software
                 designs, which have proven very successful in several
                 domains, are sequential in the simplest case. Most
                 interesting collaboration-based designs are really
                 quasi-sequential compositions of parallel compositions.
                 These designs demand and inspire new verification
                 techniques. This paper presents algorithms that exploit
                 the software's modular decomposition to verify
                 collaboration-based designs. Our technique can verify
                 most properties locally in the collaborations; we also
                 characterize when a global state space construction is
                 unavoidable. We have validated our proposal by testing
                 it on several designs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Choi:2001:AAM,
  author =       "Yunja Choi and Sanjai Rayadurgam and Mats P. E.
                 Heimdahl",
  title =        "Automatic abstraction for model checking software
                 systems with interrelated numeric constraints",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "164--174",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503232",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Model checking techniques have not been effective in
                 important classes of software systems characterized by
                 large (or infinite) input domains with interrelated
                 linear and non-linear constraints over the input
                 variables. Various model abstraction techniques have
                 been proposed to address this problem. In this paper,
                 we wish to propose domain abstraction based on data
                 equivalence and trajectory reduction as an alternative
                 and complement to other abstraction techniques. Our
                 technique applies the abstraction to the input domain
                 (environment) instead of the model and is applicable to
                 constraint-free and deterministic constrained data
                 transition system. Our technique is automatable with
                 some minor restrictions.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ramsey:2001:AAF,
  author =       "Norman Ramsey and El{\H{o}}d Csirmaz",
  title =        "An algebraic approach to file synchronization",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "175--185",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503233",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A file synchronizer restores consistency after
                 multiple replicas of a filesystem have been changed
                 independently. We present an algebra for reasoning
                 about operations on filesystems and show that it is
                 sound and complete with respect to a simple model. The
                 algebra enables us to specify a file-synchronization
                 algorithm that can be combined with several different
                 conflict-resolution policies. By contrast, previous
                 work builds the conflict-resolution policy into the
                 specification, or worse, does not specify the
                 synchronizer's behavior precisely. We classify
                 synchronizers by asking whether conflicts can be
                 resolved at a single disconnected replica and whether
                 all replicas are identical after synchronization. We
                 also discuss timestamps and argue that there is no good
                 way to propagate timestamps when there is severe clock
                 skew between replicas.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Engels:2001:MSA,
  author =       "Gregor Engels and Jochem M. K{\"u}ster and Reiko
                 Heckel and Luuk Groenewegen",
  title =        "A methodology for specifying and analyzing consistency
                 of object-oriented behavioral models",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "186--195",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503235",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Object-oriented modeling favors the modeling of object
                 behavior from different viewpoints and the successive
                 refinement of behavioral models in the development
                 process. This gives rise to consistency problems of
                 behavioral models. The absence of a formal semantics
                 for UML models and the numerous possibilities of
                 employing behavioral models within the development
                 process lead to the rise of a number of different
                 consistency notions. In this paper, we discuss the
                 issue of consistency of behavioral models in the UML
                 and present a general methodology how consistency
                 problems can be dealt with. According to the
                 methodology, those aspects of the models relevant to
                 the consistency are mapped to a semantic domain in
                 which precise consistency tests can be formulated. The
                 choice of the semantic domain and the definition of
                 consistency conditions can be used to construct
                 different consistency notions. We show the
                 applicability of our methodology by giving an example
                 of a concrete consistency problem of concurrent
                 object-oriented models.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Lavazza:2001:CUF,
  author =       "Luigi Lavazza and Gabriele Quaroni and Matteo
                 Venturelli",
  title =        "Combining {UML} and formal notations for modelling
                 real-time systems",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "196--206",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503236",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This article explores a dual approach to real-time
                 software development. Models are written in UML, as
                 this is expected to be relatively easy and economic.
                 Then models are automatically translated into a formal
                 notation that supports the verification of properties
                 such as safety, utility, liveness, etc. In this way,
                 developers can exploit the advantages of formal
                 notations while skipping the complex and expensive
                 formal modelling phase. The proposed approach is
                 applied to the Generalised Railroad Crossing (GRC)
                 problem, one of the best known benchmarks proposed in
                 the literature. A UML model of the GRC is built, and
                 then translated into TRIO (a first order temporal
                 logic). The resulting specification properties are
                 tested by a history checking tool which exploits the
                 formality of TRIO. The work described here highlights
                 the shortcomings of UML as a real-time modelling
                 language, proposes enhancements and workarounds to
                 overcome UML limitations, and demonstrates the
                 viability of using UML as a front-end for a formal
                 real-time notation. By translating the GRC model into
                 TRIO, we also give formal semantics to some of the UML
                 constructs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Luer:2001:WEC,
  author =       "Chris L{\"u}er and David S. Rosenblum",
  title =        "{WREN} --- an environment for component-based
                 development",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "207--217",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503238",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Prior research in software environments focused on
                 three important problems---tool integration, artifact
                 management, and process guidance. The context for that
                 research, and hence the orientation of the resulting
                 environments, was a traditional model of development in
                 which an application is developed completely from
                 scratch by a single organization. A notable
                 characteristic of component-based development is its
                 emphasis on integrating independently developed
                 components produced by multiple organizations. Thus,
                 while component-based development can benefit from the
                 capabilities of previous generations of environments,
                 its special nature induces requirements for new
                 capabilities not found in previous environments. This
                 paper is concerned with the design of component-based
                 development environments, or CBDEs. We identify seven
                 important requirements for CBDEs and discuss their
                 rationale, and we describe a prototype environment
                 called WREN that we are building to implement these
                 requirements and to further evaluate and study the role
                 of environment technology in component-based
                 development. Important capabilities of the environment
                 include the ability to locate potential components of
                 interest from component distribution sites, to evaluate
                 the identified components for suitability to an
                 application, to incorporate selected components into
                 application design models, and to physically integrate
                 selected components into the application.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Jahnke:2001:ECB,
  author =       "Jens H. Jahnke",
  title =        "Engineering component-based net-centric systems for
                 embedded applications",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "218--228",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503239",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The omnipresence of the Internet and the World Wide
                 Web (Web) via phone lines, cable-TV, power lines, and
                 wireless RF devices has created an inexpensive media
                 for telemonitoring and remotely controlling distributed
                 electronic appliances. The great variety of potential
                 benefits of aggregating and connecting embedded systems
                 over the Internet is matched by the currently unsolved
                 problem of how to design, test, maintain, and evolve
                 such heterogeneous, collaborative systems. Recently,
                 component-oriented software development has shown great
                 potential for cutting production costs and improving
                 the maintainability of systems. We discuss
                 component-oriented engineering of embedded control
                 software in the light of emerging requirements of
                 distributed, net-centric systems. Our approach is baed
                 on applying the graphical specification language SDL
                 for composing complex networks of embedded software
                 components. From the SDL specification, we generate
                 internet-aware connector components to local embedded
                 controller networks. The described research is carried
                 out in a collaborative effort between industry and
                 academia.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Findler:2001:BCB,
  author =       "Robert Bruce Findler and Mario Latendresse and
                 Matthias Felleisen",
  title =        "Behavioral contracts and behavioral subtyping",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "229--236",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503240",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Component-based software manufacturing has the
                 potential to bring division-of-labor benefits to the
                 world of software engineering. In order to make a
                 market of software components viable, however,
                 producers and consumers must agree on enforceable
                 software contracts. In this paper, we show how to
                 enforce contracts if components are manufactured from
                 class and interface hierarchies. In particular, we
                 focus on one style of contract: pre- and
                 post-conditions. Programmers annotate class and
                 interface methods with pre- and post-conditions and the
                 run-time system checks these conditions during
                 evaluation. These contracts guarantee that methods are
                 called properly and provide appropriate results. In
                 procedural languages, the use of pre- and
                 post-condition contracts is well-established and
                 studies have demonstrated its value. In object-oriented
                 languages, however, assigning blame for pre- and
                 post-condition failures poses subtle and complex
                 problems. Specifically, assigning blame for malformed
                 class and interface hierarchies is so difficult that
                 none of the existing contract monitoring tools
                 correctly assign blame for these failures. In this
                 paper, we show how to overcome these problems in the
                 context of Java. Our work is based on the notion of
                 behavioral subtyping.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Edvardsson:2001:ACS,
  author =       "Jon Edvardsson and Mariam Kamkar",
  title =        "Analysis of the constraint solver in {UNA} based test
                 data generation",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "237--245",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503242",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In a series of articles Gupta et al. develop a
                 framework for automatic test data generation for
                 computer programs. In general, their approach consists
                 of a branch predicate collector, which derives a system
                 of linear inequalities representing the branch
                 predicates for a given path in the program. This system
                 is solved using a solving technique of theirs called
                 the Unified Numerical Approach (UNA) [5, 7]. In this
                 paper we show that in contrast to traditional
                 optimization methods the UNA is not bounded by the size
                 of the solved system. Instead it depends on how input
                 is composed. That is, even for very simple systems
                 consisting of one variable we can easily get more than
                 a thousand iterations. We will also give a formal proof
                 that UNA does not always find a mixed integer solution
                 when there is one. Finally, we suggest using some
                 traditional optimization method instead, like the
                 simplex method in combination with branch-and-bound
                 and/or a cutting-plane algorithm as a constraint
                 solver.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Dickinson:2001:PFD,
  author =       "William Dickinson and David Leon and Andy Podgurski",
  title =        "Pursuing failure: the distribution of program failures
                 in a profile space",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "246--255",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503243",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Observation-based testing calls for analyzing profiles
                 of executions induced by potential test cases, in order
                 to select a subset of executions to be checked for
                 conformance to requirements. A family of techniques for
                 selecting such a subset is evaluated experimentally.
                 These techniques employ automatic cluster analysis to
                 partition executions, and they use various sampling
                 techniques to select executions from clusters. The
                 experimental results support the hypothesis that with
                 appropriate profiling, failures often have unusual
                 profiles that are revealed by cluster analysis. The
                 results also suggest that failures often form small
                 clusters or chains in sparsely-populated areas of the
                 profile space. A form of adaptive sampling called
                 failure-pursuit sampling is proposed for revealing
                 failures in such regions, and this sampling method is
                 evaluated experimentally. The results suggest that
                 failure-pursuit sampling is effective.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Memon:2001:CCG,
  author =       "Atif M. Memon and Mary Lou Soffa and Martha E.
                 Pollack",
  title =        "Coverage criteria for {GUI} testing",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "256--267",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503244",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A widespread recognition of the usefulness of
                 graphical user interfaces (GUIs) has established their
                 importance as critical components of today's software.
                 GUIs have characteristics different from traditional
                 software, and conventional testing techniques do not
                 directly apply to GUIs. This paper's focus is on
                 coverage criteria for GUIs, important rules that
                 provide an objective measure of test quality. We
                 present new coverage criteria to help determine whether
                 a GUI has been adequately tested. These coverage
                 criteria use events and event sequences to specify a
                 measure of test adequacy. Since the total number of
                 permutations of event sequences in any non-trivial GUI
                 is extremely large, the GUI's hierarchical structure is
                 exploited to identify the important event sequences to
                 be tested. A GUI is decomposed into GUI components,
                 each of which is used as a basic unit of testing. A
                 representation of a GUI component, called an event-flow
                 graph, identifies the interaction of events within a
                 component and intra-component criteria are used to
                 evaluate the adequacy of tests on these events. The
                 hierarchical relationship among components is
                 represented by an integration tree, and inter-component
                 coverage criteria are used to evaluate the adequacy of
                 test sequences that cross components. Algorithms are
                 given to construct event-flow graphs and an integration
                 tree for a given GUI, and to evaluate the coverage of a
                 given test suite with respect to the new coverage
                 criteria. A case study illustrates the usefulness of
                 the coverage report to guide further testing and an
                 important correlation between event-based coverage of a
                 GUI and statement coverage of its software's underlying
                 code.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Conradi:2001:ESU,
  author =       "Reidar Conradi and Tore Dyb{\aa}",
  title =        "An empirical study on the utility of formal routines
                 to transfer knowledge and experience",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "268--276",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503246",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Most quality and software process improvement
                 frameworks emphasize written (i.e. formal)
                 documentation to convey recommended work practices.
                 However, there is considerable skepticism among
                 developers to learn from and adhere to prescribed
                 process models. The latter are often perceived as
                 overly ``structured'' or implying too much ``control''.
                 Further, what is relevant knowledge has often been
                 decided by ``others''---often the quality manager. The
                 study was carried out in the context of a national
                 software process improvement program in Norway for
                 small- and medium-sized companies to assess the
                 attitude to formalized knowledge and experience
                 sources. The results show that developers are rather
                 skeptical at using written routines, while quality and
                 technical managers are taking this for granted. This is
                 an explosive combination. The conclusion is that formal
                 routines must be supplemented by collaborative, social
                 processes to promote effective dissemination and
                 organizational learning. Trying to force a
                 (well-intended) quality system down the developers'
                 throats is both futile and demoralizing. The wider
                 implications for quality and improvement work is that
                 we must strike a balance between the ``disciplined'' or
                 ``rational'' and the ``creative'' way of working.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Freimut:2001:ICS,
  author =       "Bernd Freimut and Susanne Hartkopf and Peter Kaiser
                 and Jyrki Kontio and Werner Kobitzsch",
  title =        "An industrial case study of implementing software risk
                 management",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "277--287",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503247",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Explicit risk management is gaining ground in
                 industrial software development projects. However,
                 there are few empirical studies that investigate the
                 transfer of explicit risk management into industry, the
                 adequacy of the risk management approaches to the
                 constraints of industrial contexts, or their
                 cost-benefit. This paper presents results from a case
                 study that introduced a systematic risk management
                 method, namely the Riskit method, into a large German
                 telecommunication company. The objective of the case
                 study was (1) to analyze the usefulness and adequacy of
                 the Riskit method and (2) to analyze the cost-benefit
                 of the Riskit method in this industrial context. The
                 results of (1) also aimed at improvement and
                 customization of the Riskit method. Moreover, we
                 compare our findings with results of previous case
                 studies to obtain more generalized conclusions on the
                 Riskit method. Our results showed that the Riskit
                 method is practical, adds value to the project, and
                 that its key concepts are understood and usable in
                 practice. Additionally, many lessons learned are
                 reported that are useful for the general audience who
                 wants to transfer risk management into new projects.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Shull:2001:EMI,
  author =       "Forrest Shull and Jeffrey Carver and Guilherme H.
                 Travassos",
  title =        "An empirical methodology for introducing software
                 processes",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "288--296",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503248",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "There is a growing interest in empirical study in
                 software engineering, both for validating mature
                 technologies and for guiding improvements of
                 less-mature technologies. This paper introduces an
                 empirical methodology, based on experiences garnered
                 over more than two decades of work by the Empirical
                 Software Engineering Group at the University of
                 Maryland and related organizations, for taking a newly
                 proposed improvement to development processes from the
                 conceptual phase through transfer to industry. The
                 methodology presents a series of questions that should
                 be addressed, as well as the types of studies that best
                 address those questions. The methodology is illustrated
                 by a specific research program on inspection processes
                 for Object-Oriented designs. Specific examples of the
                 studies that were performed and how the methodology
                 impacted the development of the inspection process are
                 also described.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Brada:2001:CRI,
  author =       "P{\v{r}}emysl Brada",
  title =        "Component revision identification based on {IDL\slash
                 ADL} component specification",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "297--298",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503250",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Although software components have become one of the
                 mainstream technologies, they still lack a supportive
                 versioning scheme. This paper describes a system for
                 revision identification of released components with
                 well defined semantics. It is based on the analysis of
                 changes in the component IDL or ADL specification
                 structured into a hierarchy of traits and categories of
                 declarations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Estublier:2001:MMS,
  author =       "J. Estublier and H. Verjus and P. Y. Cunin",
  title =        "Modelling and managing software federations",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "299--300",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503251",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Building large software applications from Commercial
                 Off The Shelf tools (COTS) is not an industrial reality
                 so far. This work presents a new approach to solve the
                 different problems found when building a federation of
                 COTS.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Clarke:2001:STG,
  author =       "Duncan Clarke and Thierry J{\'e}ron and Vlad Rusu and
                 Elena Zinovieva",
  title =        "{STG}: a tool for generating symbolic test programs
                 and oracles from operational specifications",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "301--302",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503252",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We report on a tool we have developed that automates
                 the derivation of tests from specifications. The tool
                 implements conformance testing techniques to derive
                 symbolic tests that incorporate their own oracles from
                 formal operational specifications. It was applied for
                 testing a simple version of the CEPS (Common Electronic
                 Purse Specification).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Basin:2001:FDM,
  author =       "David Basin and Frank Rittinger and Luca Vigan{\`o}",
  title =        "A formal data-model of the {CORBA} security service",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "303--304",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503253",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We use the formal language Z to specify and analyze
                 the security service of CORBA. In doing so, we tackle
                 the problem of how one can apply lightweight formal
                 methods to improve the precision and aid the analysis
                 of a substantial, informal specification. Our approach
                 is scenario-driven: we use representative scenarios to
                 determine which parts of the informal specification
                 should be formalized and then verify the formal
                 specification against the requirements of these
                 scenarios.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Sreedhar:2001:YPS,
  author =       "Vugranam C. Sreedhar",
  title =        "{York}: programming software components",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "305--306",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503254",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ambriola:2001:EWS,
  author =       "Vincenzo Ambriola and R. Mark Greenwood",
  title =        "{8th European Workshop on Software Process
                 Technology}: report and future directions",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "307--308",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503256",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this paper we report on the 8th European Workshop
                 on Software Process Technology held in Witten (Germany)
                 in June 2001. We also report on the outcome of a
                 working session about the future directions of research
                 in software process technology that will be addressed
                 in the next workshop of this series.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Nord:2001:SAC,
  author =       "Robert L. Nord and Daniel J. Paulish and Robert W.
                 Schwanke and Dilip Soni",
  title =        "Software architecture in a changing world: developing
                 design strategies that anticipate change",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "309--310",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503258",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "It is now generally accepted that separating software
                 architecture into multiple views can help in reducing
                 complexity and in making sound decisions about design
                 trade-offs. Our four views are based on current
                 practice; they are loosely coupled, and address
                 different engineering concerns [1]. This tutorial will
                 teach you how global analysis can improve your design,
                 and how to use UML to describe these views. You will
                 learn: (1) the purpose of having separate software
                 architecture views, (2) the difference between using
                 UML for software architecture and the use of UML for
                 designing OO implementations, (3) how to apply global
                 analysis to analyze factors that influence the
                 architecture and to develop strategies that guide the
                 design, (4) the importance of designing for anticipated
                 change to produce more maintainable architectures, and
                 (5) how to incorporate software architecture design in
                 your software process. This tutorial is aimed at
                 experienced software engineers, architects, and
                 technical managers. It is assumed that participants
                 know the basic UML diagrams. Experience in developing
                 models and software design is helpful.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Emmerich:2001:CTJ,
  author =       "Wolfgang Emmerich and Nima Kaveh",
  title =        "Component technologies: {Java Beans}, {COM}, {CORBA},
                 {RMI}, {EJB} and the {CORBA Component Model}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "311--312",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503259",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This one-day tutorial is aimed at software engineering
                 practitioners and researchers, who are familiar with
                 object-oriented analysis, design and programming and
                 want to obtain an overview of the technologies that are
                 enabling component-based development. We introduce the
                 idea of component-based development by defining the
                 concept and providing its economic rationale. We
                 describe how object-oriented programming evolved into
                 local component models, such as Java Beans and
                 distributed object technologies, such as the Common
                 Object Request Broker Architecture (CORBA), Java Remote
                 Method Invocation (RMI) and the Component Object Model
                 (COM). We then address how these technologies matured
                 into distributed component models, in particular
                 Enterprise Java Beans (EJB) and the CORBA Component
                 Model (CCM). We give an assessment of the maturity of
                 each of these technologies and sketch how they are used
                 to build distributed architectures.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kiczales:2001:AOP,
  author =       "Gregor Kiczales and Erik Hilsdale",
  title =        "Aspect-oriented programming",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "313",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503260",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Aspect-oriented programming (AOP) is a technique for
                 improving separation of concerns in software design and
                 implementation. AOP works by providing explicit
                 mechanisms for capturing the structure of crosscutting
                 concerns. This tutorial shows how to use AOP to
                 implement crosscutting concerns in a concise modular
                 way. It works with AspectJ, a seamless aspect-oriented
                 extension to the Java(tm) programming language, and
                 with AspectC, an aspect-oriented extension to C in the
                 style of AspectJ. It also includes a description of
                 their underlying model, in terms of which a wide range
                 of AOP languages can be understood.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Wallnau:2001:HDT,
  author =       "Kurt Wallnau and Scott Hissam and Robert C. Seacord",
  title =        "Half day tutorial in methods of component-based
                 software engineering essential concepts and classroom
                 experience",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "314--315",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503262",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The question of which design methods are appropriate
                 for component-based development (CBD) is complicated by
                 different understandings of the end objectives CBD. A
                 further complication is different understandings of
                 what is meant by ``component.'' These differences lead
                 to entirely distinct classes of design problem. The aim
                 of this tutorial is to, first, outline the differing
                 interpretations of CBD, and, second, to outline the
                 required methodological responses to these design
                 problems.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Lippert:2001:AXC,
  author =       "Martin Lippert and Stefan Roock",
  title =        "Adapting {XP} to complex application domains",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "316--317",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503263",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Extreme programming (XP) works well for small software
                 projects in not-too-complex application domains. In
                 many of these projects the rather simple requirements
                 engineering of XP (customers write story cards) has
                 proved suitable. But today we are more often faced with
                 complex application domains in which the classical XP
                 techniques will not suffice. The tutorial shows how to
                 adapt extreme programming to complex application
                 domains and to demanding development tasks. We focus
                 mainly on the requirements engineering part and show
                 how to enhance XP with interviews, scenarios and system
                 visions. We also integrate the management perspective
                 into the ``planning game'' reconciling this perspective
                 to users' needs. We propose a set of best-practice
                 methods we have used in a number of industrial
                 high-risk projects for different complex application
                 domains.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kirda:2001:EWS,
  author =       "Engin Kirda",
  title =        "Engineering of {Web} services with {XML} and {XSL}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "318--319",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503264",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The important role of Web services in businesses and
                 organizations is undisputed today. The construction and
                 management of large Web services is still a challenge.
                 The life cycle of a Web service includes the analysis,
                 design, implementation and maintenance stages and Web
                 service engineering covers all phases of Web service
                 life cycle. The majority of Web tools developed so far
                 only address the implementation phase and lack support
                 for the other stages. Furthermore, emerging
                 requirements such as the support for mobile devices
                 have introduced new challenges and problems developers
                 have to deal with. The World Wide Web Consortium's
                 eXtensible Markup Language (XML) and the eXtensible
                 Stylesheet Language (XSL) are standards defined in the
                 interest of multi-purpose publishing and content reuse
                 and are increasingly being deployed in the construction
                 of Web services. This tutorial shows how to design,
                 implement, and manage adaptable XML/XSL-based Web
                 services. It discusses and presents our experiences in
                 maintaining and building the Vienna International
                 Festival Web service. It gives a brief overview of
                 popular Web engineering technologies and some tools we
                 have developed. The tutorial also examines the common
                 difficulties, non-difficulties, and solutions of Web
                 service engineering and presents work being done in the
                 area.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Grunbacher:2001:EGS,
  author =       "Paul Gr{\"u}nbacher and Barry Boehm",
  title =        "{EasyWinWin}: a groupware-supported methodology for
                 requirements negotiation",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "320--321",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503265",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "EasyWinWin is a requirements definitions methodology
                 that builds on the win-win negotiation approach and
                 leverages collaborative technology to improve the
                 involvement and interaction of key stakeholders. With
                 EasyWinWin, stakeholders move through a step-by-step
                 win-win negotiation where they collect, elaborate, and
                 prioritize their requirements, and then surface and
                 resolve issues.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mannion:2001:RBP,
  author =       "Mike Mannion and Hermann Kaindl",
  title =        "Requirements-based product line engineering",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "322--323",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503266",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Reuse and requirements are very important for
                 efficient and successful systems development. This
                 tutorial presents the experiences of requirements reuse
                 using a Method for Requirements Authoring and
                 Management (MRAM). MRAM is a method for establishing
                 and selecting from product line requirements. A product
                 line is a group of products within the same market
                 segment e.g. mobile phones. TRAM (Tool for Requirements
                 Authoring and Management) is a software tool to support
                 MRAM that utilises current proven office technology
                 (MS-Word, MS-Access). The tutorial presents the results
                 of MRAM/TRAM as it has been applied to product line
                 engineering of a real-world application.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Zundorf:2001:UCC,
  author =       "Albert Z{\"u}ndorf",
  title =        "From use cases to code --- rigorous software
                 development with {UML}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "324--325",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503267",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The Rational Unified Process lacks technical guidance
                 for the development of object-oriented applications.
                 This tutorial fills this gap. We first use UML scenario
                 diagrams to analyze use-cases. Next, we show a method
                 to analyze scenarios and to derive UML class diagrams
                 and UML behavior modeling for active classes and
                 methods. We show how to choose and embed design
                 patterns in a design and how to employ different
                 architectural styles. From such a precise design, smart
                 CASE tools generate fully functional implementations.
                 We explain state-of-the-art code generation concepts
                 for UML and assess current CASE tools for their code
                 generation capabilities and for their support through
                 all software development phases more generally.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Aberer:2001:PPI,
  author =       "Karl Aberer and Manfred Hauswirth",
  title =        "Peer-to-peer information systems: concepts and models,
                 state-of-the-art, and future systems",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "326--327",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503268",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The limitations of client/server systems become
                 evident in an Internet-scale distributed environment.
                 P2P systems offer an alternative to traditional
                 client/server systems: Every node acts both as a client
                 and a server and ``pays'' its participation by
                 providing access to its computing resources. Systems
                 such as Napster and Gnutella have proven their
                 practical applicability. In this tutorial we position
                 the P2P paradigm in the design space of distributed
                 information systems, present underlying models and
                 concepts, and show the structure, protocols, and
                 algorithms of current systems. Then we elaborate on the
                 novel requirements for P2P algorithms (resource
                 discovery, complexity, and scalability) and present
                 future research areas.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ran:2001:FCP,
  author =       "Alexander Ran",
  title =        "Fundamental concepts for practical software
                 architecture",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "5",
  pages =        "328--329",
  month =        sep,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/503271.503269",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:10 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Architecture of software is a collection of design
                 decisions that are expensive to change. How to identify
                 which design decisions are expensive to change? What
                 are architecture views and which views are needed to
                 adequately describe the architecture of a specific
                 system? How to create and manage software architecture
                 for a product family? This tutorial offers answers to
                 these and other questions that arise in the context of
                 complex software development. We introduce a system of
                 concepts useful in order to understand, design, and
                 evaluate architecture of software intensive systems and
                 system families. Our approach utilizes different
                 software structures in order to control important
                 system qualities related to its development,
                 performance, and evolution. We draw our experience
                 primarily from software embedded in voice and data
                 communication systems. However the same principles can
                 be applied to software architecture in other domains.
                 This tutorial should be useful to engineers and
                 technical managers involved in construction or
                 evaluation of complex software.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2001:RPCd,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "6--15",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505534",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Pfleeger:2001:PSR,
  author =       "Shari Lawrence Pfleeger and Barbara A. Kitchenham",
  title =        "Principles of survey research: part 1: turning lemons
                 into lemonade",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "16--18",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505535",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Doernhoefer:2001:SNSd,
  author =       "Mark Doernhoefer",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "19--28",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505536",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Maurer:2001:IWS,
  author =       "Frank Maurer and Carmen Zannier",
  title =        "{4th ICSE workshop on ``Software Engineering over the
                 Internet''}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "29--31",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505538",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The 4th ICSE workshop on ``Software Engineering over
                 the Internet'' brought together researchers and
                 practitioners that are trying to use Internet
                 technologies to overcome problems in distributed
                 software development. The goal of the workshop was to
                 exchange ideas how distributed projects can utilize the
                 Internet to overcome communication, collaboration, and
                 coordination problems. We summarize the presented
                 papers of the workshop",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tiako:2001:PSD,
  author =       "Pierre F. Tiako and Tim Lindquist and Volker Gruhn",
  title =        "{Process Support for Distributed Team-Based Software
                 Development Workshop}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "31--33",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505539",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This report summarizes the 2$^{nd}$ International
                 Workshop on Process Support for Distributed Team-based
                 Software Development held at the Sheraton World Resort
                 of Orlando, Florida, on July 25, 2000 in conjunction
                 with the Information Systems, Analysis and Synthesis
                 (ISAS2000) International Conference. An overall twenty
                 people attended the workshop consisting of seven
                 technical presentations in two plenary sessions. In the
                 following, we outline the presentations and subsequent
                 discussions, which included modeling and distributing
                 process component, evolution and change, web-based
                 framework, consistency management, and reuse and
                 interoperability. The hardcopy of the papers selected
                 for PDTSD'00 are published by the International
                 Institute of Informatics and Systemics as a part of the
                 `` Industrial Systems '' volume of ISAS 2000, ISBN
                 980-07-6695-2.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Crnkovic:2001:IWC,
  author =       "Ivica Crnkovic and Heinz Schmidt and Judith Stafford
                 and Kurt Wallnau",
  title =        "{4th ICSE Workshop on Component-Based Software
                 Engineering: Component Certification and System
                 Prediction}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "33--40",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505540",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper gives a short overview of the 4th ICSE
                 Workshop on Component-based Software Engineering. The
                 workshop brought together researchers and practitioners
                 from three communities: component technology, software
                 architecture, and software certification. The goal of
                 the workshop was to find a common understanding and to
                 discuss the topics related to the component
                 composition. The workshop was divided in eight sessions
                 held in sequence, starting with invited talks and ended
                 with a final discussion. A model problem, to be used
                 for further research and work in future workshops, was
                 discussed and later selected. The paper gives a
                 comprehensive summary of the sessions and plans for
                 future work.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Thompson:2001:IWC,
  author =       "J. Barrie Thompson",
  title =        "{ICSE2001} workshop to consider global aspects of
                 software engineering professionalism",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "40--44",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505541",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The prime aim of the workshop was to provide a forum
                 to consider global aspects of a Software Engineering
                 profession and determine the relevance and usefulness
                 of an initiative concerning the harmonization of
                 professional standards which had been produced under
                 the auspices of the International Federation of
                 Information Processing. In particular the workshop
                 addressed: the current situation with regard to models
                 of certification and/or licensing in different
                 countries, the drivers and constraints regarding
                 Software Engineering professionalism, the roles of:
                 international bodies and organisations, professional
                 bodies, and learned societies. Also open questions and
                 actions for the future were identified. The planned and
                 the actual operation of the workshop are described. The
                 discussion sessions are outlined and the major issues
                 resulting from these discussions are presented. Post
                 workshop conclusions are reported, as are relevant
                 international developments that have occurred in the
                 three months following the workshop. Also included are
                 two appendices: one providing background information to
                 the workshop the other providing a copy of the IFIP
                 harmonization document.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Castro:2001:SRA,
  author =       "Jaelson Castro and Jeff Kramer",
  title =        "From software requirements to architectures
                 {(STRAW01)}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "49--51",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505542",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The First International Workshop From SofTware
                 Requirements to Architectures (STRAW'01) was held in
                 Toronto, Ontario, Canada, on May 14, 2001, just before
                 the 23$^{rd}$ International Conference on Software
                 Engineering (ICSE). In the following we give an
                 overview of the motivation, goals, selection process
                 and participation, workshop structure and activities,
                 which includes a summary of presentations and
                 discussions that took place during the workshop.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Feller:2001:MSB,
  author =       "Joseph Feller and Brian Fitzgerald and Andr{\'e} van
                 der Hoek",
  title =        "Making sense of the bazaar: {1st Workshop on Open
                 Source Software Engineering}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "51--52",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505543",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Since the coining of the term ``Open Source'' in 1998,
                 there has been a surge of academic and industrial
                 research on the topic. Making Sense of the Bazaar:
                 1$^{st}$ Workshop on Open Source Software Engineering
                 brought together 30 researchers and practitioners from
                 8 countries to discuss Open Source Software as an
                 emerging Software Engineering paradigm. The full
                 proceedings of the workshop have been made available
                 online, and the full workshop report will be published
                 in a special issue of IEE Proceedings --- Software on
                 Open Source Software Engineering.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Loconsole:2001:RMS,
  author =       "Annabella Loconsole and Daniel Rodriguez and
                 J{\"u}rgen B{\"o}rstler and Rachel Harrison",
  title =        "Report on metrics 2001: the science and practice of
                 software metrics conference",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "52--57",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505544",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper reports on the IEEE 7$^{th}$ International
                 Software Metrics Symposium (METRICS 2001), held in
                 London, England, from the 4$^{th}$ to 6$^{th}$ April
                 2001 and co-hosted with the 12$^{th}$ European Software
                 Control and Metrics conference (ESCOM 2001). Metrics
                 Symposia are the premier event in the area of software
                 metrics and attract most of the leading researchers and
                 industrial practitioners.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{vanderHoek:2001:IWS,
  author =       "Andr{\'e} van der Hoek",
  title =        "{International Workshop on Software Configuration
                 Management (SCM-10)}: new practices, new challenges,
                 and new boundaries",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "57--58",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505545",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This report provides a brief summary of SCM-10, the
                 ICSE 2001 10$^{th}$ International Workshop on Software
                 Configuration Management. The primary goal of this
                 workshop was to broaden the scope of SCM and establish
                 ties with other disciplines that are strongly related
                 to SCM---whether requiring some form of novel, advanced
                 SCM functionality or influencing the field of SCM with
                 newly available technology. As demonstrated by the
                 accepted set of position papers and the lively
                 discussion in the workshop, SCM-10 succeeded in
                 achieving this goal and raised many new and important
                 questions to be addressed in the years to come.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Hansen:2001:SDE,
  author =       "W. J. Hansen and J. T. Foreman and C. C. Albert and E.
                 Axelband and L. L. Brownsword and E. C. Forrester",
  title =        "Spiral development and evolutionary acquisition: the
                 {SEI-CSE} workshop",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "59--59",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505546",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mascolo:2001:FIW,
  author =       "Cecilia Mascolo and Wolfgang Emmerich and Anthony
                 Finkelsteiin",
  title =        "{First ICSE 2001 Workshop on XML Technologies and
                 Software Engineering}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "59--61",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505547",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Harman:2001:SWR,
  author =       "Mark Harman and Bryan F. Jones",
  title =        "The {SEMINAL} workshop: reformulating software
                 engineering as a metaheuristic search problem",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "62--66",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505548",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper reports on the first international Workshop
                 on Software Engineering using Metaheuristic INnovative
                 ALgorithms. The aim of the workshop was to bring
                 together researchers in search-based metaheuristic
                 techniques with researchers and practitioners in
                 Software Engineering. The workshop sought to support
                 and develop the embryonic community which straddles
                 these two communities and which is working on the
                 application of metaheuristic search-based techniques to
                 problems in Software Engineering. The paper outlines
                 the nature of the nascent field of Search-Based
                 Software Engineering, and briefly outlines the papers
                 presented at the workshop and the discussions which
                 took place.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Roman:2001:WSE,
  author =       "Gruia-Catalin Roman and Gian Pietro Picco",
  title =        "{Workshop on Software Engineering and Mobility}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "67--70",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505549",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Mobility is redefining the hardware and software
                 fabric of distributed systems. Wireless communication
                 allows network hosts to participate in a distributed
                 computation while on the move. Novel middleware
                 technologies allow software components to migrate
                 across hosts for enhanced flexibility or performance.
                 Workshop participants were invited to analyze the
                 software engineering implications of this wave of
                 technological changes, by discussing fundamental
                 models, emerging themes, research opportunities,
                 technological trends, and market
                 forces.http://www.elet.polimi.it/~picco/ICSE01mobility",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{vanDeursen:2001:CIE,
  author =       "Arie van Deursen",
  title =        "Customer involvement in extreme programming: {XP2001}
                 workshop report",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "70--73",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505550",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper covers customer involvement challenges in
                 light-weight software development processes. The report
                 summarizes the presentations and discussions of the
                 Workshop on Customer Involvement held during XP2001,
                 the Second International Conference on Extreme
                 Programming and Flexible Processes in Software
                 Engineering, Cagliari, Italy, May 21, 2001.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Butler:2001:GTP,
  author =       "Greg Butler",
  title =        "Generative techniques for product lines",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "74--76",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505551",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A software product line leverages the knowledge of one
                 or more domains in order to achieve short
                 time-to-market, cost savings, and high quality
                 software. The highest level of reuse comes by using
                 domain-specific languages or visual builders to
                 describe a member of the product line, and to generate
                 the member from the description. Generative techniques
                 can help us to capture the configuration knowledge for
                 a product line and use it to generate concrete family
                 members. This workshop focuses on technical issues of
                 product lines, rather than economic issues.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Easterbrook:2001:IWL,
  author =       "Steve Easterbrook and Marsha Chechik",
  title =        "{2nd International Workshop on Living with
                 Inconsistency (IWLWI01)}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "76--78",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505552",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "IWLWI-01 --- The Second International Workshop on
                 Living with Inconsistency, took place in Toronto,
                 Canada, on May 13, 2001 as part of ICSE-01. The
                 following is a short overview of this workshop.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kruchten:2001:IWD,
  author =       "Philippe Kruchten and Wojtek Kozaczynski and Bran
                 Selic",
  title =        "{ICSE 2001 Workshop on Describing Software
                 Architecture with UML}",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "78--79",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505553",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Srinivasa:2001:CPS,
  author =       "Srinath Srinivasa",
  title =        "Connotations of problem solving",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "80--82",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505555",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A lot of interest has been focused on analysis and
                 design models during information system (IS) design.
                 But fundamentally, information systems are tools of
                 ``problem solving'' where the term ``problem solving''
                 can take on different connotations. In this paper, we
                 introduce seven different connotations of problem
                 solving that describe IS functionality. Such a
                 knowledge can help the system designer in transitioning
                 between the analysis and design phases.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Dash:2001:DMD,
  author =       "Ashiss Kumar Dash and Rakesh Agarwal",
  title =        "Dimensional modeling for a data warehouse",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "83--84",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505556",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A multidimensional database stores data as groups of
                 field category values into dimensions, and then groups
                 these dimensions into multidimensional arrays. Specific
                 field category values that may occur in data identify
                 either the rows or columns of array dimensions. The
                 specific grouped field categories themselves identify
                 the row or column array dimensions. This view, when
                 presented to the end user, bring in more relevance and
                 business sense for practical decision making than the
                 views presented by standard relational tables and flat
                 file databases. On-Line Analytical Processing (OLAP) is
                 based on the multidimensional representation of data
                 which is supported by multidimensional databases,
                 relational engines or a combination of both. In this
                 paper we propose a model for multidimensional databases
                 that we had used and implemented.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Stalica:2001:MCO,
  author =       "Mark Stalica",
  title =        "Mobile commerce: opportunities, applications, and
                 technologies of wireless business",
  journal =      j-SIGSOFT,
  volume =       "26",
  number =       "6",
  pages =        "85--85",
  month =        nov,
  year =         "2001",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/505532.505558",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:13 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2002:RPCa,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "1",
  pages =        "7--17",
  month =        jan,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566493.566494",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:16 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kitchenham:2002:PSRa,
  author =       "Barbara A. Kitchenham and Shari Lawrence Pfleeger",
  title =        "Principles of survey research part 2: designing a
                 survey",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "1",
  pages =        "18--20",
  month =        jan,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566493.566495",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:16 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This second article of our series looks at the process
                 of designing a survey. The design process begins with
                 reviewing the objectives, examining the target
                 population identified by the objectives, and deciding
                 how best to obtain the information needed to address
                 those objectives. However, we also need to consider
                 factors such as determining the appropriate sample size
                 and ensuring the largest possible response rate. To
                 illustrate our ideas, we use the three surveys
                 described in Part 1 of this series to suggest good and
                 bad practice in software engineering survey research.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Doernhoefer:2002:SNSa,
  author =       "Mark Doernhoefer",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "1",
  pages =        "21--29",
  month =        jan,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566493.566496",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:16 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kim:2002:VRE,
  author =       "Hyoseob Kim",
  title =        "Visit report: {2nd European COTS User Working Group
                 Workshop (ECUA2001)}",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "1",
  pages =        "30--30",
  month =        jan,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566493.1148025",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:16 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{dAdderio:2002:PEC,
  author =       "Luciana d'Adderio and Rick Dewar and Ashley Lloyd and
                 Perdita Stevens",
  title =        "Has the pattern emperor any clothes?: a controversy in
                 three acts",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "1",
  pages =        "31--35",
  month =        jan,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566493.1148026",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:16 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The following is a light-hearted attempt to expose
                 some difficulties in the use of patterns, including
                 some places where naive ways of thinking about how they
                 are used may be insufficient. We'd very much welcome
                 comments, to feed into a more ``academic'' paper on the
                 same subject.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Garcia:2002:PLV,
  author =       "Francisco Jos{\'e} Garc{\'\i}a and Juan-Antonio Barras
                 and Miguel {\'A}ngel Laguna and Jos{\'{}}e Manuel
                 Marqu{\'e}s",
  title =        "Product line variability support by {FORM} and Mecano
                 model integration",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "1",
  pages =        "35--38",
  month =        jan,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566493.1148027",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:16 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A product line definition must cover several systems,
                 for this reason additional requirements are included as
                 product line assets during domain engineering. Generic
                 assets are presented to cover all components the
                 product line instances are built from, and their
                 corresponding composition rules. These generic assets
                 embrace common and variable product aspects supporting
                 the variability in product line definition and
                 instantiation. This paper is devoted to present the
                 problem of handling product line variability in every
                 life-cycle stage by the integration of the ideas of the
                 domain engineering method FORM (Feature-Oriented Reuse
                 Method) and the Mecano Model, which defines a
                 coarse-grained reusable element structure.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Duran:2002:VSR,
  author =       "Amador Dur{\'a}n and Antonio Ruiz and Beatriz
                 Bern{\'a}rdez and Miguel Toro",
  title =        "Verifying software requirements with {XSLT}",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "1",
  pages =        "39--44",
  month =        jan,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566493.1148028",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:16 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this article, we present an approach for the
                 automatic verification of software requirements
                 documents. This approach is based on the representation
                 of software requirements in XML and the usage of the
                 XSLT language not only to automatically generate
                 requirements documents, but also to verify some desired
                 quality properties and to compute some metrics. These
                 ideas have been implemented in REM, an experimental
                 requirements management tool that is also described in
                 this paper.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{M:2002:UCL,
  author =       "Bharath Kumar M. and Y. N. Srikant and
                 Lakshminarayanan R.",
  title =        "On the use of connector libraries in distributed
                 software architectures",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "1",
  pages =        "45--52",
  month =        jan,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566493.1148029",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:16 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Recent developments in the field of software
                 architecture have emphasized the concept of first class
                 connectors, which capture the interaction between
                 components. The concept of first class connectors aids
                 the development of distributed software architectures
                 since it can be used to separate concerns of remote
                 interaction between components. A library of prewritten
                 connectors would help prototype, develop, maintain and
                 reconfigure distributed software architectures.
                 Completely automating the usage of connector libraries
                 in distributed software architectures is not trivial
                 since code fragments implementing the connectors have
                 to be partitioned, deployed and instantiated in
                 different machines. In this paper we discuss these
                 issues in connector refinement and instantiation
                 imposed by distributed software architectures and
                 present the construction of a tool that works alongside
                 a connector library to automatically partition, deploy
                 and instantiate architectural entities in various
                 machines. Scalability of the tool to allow for new
                 connector types has been an important issue in its
                 design and function. We also demonstrate the high
                 flexibility and reconfigurability achieved on an
                 interesting application by using a connector library
                 along with our tool.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Xiaochun:2002:AIN,
  author =       "Xu Xiaochun and Xu Guanghui and Xu Yongsen",
  title =        "Architectural issues in network-centric computing",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "1",
  pages =        "53--57",
  month =        jan,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566493.1148030",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:16 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The widespread use of the Internet has led to great
                 changes in traditional computational models. The
                 concept of the network-centric computing is becoming
                 more and more popular. Software architecture, as an
                 emerging discipline, focuses on the high-level
                 structures of large complex software systems. With the
                 critical challenges from the new computational model,
                 many open issues of software architectures emerge. In
                 this paper, we present some requisite technologies that
                 are still not completely settled and offer some
                 suggestions based on a survey of relevant study
                 experience to date.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bo:2002:EOO,
  author =       "Gao Bo and Fei Qi and Chen Xueguang",
  title =        "Exploiting object-oriented methodologies to model
                 {MAS} on organizations",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "1",
  pages =        "58--62",
  month =        jan,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566493.1148031",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:16 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Researchers have recognized multi-agent systems (MAS)
                 as being a promising means to cope with distributed and
                 complex problems. However, how to analyze and design an
                 agent-based system in practical environments is still
                 difficult. Based on the inherent consistency between
                 objects and agents, MAS and human social organizations,
                 we propose an approach using comparatively mature
                 object-oriented (OO) methodologies and tools (mostly
                 UML) to model MAS from the point of view of
                 organization depiction. This paper uses a distributed
                 logistics management system (DLMS) as an example and
                 describes a method to model MAS based on extended UML
                 from the following three aspects: $ \bullet $
                 extracting roles for agent organizations based on the
                 theory of use cases, $ \bullet $ depicting the static
                 organizational structures of MAS based on the semantics
                 and syntax of class diagrams, and $ \bullet $ extending
                 collaboration diagrams, sequence diagrams and state
                 chart diagrams to portray the interactive behaviors
                 among agent roles and the reasoning behaviors within
                 agent roles themselves.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Aggarwal:2002:CPW,
  author =       "K. K. Aggarwal and Yogesh Singh and Jitender Kumar
                 Chhabra",
  title =        "Computing program weakness using module coupling",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "1",
  pages =        "63--65",
  month =        jan,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566493.566497",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:16 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this paper, a method has been developed to measure
                 the weakness of the program using module weakness and
                 different types of module coupling. The paper justifies
                 the need of considering coupling effect on program
                 weakness. Various types of coupling are computed using
                 parameters/variables and module weakness is found using
                 average number of live variables and average life of
                 variables in the module. The module coupling and module
                 weakness values are used to compute program weakness,
                 which can be used to indicate the maintainability and
                 testability of the program.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Benedicenti:2002:SCM,
  author =       "Luigi Benedicenti",
  title =        "Software Configuration Management Strategies and
                 Rational {ClearCase(r)}",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "1",
  pages =        "67--67",
  month =        jan,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566493.566499",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:16 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2002:RPCb,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "5--19",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511154",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kitchenham:2002:PSRb,
  author =       "Barbara A. Kitchenham and Shari Lawrence Pfleeger",
  title =        "Principles of survey research: part 3: constructing a
                 survey instrument",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "20--24",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511155",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this article, we discuss how to construct a
                 questionnaire. We point out the need to use any
                 previous research results to reduce the overheads of
                 survey construction. We identify a number of issues to
                 consider when selecting questions, constructing
                 questions, deciding on the type of question and
                 finalizing the format of the questionnaire.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Doernhoefer:2002:SNSb,
  author =       "Mark Doernhoefer",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "25--34",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511156",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{BenAchour-Salinesi:2002:RWS,
  author =       "Camille {Ben Achour-Salinesi} and Andreas Opdahl and
                 Matti Rossi",
  title =        "{REFSQ '2001} workshop summary: {Seventh International
                 Workshop on Requirements Engineering: Foundations for
                 Software Quality}",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "35--49",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511158",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The Seventh International Workshop on RE: Foundation
                 for Software Quality (REFSQ'2001) was held in
                 conjunction with CAiSE*01 in Interlaken, Switzerland on
                 June 4th and 5th 2001. The workshop was organised by
                 Camille Ben Achour --- Salinesi, Andreas L. Opdahl and
                 Matti Rossi, with Eric Dubois and Klaus Pohl serving on
                 the REFSQ Advisory Board. This workshop summary gives
                 an overview of the presentations and numerous fruitful
                 discussions that took place at REFSQ'2001",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Knauber:2002:PSP,
  author =       "Peter Knauber and Giancarlo Succi",
  title =        "Perspectives on Software Product Lines: report on
                 {Second International Workshop on Software Product
                 Lines: Economics, Architectures, and Implications
                 Workshop} at {23rd International Conference on Software
                 Engineering (ICSE)}",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "40--45",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511159",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Product line engineering is a recent concept and one
                 of the hottest topics in software engineering aiming at
                 synergy effects in software development. Diverse
                 benefits like cost reduction, decreased time-to-market,
                 and quality improvement can be expected from reuse of
                 domain-specific software assets, several successful
                 product line projects have been performed and
                 documented [3]. Also non-technical benefits as result
                 of network externalities, product branding, and sharing
                 organizational costs have been observed. Following the
                 remarkable success of the ``First International
                 Workshop on Software Product Lines: Economics,
                 Architectures, and Implications'' held at ICSE 2000 in
                 Limerick [1], this second workshop stresses more the
                 non-technical, that is, business and organizational
                 aspects of product line adoption and
                 institutionalization. Another major topic of interest
                 are product line tools, as tool support seems to become
                 more and more critical for the success of product line
                 approaches. Different tool concepts have been proposed
                 and discussed during the workshop. Requirements for
                 tools and respective solutions seem to become more
                 concrete, maybe resulting from the fact that the
                 technical concepts and solutions of product line
                 approaches are better understood and can therefore be
                 better supported with tools. The strong emphasis on
                 establishing contacts and giving experts and
                 practitioners from academia and industry a platform for
                 discussion has been continued during this second
                 workshop. Section 2 of this workshop summary describes
                 the formal structure of the workshop. In Section 3, a
                 short summary of the invited talk on issues and
                 opportunities in product line research is given.
                 Section 4 summarizes key points of the presentations of
                 the workshop participants that were given based on
                 their submitted papers that are fully available at [2].
                 In Section 5, the plenary discussion is described and
                 its major lessons learned are summarized. Section 6
                 concludes this paper.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Raccoon:2002:PDG,
  author =       "L. B. S. Raccoon",
  title =        "Practitioners do good work",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "46--52",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511160",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "I believe that software engineers have done, are
                 doing, and will continue to do good work. Practitioners
                 contribute to the well-being of society and add value
                 to the economy. Working applications enable hundreds of
                 millions of users around the world to productively do
                 things that would otherwise be impossible.I do not
                 claim that software engineers are perfect. Bugs seem to
                 lurk in almost all programs. Reliable schedules and
                 budgets remain elusive. And, software has created whole
                 new slates of problems, like hacking and viruses. For
                 now, I rely on Peter Neumann and his Risks columns to
                 document these concerns. I consider this paper a
                 companion to counterpoint Neumann's columns. My primary
                 purpose is to claim that software engineers are
                 successful, in spite of their shortcomings. In the
                 first section, I argue that practitioners create
                 enormous social and economic value. In the second
                 section, I discuss the ongoing improvement that
                 software engineers make in their practice. In the third
                 section, I propose documenting the greatest twenty
                 achievements of software engineering to show the
                 success of practitioners. And in the fourth section, I
                 argue that practitioners earn their keep. My secondary
                 propose is to respond to and elaborate on comments made
                 at the Why Don't We Get More (Self?) Respect panel at
                 ICSE 2000 and the Impact Project Panel at ICSE 2001. I
                 discuss how software engineers contribute to projects
                 like the world wide web, and I echo Larry Bernstein's
                 comments that software engineers deliver value.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Workman:2002:CMT,
  author =       "David A. Workman",
  title =        "A class and method taxonomy for object-oriented
                 programs",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "53--58",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511161",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The object-oriented approach to software design
                 together with the programming languages (C++, Java, and
                 Ada95) and design notations (e.g. UML) that support
                 this paradigm, have precipitated new interest in
                 developing and tailoring software metrics to more
                 effectively quantify properties of OO systems. To be
                 specific, this research on OO software is motivated by
                 two related problems. (1) In many computer science
                 courses instructors are torn between two conflicting
                 goals: (a) increasing the number and difficulty of
                 programming assignments to raise students' problem
                 solving skills and maturity, while on the other hand,
                 (b) giving meaningful feedback on the correctness and
                 quality of programs they write. To address this
                 problem, we are developing an automated Java program
                 grading system. This system will compare student
                 programs to an oracle program prepared by the
                 instructor for a given assignment. The oracle program
                 represents the ``ideal'' solution. In addition to
                 computing a quantitative score for a student program,
                 the grading program will also provide feedback on
                 modifications or changes the student could or should
                 make to improve the quality of the design of his or her
                 solution. (2) A problem that is all too common in the
                 computing industry is software theft. This has led to
                 much copyright infringement litigation within our court
                 system. As an expert witness in such cases, one of the
                 tasks I have been frequently asked to perform is
                 evaluate two programs to determine the nature and
                 extent of their similarity. A tool, such as our planned
                 program grading system, is needed to facilitate the
                 kind of analysis required in such cases. In the
                 academic world, the equivalent to software theft is
                 plagiarism. Therefore, as an application complementary
                 to program grading, our proposed system will also serve
                 as a tool for identifying ``cheaters'' by comparing two
                 student programs to one another, rather than to the
                 oracle. So, in summary, our goal is to develop the key
                 algorithms and eventually a program analysis system
                 that will effectively determine the similarity of two
                 programs written in the same language. Since Java is
                 becoming one of the most widely used programming
                 languages, and because of its relatively ``clean''
                 syntax and semantics, Java will provide the focus for
                 our initial investigation. Java programs are composed
                 of three essential building blocks: packages, classes,
                 and methods. Methods are the functional or procedural
                 units that perform or realize the algorithms necessary
                 to solve a computational problem. Methods are grouped
                 with encapsulated data to define classes -new types
                 that extend Java's set of primitive types. Finally,
                 classes are organized into subsystems or libraries
                 using packages. Thus, when comparing two Java programs
                 to determine their similarity, we must establish a
                 correspondence between the packages, classes, and
                 methods of the two programs under consideration. This
                 suggests we must ascertain for a given pair of units,
                 one from each program whether or not they are
                 sufficiently similar to warrant being identified as
                 ``matching'' in our correspondence analysis. To be
                 similar, they must be ``doing the essentially the same
                 thing'' -that is, they must both serve the same
                 computational purpose. Assuming we are successful in
                 developing some technique for determining similarity of
                 purpose, we are still faced with the potentially large
                 numbers of unit-pairs that must be considered in our
                 analysis. The sheer magnitude of our computational
                 problem thus looms as a major obstacle to obtaining any
                 real practical solution. Using the names of units to
                 limit what pairs need to be compared, while certainly
                 reducing the potential computational load, is not a
                 very reliable strategy --- particularly if the author
                 of one program has made a deliberate attempt to
                 disguise similarity with another program by uniformly
                 changing names. Thus, in an attempt to address the
                 computational load problem and the identification
                 problem for comparison analysis, we plan to make an
                 initial pass over each program to categorize methods
                 and classes according to their purpose. The rationale
                 for this is: two units will be selected for detailed
                 comparison analysis only if they belong to of the same
                 purpose category. The focus of this paper, therefore,
                 is to present definitions and examples of the purpose
                 categories for methods and classes. How these purpose
                 categories will be used in a larger comparison strategy
                 is beyond the scope of this work. Refer to Lan[13] for
                 further a more complete and detailed description of our
                 methodology.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Sagheb-Tehrani:2002:SDP,
  author =       "Mehdi Sagheb-Tehrani and Arbi Ghazarian",
  title =        "Software development process: strategies for handling
                 business rules and requirements",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "58--62",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511162",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A successful project demands a correct and thorough
                 requirements specification. This paper proposes
                 techniques and strategies for handling business rules
                 and requirements. The guidelines we provide are based
                 on our own experiences with the development of
                 large-scale enterprise applications as well as research
                 we have done on best practices for requirements
                 management proposed by other authors. The techniques
                 are based on recursively classifying software
                 requirements into logical coherent classes of
                 requirements so that they improve developers'
                 conception of the requirements and streamline the
                 navigation to the next steps in the process. The
                 techniques proposed in this paper, provide a mechanism
                 for keeping track of requirements and help the
                 development team to test the software in a more
                 efficient way.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Vogt:2002:IEC,
  author =       "Christian Vogt",
  title =        "Intractable {ERP}: a comprehensive analysis of failed
                 enterprise-resource-planning projects",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "62--68",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511163",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "An enterprise-resource-planning system --- or ERP
                 system, for short --- is by definition ``any software
                 system designed to support and automate the business
                 processes of medium and large businesses.'' [16]
                 Integrated ERP systems became popular in the early
                 1990's. Single monolithic pieces of software, ERP
                 systems promised to do away with inconsistent data,
                 incompatible formats, and uncooperative applications.
                 Still, ERP systems come with their own, unexpected
                 difficulties. Their tremendous generality and enormous
                 complexity make them prone to glitches and low
                 performance, difficult to maintain, and nightmarish to
                 implement. This study takes a close look at four
                 ERP-implementation failures, all of which occurred
                 recently in American industry. It analyses possible
                 causes that led to the disasters, and suggests
                 software-engineering processes that help avoiding such
                 outcomes. The Model-Based Architecting and Software
                 Engineering (MBASE) guidelines, developed by Professors
                 Barry Boehm and Daniel Port at the Center for Software
                 Engineering (CSE) at USC, provide a base for these
                 elaborations. The original workout is actually far more
                 extensive than the abridgement published here. It can
                 be downloaded from the CSE web page. Alternatively, it
                 may be ordered from the author directly through
                 email.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Anantharam:2002:PWD,
  author =       "Parasuram Anantharam",
  title =        "Practical {WAP}: developing applications for the
                 wireless web",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "69--69",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511165",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bielikova:2002:WWM,
  author =       "M{\'a}ria Bielikov{\'a}",
  title =        "Wireless {Web}: a manager's guide",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "69--70",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511166",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Boyer:2002:CD,
  author =       "Kenneth W. {Boyer, Jr.}",
  title =        "{CMMI} distilled",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "70--70",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511167",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Boyer:2002:AUC,
  author =       "Kenneth W. {Boyer, Jr.}",
  title =        "Advanced use case modeling: software systems",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "71--71",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511168",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Frazer:2002:BSS,
  author =       "Ken Frazer",
  title =        "Building secure software: how to avoid security
                 problems the right way",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "71--72",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511169",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Huber:2002:PRS,
  author =       "Andy Huber",
  title =        "Peer reviews in software: a practical guide",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "72--73",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511170",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Pentinmaki:2002:MED,
  author =       "Isaac Pentinmaki",
  title =        "Mastering {ENVY\slash Developer}",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "73--73",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511171",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Shakir:2002:TAB,
  author =       "Maha Shakir",
  title =        "Technology acquisition: buying the future of your
                 business",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "2",
  pages =        "73--74",
  month =        mar,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/511152.511172",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:17 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2002:RPCc,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "3",
  pages =        "5--19",
  month =        may,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/638574.638578",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:18 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kitchenham:2002:PSRc,
  author =       "Barbara Kitchenham and Shari Lawrence Pfleeger",
  title =        "Principles of survey research part 4: questionnaire
                 evaluation",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "3",
  pages =        "20--23",
  month =        may,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/638574.638580",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:18 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This article discusses how to avoid biased questions
                 in survey instruments, how to motivate people to
                 complete instruments and how to evaluate instruments.
                 In the context of survey evaluation, we discuss how to
                 assess survey reliability i.e. how reproducible a
                 survey's data is and survey validity i.e. how well a
                 survey instrument measures what it sets out to
                 measure.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Doernhoefer:2002:SNSc,
  author =       "Mark Doernhoefer",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "3",
  pages =        "24--33",
  month =        may,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/638574.638582",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:18 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Lawrie:2002:IDO,
  author =       "Tony Lawrie and Cristina Gacek",
  title =        "Issues of dependability in open source software
                 development",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "3",
  pages =        "34--37",
  month =        may,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/638574.638584",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:18 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper presents issues raised by the articles,
                 presentations, and discussions concerning Open Source
                 Software, Trustworthiness, and Dependability at the
                 Open Source Development Workshop held in Newcastle upon
                 Tyne, UK, on the 25$^{th}$ and 26$^{th}$ of February
                 2002.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Inverardi:2002:SPS,
  author =       "Paola Inverardi",
  title =        "The {SALADIN} project: summary report",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "3",
  pages =        "38--43",
  month =        may,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/638574.638585",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:18 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "It is apparent that, in the near future, software
                 production will be more and more involved with
                 applications running on heterogeneous networks, often
                 with mobile components. Witness the increasing
                 availability of reliable broadband communication
                 networks, which span local, metropolitan and worldwide
                 areas, and the high popularity of newly conceived
                 applications on Internet, such as the World Wide Web.
                 The development of applications for heterogeneous
                 distributed networks that support mobile components (in
                 short, programming mobile agents) demands innovative
                 design and programming techniques. In this report we
                 summarize the activities and results achieved in the
                 SALADIN project, an Italian National project funded by
                 the Italian Ministry of University and Research. We
                 consider our experience interesting for the Software
                 Engineering community because it has been a successful
                 experiment in putting together teams whose expertise
                 was sensibly different and complementary. This has
                 allowed us to exploit the cooperation of different
                 complementary competencies that are needed to reach
                 significant results in an area where methods and tools,
                 which are specific of several area of computing come
                 naturally together.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Liu:2002:RDR,
  author =       "Chang Liu and Debra J. Richardson",
  title =        "Research directions in {RAIC}",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "3",
  pages =        "43--46",
  month =        may,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/638574.638586",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:18 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Redundant arrays of independent components (RAIC) was
                 a technology developed to use groups of similar
                 software components to build reliable applications. The
                 principles of RAIC, however, can be applied to other
                 types of components. This paper briefly introduces RAIC
                 and discusses future research directions in RAIC.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Crnkovic:2002:CBS,
  author =       "Ivica Crnkovic and Stig Larsson and Judith Stafford",
  title =        "Component-based software engineering: building systems
                 from components at {9th IEEE Conference and Workshops
                 on Engineering of Computer-Based Systems}",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "3",
  pages =        "47--50",
  month =        may,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/638574.638587",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:18 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper gives a short overview of the Workshop on
                 Component-based Software Engineering --- Building
                 Systems from Components held at 9th IEEE Conference and
                 Workshops on Engineering of Computer-Based Systems in
                 Lund, Sweden, April, 2002. The aim of the workshop was
                 to bring together researches and practitioners from
                 system engineering, software architecture and from
                 component-based software engineering communities in
                 order to exchange experiences and research results from
                 these domains.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Vogt:2002:ACR,
  author =       "Christian Vogt",
  title =        "Admission control and resource reservation on the
                 internet",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "3",
  pages =        "80--87",
  month =        may,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/638574.638575",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:18 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Software engineers used to have a hard time developing
                 real-time and interactive Web applications, Most of
                 such software requires high and stable throughput, a
                 prerequisite which the Internet's best-effort service
                 does not provide. Hence, a large body of effort has
                 recently gone, and is currently going, into
                 modifications to the Internet architecture. Software
                 engineers should closely monitor this research, and
                 leverage new technologies to build applications that
                 get the most from the Web. This study explains how the
                 Internet Engineering Task Force's (IETF) working groups
                 IntServ and DiffServ seek to transition the Internet
                 into a robust platform for high quality of service. It
                 elaborates on the Resource Reservation Protocol's
                 (RSVP) method of procedure to reserve bandwidth and
                 buffer space in IP routers along a data flow's
                 sender-receiver path. It presents the Subnet Bandwidth
                 Manager's (SBM) mapping of RSVP functionality onto
                 local- and metropolitan-area networks that use a shared
                 medium. Furthermore, it discovers a way to implement
                 demanding, yet adaptive, Web applications that are
                 content with traditional best effort. The paper
                 concludes with the Common Open Policy Service (COPS), a
                 framework for policy decision-making and enforcement.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Han:2002:VIM,
  author =       "Hong Han and Jun Lu and Xianliang Lu",
  title =        "Virtual Interface Machine: a design pattern to solve
                 the problem of coupling and efficiency in software
                 design",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "3",
  pages =        "88--92",
  month =        may,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/638574.638576",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:18 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this paper, we try to tackle three relative
                 problems in software design. The first one is the
                 separation of user interface (UI) from logic layer. The
                 second one is the decoupling of components of UI. The
                 last one is how to combine high reusability design with
                 efficiency of drag-and-drop mode of rapid application
                 development (RAD) tools. As far as decoupling is
                 concerned, there are many design patterns to tackle it,
                 such as MVC (Model-View-Controller), Mediator,
                 Observer, Visual Proxy, etc, which are not satisfying,
                 because of the obvious disadvantage that collaborative
                 components are actually tightly coupled by a specific
                 object (like mediator, controller, etc). As for the
                 last problem, many hold that drag-and-drop mode of RAD
                 would compromise the reusability and maintainability of
                 OO design. We use a method called drag-drop-and-add to
                 achieve both reusability and efficiency. This paper
                 presents a pattern called Virtual Interface Machine
                 that let us separate UI from logic layer, decouple
                 components of UI entirely and enjoy efficiency of RAD
                 in UI design without compromising reusability and
                 maintainability of the whole design. By the thorough
                 decoupling, we could even change both logic layer and
                 UI at run time, which is impossible to other patterns.
                 In practice, we implemented the pattern in our
                 Intrusion Detection System (IDS).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Law:2002:MDI,
  author =       "James Law",
  title =        "Mechatronics and the design of intelligent machines
                 and systems",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "3",
  pages =        "93--93",
  month =        may,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/638574.638589",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:18 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Saur:2002:ERP,
  author =       "Joe Saur",
  title =        "Effective requirements practices",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "3",
  pages =        "93--94",
  month =        may,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/638574.638590",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:18 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tanuan:2002:LSD,
  author =       "Meyer Tanuan",
  title =        "Leading a software development team",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "3",
  pages =        "94--94",
  month =        may,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/638574.638591",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:18 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Weber-Wulff:2002:HCI,
  author =       "Debora Weber-Wulff",
  title =        "Human-computer interaction in the new millennium",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "3",
  pages =        "94--95",
  month =        may,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/638574.638592",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:18 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Milanova:2002:POS,
  author =       "Ana Milanova and Atanas Rountev and Barbara G. Ryder",
  title =        "Parameterized object sensitivity for points-to and
                 side-effect analyses for {Java}",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "1--11",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566174",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The goal of points-to analysis for Java is to
                 determine the set of objects pointed to by a reference
                 variable or a reference objet field. Improving the
                 precision of practical points-to analysis is important
                 because points-to information has a wide variety of
                 client applications in optimizing compilers and
                 software engineering tools. In this paper we present
                 object sensitivity, a new form of context sensitivity
                 for flow-insensitive points-to analysis for Java. The
                 key idea of our approach is to analyze a method
                 separately for each of the objects on which this method
                 is invoked. To ensure flexibility and practicality, we
                 propose a parameterization framework that allows
                 analysis designers to control the tradeoffs between
                 cost and precision in the object-sensitive analysis.
                 Side-effect analysis determines the memory locations
                 that may be modified by the execution of a program
                 statement. This information is needed for various
                 compiler optimizations and software engineering tools.
                 We present a new form of side-effect analysis for Java
                 which is based on object-sensitive points-to analysis.
                 We have implemented one instantiation of our
                 parameterized object-sensitive points-to analysis. We
                 compare this instantiation with a context-insensitive
                 points-to analysis for Java which is based on
                 Andersen's analysis for C [4]. On a set of 23 Java
                 programs, our experiments show that the two analyses
                 have comparable cost. In some cases the
                 object-sensitive analysis is actually faster than the
                 context-insensitive analysis. Our results also show
                 that object sensitivity significantly improves the
                 precision of side-effect analysis, call graph
                 construction, and virtual call resolution. These
                 experiments demonstrate that object-sensitive analyses
                 can achieve significantly better precision than
                 context-insensitive ones, while at the same time
                 remaining efficient and practical.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Groce:2002:MCJ,
  author =       "Alex Groce and Willem Visser",
  title =        "Model checking {Java} programs using structural
                 heuristics",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "12--21",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566175",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We describe work introducing heuristic search into the
                 Java PathFinder model checker, which targets Java
                 bytecode. Rather than focusing on heuristics aimed at a
                 particular kind of error (such as deadlocks) we
                 describe heuristics based on a modification of
                 traditional branch coverage metrics and other structure
                 measures, such as thread inter-dependency. We present
                 experimental results showing the utility of these
                 heuristics, and argue for the usefulness of structural
                 heuristics as a class.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Liang:2002:EPS,
  author =       "Donglin Liang and Maikel Pennings and Mary Jean
                 Harrold",
  title =        "Evaluating the precision of static reference analysis
                 using profiling",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "22--32",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566176",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Program analyses and optimizations of Java programs
                 require reference information that determines the
                 instances that may be accessed through dereferences.
                 Reference information can be computed using reference
                 analysis. This paper presents a set of studies that
                 evaluate the precision of two existing approaches for
                 identifying instances and one approach for computing
                 reference information in a reference analysis. The
                 studies use dynamic reference information collected
                 during run-time as a lower bound approximation to the
                 precise reference information. The studies measure the
                 precision of an existing approach by comparing the
                 information computed using the approach with the lower
                 bound approximation. The paper also presents case
                 studies that attempt to identify the cases under which
                 an existing approach is not effective. The presented
                 studies provide information that may guide the usage of
                 existing reference-analysis techniques and the
                 development of new reference analysis techniques.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Naumovich:2002:CAC,
  author =       "Gleb Naumovich",
  title =        "A conservative algorithm for computing the flow of
                 permissions in {Java} programs",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "33--43",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566178",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Open distributed systems are becoming increasingly
                 popular. Such systems include components that may be
                 obtained from a number of different sources. For
                 example, Java allows run-time loading of software
                 components residing on remote machines. One unfortunate
                 side-effect of this openness is the possibility that
                 ``hostile'' software components may compromise the
                 security of both the program and the system on which it
                 runs. Java offers a built-in security mechanism, using
                 which programmers can give permissions to distributed
                 components and check these permissions at run-time.
                 This security model is flexible, but using it is not
                 straightforward, which may lead to insufficiently tight
                 permission checking and therefore breaches of security.
                 In this paper, we propose a data flow algorithm for
                 automated analysis of the flow of permissions in Java
                 programs. Our algorithm produces, for a given
                 instruction in the program, a set of permissions that
                 are checked on all possible executions up to this
                 instruction. This information can be used in program
                 understanding tools or directly for checking properties
                 that assert what permissions must always be checked
                 before access to certain functionality is allowed. The
                 worst-case complexity of our algorithm is low-order
                 polynomial in the number of program statements and
                 permission types, while comparable previous approaches
                 have exponential costs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Stoller:2002:DPO,
  author =       "Scott D. Stoller",
  title =        "Domain partitioning for open reactive systems",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "44--54",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566179",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Testing or model-checking an open reactive system
                 often requires generating a model of the environment.
                 We describe a static analysis for Java that computes a
                 partition of a system's inputs: inputs in the same
                 equivalence class lead to identical behavior. The
                 partition provides a basis for generation of code for a
                 most general environment of the system, i.e., one that
                 exercises all possible behaviors of the system. The
                 partition also helps the generated environment avoid
                 exercising the same behavior multipletimes. Many
                 distributed systems with security requirements can be
                 regarded as open reactive systems whose environment is
                 an adversary-controlled network. We illustrate our
                 approach by applying it to a fault-tolerant and
                 intrusion-tolerant distributed voting system and
                 model-checking the system together with the generated
                 environment.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ostrand:2002:DFL,
  author =       "Thomas J. Ostrand and Elaine J. Weyuker",
  title =        "The distribution of faults in a large industrial
                 software system",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "55--64",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566181",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A case study is presented using thirteen releases of a
                 large industrial inventory tracking system. Several
                 types of questions are addressed in this study. The
                 first involved examining how faults are distributed
                 over the different files. This included making a
                 distinction between the release during which they were
                 discovered, the lifecycle stage at which they were
                 first detected, and the severity of the fault. The
                 second category of questions we considered involved
                 studying how the size of modules affected their fault
                 density. This included looking at questions like
                 whether or not files with high fault densities at early
                 stages of the lifecycle also had high fault densities
                 during later stages. A third type of question we
                 considered was whether files that contained large
                 numbers of faults during early stages of development,
                 also had large numbers of faults during later stages,
                 and whether faultiness persisted from release to
                 release. Finally, we examined whether newly written
                 files were more fault-prone than ones that were written
                 for earlier releases of the product. The ultimate goal
                 of this study is to help identify characteristics of
                 files that can be used as predictors of
                 fault-proneness, thereby helping organizations
                 determine how best to use their testing resources.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Orso:2002:GSC,
  author =       "Alessandro Orso and Donglin Liang and Mary Jean
                 Harrold and Richard Lipton",
  title =        "Gamma system: continuous evolution of software after
                 deployment",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "65--69",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566182",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this paper, we present the GAMMA system, which
                 facilitates remote monitoring of deployed software
                 using a new approach that exploits the opportunities
                 presented by a software product being used by many
                 users connected through a network. GAMMA splits
                 monitoring tasks across different instances of the
                 software, so that partial information can be collected
                 from different users by means of light-weight
                 instrumentation, and integrated to gather the overall
                 monitoring information. This system enables software
                 producers (1) to perform continuous, minimally
                 intrusive analyses of their software's behavior, and
                 (2) to use the information thus gathered to improve and
                 evolve their software.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Briand:2002:IUA,
  author =       "L. C. Briand and Y. Labiche and H. Sun",
  title =        "Investigating the use of analysis contracts to support
                 fault isolation in object oriented code",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "70--80",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566183",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A number of activities involved in testing software
                 are known to be difficult and time consuming. Among
                 them is the isolation of faults once failures have been
                 detected. In this paper, we investigate how the
                 instrumentation of contracts could address this issue.
                 Contracts are known to be a useful technique to specify
                 the precondition and postcondition of operations and
                 class invariants, thus making the definition of
                 object-oriented analysis or design elements more
                 precise. Our aim in this paper is to reuse and
                 instrument contracts to ease testing. A thorough case
                 study is run where we define contracts, instrument them
                 using a commercial tool, and assess the benefits and
                 limitations of doing so to support the isolation of
                 faults. We then draw practical conclusions regarding
                 the applicability of the approach and its
                 limitations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Hiller:2002:PEE,
  author =       "Martin Hiller and Arshad Jhumka and Neeraj Suri",
  title =        "{PROPANE}: an environment for examining the
                 propagation of errors in software",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "81--85",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566184",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In order to produce reliable software, it is important
                 to have knowledge on how faults and errors may affect
                 the software. In particular, designing efficient error
                 detection mechanisms requires not only knowledge on
                 which types of errors to detect but also the effect
                 these errors may have on the software as well as how
                 they propagate through the software. This paper
                 presents the Propagation Analysis Environment (PROPANE)
                 which is a tool for profiling and conducting fault
                 injection experiments on software running on desktop
                 computers. PROPANE supports the injection of both
                 software faults (by mutation of source code) and data
                 errors (by manipulating variable and memory contents).
                 PROPANE supports various error types out-of-the-box and
                 has support for user-defined error types. For logging,
                 probes are provided for charting the values of
                 variables and memory areas as well as for registering
                 events during execution of the system under test.
                 PROPANE has a flexible design making it useful for
                 development of a wide range of software systems, e.g.,
                 embedded software, generic software components, or
                 user-level desktop applications. We show examples of
                 results obtained using PROPANE and how these can guide
                 software developers to where software error detection
                 and recovery could increase the reliability of the
                 software system.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tikir:2002:EIC,
  author =       "Mustafa M. Tikir and Jeffrey K. Hollingsworth",
  title =        "Efficient instrumentation for code coverage testing",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "86--96",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566186",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Evaluation of Code Coverage is the problem of
                 identifying the parts of a program that did not execute
                 in one or more runs of a program. The traditional
                 approach for code coverage tools is to use static code
                 instrumentation. In this paper we present a new
                 approach to dynamically insert and remove
                 instrumentation code to reduce the runtime overhead of
                 code coverage. We also explore the use of dominator
                 tree information to reduce the number of
                 instrumentation points needed. Our experiments show
                 that our approach reduces runtime overhead by 38-90\%
                 compared with purecov, a commercial code coverage tool.
                 Our tool is fully automated and available for download
                 from the Internet.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Srivastava:2002:EPT,
  author =       "Amitabh Srivastava and Jay Thiagarajan",
  title =        "Effectively prioritizing tests in development
                 environment",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "97--106",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566187",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Software testing helps ensure not only that the
                 software under development has been implemented
                 correctly, but also that further development does not
                 break it. If developers introduce new defects into the
                 software, these should be detected as early and
                 inexpensively as possible in the development cycle. To
                 help optimize which tests are run at what points in the
                 design cycle, we have built Echelon, a test
                 prioritization system, which prioritizes the
                 application's given set of tests, based on what changes
                 have been made to the program. Echelon builds on the
                 previous work on test prioritization and proposes a
                 practical binary code based approach that scales well
                 to large systems. Echelon utilizes a binary matching
                 system that can accurately compute the differences at a
                 basic block granularity between two versions of the
                 program in binary form. Echelon utilizes a fast, simple
                 and intuitive heuristic that works well in practice to
                 compute what tests will cover the affected basic blocks
                 in the program. Echelon orders the given tests to
                 maximally cover the affected program so that defects
                 are likely to be found quickly and inexpensively.
                 Although the primary focus in Echelon is on program
                 changes, other criteria can be added in computing the
                 priorities. Echelon is part of a test effectiveness
                 infrastructure that runs under the Windows environment.
                 It is currently being integrated into the Microsoft
                 software development process. Echelon has been tested
                 on large Microsoft product binaries. The results show
                 that Echelon is effective in ordering tests based on
                 changes between two program versions.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Vaysburg:2002:DAR,
  author =       "Boris Vaysburg and Luay H. Tahat and Bogdan Korel",
  title =        "Dependence analysis in reduction of requirement based
                 test suites",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "107--111",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566188",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Requirement-based automated test case generation is a
                 model-based technique for generating test suites
                 related to individual requirements. The technique
                 supports test generation from EFSM (Extended Finite
                 State Machine) system models. Several requirement-based
                 selective test generation techniques were proposed.
                 These techniques may significantly reduce a number of
                 test cases with respect to a requirement under test as
                 opposed to a complete system testing. However, the
                 number of test cases may still be very large especially
                 for large systems. In this paper, we present an
                 approach of reduction of requirement based test suites
                 using EFSM dependence analysis. Different types of
                 dependencies are identified between elements of the
                 EFSM system model. These dependencies capture potential
                 interactions between elements of the model and are used
                 to determine parts of the model that affect a
                 requirement under test. This information is used to
                 reduce the test suite by identifying repetitive tests,
                 i.e., tests that exhibit the same pattern of
                 interactions with respect to the requirement under
                 test. Our initial experience shows that this approach
                 may significantly reduce the size of selective test
                 suites.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Grieskamp:2002:GFS,
  author =       "Wolfgang Grieskamp and Yuri Gurevich and Wolfram
                 Schulte and Margus Veanes",
  title =        "Generating finite state machines from abstract state
                 machines",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "112--122",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566190",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We give an algorithm that derives a finite state
                 machine (FSM) from a given abstract state machine (ASM)
                 specification. This allows us to integrate ASM specs
                 with the existing tools for test case generation from
                 FSMs. ASM specs are executable but have typically too
                 many, often infinitely many states. We group ASM states
                 into finitely many hyperstates which are the nodes of
                 the FSM. The links of the FSM are induced by the ASM
                 state transitions.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Boyapati:2002:KAT,
  author =       "Chandrasekhar Boyapati and Sarfraz Khurshid and Darko
                 Marinov",
  title =        "{Korat}: automated testing based on {Java}
                 predicates",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "123--133",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566191",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper presents Korat, a novel framework for
                 automated testing of Java programs. Given a formal
                 specification for a method, Korat uses the method
                 precondition to automatically generate all
                 (nonisomorphic) test cases up to a given small size.
                 Korat then executes the method on each test case, and
                 uses the method postcondition as a test oracle to check
                 the correctness of each output. To generate test cases
                 for a method, Korat constructs a Java predicate (i.e.,
                 a method that returns a boolean) from the method's
                 pre-condition. The heart of Korat is a technique for
                 automatic test case generation: given a predicate and a
                 bound on the size of its inputs, Korat generates all
                 (nonisomorphic) inputs for which the predicate returns
                 true. Korat exhaustively explores the bounded input
                 space of the predicate but does so efficiently by
                 monitoring the predicate's executions and pruning large
                 portions of the search space. This paper illustrates
                 the use of Korat for testing several data structures,
                 including some from the Java Collections Framework. The
                 experimental results show that it is feasible to
                 generate test cases from Java predicates, even when the
                 search space for inputs is very large. This paper also
                 compares Korat with a testing framework based on
                 declarative specifications. Contrary to our initial
                 expectation, the experiments show that Korat generates
                 test cases much faster than the declarative
                 framework.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Friedman:2002:PSM,
  author =       "G. Friedman and A. Hartman and K. Nagin and T.
                 Shiran",
  title =        "Projected state machine coverage for software
                 testing",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "134--143",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566192",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Our research deals with test generation for software
                 based on finite state machine (FSM) models of the
                 program specification. We describe a set of coverage
                 criteria and testing constraints for use in the
                 automatic generation of test suites. We also describe
                 the algorithms used to generate test suites based on
                 these coverage criteria, and the implementation of
                 these algorithms as an extension of the {Mur$ \phi $ v}
                 model checker[4]. The coverage criteria are simple but
                 powerful in that they generate test suites of high
                 quality and moderate volume, without requiring the user
                 to have a sophisticated grasp of the test generation
                 technology. The testing constraints are used to combat
                 the endemic problem of state explosion, typically
                 encountered in FSM techniques. We illustrate our
                 techniques on several well-known problems from the
                 literature and describe two industrial trials, to
                 demonstrate the validity of our claims.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Latella:2002:TCR,
  author =       "Diego Latella and Mieke Massink",
  title =        "On testing and conformance relations for {UML}
                 statechart diagrams behaviours",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "144--153",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566194",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this paper we study the formal relationship between
                 testing preorder/equivalences for a behavioural subset
                 of UML Statechart Diagrams and a conformance relation
                 for implementations with respect to specifications
                 given using such diagrams. We study the impact of
                 stuttering on the above mentioned relationship. In the
                 context of UMLSDs, stuttering occurs when no transition
                 of the UMLSD is enabled by the current event in the
                 current (global) state of the underlying state-machine.
                 We consider both the case in which the semantics
                 underlying the testing relations does not model
                 stuttering explicitly --- we call it the non-stuttering
                 semantics --- and the case in which it does it --- i.e.
                 the stuttering semantics. We show that in the first
                 case the conformance relation is stronger than the
                 reverse of the MUST preorder and, consequently,
                 stronger than the MAY preorder. Much more interesting
                 results can be proven in the second case, possibly
                 under proper conditions on the sets of events under
                 consideration. In fact the conformance relation is
                 shown to coincide with the MAY preorder, and thus be
                 implied by the reverse MUST preorder. Finally, we show
                 important substitutivity properties which hold in the
                 case of stuttering semantics.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Moors:2002:EAT,
  author =       "Tim Moors and Malathi Veeraraghavan and Zhifeng Tao
                 and Xuan Zheng and Ramesh Badri",
  title =        "Experiences in automating the testing of {SS7}
                 signalling transfer points",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "154--158",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566195",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Signalling System 7 (SS7) is widely used for telephone
                 signalling. Service providers need to frequently test
                 their Signalling Transfer Points (STPs), which switch
                 SS7 messages, for both protocol conformance and
                 interoperability. This paper describes a system that
                 automatically analyzes the data collected during STP
                 tests. It consists of files that describe how the STPs
                 are expected to behave during the test, and Perl code
                 that translates this Expected Behavior into a program
                 that can search the data collected during the test for
                 the expected events, and report on whether the system
                 passed the test. The system readily processed over
                 30,000 events for each test run, and identified
                 abnormal behavior that could interfere with
                 interoperability and protocol conformance.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Cardell-Oliver:2002:CTE,
  author =       "Rachel Cardell-Oliver",
  title =        "Conformance test experiments for distributed real-time
                 systems",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "159--163",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566196",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper introduces a new technique for testing that
                 a distributed real-time system satisfies a formal timed
                 automata specification. It outlines how to write test
                 specifications in the language of Uppaal timed
                 automata, how to translate those specifications into
                 program code for executing the tests, and describes the
                 results of test experiments on a distributed real-time
                 system with limited hardware and software resources.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Cheng:2002:RDM,
  author =       "Yung-Pin Cheng",
  title =        "Refactoring design models for inductive verification",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "164--168",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566198",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Systems composed of many identical processes can
                 sometimes be verified inductively using a network
                 invariant, but systems whose component processes vary
                 in some systematic way are not amenable to direct
                 application of that method. We describe how variations
                 in behavior can be ``factored out'' into additional
                 processes, thus enabling induction over the number of
                 processes. The process is semi-automatic: The designer
                 must choose from among a set of idiomatic
                 transformations, but each transformation is applied and
                 checked automatically.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Yavuz-Kahveci:2002:SVS,
  author =       "Tuba Yavuz-Kahveci and Tevfik Bultan",
  title =        "Specification, verification, and synthesis of
                 concurrency control components",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "169--179",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566199",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Run-time errors in concurrent programs are generally
                 due to the wrong usage of synchronization primitives
                 such as monitors. Conventional validation techniques
                 such as testing become ineffective for concurrent
                 programs since the state space increases exponentially
                 with the number of concurrent processes. In this paper,
                 we propose an approach in which (1) the concurrency
                 control component of a concurrent program is formally
                 specified, (2) it is verified automatically using model
                 checking, and (3) the code for concurrency control
                 component is automatically generated. We use monitors
                 as the synchronization primitive to control access to a
                 shared resource by multipleconcurrent processes. Since
                 our approach decouples the concurrency control
                 component from the rest of the implementation it is
                 scalable. We demonstrate the usefulness of our approach
                 by applying it to a case study on Airport Ground
                 Traffic Control. We use the Action Language to specify
                 the concurrency control component of a system. Action
                 Language is a specification language for reactive
                 software systems. It is supported by an infinite-state
                 model checker that can verify systems with boolean,
                 enumerated and unbounded integer variables. Our code
                 generation tool automatically translates the verified
                 Action Language specification into a Java monitor. Our
                 translation algorithm employs symbolic manipulation
                 techniques and the specific notification pattern to
                 generate an optimized monitor class by eliminating the
                 context switch overhead introduced as a result of
                 unnecessary thread notification. Using counting
                 abstraction, we show that we can automatically verify
                 the monitor specifications for arbitrary number of
                 threads.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bishop:2002:RRB,
  author =       "Peter G. Bishop",
  title =        "Rescaling reliability bounds for a new operational
                 profile",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "180--190",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566201",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "One of the main problems with reliability testing and
                 prediction is that the result is specific to a
                 particular operational profile. This paper extends an
                 earlier reliability theory for computing a worst case
                 reliability bound. The extended theory derives a
                 re-scaled reliability bound based on the change in
                 execution rates of the code segments in the program. In
                 some cases it is possible to derive a maximum failure
                 rate bound that applies to any change in the profile.
                 It also predicts that (in principle) a ``fair'' test
                 profile can be derived where the reliability bounds are
                 relatively insensitive to the operational profile. In
                 addition the theory allows unit and module test
                 coverage measures to be incorporated into an
                 operational reliability bound prediction. The
                 implications of the theory are discussed, and the
                 theory is evaluated by applying it to two example
                 programs with known faults.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Chen:2002:SPI,
  author =       "T. Y. Chen and T. H. Tse and Zhiquan Zhou",
  title =        "Semi-proving: an integrated method based on global
                 symbolic evaluation and metamorphic testing",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "191--195",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566202",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We present a semi-proving method for verifying
                 necessary conditions for program correctness. Our
                 approach is based on the integration of global symbolic
                 evaluation and metamorphic testing. It is relatively
                 easier than conventional program proving, and helps to
                 alleviate the problem that software testing cannot show
                 the absence of faults.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Hamlet:2002:CSS,
  author =       "Dick Hamlet",
  title =        "Continuity in software systems",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "196--200",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566203",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Most engineering artifacts behave in a continuous
                 fashion, and this property is generally believed to
                 underlie their dependability. In contrast, software
                 systems do not have continuous behavior, which is taken
                 to be an underlying cause of their undependability. The
                 theory of software reliability has been questioned
                 because technically the sampling on which it is based
                 applies only to continuous functions. This paper
                 examines the role of continuity in engineering,
                 particularly in testing and certifying artifacts, then
                 considers the analogous software situations and the
                 ways in which software is intrinsically unlike other
                 engineered objects. Several definitions of software
                 'continuity' are proposed and related to ideas in
                 software testing. It is shown how 'continuity' can be
                 established in practice, and the consequences for
                 testing and analysis of knowing that a program is
                 'continuous. Underlying any use of software
                 'continuity' is the continuity of its specification in
                 the usual mathematical sense. However, many software
                 applications are intrinsically discontinuous and one
                 reason why software is so valuable is its natural
                 ability to handle these applications, where it makes no
                 sense to seek software 'continuity' or to blame poor
                 dependability on its absence.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bertolino:2002:IPI,
  author =       "Antonia Bertolino",
  title =        "{ISSTA} 2002 panel: is {ISSTA} research relevant to
                 industrial users?",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "201--202",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566205",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "ISSTA is at its twelfth edition. Also this year,
                 researchers from academy and industry have contributed
                 with many interesting studies and experience reports in
                 software analysis and testing. We --- the ISSTA
                 partakers --- have (or at least believe to have) clear
                 ideas about which are the problems to be solved, which
                 are the real challenges, and probably each of us has
                 already settled an agenda of the next steps to take for
                 solving them looking ahead to the next ISSTA edition.
                 Are we doing right? Do we know which are the real
                 issues in the field? Is our research addressing
                 relevant points, or just aesthetic questions? Do, and
                 how much, industrial users ---the ISSTA addressees-
                 value our papers and our achievements? This panel will
                 address such questions by grouping a set of managers
                 from different industries around a table and asking
                 their opinions. As the above questions are very
                 general, in the intent to tackle the theme in a
                 concrete way, we will trigger the discussion by looking
                 at the research results in terms of their potential
                 impact in their respective enterprises. We would like
                 to know which are currently the costs of testing and
                 analysis activities in their industries, which are the
                 items summing up such costs, and how we ISSTA
                 researchers could help improving them.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Encontre:2002:IRR,
  author =       "Vincent Encontre",
  title =        "Is {ISSTA} research relevant to industrial users?
                 {Panel} --- {ISSTA 2002}: empowering the developer to
                 be a tester too!",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "203--204",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566206",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this paper --- scoped for the panel discussion at
                 ISSTA 2002 --- we are discussing some techniques to
                 ease the adoption of testing techniques by the
                 developers, by extending the debugging activity. We
                 also briefly discuss a longer term vision where the
                 same paradigm applies but at model level, when coding
                 will be achieved using visual notations such as UML.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Hartman:2002:IRR,
  author =       "A. Hartman",
  title =        "Is {ISSTA} research relevant to industry?",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "205--206",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566207",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Peciola:2002:ELI,
  author =       "Emilia Peciola",
  title =        "{Ericsson} lab {Italy}: is {ISSTA} research relevant
                 to industrial users?",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "207--207",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566208",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Sreenivas:2002:PDI,
  author =       "Ashok Sreenivas",
  title =        "Panel discussion: is {ISSTA} testing research relevant
                 to industrial users?",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "208--209",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566209",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We discuss the direct relevance of on-going testing
                 research to the 'users' of the research, namely the
                 industrial practitioners. The current
                 state-of-the-practice in software testing is quite
                 ad-hoc and provides little or no assertions about the
                 quality of the delivered software product. We propose
                 the view that research that is aligned with formal
                 approaches to software development is the best bet to
                 achieve this goal.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Choi:2002:IFI,
  author =       "Jong-Deok Choi and Andreas Zeller",
  title =        "Isolating failure-inducing thread schedules",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "210--220",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566211",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Consider a multi-threaded application that
                 occasionally fails due to non-determinism. Using the
                 DEJAVU capture/replay tool, it is possible to record
                 the thread schedule and replay the application in a
                 deterministic way. By systematically narrowing down the
                 difference between a thread schedule that makes the
                 program pass and another schedule that makes the
                 program fail, the Delta Debugging approach can pinpoint
                 the error location automatically---namely, the
                 location(s) where a thread switch causes the program to
                 fail. In a case study, Delta Debugging isolated the
                 failure-inducing schedule difference from 3.8 billion
                 differences in only 50 tests.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Whaley:2002:AEO,
  author =       "John Whaley and Michael C. Martin and Monica S. Lam",
  title =        "Automatic extraction of object-oriented component
                 interfaces",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "218--228",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566212",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Component-based software design is a popular and
                 effective approach to designing large systems. While
                 components typically have well-defined interfaces,
                 sequencing information---which calls must come in which
                 order---is often not formally specified. This paper
                 proposes using multiple finite statemachine (FSM)
                 submodels to model the interface of a class. A submodel
                 includes a subset of methods that, for example,
                 implement a Java interface, or access some particular
                 field. Each state-modifying method is represented as a
                 state in the FSM, and transitions of the FSMs represent
                 allow able pairs of consecutive methods. In addition,
                 state-preserving methods are constrained to execute
                 only under certain states. We have designed and
                 implemented a system that includes static analyses to
                 deduce illegal call sequences in a program, dynamic
                 instrumentation techniques to extract models from
                 execution runs, and a dynamic model checker that
                 ensures that the code conforms to the model. Extracted
                 models can serve as documentation; they can serve as
                 constraints to be enforced by a static checker; they
                 can be studied directly by developers to determine if
                 the program is exhibiting unexpected behavior; or they
                 can be used to determine the completeness of a test
                 suite. Our system has been run on several large code
                 bases, including the joeq virtual machine, the basic
                 Java libraries, and the Java 2 Enterprise Edition
                 library code. Our experience suggests that this
                 approach yields useful information.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Nimmer:2002:AGP,
  author =       "Jeremy W. Nimmer and Michael D. Ernst",
  title =        "Automatic generation of program specifications",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "4",
  pages =        "229--239",
  month =        jul,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/566171.566213",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:20 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Producing specifications by dynamic (runtime) analysis
                 of program executions is potentially unsound, because
                 the analyzed executions may not fully characterize all
                 possible executions of the program. In practice, how
                 accurate are the results of a dynamic analysis? This
                 paper describes the results of an investigation into
                 this question, determining how much specifications
                 generalized from program runs must be changed in order
                 to be verified by a static checker. Surprisingly, small
                 test suites captured nearly all program behavior
                 required by a specific type of static checking; the
                 static checker guaranteed that the implementations
                 satisfy the generated specifications, and ensured the
                 absence of runtime exceptions. Measured against this
                 verification task, the generated specifications scored
                 over 90\% on precision, a measure of soundness, and on
                 recall, a measure of completeness. This is a positive
                 result for testing, because it suggests that dynamic
                 analyses can capture all semantic information of
                 interest for certain applications. The experimental
                 results demonstrate that a specific technique, dynamic
                 invariant detection, is effective at generating
                 consistent, sufficient specifications for use by a
                 static checker. Finally, the research shows that
                 combining static and dynamic analyses over program
                 specifications has benefits for users of each
                 technique, guaranteeing soundness of the dynamic
                 analysis and lessening the annotation burden for users
                 of the static analysis.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2002:RPCd,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "5",
  pages =        "6--16",
  month =        sep,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/571681.571685",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:22 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kitchenham:2002:PSRd,
  author =       "Barbara Kitchenham and Shari Lawrence Pfleeger",
  title =        "Principles of survey research: part 5: populations and
                 samples",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "5",
  pages =        "17--20",
  month =        sep,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/571681.571686",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:22 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This article is the fifth installment of our series of
                 articles on survey research. In it, we discuss what we
                 mean by a population and a sample and the implications
                 of each for survey research. We provide examples of
                 correct and incorrect sampling techniques used in
                 software engineering surveys.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Doernhoefer:2002:SNSd,
  author =       "Mark Doernhoefer",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "5",
  pages =        "21--30",
  month =        sep,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/571681.571687",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:22 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Estublier:2002:IRC,
  author =       "Jacky Estublier and David Leblang and Geoff Clemm and
                 Reidar Conradi and Walter Tichy and Andr{\'e} van der
                 Hoek and Darcy Wiborg-Weber",
  title =        "Impact of the research community on the field of
                 software configuration management: summary of an impact
                 project report",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "5",
  pages =        "31--39",
  month =        sep,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/571681.571689",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:22 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Software Configuration Management (SCM) is an
                 important discipline in professional software
                 development and maintenance. The importance of SCM has
                 increased as programs have become larger and more
                 complex and mission/life-critical. This paper discusses
                 the evolution of SCM technology from the early days of
                 software development to present and the impact
                 university and industrial research has had along the
                 way. It also includes a survey of the industrial
                 state-of-the-practice and research directions. The
                 paper published here is not intended to be a definitive
                 assessment. Rather, our intention is to solicit
                 comments and corrections from the community to help
                 refine the work. If you would like to provide further
                 information, please contact the first author. A longer
                 version of this report can be found at
                 http://wwwadele.imag.fr/SCMImpact.pdf.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rhodes:2002:SEE,
  author =       "Donna H. Rhodes",
  title =        "Systems engineering: an essential discipline for the
                 21st century",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "5",
  pages =        "40--45",
  month =        sep,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/571681.571690",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:22 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Davis:2002:OSD,
  author =       "Chad Davis and Coskun Bayrak",
  title =        "Open source development and the {World Wide Web}: a
                 certain tension",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "5",
  pages =        "93--97",
  month =        sep,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/571681.571682",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:22 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The development of the World Wide Web over the course
                 of the past ten years has run rampant. The course it
                 has taken has been both swift and unpredictable. The
                 largest distributed system in the world began as a
                 utopian notion of an interconnected and open web of
                 information, the dream of the academic and intellectual
                 alike. Today it is indeed a massive interconnected web
                 of communication and content, but the content, largely
                 on the more popular, if not pornographic, end of the
                 mass media spectrum, is not what the founders intended.
                 Coinciding with the rapid growth of the web has been
                 the equally speedy rise of the open source development
                 community, which can best be understood as a
                 distributed system in its own right. Indeed, the
                 development of the web has been, outside of the Linux
                 project, the largest arena for open source development.
                 And current trends, witnessed by such significant open
                 source projects as Mozilla and Apache, seem to suggest
                 that the open source way of doing things is quickly
                 becoming the web way of doing things. However, there is
                 a certain tension growing between those who would like
                 to control, for economic profit or for the
                 gratification of control itself, the direction of the
                 web's development and those open source developers who
                 are responsible for a large portion of that growth.
                 This paper explores the natural relationship, as well
                 as the growing tension within this relationship,
                 between the open source development community and the
                 World Wide Web.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Li:2002:AIF,
  author =       "Bixin Li",
  title =        "Analyzing information-flow in {Java} program based on
                 slicing technique",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "5",
  pages =        "98--103",
  month =        sep,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/571681.571683",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:22 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Traditional information-flow analysis is mainly based
                 on dataflow and control-flow analysis. In
                 object-oriented program, because of pointer aliasing,
                 inheritance, and polymorphism, information-flow
                 analysis become very complicated. Especially, it is
                 difficult to rely only on normal data and control-flow
                 analysis techniques. some new approaches are required
                 to analyze the information-flow between components in
                 object-oriented program. In this paper, object-oriented
                 program slicing technique is introduced. By this
                 technique, the amount of information-flow, the width of
                 information-flow and correlation coefficient between
                 components can be computed. Some applications of the
                 information-flow are also discussed and analyzed in
                 this paper.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Alexander:2002:DSS,
  author =       "Larry Alexander",
  title =        "Decision support systems in the 21st century",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "5",
  pages =        "104--104",
  month =        sep,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/571681.571692",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:22 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Frazer:2002:CAI,
  author =       "Ken Frazer",
  title =        "{C++} in action: industrial-strength programming
                 techniques",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "5",
  pages =        "104--105",
  month =        sep,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/571681.571693",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:22 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tanuan:2002:TIS,
  author =       "Meyer Tanuan",
  title =        "Testing it: an off-the-shelf software testing
                 process",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "5",
  pages =        "105--105",
  month =        sep,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/571681.571694",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:22 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tracz:2002:RTL,
  author =       "Will Tracz",
  title =        "Roundtable on technical leadership: a {SHAPE} forum
                 dialog",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "5",
  pages =        "106--107",
  month =        sep,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/571681.571695",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:22 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Zeller:2002:ICE,
  author =       "Andreas Zeller",
  title =        "Isolating cause-effect chains from computer programs",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "1--10",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605468",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Consider the execution of a failing program as a
                 sequence of program states. Each state induces the
                 following state, up to the failure. Which variables and
                 values of a program state are relevant for the failure?
                 We show how the Delta Debugging algorithm isolates the
                 relevant variables and values by systematically
                 narrowing the state difference between a passing run
                 and a failing run --- by assessing the outcome of
                 altered executions to determine whether a change in the
                 program state makes a difference in the test outcome.
                 Applying Delta Debugging to multiple states of the
                 program automatically reveals the cause-effect chain of
                 the failure --- that is, the variables and values that
                 caused the failure. In a case study, our prototype
                 implementation successfully isolated the cause--effect
                 chain for a failure of the GNU C compiler: ``Initially,
                 the C program to be compiled contained an addition of
                 1.0; this caused an addition operator in the
                 intermediate RTL representation; this caused a cycle in
                 the RTL tree --- and this caused the compiler to
                 crash.''",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Nimmer:2002:IIS,
  author =       "Jeremy W. Nimmer and Michael D. Ernst",
  title =        "Invariant inference for static checking: an empirical
                 evaluation",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "11--20",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605469",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Static checking can verify the absence of errors in a
                 program, but often requires written annotations or
                 specifications. As a result, static checking can be
                 difficult to use effectively: it can be difficult to
                 determine a specification and tedious to annotate
                 programs. Automated tools that aid the annotation
                 process can decrease the cost of static checking and
                 enable it to be more widely used. This paper describes
                 an evaluation of the effectiveness of two techniques,
                 one static and one dynamic, to assist the annotation
                 process. We quantitatively and qualitatively evaluate
                 41 programmers using ESC/Java in a program verification
                 task over three small programs, using Houdini for
                 static inference and Daikon for dynamic inference. We
                 also investigate the effect of unsoundness in the
                 dynamic analysis. Statistically significant results
                 show that both inference tools improve task completion;
                 Daikon enables users to express more correct
                 invariants; unsoundness of the dynamic analysis is
                 little hindrance to users; and users imperfectly
                 exploit Houdini. Interviews indicate that beginning
                 users found Daikon to be helpful; Houdini to be
                 neutral; static checking to be of potential practical
                 use; and both assistance tools to have unique benefits.
                 Our observations not only provide a critical evaluation
                 of these two techniques, but also highlight important
                 considerations for creating future assistance tools.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Julien:2002:ECA,
  author =       "Christine Julien and Gruia Catalin Roman",
  title =        "Egocentric context-aware programming in ad hoc mobile
                 environments",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "21--30",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605471",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Some of the most dynamic systems being built today
                 consist of physically mobile hosts and logically mobile
                 agents. Such systems exhibit frequent configuration
                 changes and a great deal of resource variability.
                 Applications executing under these circumstances need
                 to react continuously and rapidly to changes in
                 operating conditions and must adapt their behavior
                 accordingly. The development of such applications
                 demands a reexamination of the notion of context and
                 the mechanisms used to manage the application's
                 response to contextual changes. This paper introduces
                 EgoSpaces, a coordination model and middleware for ad
                 hoc mobile environments. EgoSpaces focuses on the needs
                 of application development in ad hoc environments by
                 proposing an agent-centered notion of context, called a
                 view, whose scope extends beyond the local host to data
                 and resources associated with hosts and agents within a
                 subnet surrounding the agent of interest. An agent may
                 operate over multiple views whose definitions may
                 change over time. An agent uses declarative
                 specifications to constrain the contents of each view
                 by employing a rich set of constraints that take into
                 consideration properties of the individual data items,
                 the agents that own them, the hosts on which the agents
                 reside, and the physical and logical topology of the ad
                 hoc network. This paper formalizes the concept of view,
                 explores the notion of programming against views,
                 discusses possible implementation strategies for
                 transparent context maintenance, and describes our
                 current prototype of the system. We include examples to
                 illustrate the expressive power of the view abstraction
                 and to relate it to other research on coordination
                 models and middleware.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Capra:2002:MEA,
  author =       "Licia Capra and Wolfgang Emmerich and Cecilia
                 Mascolo",
  title =        "A micro-economic approach to conflict resolution in
                 mobile computing",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "31--40",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605472",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Mobile devices, such as mobile phones and personal
                 digital assistants, have gained wide-spread popularity.
                 These devices will increasingly be networked, thus
                 enabling the construction of distributed mobile
                 applications. These have to adapt to changes in
                 context, such as variations in network bandwidth,
                 exhaustion of battery power or reachability of services
                 on other devices. We show how the construction of
                 adaptive and context-aware mobile applications can be
                 supported using a reflective middleware. The middleware
                 provides software engineers with primitives to describe
                 how context changes are handled using policies. These
                 policies may conflict. In this paper, we classify the
                 different types of conflicts that may arise in mobile
                 computing. We argue that conflicts cannot be resolved
                 statically at the time applications are designed, but,
                 rather, need to be resolved at execution time. We
                 demonstrate a method by which these policy conflicts
                 can be treated. This method uses a micro-economic
                 approach that relies on a particular type of sealed-bid
                 auction.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Lopes:2002:APD,
  author =       "Ant{\'o}nia Lopes and Jos{\'e} Luiz Fiadeiro and
                 Michel Wermelinger",
  title =        "Architectural primitives for distribution and
                 mobility",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "41--50",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605473",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this paper, we address the integration of a
                 distribution dimension in an architectural approach to
                 system development and evolution based on the
                 separation between coordination and computation. This
                 third dimension allows us to separate key concerns
                 raised by mobility, thus contributing to our ability to
                 handle the complexity that is inherent to systems
                 required to operate in ``Internet time and space''.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Xie:2002:URF,
  author =       "Yichen Xie and Dawson Engler",
  title =        "Using redundancies to find errors",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "51--60",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605475",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper explores the idea that redundant
                 operations, like type errors, commonly flag correctness
                 errors. We experimentally test this idea by writing and
                 applying four redundancy checkers to the Linux
                 operating system, finding many errors. We then use
                 these errors to demonstrate that redundancies, even
                 when harmless, strongly correlate with the presence of
                 traditional hard errors (e.g., null pointer
                 dereferences, unreleased locks). Finally we show that
                 how flagging redundant operations gives a way to make
                 specifications ``fail stop'' by detecting dangerous
                 omissions.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bruns:2002:SPA,
  author =       "Glenn Bruns and Satish Chandra",
  title =        "Searching for points-to analysis",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "61--70",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605476",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The complexity of points-to analysis is well
                 understood, but the approximations used to carry out
                 points-to analysis efficiently are less well
                 understood. In this paper we characterize points-to
                 analysis as a reachability problem on a program's state
                 space. Reachability analysis can be performed
                 approximately but more efficiently for a program to
                 which certain basic program transformations have been
                 applied. We show the source of approximation and
                 efficiency in several existing points-to analysis
                 algorithms in terms of these generic program
                 transformations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mock:2002:IPS,
  author =       "Markus Mock and Darren C. Atkinson and Craig Chambers
                 and Susan J. Eggers",
  title =        "Improving program slicing with dynamic points-to
                 data",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "71--80",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605477",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Program slicing is a potentially useful analysis for
                 aiding program understanding. However, slices of even
                 small programs are often too large to be generally
                 useful. Imprecise pointer analyses have been suggested
                 as one cause of this problem. In this paper, we use
                 dynamic points-to data, which represents optimal or
                 optimistic pointer information, to obtain a bound on
                 the best case slice size improvement that can be
                 achieved with improved pointer precision. Our
                 experiments show that slice size can be reduced
                 significantly for programs that make frequent use of
                 calls through function pointers because for them the
                 dynamic pointer data results in a considerably smaller
                 call graph, which leads to fewer data dependences.
                 Programs without or with only few calls through
                 function pointers, however, show only insignificant
                 improvement. We identified Amdahl's law as the reason
                 for this behavior: C programs appear to have a large
                 fraction of direct data dependences so that reducing
                 spurious dependences via pointers is only of limited
                 benefit. Consequently, to make slicing useful in
                 general for such programs, improvements beyond better
                 pointer analyses will be necessary. On the other hand,
                 since we show that collecting dynamic function pointer
                 information can be performed with little overhead
                 (average slowdown of 10\% for our benchmarks), dynamic
                 pointer information may be a practical approach to
                 making slicing of programs with frequent function
                 pointer use more successful in reality.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Holzmann:2002:LB,
  author =       "Gerard J. Holzmann",
  title =        "The logic of bugs",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "81--87",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605479",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Real-life bugs are successful because of their
                 unfailing ability to adapt. In particular this applies
                 to their ability to adapt to strategies that are meant
                 to eradicate them as a species. Software bugs have some
                 of these same traits. We will discuss these traits, and
                 consider what we can do about them.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Li:2002:VCC,
  author =       "Harry Li and Shriram Krishnamurthi and Kathi Fisler",
  title =        "Verifying cross-cutting features as open systems",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "89--98",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605481",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Feature-oriented software designs capture many
                 interesting notions of cross-cutting, and offer a
                 powerful method for building product-line
                 architectures. Each cross-cutting feature is an
                 independent module that fundamentally yields an open
                 system from a verification perspective. We describe
                 desiderata for verifying such modules through model
                 checking and find that existing work on the
                 verification of open systems fails to address most of
                 the concerns that arise from feature-oriented systems.
                 We therefore provide a new methodology for verifying
                 such systems. To validate this new methodology, we have
                 implemented it and applied it to a suite of modules
                 that exhibit feature interaction problems. Our model
                 checker was able to automatically locate ten problems
                 previously found through a laborious simulation-based
                 effort.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Chu-Carroll:2002:SAF,
  author =       "Mark C. Chu-Carroll and James Wright and David
                 Shields",
  title =        "Supporting aggregation in fine grained software
                 configuration management",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "99--108",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605482",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Fine-grained software configuration management offers
                 substantial benefits for large-scale collaborative
                 software development, enabling a variety of interesting
                 and useful features including complexity management,
                 support for aspect-oriented software development, and
                 support for communication and coordination within
                 software engineering teams, described in [4]. However,
                 fine granularity by itself is not sufficient to achieve
                 these benefits. Most of the benefits of fine
                 granularity result from the ability to combine
                 fine-grained artifacts in various ways: supporting
                 multiple overlapping organizations of program source by
                 combining fine-grained artifacts into virtual source
                 files (VSFs); supporting coordination by allowing
                 developers to precisely mark the set of artifacts
                 affected by a change; associating products from
                 different phases of the development process; etc. In
                 this paper, we describe how a general aggregation
                 mechanism can be used to support the various
                 functionality enabled by fine grained SCM. We present a
                 set of requirements that an aggregation facility must
                 provide in order to yield these benefits, and we
                 provide a description of the implementation of such an
                 aggregation system in our experimental SCM system.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Uchitel:2002:NSI,
  author =       "Sebastian Uchitel and Jeff Kramer and Jeff Magee",
  title =        "Negative scenarios for implied scenario elicitation",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "109--118",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605484",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Scenario-based specifications such as Message Sequence
                 Charts (MSCs) are popular for requirement elicitation
                 and specification. MSCs describe two distinct aspects
                 of a system: on the one hand they provide examples of
                 intended system behaviour and on the other they outline
                 the system architecture. A mismatch between
                 architecture and behaviour may give rise to implied
                 scenarios. Implied scenarios occur because a
                 component's local view of the system state is
                 insufficient to enforce specified system behaviour. An
                 implied scenario indicates a gap in the MSC
                 specification that needs to be clarified. It may simply
                 mean that an acceptable scenario has been overlooked
                 and should be added to the scenario specification.
                 Alternatively, it may represent an unacceptable
                 behaviour which should be documented and avoided in the
                 final implementation. Thus implied scenarios can be
                 used to iteratively drive requirements elicitation.
                 However, in order to do so, tools for coping with
                 rejected implied scenarios are needed. The
                 contributions of this paper are twofold. Firstly, we
                 define a language for describing negative scenarios.
                 Secondly, we complement existing implied scenario
                 detection methods with techniques for accommodating
                 negative scenarios.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Letier:2002:DOS,
  author =       "Emmanuel Letier and Axel van Lamsweerde",
  title =        "Deriving operational software specifications from
                 system goals",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "119--128",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605485",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Goal orientation is an increasingly recognized
                 paradigm for eliciting, modeling, specifying and
                 analyzing software requirements. Goals are statements
                 of intent organized in AND/OR refinement structures;
                 they range from high-level, strategic concerns to
                 low-level, technical requirements on the software-to-be
                 and assumptions on its environment. The
                 operationalization of system goals into specifications
                 of software services is a core aspect of the
                 requirements elaboration process for which little
                 systematic and constructive support is available. In
                 particular, most formal methods assume such operational
                 specifications to be given and focus on their a
                 posteriori analysis. The paper considers a formal,
                 constructive approach in which operational software
                 specifications are built incrementally from
                 higher-level goal formulations in a way that guarantees
                 their correctness by construction. The
                 operationalization process is based on formal
                 derivation rules that map goal specifications to
                 specifications of software operations; more
                 specifically, these rules map real-time temporal logic
                 specifications to sets of pre-, post- and trigger
                 conditions. The rules define operationalization
                 patterns that may be used for guiding and documenting
                 the operationalization process while hiding all formal
                 reasoning details; the patterns are formally proved
                 correct once and for all. The catalog of
                 operationalization patterns is structured according to
                 a rich taxonomy of goal specification patterns. Our
                 constructive approach to requirements elaboration
                 requires a multiparadigm specification language that
                 supports incremental reasoning about partial models.
                 The paper also provides a formal semantics for goal
                 operationalization and discusses several semantic
                 features of our language that allow for such
                 incremental reasoning.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Vetterling:2002:SSD,
  author =       "Monika Vetterling and Guido Wimmel and Alexander
                 Wisspeintner",
  title =        "Secure systems development based on the common
                 criteria: the {PalME} project",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "129--138",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605486",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Security is a very important issue in information
                 processing, especially in open network environments
                 like the Internet. The Common Criteria (CC) is the
                 standard requirements catalogue for the evaluation of
                 security critical systems. Using the CC, a large number
                 of security requirements on the system itself and on
                 the system development can be defined. However, the CC
                 does not give methodological support. In this paper, we
                 show how integrate security aspects into the software
                 engineering process. The activities and documents from
                 the Common Criteria are tightly intertwined with the
                 system development, which improves the quality of the
                 developed system and reduces the additional cost and
                 effort due to high security requirements. For modelling
                 and verification of critical parts of the system, we
                 use formal description techniques and model checking
                 (supported by the graphical CASE tool AUTOFOCUS), which
                 increases both the understanding of the system
                 specification and the system's reliability. We
                 demonstrate our ideas by means of a case-study, the
                 PalME project--an electronic purse application for Palm
                 handhelds.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Gurfinkel:2002:MET,
  author =       "Arie Gurfinkel and Benet Devereux and Marsha Chechik",
  title =        "Model exploration with temporal logic query checking",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "139--148",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605488",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A temporal logic query is a temporal logic formula
                 with placeholders. Given a model, a solution to a query
                 is a set of assignments of propositional formulas to
                 placeholders, such that replacing the placeholders with
                 any of these assignments results in a temporal logic
                 formula that holds in the model. Query checking, first
                 introduced by William Chan [2], is an automated
                 technique for finding solutions to temporal logic
                 queries. It allows discovery of the temporal properties
                 of the system and as such may be a useful tool for
                 model exploration and reverse engineering. This paper
                 describes an implementation of a temporal logic query
                 checker. It then suggests some applications of this
                 tool, ranging from invariant computation to test case
                 generation, and illustrates them using a Cruise Control
                 System.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Niu:2002:CSM,
  author =       "Jianwei Niu and Joanne M. Atlee and Nancy A. Day",
  title =        "Composable semantics for model-based notations",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "149--158",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605489",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We propose a unifying framework for model-based
                 specification notations. Our framework captures the
                 execution semantics that are common among model-based
                 notations, and leaves the distinct elements to be
                 defined by a set of parameters. The basic components of
                 a specification are non-concurrent state-transition
                 machines which are combined by composition operators to
                 form more complex, concurrent specifications. We define
                 the step-semantics of these basic components in terms
                 of an operational semantics template whose parameters
                 specialize both the enabling of transitions and
                 transitions' effects. We also provide the operational
                 semantics of seven composition operators, defining each
                 as the concurrent execution of components, with changes
                 to their shared variables and events to reflect
                 inter-component communication and synchronization; the
                 definitions of these operators use the template
                 parameters to preserve in composition notation-specific
                 behaviour. By separating a notation's step-semantics
                 from its composition and concurrency operators, we
                 simplify the definitions of both. Our framework is
                 sufficient to capture the semantics of basic transition
                 systems, CSP, CCS, basic LOTOS, ESTELLE, a subset of
                 SDL88, and a variety of statecharts notations. We
                 believe that a description of a notation's semantics in
                 our framework can be used as input to a tool that
                 automatically generates formal analysis tools.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Cobleigh:2002:CUH,
  author =       "Jamieson M. Cobleigh and Leon J. Osterweil and
                 Alexander Wise and Barbara Staudt Lerner",
  title =        "Containment units: a hierarchically composable
                 architecture for adaptive systems",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "159--165",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605491",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Software is increasingly expected to run in a variety
                 of environments. The environments themselves are often
                 dynamically changing when using mobile computers or
                 embedded systems, for example. Network bandwidth,
                 available power, or other physical conditions may
                 change, necessitating the use of alternative algorithms
                 within the software, and changing resource mixes to
                 support the software. We present Containment Units as a
                 software architecture useful for recognizing
                 environmental changes and dynamically reconfiguring
                 software and resource allocations to adapt to those
                 changes. We present examples of Containment Units used
                 within robotics along with the results of actual
                 executions, and the application of static analysis to
                 obtain assurances that those Containment Units can be
                 expected to demonstrate the robustness for which they
                 were designed.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Sengupta:2002:TMS,
  author =       "Bikram Sengupta and Rance Cleaveland",
  title =        "Triggered message sequence charts",
  journal =      j-SIGSOFT,
  volume =       "27",
  number =       "6",
  pages =        "167--176",
  month =        nov,
  year =         "2002",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/605466.605492",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:23 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We propose an extension to Message Sequence Charts
                 called Triggered Message Sequence Charts (TMSCs) that
                 are intended to capture system specifications involving
                 nondeterminism in the form of conditional scenarios.
                 The visual syntax of TMSCs closely resembles that of
                 MSCs; the semantics allows us to translate a TMSC
                 specification into a framework that supports a notion
                 of refinement based on Denicola's and Hennessy's must
                 preorder. A simple but non-trivial example illustrates
                 the utility of our extension to MSCs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Notkin:2003:LPA,
  author =       "David Notkin",
  title =        "Longitudinal program analysis",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "1",
  pages =        "1--1",
  month =        jan,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/634636.586095",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:25 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The field of program analysis has made significant
                 improvements recently, but still faces some major
                 obstacles. In this talk I argue that considering
                 analysis as applying longitudinally across the
                 multitude of versions created during a program's
                 lifetime -rather than to a given instance of a program
                 --- shows significant promise in overcoming some of
                 these obstacles. I focus on identifying a set of
                 opportunities that arise when this shift in outlook is
                 taken. Most program analysis techniques have focused on
                 questions of the form ``Does program P satisfy a given
                 property A?'' or ``What program points in P satisfy a
                 given property A?'' Type-checking is the classic
                 example of the first form, while lexical, syntactic,
                 and semantic analyses are examples of the second form.
                 The key point (with respect to this talk) is that a
                 single program P is being analyzed. Some analyses
                 expand this view and explicitly consider a pair of
                 programs, P and P', where P' represents a modified
                 version of P. Test selection and prioritization
                 techniques are among the best examples of this
                 approach: the idea is to analyze the delta between P
                 and P', and to use that information to determine which
                 test cases must be re-run (for test selection) or
                 should be re-run (for test prioritization). There are
                 dozens of results in these areas; Harrold et al.'s
                 empirical study is one recent example of test selection
                 [1], and the recent work at Microsoft Research is an
                 example of test prioritization [2]. There are at least
                 three ways in which a longitudinal approach could
                 improve analysis. Second, we can use previously
                 computed information to better inform analysis on a
                 newer version. One recent example of this is the work
                 by Kim and Porter that uses historical information
                 about the application of tests of a set of versions as
                 a basis for test prioritization algorithms [3]. Third,
                 we can imagine applying otherwise ``intractable''
                 analyses over the lifetime of (multiple versions of) a
                 program, as opposed to the (much more limited) time
                 available to analyze a specific version. In essence,
                 there is an opportunity to compute the analysis in
                 stages, with the goal of completing the analysis by
                 specific important points in the program lifetime
                 (e.g., external releases). Work on vertical staging of
                 analyses for runtime compilation is one place to look
                 for ideas and techniques for this kind of
                 ``horizontal'' staging [4]. The traditional view of
                 software evolution says that (to accommodate needed
                 change) program structure degrades and program size
                 increases [5][6]; this in turn tends to increase the
                 difficult of analysis. I propose here some
                 opportunities for viewing time and change as potential
                 benefits with respect to analysis, rather than as
                 roadblocks. This provides potential for significantly
                 improving software dependability over time.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bowring:2003:MDS,
  author =       "Jim Bowring and Alessandro Orso and Mary Jean
                 Harrold",
  title =        "Monitoring deployed software using software
                 tomography",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "1",
  pages =        "2--9",
  month =        jan,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/634636.586099",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:25 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Software products are often released with missing
                 functionality or errors that result in failures in the
                 field. In previous work, we presented the Gamma
                 technology, which facilitates remote monitoring of
                 deployed software and allows for a prompt reaction to
                 failures. In this paper, we investigate one of the
                 principal technologies on which Gamma is based:
                 software tomography. Software tomography splits
                 monitoring tasks across many instances of the software,
                 so that partial information can be (1) collected from
                 users by means of light-weight instrumentation and (2)
                 merged to gather the overall monitoring information.
                 After describing the technology, we illustrate an
                 instance of software tomography for a specific
                 monitoring task. We also present two case studies that
                 we performed to evaluate the presented technique on a
                 real program. The results of the studies show that
                 software tomography can be successfully applied to
                 collect accurate monitoring information using only
                 minimal instrumentation on each deployed program
                 instance.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tikir:2003:RDS,
  author =       "Mustafa M. Tikir and Jeffrey K. Hollingsworth and
                 Guei-Yuan Lueh",
  title =        "Recompilation for debugging support in a
                 {JIT-compiler}",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "1",
  pages =        "10--17",
  month =        jan,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/634636.586100",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:25 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "A static Java compiler converts Java source code into
                 a verifiably secure and compact architecture-neutral
                 intermediate format, called Java byte codes. The Java
                 byte codes can be either interpreted by a Java Virtual
                 Machine or translated into native code by Java
                 Just-In-Time compilers. Static Java compilers embed
                 debug information in the Java class files to be used by
                 the source level debuggers. However, the debug
                 information is generated for architecture independent
                 byte codes and most of the debug information is valid
                 only when the byte codes are interpreted. Translating
                 byte codes into native instructions puts a limitation
                 on the amount of usable debug information that can be
                 used by source level debuggers. In this paper, we
                 present a new technique to generate valid debug
                 information when Just-In-Time compilers are used. Our
                 approach is based on the dynamic recompilation of Java
                 methods by a fast code generator and lazily generates
                 debug information when it is required. We also present
                 three implementations for field watch support in the
                 Java Virtual Machine Debugger Interface to investigate
                 the runtime overhead and code size growth by our
                 approach.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Akgul:2003:ILR,
  author =       "Tankut Akgul and Vincent J. {Mooney III}",
  title =        "Instruction-level reverse execution for debugging",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "1",
  pages =        "18--25",
  month =        jan,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/634636.586101",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:25 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The ability to execute a program in reverse is
                 advantageous for shortening debug time. This paper
                 presents a reverse execution methodology at the
                 assembly instruction-level with low memory and time
                 overheads. The core idea of this approach is to
                 generate a reverse program able to undo, in almost all
                 cases, normal forward execution of an assembly
                 instruction in the program being debugged. The
                 methodology has been implemented on a PowerPC processor
                 in a custom made debugger. Compared to previous work
                 --- all of which use a variety of state saving
                 techniques --- the experimental results show 2.5X to
                 400X memory overhead reduction for the tested
                 benchmarks. Furthermore, the results with the same
                 benchmarks show an average of 4.1X to 5.7X time
                 overhead reduction.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Morrisett:2003:AIC,
  author =       "Greg Morrisett",
  title =        "Analysis issues for cyclone",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "1",
  pages =        "26--26",
  month =        jan,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/634636.586096",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:25 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Cyclone [1, 2] is an experimental, type-safe
                 programming language based upon the syntax, semantics,
                 and spirit of C. The primary goal of the language is to
                 provide a type-safe environment that is close enough to
                 C in both appearance and functionality, that systems
                 programmers will find it attractive and useful. The
                 most challenging aspect of the design is capturing the
                 spirit of C without compromising type-safety. In
                 particular, systems programmers expect to have good
                 control over data representations, memory management,
                 and performance. Yet, these features are usually absent
                 from high-level, type-safe languages (e.g., Java).
                 Another challenge is validating a sufficiently wide set
                 of idioms that are in fact type-safe, but which
                 conventional type systems reject. To address these
                 issues, we have used a novel combination of typing
                 features in conjunction with some interesting inference
                 and dataflow techniques. The most novel typing feature
                 is the support for region-based memory management which
                 was summarized in an earlier paper [1]. However, this
                 paper did not discuss the inference techniques we use
                 to validate the regions and effects. In this talk, I
                 will briefly summarize the Cyclone type system and then
                 focus on the analysis issues that arise in its
                 implementation, including (a) kind and type inference,
                 (b) region and effect inference, and (c) dataflow
                 analysis for validating initialization, array
                 subscripts, and linear pointers.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Brown:2003:SFE,
  author =       "Rhodes Brown and Karel Driesen and David Eng and
                 Laurie Hendren and John Jorgensen and Clark Verbrugge
                 and Qin Wang",
  title =        "{STEP}: a framework for the efficient encoding of
                 general trace data",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "1",
  pages =        "27--34",
  month =        jan,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/634636.586103",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:25 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Traditional tracing systems are often limited to
                 recording a fixed set of basic program events. This
                 limitation can frustrate an application or compiler
                 developer who is trying to understand and characterize
                 the complex behavior of software systems such as a Java
                 program running on a Java Virtual Machine. In the past,
                 many developers have resorted to specialized tracing
                 systems that target a particular type of program event.
                 This approach often results in an obscure and poorly
                 documented encoding format which can limit the reuse
                 and sharing of potentially valuable information. To
                 address this problem, we present STEP, a system
                 designed to provide profiler developers with a standard
                 method for encoding general program trace data in a
                 flexible and compact format. The system consists of a
                 trace data definition language along with a compiler
                 and an architecture that simplifies the client
                 interface by encapsulating the details of encoding and
                 interpretation.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Apiwattanapong:2003:SPP,
  author =       "Taweesup Apiwattanapong and Mary Jean Harrold",
  title =        "Selective path profiling",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "1",
  pages =        "35--42",
  month =        jan,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/634636.586104",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:25 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Recording dynamic information for only a subset of
                 program entities can reduce monitoring overhead and can
                 facilitate efficient monitoring of deployed software.
                 Program entities, such as statements, can be monitored
                 using probes that track the execution of those
                 entities. Monitoring more complicated entities, such as
                 paths or definition-use associations, requires more
                 sophisticated techniques that track not only the
                 execution of the desired entities but also the
                 execution of other entities with which they interact.
                 This paper presents an approach for monitoring subsets
                 of one such program entity---acyclic paths in
                 procedures. Our selective path profiling algorithm
                 computes values for probes that guarantee that the sum
                 of the assigned value along each acyclic path (path
                 sum) in the subset is unique; acyclic paths not in the
                 subset may or may not have unique path sums. The paper
                 also presents the results of studies that compare the
                 number of probes required for subsets of various sizes
                 with the number of probes required for profiling all
                 paths, computed using Ball and Larus' path profiling
                 algorithm. Our results indicate that the algorithm
                 performs well on many procedures by requiring only a
                 small percentage of probes for monitoring the subset.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Eng:2003:CSD,
  author =       "David Eng",
  title =        "Combining static and dynamic data in code
                 visualization",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "1",
  pages =        "43--50",
  month =        jan,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/634636.586105",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:25 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The task of developing, tuning, and debugging compiler
                 optimizations is a difficult one which can be
                 facilitated by software visualization. There are many
                 characteristics of the code which must be considered
                 when studying the kinds of optimizations which can be
                 performed. Both static data collected at compile-time
                 and dynamic runtime data can reveal opportunities for
                 optimization and affect code transformations. In order
                 to expose the behavior of such complex systems,
                 visualizations should include as much information as
                 possible and accommodate the different sources from
                 which this information is acquired. This paper presents
                 a visualization framework designed to address these
                 issues. The framework is based on a new, extensible
                 language called JIL which provides a common format for
                 encapsulating intermediate representations and
                 associating them with compile-time and runtime data. We
                 present new contributions which extend existing
                 compiler and profiling frameworks, allowing them to
                 export the intermediate languages, analysis results,
                 and code metadata they collect as JIL documents.
                 Visualization interfaces can then combine the JIL data
                 from separate tools, exposing both static and dynamic
                 characteristics of the underlying code. We present such
                 an interface in the form of a new web-based visualizer,
                 allowing JIL documents to be visualized online in a
                 portable, customizable interface.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Chelf:2003:HWS,
  author =       "Benjamin Chelf and Dawson Engler and Seth Hallem",
  title =        "How to write system-specific, static checkers in
                 metal",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "1",
  pages =        "51--60",
  month =        jan,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/634636.586097",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:25 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Naumovich:2003:UOD,
  author =       "Gleb Naumovich",
  title =        "Using the observer design pattern for implementation
                 of data flow analyses",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "1",
  pages =        "61--68",
  month =        jan,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/634636.586107",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:25 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Data flow analysis is used widely in program
                 compilation, understanding, design, and analysis tools.
                 In data flow analysis, problem-specific information is
                 associated with nodes and/or edges in the flow graph
                 representation of a program or component and
                 re-comp\-uted iteratively. A popular data flow analysis
                 design relies on a worklist that stores all nodes and
                 edges whose data flow information has to be
                 re-computed. While this approach is straightforward, it
                 has some drawbacks. First, the presence of the worklist
                 makes data flow algorithms centralized, which may
                 reduce effectiveness of parallel implementations of
                 these algorithms. Second, the worklist approach is
                 difficult to implement in a way that minimizes the
                 amount of information passed between flow graph nodes.
                 In this paper, we propose to use the well-known
                 Observer pattern for implementation of data flow
                 analyses. We argue that such implementations are more
                 object-oriented in nature, as well as less centralized,
                 than worklist-based ones. We argue that by adopting
                 this Observer-based view, data flow analyses that
                 minimize the amount of information passed between flow
                 graph nodes can be implemented easier than by using the
                 worklist view. We present experimental data indicating
                 that for some types of data flow problems, even
                 single-threaded implementations of Observer-based data
                 flow analysis have better run times than comparable
                 worklist-based implementations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Fiskio-Lasseter:2003:FEG,
  author =       "John Fiskio-Lasseter and Michal Young",
  title =        "Flow equations as a generic programming tool for
                 manipulation of attributed graphs",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "1",
  pages =        "69--76",
  month =        jan,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/634636.586108",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:25 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The past three decades have seen the creation of
                 several tools that extract, visualize, and manipulate
                 graph-structured representations of program
                 information. To facilitate interconnection and exchange
                 of information between these tools, and to support the
                 prototyping and development of new tools, it is
                 desirable to have some generic support for the
                 specification of graph transformations and exchanges
                 between them. GenSet is a generic programmable tool for
                 transformation of graph-structured data. The
                 implementation of the GenSet system and the programming
                 paradigm of its language are both based on the view of
                 a directed graph as a binary relation. Rather than use
                 traditional relational algebra to specify
                 transformations, however, we opt instead for the more
                 expressive class of flow equations. Flow
                 equations---or, more generally, systems of simultaneous
                 fixpoint equations---have seen fruitful applications in
                 several areas, including data and control flow
                 analysis, formal verification, and logic programming.
                 In GenSet, they provide the fundamental construct for
                 the programmer to use in defining new
                 transformations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Sutherland:2003:CMC,
  author =       "Dean F. Sutherland and Aaron Greenhouse and William L.
                 Scherlis",
  title =        "The code of many colors: relating threads to code and
                 shared state",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "1",
  pages =        "77--83",
  month =        jan,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/634636.586109",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:25 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We introduce a thread colors model as a way to express
                 design intent concerning the relationships between
                 threads, executable code, and shared state. By
                 expressing the model as annotations in code, it is
                 possible to formally link the model with source code
                 and to analyze the consistency of model and code in a
                 composable manner. By using annotations as cut-points,
                 APIs can be annotated and compliance with library
                 threading policies can be evaluated. This is
                 illustrated using case study examples from published
                 code that show how thread coloring models can assist in
                 assuring policy compliance and in identifying
                 concurrency errors.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Agarwal:2003:RDI,
  author =       "Rakesh Agarwal and Ajit Sarangi and Swati Das",
  title =        "Reengineering of database intensive application",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "1--1",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773136",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Reengineering databases has been a challenge since
                 ages and it requires process mapping to understand
                 better and significantly improve the business processes
                 and performance. In this paper we describe a generic
                 architecture for reengineering legacy databases, which
                 is an outcome of working on a real software project.
                 The goal of this research is to formalize a process
                 that is applicable to different database reengineering
                 scenarios and requirements. We elaborate the steps that
                 were actually done for implementing the project.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tracz:2003:FML,
  author =       "Will Tracz",
  title =        "Front matter (letters and notices)",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "1--8",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773127",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bayrak:2003:LAN,
  author =       "Coskun Bayrak and Chad Davis",
  title =        "The liquid architecture: a non-linear peer-to-peer
                 distributed architecture with polymorphic message
                 passing",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "2--2",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773137",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In terms of benefiting from the potential to be gained
                 from full distribution, today's most common
                 implementations of distributed systems follow only
                 limited linear versions of distribution such as
                 client-server or n-tier models. Even many ``peer to
                 peer'' systems still rely on centralized servers to
                 provide the message passing connectivity between the
                 peers. While these systems do provide increased
                 robustness and computational speedup, they fail to
                 realize the full measure of what fully distributed
                 architectures offer. With many of the techno-historical
                 reasons behind these linear distributed systems
                 becoming obsolete, we should try to think of new, more
                 truly distributed models. Fully distributed
                 architectures should demonstrate the ability to move
                 functionality to a completely contingent set of
                 machines determined at or just prior to run time. Under
                 such an architecture --- a`` liquid'' architecture,
                 functionality and data are completely freed from any
                 fixed locations or functional paths and may flow at
                 will. Especially in the domain of shared space
                 applications such as chat and pseudochat (i.e. instant
                 messaging) services, and virtual collaboration, the
                 flexibility and security to be gained from the full
                 distribution of a liquid architecture represent not
                 only premium benefits but possibly core requisites to
                 their essential purpose and functionality. This paper
                 examines the notion of a liquid architecture and
                 explores a case study implementation of such an
                 architecture via the Virtual Collaboration Tool
                 introduced below.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Billard:2003:LDP,
  author =       "Edward A. Billard",
  title =        "Language-Dependent performance of design patterns",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "3--3",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773138",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The Gang of Four design patterns represent a catalog
                 of 23 reusable design solutions to classes of problems
                 that arise in a variety of applications. This study
                 examines the execution performance of the patterns, as
                 implemented in C++, Java (native and JDK 1.0 through
                 1.4), Smalltalk, and Perl 5.0. Each pattern is
                 implemented independent of an application and, hence,
                 represents just the pure object structure. Because the
                 patterns themselves demonstrate a variety of
                 structures, the results represent a good benchmark for
                 how well the object-oriented compilers actually handle
                 object-oriented programming, in particular, object
                 creation and object reference to methods/attributes.
                 The results indicate that the C++ compiler provided the
                 fastest code, Java was second, followed by Smalltalk,
                 and then Perl. However, Java 1.2 and 1.4 held their own
                 against the optimized version of C++ and even did
                 slightly better than non-optimized C++. Optimized C++
                 code was the best in 11 of the 23 patterns, with Java
                 1.2 and 1.4 sharing the remaining honors for the other
                 12 patterns, that is, a ``winning'' Java compiler can
                 be found for just over half of the design patterns.
                 Smalltalk was an order of magnitude, and Perl two
                 orders of magnitude, slower. Although there is a wide
                 variety of performance among the design patterns, the
                 overall averages are much in-line with the averages of
                 four simple test programs. The results may provide
                 guidelines for future application development.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Brebner:2003:HSJ,
  author =       "Paul Brebner and Jeffrey Gosper",
  title =        "How scalable is {J2EE} technology?",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "4--4",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773139",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "ECperf, the widely recognized industry standard J2EE
                 benchmark, has attracted a large number of results
                 submissions and their subsequent publication. However,
                 ECperf places little restriction on the hardware
                 platform, operating systems and databases utilized in
                 the benchmarking process. This, combined with the
                 existence of only two primary metrics, makes it
                 difficult to answer critical questions such as ``Is
                 there a limit to J2EE scalability?'' and ``Is scale-up
                 or scale-out more effective?''. By mining the
                 full-disclosure archives for trends and correlations we
                 have discovered that J2EE technology is very scalable,
                 both in a scale-up and scale-out manner. Other observed
                 trends include, a linear correlation between
                 middle-tier total processing power and throughput, as
                 well as between J2EE Application Server license costs
                 and throughput. However, the results clearly indicate
                 that there is an increasing cost per user with
                 increasing capacity systems, and scale-up is
                 proportionately more expensive than scale-out.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Perez-Martinez:2003:HEU,
  author =       "Jorge Enrique P{\'e}rez-Mart{\'\i}nez",
  title =        "Heavyweight extensions to the {UML} metamodel to
                 describe the {C3} architectural style",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "5--5",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773140",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "UML is widely accepted as the standard for
                 representing the various software artifacts generated
                 by a development process. For this reason, there have
                 been attempts to use this language to represent the
                 software architecture of systems as well.
                 Unfortunately, these attempts have ended in the same
                 representations (boxes and lines) already criticized by
                 the software architecture community. In this work we
                 propose an extension to the UML metamodel that is able
                 to represent the syntactics and semantics of the C3
                 architectural style. This style is derived from C2. The
                 modifications to define C3 are described in section 4.
                 This proposal is innovative regarding UML extensions
                 for software architectures, since previous proposals
                 where based on light extensions to the UML meta-model,
                 while we propose a heavyweight extension of the
                 metamodel. On the other hand, this proposal is less
                 ambitious than previous proposals, since we do not want
                 to represent in UML any architectural style, but only
                 one: C3.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2003:RPC,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "5--9",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773130",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Heering:2003:QSI,
  author =       "Jan Heering",
  title =        "Quantification of structural information: on a
                 question raised by {Brooks}",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "6--6",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773141",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We introduce the notion of generative software
                 complexity to illustrate some of the problems one may
                 run into when trying to tackle a special case of a
                 question recently raised by Brooks.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Henderson:2003:SEE,
  author =       "Peter B. Henderson",
  title =        "Software engineering education {(SEEd)}",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "11--12",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773132",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Doernhoefer:2003:SNS,
  author =       "Mark Doernhoefer",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "13--21",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773134",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{staff:2003:BM,
  author =       "{ACM SIGSOFT Software Engineering Notes Staff}",
  title =        "Back matter",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "22--37",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773128",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ben-Menachem:2003:SYH,
  author =       "Mordechai Ben-Menachem",
  title =        "Software for your head",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "24--24",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773143",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Pentinmaki:2003:OMU,
  author =       "Isaac Pentinmaki",
  title =        "Object modeling and user interface design designing
                 interactive systems",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "24--24",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773144",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Pentinmaki:2003:IMP,
  author =       "Isaac Pentinmaki",
  title =        "{IT} measurement: practical advice from the experts",
  journal =      j-SIGSOFT,
  volume =       "28",
  number =       "3",
  pages =        "25--25",
  month =        may,
  year =         "2003",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/773126.773145",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:27 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tracz:2004:FML,
  author =       "Will Tracz",
  title =        "Front matter (letters and notices)",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "0--6",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979744",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Agarwal:2004:IAL,
  author =       "Rakesh Agarwal and Amrita Deo and Swati Das",
  title =        "Intelligent agents in E-learning",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "1--1",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979755",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this competitive era, education has become equally
                 demanding and competitive. Innovation in the sphere of
                 education has led to new ways of learning. Internet has
                 now made learning dynamic by introducing the concept of
                 learning through E-learning. The dynamism in E-Learning
                 can be made more powerful with the help of intelligent
                 agents. Intelligent, autonomous, mobile, rational,
                 reactive, persistent and moreover proactive computer
                 code so called as agents represent the next tidal wave
                 of innovation and development in the Information age.
                 These agents perform specific tasks on the behalf of
                 students, instructors, and other members of the
                 educational community including parents and alumni. The
                 agent-based technology is expected to have an effect as
                 profound and lasting as the World Wide Web. It is
                 growing to be a continuously evolving and expanding
                 area. The paper focuses on the use of intelligent
                 agents in the sphere of effective E-learning
                 education.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Wyss:2004:REF,
  author =       "C. M. Wyss and A. James and W. Hasselbring and S.
                 Conrad and Hagen H{\"o}pfner",
  title =        "Report on the {Engineering Federated Information
                 Systems 2003 workshop (EFIS 2003)}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "1--3",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979753",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper summarizes the EFIS 2003 workshop, held in
                 Coventry, U.K. in July, as part of Coventry
                 University's Data Horizons Week. Major research issues
                 discussed include metadata/ontologies, integration
                 frameworks, data quality and evolution, and mobile
                 interfaces. Topics for future work include evolution,
                 expressiveness, maintenance, and dissemination of
                 FIS.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Gervasi:2004:RFI,
  author =       "Vincenzo Gervasi and Didar Zowghi and Steve
                 Easterbrook and Susan Elliott Sim",
  title =        "Report on the {First International Workshop on
                 Comparative Evaluation in Requirements Engineering}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "1--4",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979751",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Requirements Engineering (RE) research is believed to
                 be mature enough for the community to be able to make
                 comparative evaluations of alternative tools,
                 techniques, approaches and methods. Commonly used
                 exemplars in RE that have emerged over the years all
                 suffer from well-defined and widely accepted evaluation
                 criteria which makes comparison of the effectiveness of
                 different research outcomes impossible. The first
                 International Workshop on Comparative Evaluation on
                 Requirements Engineering was held in conjunction with
                 the 11$^{th}$ IEEE International Requirements
                 Engineering Conference in Monterey Bay, California.
                 This workshop was conceived to address these issues and
                 facilitate a community initiative in developing a
                 common understanding of evaluation criteria and
                 developing benchmarks for comparative evaluation in RE.
                 Content, of course, is important.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Walenstein:2004:SIW,
  author =       "Andrew Walenstein and Arun Lakhotia and Rainer
                 Koschke",
  title =        "The {Second International Workshop on Detection of
                 Software Clones}: workshop report",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "1--5",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979752",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This report is intended to summarize the proceedings
                 of the Second International Workshop on Detection of
                 Software Clones (IWDSC'2003). The aim of the workshop
                 was to bring together researchers within the field of
                 clone detection to critically assess the current state
                 of research, and to establish new directions and
                 partnerships for research. There were at least 30
                 people in attendance. Five position papers were
                 presented and discussed. In addition, an index
                 card-based brainstorming technique was used to focus
                 discussion on assessing the current state of clone
                 analysis and detection. A report and analysis of the
                 results of this brainstorming session is the main
                 content of this report. We recommend another
                 international workshop on clones and clone detection be
                 set to be held alongside another conference sometime in
                 2004.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Cardoso:2004:ASS,
  author =       "Ana Isabel Cardoso and Rui Gustavo Crespo and Peter
                 Kokol",
  title =        "Assessing software structure by entropy and
                 information density",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "2--2",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979756",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this paper we show how the long range correlation
                 and the local entropy measures in the software program
                 can give indication about its structure. First we
                 define a long range correlation and local entropy
                 introducing a list of examples of use of those measures
                 across different fields. We then present a method to
                 calculate the long range correlation in the Software
                 Engineering and we use that method in a Case Study.
                 Finally we conclude that the use of those two metrics,
                 borrowed from the complex systems theory, are potential
                 and easier for measuring the object program
                 structure.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Fass:2004:AAP,
  author =       "Leona F. Fass",
  title =        "Approximations, anomalies and {``the proof of
                 correctness wars''}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "3--3",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979757",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "We discuss approaches to establishing ``correctness''
                 and describe the usefulness of logic-based model
                 checkers for producing better practical system designs.
                 While we could develop techniques for ``constructing
                 correctness'' in our theoretical behavioral-modeling
                 research, when applied to Real World processes such as
                 software development only approximate correctness might
                 be established and anomalous behaviors subsequently
                 found. This we view as a positive outcome since
                 resultant adaptation, or flaw detection and correction,
                 may lead to improved development and designs. We find
                 researchers employing model checking as a formal
                 methods tool to develop empirical techniques have
                 reached similar conclusions. Thus we cite some
                 applications of model checking to generate tests and
                 detect defects in such Real World processes as aviation
                 system development, fault-detection systems, and
                 security.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Gill:2004:FIC,
  author =       "Nasib S. Gill and P. S. Grover",
  title =        "Few important considerations for deriving interface
                 complexity metric for component-based systems",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "4--4",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979758",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Component-based software engineering (CBSE) represents
                 an exciting and promising paradigm for software
                 development. Software components are one of the key
                 issues in CBSE. The software development community is
                 continuously seeking new methods for improving software
                 quality and enhancing development productivity. There
                 is an increasing need for component-based metrics to
                 help manage and foster quality in component-based
                 software development. The traditional software product
                 and process metrics are neither suitable nor sufficient
                 in measuring the complexity of software components,
                 which ultimately is necessary for quality and
                 productivity improvement within organisations adopting
                 CBSE. In this paper, we propose an interface complexity
                 metric (ICM) aimed at measuring the complexity of a
                 software component based on the interface
                 characterisation model of a software component that
                 mainly include such as interface signature, interface
                 constraints, interface packaging and configurations.
                 Based on the value of this metric, the complexity of
                 the software component could be managed within
                 reasonable complexity limits. In this way, the software
                 components could be kept simple which in turn help in
                 enhancing the quality and productivity.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Guo:2004:KNT,
  author =       "Bing Guo and Yan Shen and Jun Xie and Yong Wang and
                 Guang-Ze Xiong",
  title =        "A kind of new {ToolBus} model research and
                 implementation",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "5--5",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979759",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Nowadays, software architecture of CASE (Computer
                 Aided Software Engineering) environments is evolving
                 from layered structure to bus structure. This bus
                 structure can greatly simplify the interconnection
                 structure among tools and facilitate the construction
                 of distributed CASE environments. In this paper, from
                 the viewpoint that tool integration facilities are
                 separated from tool logic processing function, a pure
                 model of ToolBus first is introduced, then its
                 functional abstraction, internal structure, interface
                 specifications and implementation approaches are
                 explored, last a software prototype LambdaBus which
                 verifies the validity to ToolBus model is implemented
                 based on CORBA specifications.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Javed:2004:SEE,
  author =       "Talha Javed and Manzil-e-Maqsood and Qaiser S.
                 Durrani",
  title =        "A survey to examine the effect of team communication
                 on job satisfaction in software industry",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "6--6",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979760",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Effective communication at work places contributes
                 significantly towards the performance of employees. It
                 gives rise to enhanced job satisfaction, a good feeling
                 of personal accomplishment and increased productivity.
                 In this paper we have investigated the factors (related
                 to team communication) that have a significant
                 influence on job satisfaction. For this study, 23
                 factors that could possibly affect job satisfaction are
                 taken into consideration. These factors were grouped
                 into categories like working environment, duration of
                 service, personal communication terms, performance
                 feedback, horizontal, vertical and formal
                 communication. Our findings, based on the statistical
                 analysis of industry data, indicate that working
                 environment, quality work, performance appraisals and
                 clarity of information provided by project managers to
                 team members are the factors that positively contribute
                 towards job satisfaction.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Henderson:2004:SEEa,
  author =       "Peter B. Henderson",
  title =        "Software engineering education {(SEEd)}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "6--8",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979747",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kanmani:2004:IEO,
  author =       "S. Kanmani and V. Rhymend Uthariaraj and V.
                 Sankaranarayanan and P. Thambidurai",
  title =        "Investigation into the exploitation of Object-Oriented
                 features",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "7--7",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979761",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper discusses the results arrived at employing
                 Object-Oriented (OO) measures on the small-sized
                 programs developed by the Under Graduate (UG) students
                 during the study of C++ laboratory course. The metric
                 values computed reflect the experience/knowledge of the
                 developer in various mechanisms (inheritance, coupling
                 and cohesion) in developing the modules (classes). We
                 propose six hypotheses to validate the measures. For
                 this experiment, the number of attributes and number of
                 methods defined in the class are correlated with the
                 metric values. The result of the experiment shows that
                 the programs used inheritance and cohesion properties
                 appropriately in the design of the class level
                 attributes.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Lu:2004:SRC,
  author =       "Jian Lu",
  title =        "Some research on componentware frameworks based on
                 mobile agent technology",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "8--8",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979762",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "With the development of mobile agent technology and
                 the applications of componentware, the requirements for
                 a new componentware framework based on mobile agent
                 technology are increasing. These requirements include
                 requirements from programming methodology, requirements
                 from componentware, and requirements from mobile agent
                 technology. According to these requirements and after
                 analyzing the limitations of ``traditional'' component
                 software, this paper presents some ideas about what the
                 mobile agent technology can do to overcome these
                 limitations. Then based on the above analysis and the
                 mobile agent technology, this paper proposes three new
                 conceptual componentware frameworks. They include an
                 adjustable componentware framework, a smart
                 componentware framwork, and a flexible framework. These
                 new frameworks provides much more flexibility than the
                 traditional componentware frameworks and more suitable
                 to the open environment of Internet. In order to
                 support previously proposed new conceptual
                 componentware frameworks based on mobile agent
                 technology, some issues about the infrastructure,
                 methodology and technical challenge are also discussed
                 in this paper. Our goal is to build a new componentware
                 framework based on mobile agent technology, overcome
                 the limitations of the current approaches, and further
                 popularize the Internet by giving people greater access
                 to it with less effort.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2004:RPCa,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "8--16",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979748",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rosen:2004:NDS,
  author =       "Clive Rosen",
  title =        "Non-directive software engineering",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "9--9",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979763",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Shimomura:2004:PTF,
  author =       "Takao Shimomura",
  title =        "A page-transition framework for image-oriented {Web}
                 programming",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "10--10",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979764",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "To develop Web applications, various integrated
                 development environments have been used. In addition,
                 several frameworks for efficiently developing those
                 applications have been proposed. This paper presents
                 the image-oriented page-transition framework that
                 models a Web application as a set of transitions of Web
                 pages, and using visual components, makes it easier to
                 write processes executed when a Web page transfers to
                 another Web page. This page-transition framework has
                 the following novel features: (1) The developers of Web
                 applications do not need to write any processes for
                 receiving and analyzing submitted form data. (2) The
                 data submitted by page transfers are stored in the
                 appropriate variables that are automatically generated.
                 Using these automatically generated variables, the
                 developers can write necessary actions for each Web
                 page from which control transfers. (3) The developers
                 can deal with tables used inside the programs as visual
                 components, and can use these components to design
                 dynamic Web pages.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Terekhov:2004:DAI,
  author =       "Andrey A. Terekhov",
  title =        "Dealing with architectural issues: a case study",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "11--11",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979765",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper describes an effort to recover and improve
                 software architecture in a large-scale industrial
                 project. We describe our motivation for architecture
                 recovery and present a summary of its results. We also
                 attempt to generalize our findings by arguing that the
                 current level of understanding of software architecture
                 is not sufficient to determine in advance which factors
                 will be important (i.e., ``architectural'') for a
                 software product in the long term.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tevanlinna:2004:PFT,
  author =       "Antti Tevanlinna and Juha Taina and Raine Kauppinen",
  title =        "Product family testing: a survey",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "12--12",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979766",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this paper we discuss the current state of product
                 family testing. Testing, unlike other areas of software
                 development, has received only little attention in this
                 context despite the problems directly rising from
                 scale, reuse and variability. We present the current
                 approaches to product family testing methodology and
                 processes. We also evaluate the current
                 state-of-the-art in product family testing and
                 highlight problems that need to be addressed in the
                 future.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Zhou:2004:CSG,
  author =       "Yuming Zhou and Jiangtao Lu and Hongmin Lu Baowen Xu",
  title =        "A comparative study of graph theory-based class
                 cohesion measures",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "13--13",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979767",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Among a large number of cohesion measures for classes
                 proposed in last decade, many measures abstract a class
                 by an undirected or directed graph, in which the nodes
                 represent the class members and the edges represent the
                 relationships among these members. This paper compares
                 six typical graph theory-based cohesion measures for
                 classes, and states what problems should be addressed
                 during the development of new cohesion measures.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Doernhoefer:2004:SNSa,
  author =       "Mark Doernhoefer",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "17--26",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979749",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{staff:2004:BMA,
  author =       "{ACM SIGSOFT Software Engineering Notes Staff}",
  title =        "Back matter (abstracts and calendar)",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "27--62",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979745",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ben-Menachem:2004:RIP,
  author =       "Mordechai Ben-Menachem",
  title =        "Review of {{\booktitle{IT project estimation: a
                 practical guide to the costing of software}} by Paul
                 Coombs. Cambridge University Press 2003}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "31--31",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979769",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Harris:2004:RAS,
  author =       "Gregory H. Harris",
  title =        "Review of {{\booktitle{Abstract state machines: a
                 method for high-level system design and analysis}} by
                 Egon B{\"o}rger and Robert St{\"a}rk. Springer-Verlag
                 2003}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "31--32",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979770",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Law:2004:RDL,
  author =       "James Law",
  title =        "Review of {{\booktitle{The description logic
                 handbook}} by Franz Bader, Diego Calvanese, Deborah L.
                 McGuinness, Daniele Nardi, Peter Patel-Schneider.
                 Cambridge University Press 2003}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "32--33",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979771",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Law:2004:RTR,
  author =       "James Law",
  title =        "Review of {{\booktitle{Term rewriting systems}} by
                 Mark Bezem, Jan Willem Klop, and Roel de Vrijer.
                 Cambridge University Press 2003}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "33--33",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979772",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Pentinmaki:2004:RLS,
  author =       "Isaac Pentinmaki",
  title =        "Review of {{\booktitle{Lean software development: an
                 agile tookit}} by Mary and Tom Poppendieck. Addison
                 Wesley 2003}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "2",
  pages =        "33--33",
  month =        mar,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/979743.979773",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:31 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tracz:2004:FLN,
  author =       "Will Tracz",
  title =        "Frontmatter (letters and notices)",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "0--4",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986711",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ramachandran:2004:KBR,
  author =       "Muthu Ramachandran and Domenic Mangano",
  title =        "Knowledge based reasoning for software architectural
                 design strategies",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "1--4",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986730",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "It is well known that the backbone of any system is
                 the architecture which holds the whole system together
                 to manage the complexity and requirements changes. The
                 past twenty years or more of research into software and
                 IT systems design has resulted in exponential growth of
                 architectural design strategies. Therefore it has also
                 resulted in confusion for many software engineers who
                 may not be experts in software design to understand and
                 choose a suitable architectural solution to their
                 problem. We have tackled this issue by providing a
                 classification framework and knowledge based reasoning
                 for software designers to choose the appropriate
                 strategies for their problem. This paper illustrates a
                 classification schemes for architectural design
                 strategies and a tool support for knowledge based
                 reasoning for choosing a design solution.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Berry:2004:SIW,
  author =       "Daniel M. Berry and Rick Kazman and Roel Wieringa",
  title =        "{Second International Workshop on From SofTware
                 Requirements to Architectures (STRAW'03)}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "1--5",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986722",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The Second International Workshop on From SofTware
                 Requirements to Architectures (STRAW'03) was held in
                 Portland, Oregon, USA on 9 May 2003 just after the
                 Twenty-Fifth International Conference on Software
                 Engineering (ICSE'03). This brief paper outlines the
                 motivation, goals, and organization of the workshop,
                 summarizes the presentations, and, along the way,
                 gathers some lessons learned about running a
                 workshop.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Aggarwal:2004:NNB,
  author =       "K. K. Aggarwal and Yogesh Singh and A. Kaur and O. P.
                 Sangwan",
  title =        "A neural net based approach to Test Oracle",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "1--6",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986725",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this paper an attempt has been made to explore the
                 possibility of the usage of artificial neural networks
                 as Test Oracle. The triangle classification problem has
                 been used as a case study. Results for the usage of
                 unsupervised artificial networks indicate that they are
                 not suitable for this purpose. The Feed-forward back
                 propagation neural networks are demonstrated to be
                 suitable.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Crnkovic:2004:IWC,
  author =       "Ivica Crnkovic and Heinz Schmidt and Judith Stafford
                 and Kurt Wallnau",
  title =        "{6th ICSE Workshop on Component-Based Software
                 Engineering}: automated reasoning and prediction",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "1--7",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986723",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This report gives an overview of the 6th ICSE Workshop
                 on Component-Based Software Engineering held at
                 25$^{th}$ International Conference on Software
                 Engineering. The workshop brought together researchers
                 and practitioners from three communities: component
                 technology, software architecture, and software
                 certification. The primary goal of the workshop was to
                 continue clarifying the concepts, identifying the main
                 challenges and findings of predictable assembly of
                 certifiable software components. This report gives a
                 comprehensive summary of the position papers, of the
                 workshop, its findings, and its results.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Javed:2004:SII,
  author =       "Talha Javed and Manzil e Maqsood and Qaiser S.
                 Durrani",
  title =        "A study to investigate the impact of requirements
                 instability on software defects",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "1--7",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986727",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Software development is a dynamic process and is
                 characterized by change. Software projects often begin
                 with unclear, ambiguous, and incomplete requirements
                 which give rise to intrinsic volatility. Constant
                 change in requirements is one of the main causes of
                 software defects and a major issue faced by the
                 software industry. This paper describes the findings of
                 our research-based study that investigates the impact
                 of both the pre-release and post-release requirements
                 changes on overall defects by defining measures,
                 collecting data against those measures and analyzing
                 the collected data through statistical techniques. Our
                 findings, based on industry data from 4 software
                 projects consisting of 30 releases, all in e-commerce
                 domain, indicate that there is a significant
                 relationship between pre/post release change requests
                 initiated by the client and software defects. In
                 addition, our data analysis indicates that changes in
                 the design of the system at the later stages of
                 software development i.e., during coding, testing and
                 after release have a significant impact on the high
                 severity defects that affect the major functionality of
                 the system. Also, we found that insufficient time spent
                 on the design phase and inadequate communication with
                 the client could be some of the causes of requirements
                 changes and consequently software defects.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Lima:2004:AMA,
  author =       "Emerson F. A. Lima and Patr{\'\i}cia D. L. Machado and
                 Fl{\'a}avio R. Sampaio and Jorge C. A. Figueiredo",
  title =        "An approach to modelling and applying mobile agent
                 design patterns",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "1--8",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986726",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Mobile agent design patterns represent solutions to
                 specific problems of implementing mobile agent-based
                 applications that have evolved over time. The use of
                 design patterns can increase productivity, promote
                 reuse and reduce complexity when developing
                 applications. However, most of the mobile agent design
                 patterns presented in the literature are difficult to
                 apply in practice due to the lack of a suitable
                 approach to identify, document and apply them. Also,
                 they are usually related to a specific mobile agent
                 platform. We present an approach for modelling and
                 applying patterns independently of specific platforms
                 along with their counterparts in specific platforms.
                 Also, we show that an adequate platform independent
                 view can be constructed to be used as a guide to
                 implement the pattern in different platforms.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ram:2004:PHB,
  author =       "D. Janaki Ram and P. Jithendra Kumar Reddy and M. S.
                 Rajasree",
  title =        "Pattern hybridization: breeding new designs out of
                 pattern interactions",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "1--10",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986729",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "Class or object interactions form the basis of
                 object-oriented design. However, design pattern
                 interaction can be viewed as a higher level of
                 abstraction for system design. The typical interactions
                 among the patterns are a pattern uses another pattern
                 to solve one of its sub problem, and a pattern combines
                 with another pattern for completeness. This paper
                 proposes a mechanism called pattern hybridization for
                 breeding new patterns from the pattern interactions
                 which solve more specialized problems than the original
                 patterns do. Rules for generating hybrid patterns are
                 also mentioned in the paper. This paper also views
                 design pattern interactions for system design.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Oquendo:2004:AAD,
  author =       "Flavio Oquendo",
  title =        "{$ \pi $-ADL}: an Architecture Description Language
                 based on the higher-order typed $ \pi $-calculus for
                 specifying dynamic and mobile software architectures",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "1--14",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986728",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "A key aspect of the design of any software system is
                 its architecture. An architecture description, from a
                 runtime perspective, should provide a formal
                 specification of the architecture in terms of
                 components and connectors and how they are composed
                 together. Further, a dynamic or mobile architecture
                 description must provide a specification of how the
                 architecture of the software system can change at
                 runtime. Enabling specification of dynamic and mobile
                 architectures is a large challenge for an Architecture
                 Description Language (ADL). This article describes
                 {\pi}-ADL, a novel ADL that has been designed in the
                 ArchWare European Project to address specification of
                 dynamic and mobile architectures. It is a formal,
                 well-founded theoretically language based on the
                 higher-order typed {\pi}-calculus. While most ADLs
                 focus on describing software architectures from a
                 structural viewpoint, {\pi}-ADL focuses on formally
                 describing architectures encompassing both the
                 structural and behavioural viewpoints. The {\pi}-ADL
                 design principles, concepts and notation are presented.
                 How {\pi}-ADL can be used for specifying static,
                 dynamic and mobile architectures is illustrated through
                 case studies. The {\pi}-ADL toolset is outlined.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Henderson:2004:SEEb,
  author =       "Peter B. Henderson",
  title =        "Software engineering education {(SEEd)}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "5--6",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986714",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Neumann:2004:RPCb,
  author =       "Peter G. Neumann",
  title =        "Risks to the public in computers and related systems",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "7--14",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986716",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Doernhoefer:2004:SNSb,
  author =       "Mark Doernhoefer",
  title =        "Surfing the net for {{\booktitle{Software Engineering
                 Notes}}}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "15--24",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986718",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ovans:2004:PLC,
  author =       "Russell Ovans",
  title =        "The programmer life-cycle",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "25--26",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986720",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "The traditional analysis of programmer productivity
                 ignores the reality that work rates of programmers are
                 variable over time. Not unlike the software systems
                 they construct, programmers follow a predictable
                 life-cycle. However, the programmer life-cycle is not
                 comprised of activities but rather by phases that
                 directly affect and predict productivity. The sequence
                 of phases is: euphoric, productive, irreplaceable,
                 resentful, bored, and unproductive. Overall
                 productivity is characterized by an initial six month
                 period of intense interest, at which time productivity
                 rates are often an order of magnitude higher than the
                 oft-quoted 500 LOC/month average. After a short period
                 of volatility, the programmer then enters a prolonged
                 phase of steadily dwindling interest, resulting in
                 productivity rates that mimic the average. Each time a
                 programmer switches employers or begins a significantly
                 new project, the life-cycle starts anew.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Saur:2004:RSN,
  author =       "Joseph M. Saur",
  title =        "Review of {{\booktitle{Software by numbers: low-risk,
                 high-return development}} by Mark Denne and Jane
                 Cleland-Huang. Prentice Hall 2004}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "29--30",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986732",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Saur:2004:RCT,
  author =       "Joseph M. Saur",
  title =        "Review of {{\booktitle{Critical testing processes:
                 plan, prepare, perform, perfect}} by Rex Black.
                 Addison-Wesley 2004}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "30--30",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986734",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Saur:2004:RSE,
  author =       "Joseph M. Saur",
  title =        "Review of {{\booktitle{Software engineering
                 measurement}} by John C. Munson. Auerbach Publications
                 2003}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "30--30",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986733",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{staff:2004:BAC,
  author =       "{ACM SIGSOFT Software Engineering Notes Staff}",
  title =        "Backmatter (abstracts and calendar)",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "3",
  pages =        "31--37",
  month =        may,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/986710.986712",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:33 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rountev:2004:SDA,
  author =       "Atanas Rountev and Scott Kagan and Michael Gibas",
  title =        "Static and dynamic analysis of call chains in {Java}",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "4",
  pages =        "1--11",
  month =        jul,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/1013886.1007514",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:35 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This work presents a parameterized framework for
                 static and dynamic analysis of call chains in Java
                 components. Such analyses have a wide range of uses in
                 tools for software understanding and testing. We also
                 describe a test coverage tool built with these analyses
                 and the use of the tool on a real-world test suite. Our
                 experiments evaluate the exact precision of several
                 instances of the framework and provide a novel approach
                 for estimating the limits of class analysis technology
                 for computing precise call chains.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Dor:2004:SVS,
  author =       "Nurit Dor and Stephen Adams and Manuvir Das and Zhe
                 Yang",
  title =        "Software validation via scalable path-sensitive value
                 flow analysis",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "4",
  pages =        "12--22",
  month =        jul,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/1013886.1007515",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:35 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "In this paper, we present a new algorithm for tracking
                 the flow of values through a program. Our algorithm
                 represents a substantial improvement over the state of
                 the art. Previously described value flow analyses that
                 are control-flow sensitive do not scale well, nor do
                 they eliminate value flow information from infeasible
                 execution paths (i.e., they are path-insensitive). Our
                 algorithm scales to large programs, and it is
                 path-sensitive. The efficiency of our algorithm arises
                 from three insights: The value flow problem can be
                 ``bit-vectorized'' by tracking the flow of one value at
                 a time; dataflow facts from different execution paths
                 with the same value flow information can be merged; and
                 information about complex aliasing that affects value
                 flow can be plugged in from a different analysis. We
                 have incorporated our analysis in ESP, a software
                 validation tool. We have used ESP to validate the
                 Windows operating system kernel (a million lines of
                 code) against an important security property. This
                 experience suggests that our algorithm scales to large
                 programs, and is accurate enough to trace the flow of
                 values in real code.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Fu:2004:TJW,
  author =       "Chen Fu and Barbara G. Ryder and Ana Milanova and
                 David Wonnacott",
  title =        "Testing of {Java} web services for robustness",
  journal =      j-SIGSOFT,
  volume =       "29",
  number =       "4",
  pages =        "23--34",
  month =        jul,
  year =         "2004",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/1013886.1007516",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:14:35 MDT 2018",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsoft2000.bib",
  abstract =     "This paper presents a new compile-time analysis that
                 enables a testing metho